@Test
public void checkHappyPathStreamStoreOperations() {
try {
cassandraConnector.saveStreamDefinitionToStore(getCluster(), streamDefinition1);
} catch (StreamDefinitionStoreException e) {
e.printStackTrace();
fail();
}
StreamDefinition streamDefinitionFromStore = null;
try {
Credentials credentials = getCredentials(cluster);
streamDefinitionFromStore =
cassandraConnector.getStreamDefinitionFromCassandra(
getCluster(), streamDefinition1.getStreamId());
} catch (Exception e) {
e.printStackTrace();
fail();
}
assertEquals(streamDefinition1, streamDefinitionFromStore);
List<Event> eventList =
EventConverterUtils.convertFromJson(
CassandraTestConstants.properEvent, streamDefinition1.getStreamId());
try {
int eventCounter = 0;
for (Event event : eventList) {
insertEvent(cluster, event, eventCounter++);
}
} catch (Exception e) {
e.printStackTrace();
fail();
}
}
@Test
public void updateUser() {
boolean thrown = false;
WebResource webResource = resource();
try {
JSONObject user =
webResource
.path("resources/users/testuid")
.accept("application/json")
.get(JSONObject.class);
user.put("password", "NEW PASSWORD")
.put("email", "*****@*****.**")
.put("username", "UPDATED TEST USER");
webResource.path("resources/users/testuid").type("application/json").put(user);
user =
webResource
.path("resources/users/testuid")
.accept("application/json")
.get(JSONObject.class);
assertEquals(user.get("username"), "UPDATED TEST USER");
assertEquals(user.get("email"), "*****@*****.**");
assertEquals(user.get("password"), "NEW PASSWORD");
} catch (Exception e) {
e.printStackTrace();
thrown = true;
}
assertFalse(thrown);
}
@Test
@ElasticsearchIndex(indexName = "twitter")
public void updateWithValidParameters() {
String script =
"{\n"
+ " \"script\" : \"ctx._source.tags += tag\",\n"
+ " \"params\" : {\n"
+ " \"tag\" : \"blue\"\n"
+ " }\n"
+ "}";
try {
Index index =
new Index.Builder("{\"user\":\"kimchy\", \"tags\":\"That is test\"}")
.index("twitter")
.type("tweet")
.id("1")
.build();
index.addParameter(Parameters.REFRESH, true);
client.execute(index);
JestResult result =
client.execute(new Update.Builder(script).index("twitter").type("tweet").id("1").build());
assertNotNull(result);
assertTrue(result.isSucceeded());
JestResult getResult =
client.execute(new Get.Builder("1").index("twitter").type("tweet").build());
assertEquals("That is testblue", ((Map) getResult.getValue("_source")).get("tags"));
} catch (Exception e) {
fail("Failed during the update with valid parameters. Exception:" + e.getMessage());
}
}
/** Verify constructor */
@Test
public void testConstructor() {
try {
new SCMProjectProperty(null);
fail("Null should be handled by SCMProjectProperty constructor.");
} catch (Exception e) {
assertEquals(BaseProjectProperty.INVALID_JOB_EXCEPTION, e.getMessage());
}
}
@Test
public void shouldNotThrowExceptionIfXmlnsNotRecognized() {
Map<String, String> motherFormValuesWithoutXmlns =
motherFormValues(
"94d5374f-290e-409f-bc57-86c2e4bcc43f", "89fda0284e008d2e0c980fb13fa0e5bb");
motherFormValuesWithoutXmlns.put("xmlns", "randomurl");
try {
careService.processAndSaveForms(
motherFormValuesWithoutXmlns, new ArrayList<Map<String, String>>());
} catch (Exception e) {
fail("The exception should not have been thrown: " + e.getMessage());
}
}
// ugly.. but separation into separate test cases would be probably uglier
@Test
public void getUserBookmarkList() {
boolean thrown = false;
try {
WebResource webResource = resource();
JSONObject user =
webResource
.path("resources/users/testuid")
.accept("application/json")
.get(JSONObject.class);
assertTrue(user != null);
webResource = client().resource(user.getString("bookmarks"));
JSONObject bookmark = new JSONObject();
bookmark
.put("uri", "http://java.sun.com")
.put("sdesc", "test desc")
.put("ldesc", "long test description");
webResource.type("application/json").post(bookmark);
JSONArray bookmarks = webResource.accept("application/json").get(JSONArray.class);
assertTrue(bookmarks != null);
int bookmarksSize = bookmarks.length();
String testBookmarkUrl = bookmarks.getString(0);
WebResource bookmarkResource = client().resource(testBookmarkUrl);
bookmark = bookmarkResource.accept("application/json").get(JSONObject.class);
assertTrue(bookmark != null);
bookmarkResource.delete();
bookmarks =
resource()
.path("resources/users/testuid/bookmarks")
.accept("application/json")
.get(JSONArray.class);
assertTrue(bookmarks != null);
assertTrue(bookmarks.length() == (bookmarksSize - 1));
} catch (Exception e) {
e.printStackTrace();
thrown = true;
}
assertFalse(thrown);
}
@Test
public void deleteUser() {
boolean thrown = false;
WebResource webResource = resource();
JSONObject user = new JSONObject();
try {
webResource.path("resources/users/testuid").delete();
} catch (Exception e) {
e.printStackTrace();
thrown = true;
}
assertFalse(thrown);
}
@Before
public void setUpProductCatalogue() {
try {
new CoreBasicDataCreator().createEssentialData(Collections.EMPTY_MAP, null);
importCsv("/merchandisefulfilmentprocess/test/testBasics.csv", "windows-1252");
importCsv("/merchandisefulfilmentprocess/test/testCatalog.csv", "windows-1252");
baseSiteService.setCurrentBaseSite(baseSiteService.getBaseSiteForUID("testSite"), false);
LOG.warn("Catalogue has been imported");
} catch (final ImpExException e) {
LOG.warn("Catalogue import has failed");
e.printStackTrace();
} catch (final Exception e) {
LOG.warn("createEssentialData(...) has failed");
e.printStackTrace();
}
}
@Test
public void createUser() {
boolean thrown = false;
WebResource webResource = resource();
JSONObject user = new JSONObject();
try {
user.put("userid", "testuid")
.put("password", "test")
.put("email", "*****@*****.**")
.put("username", "Test User");
webResource.path("resources/users/testuid").type("application/json").put(user);
} catch (Exception e) {
e.printStackTrace();
thrown = true;
}
assertFalse(thrown);
}
@Test
public void informationModel() throws Exception {
String serviceUrl = "http://service.url";
GridDataService dataService = new GridDataService();
dataService.setUrl(serviceUrl);
getGridServiceDao().save(dataService);
Metadata meta = new Metadata();
try {
meta.dmodel =
MetadataUtils.deserializeDomainModel(new FileReader("test/data/cabioModelSnippet.xml"));
meta.smeta =
MetadataUtils.deserializeServiceMetadata(
new FileReader("test/data/cabioServiceMetadata.xml"));
} catch (Exception ex) {
fail("Error deserializing test data: " + ex.getMessage());
ex.printStackTrace();
}
try {
getMetadataListener().loadMetadata(dataService, meta);
} catch (Exception ex) {
fail("Error loading metadata: " + ex.getMessage());
ex.printStackTrace();
}
ServiceMetadataCatalogEntryBuilder b =
(ServiceMetadataCatalogEntryBuilder)
getApplicationContext().getBean("serviceMetadataCatalogEntryBuilder");
final GridServiceEndPointCatalogEntry endpointCe = b.build(dataService);
assertTrue(endpointCe instanceof GridDataServiceEndPointCatalogEntry);
InformationModelCatalogEntryDao infoDao =
(InformationModelCatalogEntryDao)
TestDB.getApplicationContext().getBean("informationModelCatalogEntryDao");
assertEquals(1, infoDao.getAll().size());
InformationModelCatalogEntry infoEntry = (InformationModelCatalogEntry) infoDao.getAll().get(0);
infoEntry.setAuthor(pUser);
infoDao.save(infoEntry);
GridServiceEndPointCatalogEntry endpointCe2 = b.build(dataService);
assertEquals(endpointCe.getId(), endpointCe2.getId());
assertEquals("Duplicate Information Model CE is being created", 1, infoDao.getAll().size());
}
@Test
@ElasticsearchIndex(
indexName = "histogram_facet",
mappings = {
@ElasticsearchMapping(
typeName = "document",
properties = {
@ElasticsearchMappingField(
name = "quantity",
store = ElasticsearchMappingField.Store.Yes,
type = ElasticsearchMappingField.Types.Integer)
})
})
public void testQuery() {
String query =
"{\n"
+ " \"query\" : {\n"
+ " \"match_all\" : {}\n"
+ " },\n"
+ " \"facets\" : {\n"
+ " \"histo1\" : {\n"
+ " \"histogram\" : {\n"
+ " \"field\" : \"quantity\",\n"
+ " \"interval\" : 100\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ "}";
try {
for (int i = 0; i < 2; i++) {
Index index =
new Index.Builder("{\"quantity\":\"910\"}")
.index("histogram_facet")
.type("document")
.build();
index.addParameter(Parameters.REFRESH, true);
client.execute(index);
}
Index index =
new Index.Builder("{\"quantity\":\"800\"}")
.index("histogram_facet")
.type("document")
.build();
index.addParameter(Parameters.REFRESH, true);
client.execute(index);
index =
new Index.Builder("{\"quantity\":\"1110\"}")
.index("histogram_facet")
.type("document")
.build();
index.addParameter(Parameters.REFRESH, true);
client.execute(index);
Search search =
(Search)
new Search.Builder(query)
.addIndexName("histogram_facet")
.addIndexType("document")
.build();
JestResult result = client.execute(search);
List<HistogramFacet> histogramFacets = result.getFacets(HistogramFacet.class);
assertEquals(1, histogramFacets.size());
HistogramFacet histogramFacetFirst = histogramFacets.get(0);
assertEquals("histo1", histogramFacetFirst.getName());
List<HistogramFacet.Histogram> histograms = histogramFacetFirst.getHistograms();
assertEquals(3, histograms.size());
assertTrue(1L == histograms.get(0).getCount());
assertTrue(800L == histograms.get(0).getKey());
assertTrue(2L == histograms.get(1).getCount());
assertTrue(900L == histograms.get(1).getKey());
assertTrue(1L == histograms.get(2).getCount());
assertTrue(1100L == histograms.get(2).getKey());
} catch (Exception e) {
fail("Failed during facet tests " + e.getMessage());
}
}
@Test
public void insertEventsFromMultipleStreams() {
try {
// save stream defn 1
cassandraConnector.saveStreamDefinitionToStore(getCluster(), streamDefinition1);
// save stream defn 3
cassandraConnector.saveStreamDefinitionToStore(getCluster(), streamDefinition3);
} catch (StreamDefinitionStoreException e) {
e.printStackTrace();
fail();
}
List<Event> eventList = new ArrayList<Event>();
// retrieve stream id 1
eventList.addAll(
EventConverterUtils.convertFromJson(
CassandraTestConstants.multipleProperEvent1, streamDefinition1.getStreamId()));
// retrieve stream id 3
eventList.addAll(
EventConverterUtils.convertFromJson(
CassandraTestConstants.multipleProperEvent3, streamDefinition3.getStreamId()));
Map<String, Event> insertedEvents = new HashMap<String, Event>();
int eventCounter = 0;
for (Event event : eventList) {
try {
String rowKey = insertEvent(cluster, event, eventCounter++);
// inserts row key only if event is valid, i.e. only proper events will add a row key
insertedEvents.put(rowKey, event);
} catch (Exception e) {
e.printStackTrace();
}
}
assertEquals(4, insertedEvents.size());
Map<String, Event> retrievedEvents = new HashMap<String, Event>();
for (Map.Entry<String, Event> eventProps : insertedEvents.entrySet()) {
try {
retrievedEvents.put(
eventProps.getKey(),
getEvent(cluster, eventProps.getValue().getStreamId(), eventProps.getKey()));
} catch (EventProcessingException e) {
e.printStackTrace();
fail();
}
}
for (Map.Entry<String, Event> rowKeyAndEvent : retrievedEvents.entrySet()) {
Event retrievedEvent = rowKeyAndEvent.getValue();
Event originialEvent = insertedEvents.get(rowKeyAndEvent.getKey());
System.out.println(
"Retrieved Event : " + retrievedEvent + "\n Original Event : " + originialEvent + "\n\n");
if (streamDefinition1.getStreamId().equals(originialEvent.getStreamId())) {
assertTrue(DataBridgeUtils.equals(originialEvent, retrievedEvent, streamDefinition1));
} else if (streamDefinition2.getStreamId().equals(originialEvent.getStreamId())) {
assertTrue(DataBridgeUtils.equals(originialEvent, retrievedEvent, streamDefinition3));
}
}
}
