@Test(groups = "unit")
public void readAny() {

    List<Uri> secondaries = ImmutableList.of(Uri.create("secondary1"), Uri.create("secondary2"), Uri.create("secondary3"));
    Uri primaryAddress = Uri.create("primary");
    AddressSelectorWrapper addressSelectorWrapper = AddressSelectorWrapper.Builder.Simple.create()
            .withPrimary(primaryAddress)
            .withSecondary(secondaries)
            .build();
    StoreResponse primaryResponse = StoreResponseBuilder.create()
            .withLSN(54)
            .withLocalLSN(18)
            .withRequestCharge(1.1)
            .build();
    StoreResponse secondaryResponse1 = StoreResponseBuilder.create()
            .withLSN(53)
            .withLocalLSN(17)
            .withRequestCharge(1.1)
            .build();
    StoreResponse secondaryResponse2 = StoreResponseBuilder.create()
            .withLSN(52)
            .withLocalLSN(16)
            .withRequestCharge(1.1)
            .build();
    StoreResponse secondaryResponse3 = StoreResponseBuilder.create()
            .withLSN(51)
            .withLocalLSN(15)
            .withRequestCharge(1.1)
            .build();
    TransportClientWrapper transportClientWrapper = TransportClientWrapper.Builder.uriToResultBuilder()
            .storeResponseOn(primaryAddress, OperationType.Read, ResourceType.Document, primaryResponse, true)
            .storeResponseOn(secondaries.get(0), OperationType.Read, ResourceType.Document, secondaryResponse1, true)
            .storeResponseOn(secondaries.get(1), OperationType.Read, ResourceType.Document, secondaryResponse2, true)
            .storeResponseOn(secondaries.get(2), OperationType.Read, ResourceType.Document, secondaryResponse3, true)
            .build();
    GatewayServiceConfiguratorReaderMock gatewayServiceConfigurationReaderWrapper = GatewayServiceConfiguratorReaderMock.from(ConsistencyLevel.Strong);
    ISessionContainer sessionContainer = Mockito.mock(ISessionContainer.class);
    IAuthorizationTokenProvider authorizationTokenProvider = Mockito.mock(IAuthorizationTokenProvider.class);
    ConsistencyReaderUnderTest consistencyReader = new ConsistencyReaderUnderTest(addressSelectorWrapper.addressSelector,
                                                                                  sessionContainer,
                                                                                  transportClientWrapper.transportClient,
                                                                                  gatewayServiceConfigurationReaderWrapper.gatewayServiceConfigurationReader,
                                                                                  authorizationTokenProvider);
    RxDocumentServiceRequest request = RxDocumentServiceRequest.createFromName(
            OperationType.Read, "/dbs/db/colls/col/docs/docId", ResourceType.Document);
    request.getHeaders().put(HttpConstants.HttpHeaders.CONSISTENCY_LEVEL, ConsistencyLevel.Eventual.name());
    TimeoutHelper timeout = Mockito.mock(TimeoutHelper.class);
    boolean forceRefresh = false;
    boolean isInRetry = false;
    Single<StoreResponse> storeResponseSingle = consistencyReader.readAsync(request, timeout, isInRetry, forceRefresh);
    StoreResponseValidator validator = StoreResponseValidator.create()
            .withBELSNGreaterThanOrEqualTo(51)
            .withRequestCharge(1.1)
            .in(primaryResponse, secondaryResponse1, secondaryResponse2, secondaryResponse3)
            .build();
    validateSuccess(storeResponseSingle, validator);
    Mockito.verifyZeroInteractions(consistencyReader.getSpyQuorumReader());
    Mockito.verify(consistencyReader.getSpyStoreReader(), Mockito.times(1))
            .readMultipleReplicaAsync(Mockito.any(RxDocumentServiceRequest.class),
                                      Mockito.anyBoolean(),
                                      Mockito.anyInt(),
                                      Mockito.anyBoolean(),
                                      Mockito.anyBoolean(),
                                      Mockito.any(),
                                      Mockito.anyBoolean(),
                                      Mockito.anyBoolean());
    transportClientWrapper.validate()
            .verifyNumberOfInvocations(1);
    addressSelectorWrapper.validate()
            .verifyTotalInvocations(1)
            .verifyNumberOfForceCachRefresh(0)
            .verifyVesolvePrimaryUriAsyncCount(0)
            .verifyResolveAllUriAsync(1);
}