@Test public void getPersonalNamespaces_withForceListAll() throws Exception { when(storeConfig.subscribedFoldersOnly()).thenReturn(true); ImapConnection imapConnection = mock(ImapConnection.class); List<ImapResponse> imapResponses = Arrays.asList( createImapResponse("* LIST (\\HasNoChildren) \".\" \"INBOX\""), createImapResponse("* LIST (\\Noselect \\HasChildren) \".\" \"Folder\""), createImapResponse("* LIST (\\HasNoChildren) \".\" \"Folder.SubFolder\""), createImapResponse("6 OK Success") ); when(imapConnection.executeSimpleCommand("LIST \"\" \"*\"")).thenReturn(imapResponses); imapStore.enqueueImapConnection(imapConnection); List<? extends Folder> result = imapStore.getFolders(true); assertNotNull(result); assertEquals(Sets.newSet("INBOX", "Folder.SubFolder"), extractFolderIds(result)); }
@Test public void getPersonalNamespaces_withoutForceListAllAndWithoutSubscribedFoldersOnly() throws Exception { when(storeConfig.subscribedFoldersOnly()).thenReturn(false); ImapConnection imapConnection = mock(ImapConnection.class); List<ImapResponse> imapResponses = Arrays.asList( createImapResponse("* LIST (\\HasNoChildren) \".\" \"INBOX\""), createImapResponse("* LIST (\\Noselect \\HasChildren) \".\" \"Folder\""), createImapResponse("* LIST (\\HasNoChildren) \".\" \"Folder.SubFolder\""), createImapResponse("6 OK Success") ); when(imapConnection.executeSimpleCommand("LIST \"\" \"*\"")).thenReturn(imapResponses); imapStore.enqueueImapConnection(imapConnection); List<? extends Folder> result = imapStore.getFolders(false); assertNotNull(result); assertEquals(Sets.newSet("INBOX", "Folder.SubFolder"), extractFolderIds(result)); }
public void testVariousPartitionSizes() throws Exception { for (int shards = 1; shards <= 4; shards++) { for (int partitionSize = 1; partitionSize < shards; partitionSize++) { String index = "index_" + shards + "_" + partitionSize; client().admin().indices().prepareCreate(index) .setSettings(Settings.builder() .put("index.number_of_shards", shards) .put("index.routing_partition_size", partitionSize)) .addMapping("type", "{\"type\":{\"_routing\":{\"required\":true}}}", XContentType.JSON) .execute().actionGet(); ensureGreen(); Map<String, Set<String>> routingToDocumentIds = generateRoutedDocumentIds(index); verifyGets(index, routingToDocumentIds); verifyBroadSearches(index, routingToDocumentIds, shards); verifyRoutedSearches(index, routingToDocumentIds, Sets.newSet(partitionSize)); } } }
@Test public void testParse_tutorCorrectlyFormed() { JsonObject mockObject = formMockJson(); ParsedULCResponse response = DataParse.parse(mockObject); // Verify correctly formed Tutor Tutor tutor = response.getTutors().get(0); assertThat(tutor.getId(), is(4850785)); assertThat(tutor.getFirstName(), is("Luke")); assertThat(tutor.getLastName(), is("Skywalker")); assertThat(tutor.getTutorPreferences().getCoursePreferences().get(Rank.PREFER).stream().map(Course::getId).collect(Collectors.toSet()), is(Sets.newSet(11995, 11996))); assertThat(tutor.getTutorPreferences().getCoursePreferences().get(Rank.WILLING).stream().map(Course::getId).collect(Collectors.toSet()), is(Sets.newSet(2749, 2750, 11991, 15599, 15600, 15602, 15606))); assertThat(tutor.getTutorPreferences().getShiftPreferences().get(Rank.PREFER).stream().map(Shift::getId).collect(Collectors.toSet()), is(Sets.newSet(5))); assertThat(tutor.getTutorPreferences().getShiftPreferences().get(Rank.WILLING).stream().map(Shift::getId).collect(Collectors.toSet()), is(Sets.newSet(1, 2))); assertThat(tutor.getTutorPreferences().getShiftFrequencyPreferences().get(Rank.PREFER), is(1)); assertThat(tutor.getTutorPreferences().getShiftFrequencyPreferences().get(Rank.WILLING), is(3)); assertThat(tutor.getTutorStatus(), is(TutorStatus.ACTIVE)); }
@Test public void testAssertConsentDto_Fail_With_To_Ind_To_Org_From_Ind_From_Org() { thrown.expect(IllegalArgumentException.class); // To Org Set<String> mockOrganizationalProvidersDisclosureIsMadeTo = Sets .newSet("mockOrganizationalProvidersDisclosureIsMadeTo"); // To Ind Set<String> mockProvidersDisclosureIsMadeTo = Sets .newSet("mockProvidersDisclosureIsMadeTo"); // From Org Set<String> mockOrganizationalProvidersPermittedToDisclose = Sets .newSet("mockOrganizationalProvidersPermittedToDisclose"); // From Ind Set<String> mockProvidersPermittedToDisclose = Sets .newSet("mockProvidersPermittedToDisclose"); ConsentDto mockConsentDto = new ConsentDto(); mockConsentDto .setOrganizationalProvidersDisclosureIsMadeTo(mockOrganizationalProvidersDisclosureIsMadeTo); mockConsentDto .setProvidersDisclosureIsMadeTo(mockProvidersDisclosureIsMadeTo); mockConsentDto .setOrganizationalProvidersPermittedToDisclose(mockOrganizationalProvidersPermittedToDisclose); mockConsentDto .setProvidersPermittedToDisclose(mockProvidersPermittedToDisclose); sut.assertConsentDto(mockConsentDto); }
@Test public void testAssertConsentDto_Fail_With_To_Org_From_Ind_From_Org() { thrown.expect(IllegalArgumentException.class); // To Org Set<String> mockOrganizationalProvidersDisclosureIsMadeTo = Sets .newSet("mockOrganizationalProvidersDisclosureIsMadeTo"); // From Org Set<String> mockOrganizationalProvidersPermittedToDisclose = Sets .newSet("mockOrganizationalProvidersPermittedToDisclose"); // From Ind Set<String> mockProvidersPermittedToDisclose = Sets .newSet("mockProvidersPermittedToDisclose"); ConsentDto mockConsentDto = new ConsentDto(); mockConsentDto .setOrganizationalProvidersDisclosureIsMadeTo(mockOrganizationalProvidersDisclosureIsMadeTo); mockConsentDto .setOrganizationalProvidersPermittedToDisclose(mockOrganizationalProvidersPermittedToDisclose); mockConsentDto .setProvidersPermittedToDisclose(mockProvidersPermittedToDisclose); sut.assertConsentDto(mockConsentDto); }
@Test public void testAssertConsentDto_Fail_With_To_Ind_From_Ind_From_Org() { thrown.expect(IllegalArgumentException.class); // To Ind Set<String> mockProvidersDisclosureIsMadeTo = Sets .newSet("mockProvidersDisclosureIsMadeTo"); // From Org Set<String> mockOrganizationalProvidersPermittedToDisclose = Sets .newSet("mockOrganizationalProvidersPermittedToDisclose"); // From Ind Set<String> mockProvidersPermittedToDisclose = Sets .newSet("mockProvidersPermittedToDisclose"); ConsentDto mockConsentDto = new ConsentDto(); mockConsentDto .setProvidersDisclosureIsMadeTo(mockProvidersDisclosureIsMadeTo); mockConsentDto .setOrganizationalProvidersPermittedToDisclose(mockOrganizationalProvidersPermittedToDisclose); mockConsentDto .setProvidersPermittedToDisclose(mockProvidersPermittedToDisclose); sut.assertConsentDto(mockConsentDto); }
@Test public void testAssertConsentDto_Fail_With_To_Ind_To_Org_From_Org() { thrown.expect(IllegalArgumentException.class); // To Org Set<String> mockOrganizationalProvidersDisclosureIsMadeTo = Sets .newSet("mockOrganizationalProvidersDisclosureIsMadeTo"); // To Ind Set<String> mockProvidersDisclosureIsMadeTo = Sets .newSet("mockProvidersDisclosureIsMadeTo"); // From Org Set<String> mockOrganizationalProvidersPermittedToDisclose = Sets .newSet("mockOrganizationalProvidersPermittedToDisclose"); ConsentDto mockConsentDto = new ConsentDto(); mockConsentDto .setOrganizationalProvidersDisclosureIsMadeTo(mockOrganizationalProvidersDisclosureIsMadeTo); mockConsentDto .setProvidersDisclosureIsMadeTo(mockProvidersDisclosureIsMadeTo); mockConsentDto .setOrganizationalProvidersPermittedToDisclose(mockOrganizationalProvidersPermittedToDisclose); sut.assertConsentDto(mockConsentDto); }
@Test public void testAssertConsentDto_Fail_With_To_Ind_To_Org_From_Ind() { thrown.expect(IllegalArgumentException.class); // To Org Set<String> mockOrganizationalProvidersDisclosureIsMadeTo = Sets .newSet("mockOrganizationalProvidersDisclosureIsMadeTo"); // To Ind Set<String> mockProvidersDisclosureIsMadeTo = Sets .newSet("mockProvidersDisclosureIsMadeTo"); // From Ind Set<String> mockProvidersPermittedToDisclose = Sets .newSet("mockProvidersPermittedToDisclose"); ConsentDto mockConsentDto = new ConsentDto(); mockConsentDto .setOrganizationalProvidersDisclosureIsMadeTo(mockOrganizationalProvidersDisclosureIsMadeTo); mockConsentDto .setProvidersDisclosureIsMadeTo(mockProvidersDisclosureIsMadeTo); mockConsentDto .setProvidersPermittedToDisclose(mockProvidersPermittedToDisclose); sut.assertConsentDto(mockConsentDto); }
@Test public void testAssertConsentDto_Success_With_To_Ind_From_Org() { // To Ind Set<String> mockProvidersDisclosureIsMadeTo = Sets .newSet("mockProvidersDisclosureIsMadeTo"); // From Org Set<String> mockOrganizationalProvidersPermittedToDisclose = Sets .newSet("mockOrganizationalProvidersPermittedToDisclose"); ConsentDto mockConsentDto = new ConsentDto(); mockConsentDto .setProvidersDisclosureIsMadeTo(mockProvidersDisclosureIsMadeTo); mockConsentDto .setOrganizationalProvidersPermittedToDisclose(mockOrganizationalProvidersPermittedToDisclose); sut.assertConsentDto(mockConsentDto); }
@Test public void testAssertConsentDto_Success_With_To_Org_From_Org() { // To Org Set<String> mockOrganizationalProvidersDisclosureIsMadeTo = Sets .newSet("mockOrganizationalProvidersDisclosureIsMadeTo"); // From Org Set<String> mockOrganizationalProvidersPermittedToDisclose = Sets .newSet("mockOrganizationalProvidersPermittedToDisclose"); ConsentDto mockConsentDto = new ConsentDto(); mockConsentDto .setOrganizationalProvidersDisclosureIsMadeTo(mockOrganizationalProvidersDisclosureIsMadeTo); mockConsentDto .setOrganizationalProvidersPermittedToDisclose(mockOrganizationalProvidersPermittedToDisclose); sut.assertConsentDto(mockConsentDto); }
@Test public void testAssertConsentDto_Success_With_To_Ind_From_Ind() { // To Ind Set<String> mockProvidersDisclosureIsMadeTo = Sets .newSet("mockProvidersDisclosureIsMadeTo"); // From Ind Set<String> mockProvidersPermittedToDisclose = Sets .newSet("mockProvidersPermittedToDisclose"); ConsentDto mockConsentDto = new ConsentDto(); mockConsentDto .setProvidersDisclosureIsMadeTo(mockProvidersDisclosureIsMadeTo); mockConsentDto .setProvidersPermittedToDisclose(mockProvidersPermittedToDisclose); sut.assertConsentDto(mockConsentDto); }
@Test public void getPersonalNamespaces_withForceListAll() throws Exception { when(storeConfig.subscribedFoldersOnly()).thenReturn(true); ImapConnection imapConnection = mock(ImapConnection.class); List<ImapResponse> imapResponses = Arrays.asList( createImapResponse("* LIST (\\HasNoChildren) \".\" \"INBOX\""), createImapResponse("* LIST (\\Noselect \\HasChildren) \".\" \"Folder\""), createImapResponse("* LIST (\\HasNoChildren) \".\" \"Folder.SubFolder\""), createImapResponse("6 OK Success") ); when(imapConnection.executeSimpleCommand("LIST \"\" \"*\"")).thenReturn(imapResponses); imapStore.enqueueImapConnection(imapConnection); List<? extends Folder> result = imapStore.getPersonalNamespaces(true); assertNotNull(result); assertEquals(Sets.newSet("INBOX", "Folder.SubFolder"), extractFolderNames(result)); }
@Test public void getPersonalNamespaces_withoutForceListAllAndWithoutSubscribedFoldersOnly() throws Exception { when(storeConfig.subscribedFoldersOnly()).thenReturn(false); ImapConnection imapConnection = mock(ImapConnection.class); List<ImapResponse> imapResponses = Arrays.asList( createImapResponse("* LIST (\\HasNoChildren) \".\" \"INBOX\""), createImapResponse("* LIST (\\Noselect \\HasChildren) \".\" \"Folder\""), createImapResponse("* LIST (\\HasNoChildren) \".\" \"Folder.SubFolder\""), createImapResponse("6 OK Success") ); when(imapConnection.executeSimpleCommand("LIST \"\" \"*\"")).thenReturn(imapResponses); imapStore.enqueueImapConnection(imapConnection); List<? extends Folder> result = imapStore.getPersonalNamespaces(false); assertNotNull(result); assertEquals(Sets.newSet("INBOX", "Folder.SubFolder"), extractFolderNames(result)); }
@Test public void test_should_find_signaling_messages_and_areas_for_geofencing_request_ids_and_event_type() throws Exception { // Given Area area = createArea("areaId1"); Message message = createMessage(context, "messageId1", "campaigId1", true, area); // When Map<Message, List<Area>> messageAreas = GeoReportHelper.findSignalingMessagesAndAreas(context, geoStore, Sets.newSet("areaId1"), GeoEventType.entry); // Then // internalData is String, so has to be compared as JSON separately assertJEquals(message, messageAreas.keySet().iterator().next(), "internalData"); JSONAssert.assertEquals(message.getInternalData(), messageAreas.keySet().iterator().next().getInternalData(), true); assertJEquals(area, messageAreas.values().iterator().next().get(0)); }
@Test public void test_should_filter_reports_for_inactive_campaigns() throws Exception { // Given Area area = createArea("areaId"); EventReportResponse reportResponse = new EventReportResponse(); reportResponse.setFinishedCampaignIds(Sets.newSet("campaignId1")); reportResponse.setSuspendedCampaignIds(Sets.newSet("campaignId2")); createMessage(context, "signalingMessageId1", "campaignId1", true, area); createMessage(context, "signalingMessageId2", "campaignId2", true, area); createMessage(context, "signalingMessageId3", "campaignId3", true, area); GeoReportingResult geoReportingResult = new GeoReportingResult(reportResponse); List<GeoReport> reports = Arrays.asList( createReport(context, "signalingMessageId1", "campaignId1", "sdkMessageId1", false, area), createReport(context, "signalingMessageId2", "campaignId2", "sdkMessageId2", false, area), createReport(context, "signalingMessageId3", "campaignId3", "sdkMessageId3", false, area)); // When List<GeoReport> filtered = GeoReportHelper.filterOutNonActiveReports(context, reports, geoReportingResult); // Then assertJEquals(reports.get(2), filtered.get(0)); }
@Test public void test_should_update_list_of_inactive_campaigns_based_on_report_result() { // Given EventReportResponse reportResponse = new EventReportResponse(); reportResponse.setSuspendedCampaignIds(Sets.newSet("campaignId1")); reportResponse.setFinishedCampaignIds(Sets.newSet("campaignId2")); // When Set<String> ids = GeoReportHelper.getAndUpdateInactiveCampaigns(context, new GeoReportingResult(reportResponse)); // Then assertTrue(GeofencingHelper.getSuspendedCampaignIds(context).contains("campaignId1")); assertTrue(ids.contains("campaignId1")); assertTrue(GeofencingHelper.getFinishedCampaignIds(context).contains("campaignId2")); assertTrue(ids.contains("campaignId2")); }
@Test public void testConvert() { Date date = new Date(12345L); BeamSqlPrimitive stringPrimitive = BeamSqlPrimitive.of(SqlTypeName.VARCHAR, "hello"); BeamSqlPrimitive datePrimitive = BeamSqlPrimitive.of(SqlTypeName.DATE, date); ReinterpretConversion mockConversion = mock(ReinterpretConversion.class); doReturn(Sets.newSet(SqlTypeName.VARCHAR)).when(mockConversion).from(); doReturn(SqlTypeName.DATE).when(mockConversion).to(); doReturn(datePrimitive).when(mockConversion).convert(same(stringPrimitive)); Reinterpreter reinterpreter = Reinterpreter.builder().withConversion(mockConversion).build(); BeamSqlPrimitive converted = reinterpreter.convert(SqlTypeName.DATE, stringPrimitive); assertSame(datePrimitive, converted); verify(mockConversion).convert(same(stringPrimitive)); }
@Test public void testAddressAdded() throws InterruptedException { TestBroker br1 = deployBroker(POOLED_INMEMORY); scheduler.addressesChanged(Collections.singletonMap(POOLED_INMEMORY, Sets.newSet(createQueue("queue1", true, false), createQueue("queue2", true, false)))); waitForAddresses(br1, 2); assertThat(br1.getQueueNames(), hasItem("queue1")); assertThat(br1.getQueueNames(), hasItem("queue2")); scheduler.addressesChanged(Collections.singletonMap(POOLED_INMEMORY, Sets.newSet(createQueue("queue1", true, false), createQueue("queue2", true, false), createQueue("queue3", true, false)))); waitForAddresses(br1, 3); assertThat(br1.getQueueNames(), hasItem("queue1")); assertThat(br1.getQueueNames(), hasItem("queue2")); assertThat(br1.getQueueNames(), hasItem("queue3")); }
@Test public void testGroupDeleted() throws InterruptedException { TestBroker br1 = deployBroker(POOLED_INMEMORY); TestBroker br2 = deployBroker(POOLED_PERSISTED); scheduler.addressesChanged(createMap(POOLED_INMEMORY, POOLED_PERSISTED, createQueue("queue1", true, false), createQueue("queue2", true, true))); waitForAddresses(br1, 1); waitForAddresses(br2, 1); assertThat(br1.getQueueNames(), hasItem("queue1")); assertThat(br2.getQueueNames(), hasItem("queue2")); scheduler.addressesChanged(Collections.singletonMap(POOLED_PERSISTED, Sets.newSet(createQueue("queue2", true, true)))); waitForAddresses(br1, 1); waitForAddresses(br2, 1); assertThat(br1.getQueueNames(), hasItem("queue1")); assertThat(br2.getQueueNames(), hasItem("queue2")); }
@Test public void testClientUpdatesListener() throws Exception { assertNull(listener.addressMap); client.resourcesUpdated(Sets.newSet( createAddress("queue1", StandardType.QUEUE, "pooled-inmemory"), createAddress("queue2", StandardType.QUEUE, "pooled-inmemory"), createAddress("queue3", StandardType.QUEUE, "inmemory"), createAddress("direct1", StandardType.ANYCAST, "standard"))); assertNotNull(listener.addressMap); assertThat(listener.addressMap.size(), is(2)); assertNotNull(listener.addressMap.get("pooled-inmemory")); assertNotNull(listener.addressMap.get("queue3")); assertThat(listener.addressMap.get("pooled-inmemory"), hasItem("queue1")); assertThat(listener.addressMap.get("pooled-inmemory"), hasItem("queue2")); assertThat(listener.addressMap.get("queue3"), hasItem("queue3")); }
@Test public void testNodesAreRetained() throws Exception { Address queue = createAddress("myqueue", StandardType.QUEUE); KubernetesList resources = new KubernetesList(); resources.setItems(Arrays.asList(new ConfigMap())); AddressCluster existing = new AddressCluster(queue.getAddress(), resources); when(mockHelper.listClusters()).thenReturn(Collections.singletonList(existing)); Address newQueue = createAddress("newqueue", StandardType.QUEUE); AddressCluster newCluster = new AddressCluster(newQueue.getAddress(), resources); when(mockGenerator.generateCluster("newqueue", Collections.singleton(newQueue))).thenReturn(newCluster); ArgumentCaptor<Set<io.enmasse.address.model.Address>> arg = ArgumentCaptor.forClass(Set.class); controller.resourcesUpdated(Sets.newSet(queue, newQueue)); verify(mockGenerator).generateCluster(anyString(), arg.capture()); assertThat(arg.getValue(), is(Sets.newSet(newQueue))); verify(mockHelper).create(resources); }
@Test public void testAddressesAreGrouped() throws Exception { Address addr0 = createAddress("myqueue0", StandardType.QUEUE); Address addr1 = createAddress("myqueue1", StandardType.QUEUE, "pooled-inmemory"); Address addr2 = createAddress("myqueue2", StandardType.QUEUE, "pooled-inmemory"); Address addr3 = createAddress("myqueue3", StandardType.QUEUE); KubernetesList resources = new KubernetesList(); resources.setItems(Arrays.asList(new ConfigMap())); AddressCluster existing = new AddressCluster("myqueue0", resources); when(mockHelper.listClusters()).thenReturn(Collections.singletonList(existing)); ArgumentCaptor<Set<io.enmasse.address.model.Address>> arg = ArgumentCaptor.forClass(Set.class); when(mockGenerator.generateCluster(anyString(), arg.capture())).thenReturn(new AddressCluster("foo", resources)); controller.resourcesUpdated(Sets.newSet(addr0, addr1, addr2, addr3)); Set<io.enmasse.address.model.Address> generated = arg.getAllValues().stream().flatMap(Collection::stream).collect(Collectors.toSet()); assertThat(generated.size(), is(3)); }
@Test public void testAddressesAreNotRecreated() throws Exception { Address address = createAddress("addr1", StandardType.ANYCAST); Address newAddress = createAddress("addr2", StandardType.ANYCAST); KubernetesList resources = new KubernetesList(); when(mockGenerator.generateCluster(eq("addr1"), anySet())).thenReturn(new AddressCluster("addr1", resources)); when(mockGenerator.generateCluster(eq("addr2"), anySet())).thenReturn(new AddressCluster("addr2", resources)); doThrow(new KubernetesClientException("Unable to replace resource")).when(mockApi).replaceAddress(address); try { controller.resourcesUpdated(Sets.newSet(address, newAddress)); ArgumentCaptor<Address> addressArgumentCaptor = ArgumentCaptor.forClass(Address.class); verify(mockApi, times(2)).replaceAddress(addressArgumentCaptor.capture()); List<Address> replaced = addressArgumentCaptor.getAllValues(); assertThat(replaced, hasItem(newAddress)); } catch (KubernetesClientException e) { fail("Should not throw exception with multiple items"); } }
@Test public void testController(TestContext context) throws Exception { EventLogger testLogger = mock(EventLogger.class); Controller controller = new Controller(client, testApi, kubernetes, (a) -> new NoneAuthenticationServiceResolver("localhost", 1234), testLogger, null); vertx.deployVerticle(controller, context.asyncAssertSuccess()); AddressSpace a1 = new AddressSpace.Builder() .setName("myspace") .setType(new StandardAddressSpaceType()) .setStatus(new Status(false)) .build(); AddressSpace a2 = new AddressSpace.Builder() .setName("myspace") .setType(new BrokeredAddressSpaceType()) .setStatus(new Status(false)) .build(); controller.resourcesUpdated(Sets.newSet(a1, a2)); for (AddressSpace space : testApi.listAddressSpaces()) { assertTrue(space.getStatus().isReady()); } }
@Test public void testAddAddressSpace() { manager.resourcesUpdated(Sets.newSet(createAddressSpace("a1", AuthenticationServiceType.NONE))); assertTrue(realms.isEmpty()); manager.resourcesUpdated(Sets.newSet(createAddressSpace("a1", AuthenticationServiceType.NONE), createAddressSpace("a2", AuthenticationServiceType.STANDARD))); assertTrue(realms.contains("a2")); manager.resourcesUpdated(Sets.newSet(createAddressSpace("a2", AuthenticationServiceType.STANDARD), createAddressSpace("a3", AuthenticationServiceType.STANDARD))); assertTrue(realms.contains("a2")); assertTrue(realms.contains("a3")); assertEquals(2, realms.size()); assertTrue(realmAdminUsers.get("a2").length() > 0); assertTrue(realmAdminUsers.get("a3").length() > 0); }
@Test public void testSerializeAddressList() throws IOException { Address addr1 = new Address.Builder() .setName("addr1") .setAddressSpace("a1") .setType(new AddressType("queue")) .setPlan(new Plan("myplan")) .build(); Address addr2 = new Address.Builder() .setName("a2") .setAddressSpace("a1") .setAddress("addr2") .setType(new AddressType("anycast")) .setPlan(new Plan("myplan")) .build(); AddressList list = new AddressList(Sets.newSet(addr1, addr2)); String serialized = CodecV1.getMapper().writeValueAsString(list); List<Address> deserialized = CodecV1.getMapper().readValue(serialized, AddressList.class); assertThat(deserialized, is(list)); }
@Test public void shouldValidateComponentTypesAndReturnTrueWhenIdentifiersAndPropertiesHaveClasses() { // Given final SchemaElementDefinition elementDef = mock(SchemaElementDefinition.class); final SchemaElementDefinitionValidator validator = new SchemaElementDefinitionValidator(); given(elementDef.getIdentifiers()).willReturn(Sets.newSet(IdentifierType.DESTINATION, IdentifierType.SOURCE)); given(elementDef.getProperties()).willReturn(Sets.newSet(TestPropertyNames.PROP_1, TestPropertyNames.PROP_2)); given(elementDef.getIdentifierClass(IdentifierType.DESTINATION)).willReturn((Class) Double.class); given(elementDef.getIdentifierClass(IdentifierType.SOURCE)).willReturn((Class) Long.class); given(elementDef.getPropertyClass(TestPropertyNames.PROP_1)).willReturn((Class) Integer.class); given(elementDef.getPropertyClass(TestPropertyNames.PROP_2)).willReturn((Class) String.class); // When final ValidationResult result = validator.validateComponentTypes(elementDef); // Then assertTrue(result.isValid()); }
@Test public void shouldValidateComponentTypesAndReturnFalseForInvalidPropertyClass() { // Given final SchemaElementDefinition elementDef = mock(SchemaElementDefinition.class); final SchemaElementDefinitionValidator validator = new SchemaElementDefinitionValidator(); given(elementDef.getIdentifiers()).willReturn(new HashSet<>()); given(elementDef.getProperties()).willReturn(Sets.newSet(TestPropertyNames.PROP_1)); given(elementDef.getPropertyClass(TestPropertyNames.PROP_1)).willThrow(new IllegalArgumentException()); // When final ValidationResult result = validator.validateComponentTypes(elementDef); // Then assertFalse(result.isValid()); assertEquals("Validation errors: \nClass null for property property1 could not be found", result.getErrorString()); }
@Test public void shouldValidateAndReturnFalseWhenAggregatorProvidedWithNoProperties() { // Given final SchemaElementDefinitionValidator validator = new SchemaElementDefinitionValidator(); final BinaryOperator<Integer> function1 = mock(BinaryOperator.class); final Schema schema = new Schema.Builder() .entity(TestGroups.ENTITY, new SchemaEntityDefinition.Builder() .vertex("id") .aggregator(new ElementAggregator.Builder() .select(IdentifierType.VERTEX.name()) .execute(function1) .build()) .build()) .type("id", new TypeDefinition.Builder() .clazz(String.class) .build()) .build(); // When final ValidationResult result = validator.validate(schema.getElement(TestGroups.ENTITY)); // Then assertFalse(result.isValid()); assertEquals(com.google.common.collect.Sets.newHashSet("Groups with no properties should not have any aggregators"), result.getErrors()); }
@Test public void testHashBaseForItemCorePropertiesPreservesNullsLiterally() throws NoSuchAlgorithmException, IOException, ServerOverloadException { final ItemData item = new ItemData(); item.setTypeId(TypeIfc.FILL_IN_BLANK); // have to explicitly initialize this collection, else NPE in getText() final ItemText itemText = new ItemText(item, 1L, null, null); item.setItemTextSet(Sets.newSet(itemText)); final StringBuilder expectedHashBase = new StringBuilder("TypeId:"+TypeIfc.FILL_IN_BLANK + "::") .append("ItemText:null::"); //.append("null") //.append("null") //.append("null") //.append("null") //.append("null") final StringBuilder actualHashBase = new StringBuilder(); itemHashUtil.hashBaseForItemCoreProperties(item, actualHashBase); assertThat(actualHashBase.toString(), equalTo(expectedHashBase.toString())); }
@Test public void testHashBaseForItemAnswersPreservesNullsLiterally() throws IOException, NoSuchAlgorithmException, ServerOverloadException { final ItemData item = new ItemData(); item.setTypeId(TypeIfc.FILL_IN_BLANK); // sequence, at least, is required, else ordering is completely non-deterministic final Pair<Answer,String> answer1 = answerAndExpectedHashBaseFor(item, 1L, null, null, null, null, null, null); final Pair<Answer,String> answer2 = answerAndExpectedHashBaseFor(item, 2L, null, null, null, null, null, null); final ItemText itemText1 = new ItemText(item, 1L, null, Sets.newSet(answerFrom(answer1), answerFrom(answer2))); answerFrom(answer1).setItemText(itemText1); answerFrom(answer2).setItemText(itemText1); item.setItemTextSet(Sets.newSet(itemText1)); final StringBuilder expectedHashBase = new StringBuilder() .append(stringFrom(answer1)) .append(stringFrom(answer2)); final StringBuilder actualHashBase = new StringBuilder(); itemHashUtil.hashBaseForItemAnswers(item, actualHashBase); assertThat(actualHashBase.toString(), equalTo(expectedHashBase.toString())); }
@Test public void testHashBaseForItemAttachmentsSkipSingleMissingResources() throws IOException, IdUnusedException, PermissionException, TypeException, ServerOverloadException, NoSuchAlgorithmException { final ItemData item = new ItemData(); item.setTypeId(TypeIfc.FILL_IN_BLANK); final ItemAttachment attachment1 = new ItemAttachment(1L, item, idForContentResource(CONTENT_RESOURCES[0]), CONTENT_RESOURCES[0][CR_NAME_IDX], null, Long.MAX_VALUE - 1, null, null, null, null, null, null, null, null); item.setItemAttachmentSet(Sets.newSet(attachment1)); expectServerUrlLookup(); failResourceLookup(CONTENT_RESOURCES[0]); final StringBuilder actualHashBase = new StringBuilder(); itemHashUtil.hashBaseForItemAttachments(item, actualHashBase); assertThat(actualHashBase.toString(), equalTo("")); }
@Test public void testHashBaseForItemAttachmentsSkipsMissingResources() throws IOException, IdUnusedException, PermissionException, TypeException, ServerOverloadException, NoSuchAlgorithmException { final ItemData item = new ItemData(); item.setTypeId(TypeIfc.FILL_IN_BLANK); final ItemAttachment attachment1 = new ItemAttachment(1L, item, idForContentResource(CONTENT_RESOURCES[0]), CONTENT_RESOURCES[0][CR_NAME_IDX], null, Long.MAX_VALUE - 1, null, null, null, null, null, null, null, null); final ItemAttachment attachment2 = new ItemAttachment(2L, item, idForContentResource(CONTENT_RESOURCES[1]), CONTENT_RESOURCES[1][CR_NAME_IDX], null, Long.MAX_VALUE, null, null, null, null, null, null, null, null); item.setItemAttachmentSet(Sets.newSet(attachment1, attachment2)); // for a straight-up attachment (as opposed to an inlined HTML doc containing question or answer text), // we hash the attachment contents, not a doc referring to the attachment. final StringBuilder expectedHashBase = new StringBuilder() .append(expectedContentResourceHash1(CONTENT_RESOURCES[0])); expectServerUrlLookup(); expectResourceLookup(CONTENT_RESOURCES[0]); failResourceLookup(CONTENT_RESOURCES[1]); final StringBuilder actualHashBase = new StringBuilder(); itemHashUtil.hashBaseForItemAttachments(item, actualHashBase); assertThat(actualHashBase.toString(), equalTo(expectedHashBase.toString())); }
@Test public void testHashBaseForItemMetadataSkipsUnimportantKeys() throws NoSuchAlgorithmException, IOException, ServerOverloadException { final ItemData item = new ItemData(); item.setTypeId(TypeIfc.FILL_IN_BLANK); final ItemMetaDataIfc metaData1 = newItemMetaData(item, ItemMetaDataIfc.RANDOMIZE, 0); final ItemMetaDataIfc metaData2 = newItemMetaData(item, ItemMetaDataIfc.OBJECTIVE, 1); // this one should be ignored final ItemMetaDataIfc metaData3 = newItemMetaData(item, ItemMetaDataIfc.REQUIRE_ALL_OK, 2); item.setItemMetaDataSet(Sets.newSet(metaData1, metaData2, metaData3)); final StringBuilder expectedHashBase = new StringBuilder() .append("RANDOMIZE:" + resourceDocTemplate1(fullUrlForContentResource(CONTENT_RESOURCES[0])) + "::") .append("REQUIRE_ALL_OK:" + resourceDocTemplate1(fullUrlForContentResource(CONTENT_RESOURCES[2]))+ "::"); // nulls for the other 14 "important" keys IntStream.rangeClosed(0, 13).forEach( i -> expectedHashBase.append("") ); final StringBuilder actualHashBase = new StringBuilder(); itemHashUtil.hashBaseForItemMetadata(item, actualHashBase); assertThat(actualHashBase.toString(), equalTo(expectedHashBase.toString())); }
@Test public void shouldReturnHasMissingComparisonValues_withConditionWhichRequiresComparisonValuesAndNullOrEmptyValues() { // Given final Set<Operators> operatorsWhichRequireNonNullOrEmptyValues = Sets.newSet(Operators.EQUALS, Operators.GREATER_THAN_OR_EQUALS, Operators.LESS_THAN_OR_EQUALS); final Operators operatorWhichRequiresNonNullOrEmptyValue = randomEnumInSet( operatorsWhichRequireNonNullOrEmptyValues); final String value = randomBoolean() ? null : ""; final Condition condition = new Condition(operatorWhichRequiresNonNullOrEmptyValue, value); // When final boolean hasMissingComparisonValues = condition.hasMissingComparisonValues(); // Then assertTrue(hasMissingComparisonValues); }
@Test public void shouldReturnDoesNotHaveMissingComparisonValues_withConditionWhichRequiresComparisonValuesAndNonNullOrEmptyValues() { // Given final Set<Operators> operatorsWhichRequireNonNullOrEmptyValues = Sets.newSet(Operators.EQUALS, Operators.GREATER_THAN_OR_EQUALS, Operators.LESS_THAN_OR_EQUALS); final Operators operatorWhichRequiresNonNullOrEmptyValue = randomEnumInSet( operatorsWhichRequireNonNullOrEmptyValues); final String value = randomString(10); final Condition condition = new Condition(operatorWhichRequiresNonNullOrEmptyValue, value); // When final boolean hasMissingComparisonValues = condition.hasMissingComparisonValues(); // Then assertFalse(hasMissingComparisonValues); }
@Test public void shouldReturnDoesNotHaveMissingComparisonValues_withConditionWhichDoesNotRequireComparisonValuesAndNullOrEmptyValues() { // Given final Set<Operators> operatorsWhichDoNotRequireNonNullOrEmptyValues = Sets.newSet(Operators.NOT_NULL, Operators.NULL); final Operators operatorWhichRequiresNonNullOrEmptyValue = randomEnumInSet( operatorsWhichDoNotRequireNonNullOrEmptyValues); final String value = randomBoolean() ? null : ""; final Condition condition = new Condition(operatorWhichRequiresNonNullOrEmptyValue, value); // When final boolean hasMissingComparisonValues = condition.hasMissingComparisonValues(); // Then assertFalse(hasMissingComparisonValues); }
@Test public void shouldReturnDoesNotHaveMissingComparisonValues_withConditionWhichDoesNotRequireComparisonValuesAndNonNullOrEmptyValues() { // Given final Set<Operators> operatorsWhichDoNotRequireNonNullOrEmptyValues = Sets.newSet(Operators.NOT_NULL, Operators.NULL); final Operators operatorWhichRequiresNonNullOrEmptyValue = randomEnumInSet( operatorsWhichDoNotRequireNonNullOrEmptyValues); final String value = randomString(); final Condition condition = new Condition(operatorWhichRequiresNonNullOrEmptyValue, value); // When final boolean hasMissingComparisonValues = condition.hasMissingComparisonValues(); // Then assertFalse(hasMissingComparisonValues); }