Java 类org.mockito.internal.util.collections.Sets 实例源码

@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);
}