@Test(groups = "unit", dataProvider = "readMultipleReplicasAsyncArgProvider")
public void readMultipleReplicasAsync(boolean includePrimary, int replicaCountToRead, ReadMode readMode) {

    // This adds basic tests for StoreReader.readMultipleReplicasAsync(.) without failure
    // TODO: add some tests for readMultipleReplicasAsync which mock behaviour of failure of reading from a replica
    ISessionContainer sessionContainer = Mockito.mock(ISessionContainer.class);
    Uri primaryReplicaURI = Uri.create("primary");
    ImmutableList<Uri> secondaryReplicaURIs = ImmutableList.of(Uri.create("secondary1"), Uri.create("secondary2"), Uri.create("secondary3"));
    AddressSelectorWrapper addressSelectorWrapper = AddressSelectorWrapper.Builder.Simple.create()
            .withPrimary(primaryReplicaURI)
            .withSecondary(secondaryReplicaURIs)
            .build();
    RxDocumentServiceRequest request = RxDocumentServiceRequest.createFromName(
            OperationType.Read, "/dbs/db/colls/col/docs/docId", ResourceType.Document);
    request.requestContext = Mockito.mock(DocumentServiceRequestContext.class);
    request.requestContext.timeoutHelper = Mockito.mock(TimeoutHelper.class);
    request.requestContext.resolvedPartitionKeyRange = partitionKeyRangeWithId("12");
    request.requestContext.requestChargeTracker = new RequestChargeTracker();
    double requestChargePerRead = 1.1;
    StoreResponse primaryResponse = StoreResponseBuilder.create()
            .withLSN(51)
            .withLocalLSN(18)
            .withRequestCharge(requestChargePerRead)
            .build();
    StoreResponse secondaryResponse1 = StoreResponseBuilder.create()
            .withLSN(50)
            .withLocalLSN(17)
            .withRequestCharge(requestChargePerRead)
            .build();
    StoreResponse secondaryResponse2 = StoreResponseBuilder.create()
            .withLSN(49)
            .withLocalLSN(16)
            .withRequestCharge(requestChargePerRead)
            .build();
    StoreResponse secondaryResponse3 = StoreResponseBuilder.create()
            .withLSN(48)
            .withLocalLSN(15)
            .withRequestCharge(requestChargePerRead)
            .build();
    List<StoreResponse> responseList = ImmutableList.of(primaryResponse, secondaryResponse1, secondaryResponse2, secondaryResponse3);
    TransportClientWrapper transportClientWrapper = TransportClientWrapper.Builder.uriToResultBuilder()
            .storeResponseOn(primaryReplicaURI, OperationType.Read, ResourceType.Document, primaryResponse, false)
            .storeResponseOn(secondaryReplicaURIs.get(0), OperationType.Read, ResourceType.Document, secondaryResponse1, false)
            .storeResponseOn(secondaryReplicaURIs.get(1), OperationType.Read, ResourceType.Document, secondaryResponse2, false)
            .storeResponseOn(secondaryReplicaURIs.get(2), OperationType.Read, ResourceType.Document, secondaryResponse3, false)
            .build();
    StoreReader storeReader = new StoreReader(transportClientWrapper.transportClient, addressSelectorWrapper.addressSelector, sessionContainer);
    Single<List<StoreResult>> readResult = storeReader.readMultipleReplicaAsync(request, includePrimary, replicaCountToRead, true, true, readMode);
    long expectedMinLsn =
            responseList
                    .stream()
                    .filter(sr -> (sr != primaryResponse || includePrimary))
                    .mapToLong(sr ->
                               {
                                   String value = (ReadMode.Strong == readMode)?
                                           sr.getHeaderValue(WFConstants.BackendHeaders.LSN) :
                                           sr.getHeaderValue(WFConstants.BackendHeaders.LOCAL_LSN);
                                   return Long.parseLong(value);
                               })
                    .min().orElse(-1);
    MultiStoreResultValidator validator = MultiStoreResultValidator.create()
            .withSize(replicaCountToRead)
            .withMinimumLSN(expectedMinLsn)
            .noFailure()
            .withTotalRequestCharge(requestChargePerRead * replicaCountToRead)
            .build();
    validateSuccess(readResult, validator);
    transportClientWrapper.validate()
            .verifyNumberOfInvocations(replicaCountToRead);
    addressSelectorWrapper.validate()
            .verifyNumberOfForceCachRefresh(0)
            .verifyVesolvePrimaryUriAsyncCount(0)
            .verifyTotalInvocations(1);
}