internal Task CreateIngestQueryDeleteAsync <T>(
ConnectionModes connectionModes,
CollectionTypes collectionTypes,
IEnumerable <string> documents,
Query <T> query,
T testArgs,
string partitionKey = "/id",
Cosmos.IndexingPolicy indexingPolicy = null,
CosmosClientFactory cosmosClientFactory = null)
{
return(this.CreateIngestQueryDeleteAsync(
connectionModes,
collectionTypes,
documents,
query,
cosmosClientFactory ?? this.CreateDefaultCosmosClient,
testArgs,
partitionKey,
indexingPolicy));
}
internal Task CreateIngestQueryDeleteAsync(
ConnectionModes connectionModes,
CollectionTypes collectionTypes,
IEnumerable <string> documents,
Query query,
string partitionKey = "/id",
Cosmos.IndexingPolicy indexingPolicy = null,
CosmosClientFactory cosmosClientFactory = null)
{
Task queryWrapper(Container container, IReadOnlyList <CosmosObject> inputDocuments, object throwaway)
{
return(query(container, inputDocuments));
}
return(this.CreateIngestQueryDeleteAsync <object>(
connectionModes,
collectionTypes,
documents,
queryWrapper,
null,
partitionKey,
indexingPolicy,
cosmosClientFactory));
}
/// <summary>
/// Task that wraps boiler plate code for query tests (container create -> ingest documents -> query documents -> delete collections).
/// Note that this function will take the cross product connectionModes
/// </summary>
/// <param name="connectionModes">The connection modes to use.</param>
/// <param name="documents">The documents to ingest</param>
/// <param name="query">
/// The callback for the queries.
/// All the standard arguments will be passed in.
/// Please make sure that this function is idempotent, since a container will be reused for each connection mode.
/// </param>
/// <param name="cosmosClientFactory">
/// The callback for the create CosmosClient. This is invoked for the different ConnectionModes that the query is targeting.
/// If CosmosClient instantiated by this does not apply the expected ConnectionMode, an assert is thrown.
/// </param>
/// <param name="partitionKey">The partition key for the partition container.</param>
/// <param name="testArgs">The optional args that you want passed in to the query.</param>
/// <returns>A task to await on.</returns>
internal async Task CreateIngestQueryDeleteAsync <T>(
ConnectionModes connectionModes,
CollectionTypes collectionTypes,
IEnumerable <string> documents,
Query <T> query,
CosmosClientFactory cosmosClientFactory,
T testArgs,
string partitionKey = "/id",
Cosmos.IndexingPolicy indexingPolicy = null)
{
try
{
IList <(Container, IReadOnlyList <CosmosObject>)> collectionsAndDocuments = new List <(Container, IReadOnlyList <CosmosObject>)>();
foreach (CollectionTypes collectionType in Enum.GetValues(collectionTypes.GetType()).Cast <Enum>().Where(collectionTypes.HasFlag))
{
if (collectionType == CollectionTypes.None)
{
continue;
}
Task <(Container, IReadOnlyList <CosmosObject>)> createContainerTask = collectionType switch
{
CollectionTypes.NonPartitioned => this.CreateNonPartitionedContainerAndIngestDocumentsAsync(
documents,
indexingPolicy),
CollectionTypes.SinglePartition => this.CreateSinglePartitionContainerAndIngestDocumentsAsync(
documents,
partitionKey,
indexingPolicy),
CollectionTypes.MultiPartition => this.CreateMultiPartitionContainerAndIngestDocumentsAsync(
documents,
partitionKey,
indexingPolicy),
_ => throw new ArgumentException($"Unknown {nameof(CollectionTypes)} : {collectionType}"),
};
collectionsAndDocuments.Add(await createContainerTask);
}
List <CosmosClient> cosmosClients = new List <CosmosClient>();
foreach (ConnectionModes connectionMode in Enum.GetValues(connectionModes.GetType()).Cast <Enum>().Where(connectionModes.HasFlag))
{
if (connectionMode == ConnectionModes.None)
{
continue;
}
ConnectionMode targetConnectionMode = GetTargetConnectionMode(connectionMode);
CosmosClient cosmosClient = cosmosClientFactory(targetConnectionMode);
Assert.AreEqual(
targetConnectionMode,
cosmosClient.ClientOptions.ConnectionMode,
"Test setup: Invalid connection policy applied to CosmosClient");
cosmosClients.Add(cosmosClient);
}
List <Task> queryTasks = new List <Task>();
foreach (CosmosClient cosmosClient in cosmosClients)
{
foreach ((Container container, IReadOnlyList <CosmosObject> insertedDocuments) in collectionsAndDocuments)
{
Task queryTask = Task.Run(() => query(container, insertedDocuments, testArgs));
queryTasks.Add(queryTask);
}
}
await Task.WhenAll(queryTasks);
List <Task <ContainerResponse> > deleteContainerTasks = new List <Task <ContainerResponse> >();
foreach (Container container in collectionsAndDocuments.Select(tuple => tuple.Item1))
{
deleteContainerTasks.Add(container.DeleteContainerAsync());
}
await Task.WhenAll(deleteContainerTasks);
}
catch (Exception ex) when(ex.GetType() != typeof(AssertFailedException))
{
while (ex.InnerException != null)
{
ex = ex.InnerException;
}
ExceptionDispatchInfo.Capture(ex).Throw();
}
}
public CosmosDataStorageService(CosmosClientFactory clientFactory)
{
_clientFactory = clientFactory;
}
