public async Task DefaultThroughputTest()
{
string containerName = Guid.NewGuid().ToString();
string partitionKeyPath = "/users";
CosmosContainerResponse containerResponse = await this.cosmosDatabase.Containers.CreateContainerIfNotExistsAsync(containerName, partitionKeyPath);
Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode);
CosmosContainer cosmosContainer = this.cosmosDatabase.Containers[containerName];
int?readThroughput = await cosmosContainer.ReadProvisionedThroughputAsync();
Assert.IsNotNull(readThroughput);
containerResponse = await cosmosContainer.DeleteAsync();
Assert.AreEqual(HttpStatusCode.NoContent, containerResponse.StatusCode);
}
public async Task <OperationResult> DeleteContainerAsync(CosmosContainer container, CancellationToken cancellationToken)
{
try
{
var c = _databaseGetter().GetContainer(container.Id);
await c.DeleteContainerAsync(new ContainerRequestOptions { IfMatchEtag = container.ETag }, cancellationToken);
return(OperationResult.Success);
}
catch (CosmosException ex) when(ex.StatusCode == HttpStatusCode.Conflict)
{
return(OperationResult.EditConflict);
}
catch (CosmosException ex) when(ex.StatusCode == HttpStatusCode.NotFound)
{
return(OperationResult.NotFound);
}
}
public async Task ChangeFeedTestInit()
{
await base.TestInit();
string PartitionKey = "/id";
ContainerResponse response = await this.database.CreateContainerAsync(
new CosmosContainerProperties(id : "monitored", partitionKeyPath : PartitionKey),
cancellationToken : this.cancellationToken);
this.Container = response;
response = await this.database.CreateContainerAsync(
new CosmosContainerProperties(id : "leases", partitionKeyPath : PartitionKey),
cancellationToken : this.cancellationToken);
this.LeaseContainer = response;
}
public async Task DeleteAsync(string entityId)
{
try
{
CosmosContainer container = GetContainer();
await container.DeleteItemAsync <T>(entityId, new PartitionKey(entityId));
}
catch (CosmosException ex)
{
_logger.LogError(ex.Message);
if (ex.Status != (int)HttpStatusCode.NotFound)
{
throw;
}
}
}
/// <summary>
/// Run a query (using Azure Cosmos DB SQL syntax) against the container
/// </summary>
private static async Task QueryItemsAsync(CosmosClient cosmosClient)
{
var sqlQueryText = "SELECT * FROM c WHERE c.LastName = 'Andersen'";
Console.WriteLine("Running query: {0}\n", sqlQueryText);
CosmosContainer container = cosmosClient.GetContainer(Program.DatabaseId, Program.ContainerId);
QueryDefinition queryDefinition = new QueryDefinition(sqlQueryText);
List <Family> families = new List <Family>();
await foreach (Family family in container.GetItemQueryIterator <Family>(queryDefinition))
{
families.Add(family);
Console.WriteLine("\tRead {0}\n", family);
}
}
private static async Task ReplaceFamilyItemAsync(CosmosClient cosmosClient)
{
CosmosContainer container = cosmosClient.GetContainer(Program.DatabaseId, Program.ContainerId);
ItemResponse <Family> wakefieldFamilyResponse = await container.ReadItemAsync <Family> ("Wakefield.7", new PartitionKey ("Wakefield"));
Family itemBody = wakefieldFamilyResponse;
// update registration status from false to true
itemBody.IsRegistered = true;
// update grade of child
itemBody.Children[0].Grade = 6;
// replace the item with the updated content
wakefieldFamilyResponse = await container.ReplaceItemAsync <Family> (itemBody, itemBody.Id, new PartitionKey (itemBody.LastName));
Console.WriteLine("Updated Family [{0},{1}].\n \tBody is now: {2}\n", itemBody.LastName, itemBody.Id, wakefieldFamilyResponse.Value);
}
public static async Task Initialize(IConfiguration configuration)
{
databaseId = configuration.GetSection("CosmosDb").GetSection("Database").Value ?? "Tasks";
containerId = configuration.GetSection("CosmosDb").GetSection("Container").Value ?? "Items";
endpoint = configuration.GetSection("CosmosDb").GetSection("Endpoint").Value;
primaryKey = configuration.GetSection("CosmosDb").GetSection("PrimaryKey").Value;
var config = new CosmosConfiguration(endpoint, primaryKey);
client = new CosmosClient(config);
CosmosDatabase database = await client.Databases.CreateDatabaseIfNotExistsAsync(databaseId);
CosmosContainer container =
await database.Containers.CreateContainerIfNotExistsAsync(containerId, "/category");
items = container.Items;
}
public async Task CosmosConflictsStreamIteratorBuildsSettings()
{
string conflictResponsePayload = @"{ 'Data':[{
id: 'Conflict1',
operationType: 'Replace',
resourceType: 'trigger'
}]}";
CosmosClient mockClient = MockCosmosUtil.CreateMockCosmosClient(
(cosmosClientBuilder) => cosmosClientBuilder.WithConnectionModeDirect());
CosmosContainer container = mockClient.GetContainer("database", "container");
FeedIterator feedIterator = container.GetConflicts().GetConflictsStreamIterator();
TestHandler testHandler = new TestHandler((request, cancellationToken) =>
{
Assert.AreEqual(OperationType.ReadFeed, request.OperationType);
Assert.AreEqual(ResourceType.Conflict, request.ResourceType);
CosmosResponseMessage handlerResponse = TestHandler.ReturnSuccess().Result;
MemoryStream stream = new MemoryStream();
StreamWriter writer = new StreamWriter(stream);
writer.Write(conflictResponsePayload);
writer.Flush();
stream.Position = 0;
handlerResponse.Content = stream;
return(Task.FromResult(handlerResponse));
});
mockClient.RequestHandler.InnerHandler = testHandler;
CosmosResponseMessage streamResponse = await feedIterator.FetchNextSetAsync();
Collection <CosmosConflictSettings> response = new CosmosJsonSerializerCore().FromStream <CosmosFeedResponseUtil <CosmosConflictSettings> >(streamResponse.Content).Data;
Assert.AreEqual(1, response.Count());
CosmosConflictSettings responseSettings = response.FirstOrDefault();
Assert.IsNotNull(responseSettings);
Assert.AreEqual("Conflict1", responseSettings.Id);
Assert.AreEqual(Cosmos.OperationKind.Replace, responseSettings.OperationKind);
Assert.AreEqual(typeof(CosmosTriggerSettings), responseSettings.ResourceType);
}
public async Task VerifyCosmosDefaultResultSetStreamIteratorOperationType()
{
CosmosClient mockClient = MockCosmosUtil.CreateMockCosmosClient(
(cosmosClientBuilder) => cosmosClientBuilder.UseConnectionModeDirect());
CosmosContainer container = mockClient.Databases["database"].Containers["container"];
CosmosSqlQueryDefinition sql = new CosmosSqlQueryDefinition("select * from r");
CosmosResultSetIterator setIterator = container.Items.CreateItemQueryAsStream(
sqlQueryDefinition: sql,
maxConcurrency: 1,
partitionKey: "pk",
requestOptions: new CosmosQueryRequestOptions());
TestHandler testHandler = new TestHandler((request, cancellationToken) => {
Assert.AreEqual(
15, //OperationType.SqlQuery
(int)request.GetType().GetProperty("OperationType", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).GetValue(request, null)
);
return(TestHandler.ReturnSuccess());
});
mockClient.RequestHandler.InnerHandler = testHandler;
CosmosQueryResponse response = await setIterator.FetchNextSetAsync();
//Test gateway mode
mockClient = MockCosmosUtil.CreateMockCosmosClient(
(cosmosClientBuilder) => cosmosClientBuilder.UseConnectionModeGateway());
container = mockClient.Databases["database"].Containers["container"];
setIterator = container.Items.CreateItemQueryAsStream(
sqlQueryDefinition: sql,
maxConcurrency: 1,
partitionKey: "pk",
requestOptions: new CosmosQueryRequestOptions());
testHandler = new TestHandler((request, cancellationToken) => {
Assert.AreEqual(
14, //OperationType.Query
(int)request.GetType().GetProperty("OperationType", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).GetValue(request, null)
);
return(TestHandler.ReturnSuccess());
});
mockClient.RequestHandler.InnerHandler = testHandler;
response = await setIterator.FetchNextSetAsync();
}
public async Task <Item> Get(string partitionKey, string id)
{
CosmosDatabase database = await client.Databases.CreateDatabaseIfNotExistsAsync(DatabaseName);
CosmosContainer container = await database.Containers.CreateContainerIfNotExistsAsync(ContainerName, PartitionKeyPath);
var query = new CosmosSqlQueryDefinition("SELECT * FROM x WHERE x.id = @id")
.UseParameter("@id", id);
List <Item> results = new List <Item>();
var resultSetIterator = container.Items.CreateItemQuery <Item>(query, partitionKey: partitionKey);
while (resultSetIterator.HasMoreResults)
{
results.AddRange((await resultSetIterator.FetchNextSetAsync()));
}
return(results.Any() ? results.ElementAt(0) : null);
}
private static async Task ItemFeed(CosmosContainer container)
{
List <Family> families = new List <Family>();
// SQL
FeedIterator <Family> setIterator = container.GetItemsIterator <Family>(maxItemCount: 1);
while (setIterator.HasMoreResults)
{
int count = 0;
foreach (Family item in await setIterator.FetchNextSetAsync())
{
Assert("Should only return 1 result at a time.", count <= 1);
families.Add(item);
}
}
Assert("Expected two families", families.ToList().Count == 2);
}
public async Task PartitionedCRUDTest()
{
string containerName = Guid.NewGuid().ToString();
string partitionKeyPath = "/users";
ContainerResponse containerResponse = await this.cosmosDatabase.CreateContainerAsync(containerName, partitionKeyPath);
Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode);
Assert.AreEqual(containerName, containerResponse.Resource.Id);
Assert.AreEqual(partitionKeyPath, containerResponse.Resource.PartitionKey.Paths.First());
CosmosContainerSettings settings = new CosmosContainerSettings(containerName, partitionKeyPath)
{
IndexingPolicy = new Cosmos.IndexingPolicy()
{
IndexingMode = Cosmos.IndexingMode.None,
Automatic = false
}
};
CosmosContainer cosmosContainer = containerResponse;
containerResponse = await cosmosContainer.ReplaceAsync(settings);
Assert.AreEqual(HttpStatusCode.OK, containerResponse.StatusCode);
Assert.AreEqual(containerName, containerResponse.Resource.Id);
Assert.AreEqual(partitionKeyPath, containerResponse.Resource.PartitionKey.Paths.First());
Assert.AreEqual(Cosmos.IndexingMode.None, containerResponse.Resource.IndexingPolicy.IndexingMode);
Assert.IsFalse(containerResponse.Resource.IndexingPolicy.Automatic);
containerResponse = await cosmosContainer.ReadAsync();
Assert.AreEqual(HttpStatusCode.OK, containerResponse.StatusCode);
Assert.AreEqual(containerName, containerResponse.Resource.Id);
Assert.AreEqual(Cosmos.PartitionKeyDefinitionVersion.V2, containerResponse.Resource.PartitionKeyDefinitionVersion);
Assert.AreEqual(partitionKeyPath, containerResponse.Resource.PartitionKey.Paths.First());
Assert.AreEqual(Cosmos.IndexingMode.None, containerResponse.Resource.IndexingPolicy.IndexingMode);
Assert.IsFalse(containerResponse.Resource.IndexingPolicy.Automatic);
containerResponse = await containerResponse.Container.DeleteAsync();
Assert.AreEqual(HttpStatusCode.NoContent, containerResponse.StatusCode);
}
public async Task TestPreProcessingHandler()
{
CosmosRequestHandler preProcessHandler = new PreProcessingTestHandler();
CosmosClient client = MockCosmosUtil.CreateMockCosmosClient((builder) => builder.AddCustomHandlers(preProcessHandler));
Assert.IsTrue(typeof(RequestInvokerHandler).Equals(client.RequestHandler.GetType()));
Assert.IsTrue(typeof(PreProcessingTestHandler).Equals(client.RequestHandler.InnerHandler.GetType()));
CosmosContainer container = client.Databases["testdb"]
.Containers["testcontainer"];
HttpStatusCode[] testHttpStatusCodes = new HttpStatusCode[]
{
HttpStatusCode.OK,
HttpStatusCode.NotFound
};
// User operations
foreach (HttpStatusCode code in testHttpStatusCodes)
{
ItemRequestOptions options = new ItemRequestOptions();
options.Properties = new Dictionary <string, object>();
options.Properties.Add(PreProcessingTestHandler.StatusCodeName, code);
ItemResponse <object> response = await container.ReadItemAsync <object>("pk1", "id1", options);
Console.WriteLine($"Got status code {response.StatusCode}");
Assert.AreEqual(code, response.StatusCode);
}
// Meta-data operations
foreach (HttpStatusCode code in testHttpStatusCodes)
{
ContainerRequestOptions options = new ContainerRequestOptions();
options.Properties = new Dictionary <string, object>();
options.Properties.Add(PreProcessingTestHandler.StatusCodeName, code);
ContainerResponse response = await container.DeleteAsync(options);
Console.WriteLine($"Got status code {response.StatusCode}");
Assert.AreEqual(code, response.StatusCode);
}
}
public GenericCosmosDbRepository(IConfiguration configuration, IWebHostEnvironment env)
{
_configuration = configuration;
string endpointUri = _configuration["CosmosDbRepository:EndpointUri"];
string primaryKey = _configuration["CosmosDbRepository:PrimaryKey"];
_cosmosClient = new CosmosClient(endpointUri, primaryKey);
_databaseId = _configuration["CosmosDbRepository:DatabaseId"];
_containerId = typeof(T).Name;
_container = _cosmosClient.GetContainer(_databaseId, _containerId);
if (env.IsDevelopment())
{
Setup();
}
}
private static async Task QueryWithSqlParameters(CosmosContainer container)
{
// Query using two properties within each item. WHERE Id == "" AND Address.City == ""
// notice here how we are doing an equality comparison on the string value of City
CosmosSqlQueryDefinition query = new CosmosSqlQueryDefinition("SELECT * FROM Families f WHERE f.id = @id AND f.Address.City = @city")
.UseParameter("@id", "AndersonFamily")
.UseParameter("@city", "Seattle");
List <Family> results = new List <Family>();
FeedIterator <Family> resultSetIterator = container.CreateItemQuery <Family>(query, partitionKey: new PartitionKey("Anderson"));
while (resultSetIterator.HasMoreResults)
{
results.AddRange((await resultSetIterator.FetchNextSetAsync()));
}
Assert("Expected only 1 family", results.Count == 1);
}
/// <summary>
/// Run through basic container access methods as a console app demo.
/// </summary>
/// <returns></returns>
private static async Task RunContainerDemo(CosmosClient client)
{
// Create the database if necessary
await Program.Setup(client);
CosmosContainer simpleContainer = await Program.CreateContainer();
await Program.CreateContainerWithCustomIndexingPolicy();
await Program.CreateContainerWithTtlExpiration();
await Program.GetAndChangeContainerPerformance(simpleContainer);
await Program.ReadContainerProperties();
await Program.ListContainersInDatabase();
// Uncomment to delete container!
// await Program.DeleteContainer();
}
public async Task TimeToLiveTest()
{
string containerName = Guid.NewGuid().ToString();
string partitionKeyPath = "/users";
TimeSpan timeToLive = TimeSpan.FromSeconds(1);
CosmosContainerSettings setting = new CosmosContainerSettings()
{
Id = containerName,
PartitionKey = new PartitionKeyDefinition()
{
Paths = new Collection <string> {
partitionKeyPath
}, Kind = PartitionKind.Hash
},
DefaultTimeToLive = timeToLive
};
CosmosContainerResponse containerResponse = await this.cosmosDatabase.Containers.CreateContainerIfNotExistsAsync(setting);
Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode);
CosmosContainer cosmosContainer = containerResponse;
CosmosContainerSettings responseSettings = containerResponse;
Assert.AreEqual(timeToLive.TotalSeconds, responseSettings.DefaultTimeToLive.Value.TotalSeconds);
CosmosContainerResponse readResponse = await cosmosContainer.ReadAsync();
Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode);
Assert.AreEqual(timeToLive.TotalSeconds, readResponse.Resource.DefaultTimeToLive.Value.TotalSeconds);
JObject itemTest = JObject.FromObject(new { id = Guid.NewGuid().ToString(), users = "testUser42" });
CosmosItemResponse <JObject> createResponse = await cosmosContainer.Items.CreateItemAsync <JObject>(partitionKey : itemTest["users"].ToString(), item : itemTest);
JObject responseItem = createResponse;
Assert.IsNull(responseItem["ttl"]);
containerResponse = await cosmosContainer.DeleteAsync();
Assert.AreEqual(HttpStatusCode.NoContent, containerResponse.StatusCode);
}
public async Task <T> AddAsync(T newEntity)
{
try
{
CosmosContainer container = GetContainer();
ItemResponse <T> createResponse = await container.CreateItemAsync(newEntity);
return(createResponse.Value);
}
catch (CosmosException ex)
{
_logger.LogError(ex.Message);
if (ex.Status != (int)HttpStatusCode.NotFound)
{
throw;
}
return(null);
}
}
private static async Task Initialize(CosmosClient client)
{
database = await client.Databases.CreateDatabaseIfNotExistsAsync(databaseId);
// Delete the existing container to prevent create item conflicts
await database.Containers[containerId].DeleteAsync();
// We create a partitioned collection here which needs a partition key. Partitioned collections
// can be created with very high values of provisioned throughput (up to Throughput = 250,000)
// and used to store up to 250 GB of data. You can also skip specifying a partition key to create
// single partition collections that store up to 10 GB of data.
// For this demo, we create a collection to store SalesOrders. We set the partition key to the account
// number so that we can retrieve all sales orders for an account efficiently from a single partition,
// and perform transactions across multiple sales order for a single account number.
CosmosContainerSettings containerSettings = new CosmosContainerSettings(containerId, partitionKeyPath: "/AccountNumber");
// Create with a throughput of 1000 RU/s
container = await database.Containers.CreateContainerIfNotExistsAsync(
containerSettings,
throughput : 1000);
}
public async Task <T> GetAsync(string entityId, string partionKey)
{
try
{
CosmosContainer container = GetContainer();
ItemResponse <T> entityResult = await container.ReadItemAsync <T>(entityId, new PartitionKey(partionKey));
return(entityResult.Value);
}
catch (CosmosException ex)
{
Log.Error($"Entity with ID: {entityId} was not retrieved successfully - error details: {ex.Message}");
if (ex.ErrorCode != "404")
{
throw;
}
return(null);
}
}
private static async Task RunDemoAsync(CosmosClient client)
{
cosmosDatabase = await client.CreateDatabaseIfNotExistsAsync(CosmosDatabaseId);
CosmosContainer container = await Program.GetOrCreateContainerAsync(cosmosDatabase, containerId);
await Program.CreateItems(container);
await Program.ItemFeed(container);
await Program.ItemStreamFeed(container);
await Program.QueryItemsInPartitionAsStreams(container);
await Program.QueryPartitionedContainerInParallelAsync(container);
await Program.QueryWithSqlParameters(container);
// Uncomment to Cleanup
//await cosmosDatabase.DeleteAsync();
}
public async Task <T> AddAsync(T newEntity)
{
try
{
CosmosContainer container = GetContainer();
ItemResponse <T> createResponse = await container.CreateItemAsync(newEntity);
return(createResponse.Value);
}
catch (CosmosException ex)
{
Log.Error($"New entity with ID: {newEntity.Id} was not added successfully - error details: {ex.Message}");
if (ex.Status != (int)HttpStatusCode.NotFound)
{
throw;
}
return(null);
}
}
public AdRepository(string cacheConnectionString,
string cosmosEndpointUri,
string cosmosKey)
{
try
{
Lazy <ConnectionMultiplexer> lazyConnection = GetLazyConnection(cacheConnectionString);
cache = lazyConnection.Value.GetDatabase();
client = new CosmosClient(cosmosEndpointUri, cosmosKey);
container = client.Databases[databaseId].Containers[containerId];
}
catch (Exception ex) when(ex is RedisConnectionException ||
ex is RedisException)
{
throw new AdRepositoryException("Redis connection initialization error", ex);
}
catch (Exception ex) when(ex is CosmosException)
{
throw new AdRepositoryException("Cosmos initialization error", ex);
}
}
public async Task ThroughputTest()
{
int expectedThroughput = 2400;
string containerName = Guid.NewGuid().ToString();
string partitionKeyPath = "/users";
ContainerResponse containerResponse
= await this.database.DefineContainer(containerName, partitionKeyPath)
.CreateAsync(expectedThroughput);
Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode);
CosmosContainer cosmosContainer = this.database.GetContainer(containerName);
int?readThroughput = await cosmosContainer.ReadProvisionedThroughputAsync();
Assert.IsNotNull(readThroughput);
Assert.AreEqual(expectedThroughput, readThroughput);
containerResponse = await cosmosContainer.DeleteAsync();
Assert.AreEqual(HttpStatusCode.NoContent, containerResponse.StatusCode);
}
public async Task <T> GetAsync(string entityId)
{
try
{
CosmosContainer container = GetContainer();
ItemResponse <T> entityResult = await container.ReadItemAsync <T>(entityId, new PartitionKey(entityId));
return(entityResult.Value);
}
catch (CosmosException ex)
{
_logger.LogError(ex.Message);
if (ex.Status != (int)HttpStatusCode.NotFound)
{
throw;
}
return(null);
}
}
private async void dataGridView1_UserDeletingRow(object sender, DataGridViewRowCancelEventArgs e)
{
this.Cursor = System.Windows.Forms.Cursors.WaitCursor;
var clickedId = dataGridView1.Rows[e.Row.Index].Cells[0].Value.ToString();
try
{
CosmosContainer container = cosmosClient.GetContainer(_settings.DatabaseId, _settings.ContainerId);
Session session = new Session();
ItemResponse <Session> sessionCosmos = await container.DeleteItemAsync <Session>(clickedId, new PartitionKey(session.partition));
_allSessions.Remove(_allSessions.Where(c => c.id.Equals(clickedId)).FirstOrDefault());
}
catch (Exception)
{
this.Cursor = System.Windows.Forms.Cursors.Default;
}
Thread.Sleep(100);
this.Cursor = System.Windows.Forms.Cursors.Default;
}
public FeedProcessorFactoryCore(
CosmosContainer container,
ChangeFeedProcessorOptions changeFeedProcessorOptions,
DocumentServiceLeaseCheckpointer leaseCheckpointer)
{
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
if (changeFeedProcessorOptions == null)
{
throw new ArgumentNullException(nameof(changeFeedProcessorOptions));
}
if (leaseCheckpointer == null)
{
throw new ArgumentNullException(nameof(leaseCheckpointer));
}
this.container = container;
this.changeFeedProcessorOptions = changeFeedProcessorOptions;
this.leaseCheckpointer = leaseCheckpointer;
}
public async Task <OperationResult> CreateContainerAsync(CosmosContainer container, int?throughput, CancellationToken cancellationToken)
{
var properties = new ContainerProperties(container.Id, container.PartitionKeyPath)
{
DefaultTimeToLive = container.DefaultTTL,
PartitionKeyDefinitionVersion = container.LargePartitionKey
? PartitionKeyDefinitionVersion.V2
: PartitionKeyDefinitionVersion.V1
};
try
{
var response = await _databaseGetter().CreateContainerAsync(properties, throughput, cancellationToken: cancellationToken);
container.ETag = response.Resource.ETag;
return(OperationResult.Success);
}
catch (CosmosException ex) when(ex.StatusCode == HttpStatusCode.Conflict)
{
return(OperationResult.AlreadyExists);
}
}
public RemainingWorkEstimatorCore(
DocumentServiceLeaseContainer leaseContainer,
CosmosContainer container,
int degreeOfParallelism)
{
if (leaseContainer == null)
{
throw new ArgumentNullException(nameof(leaseContainer));
}
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
if (degreeOfParallelism < 1)
{
throw new ArgumentException("Degree of parallelism is out of range", nameof(degreeOfParallelism));
}
this.leaseContainer = leaseContainer;
this.container = container;
this.degreeOfParallelism = degreeOfParallelism;
}
public async Task TestInitialize()
{
this.cancellationTokenSource = new CancellationTokenSource();
this.cancellationToken = this.cancellationTokenSource.Token;
this.cosmosClient = TestCommon.CreateCosmosClient();
this.database = await this.cosmosClient.Databases.CreateDatabaseAsync(Guid.NewGuid().ToString(),
cancellationToken : this.cancellationToken);
this.documentClient = TestCommon.CreateClient(true, defaultConsistencyLevel: Documents.ConsistencyLevel.Session);
string PartitionKey = "/partitionKey";
CosmosContainerResponse response = await this.database.Containers.CreateContainerAsync(
new CosmosContainerSettings(id : Guid.NewGuid().ToString(), partitionKeyPath : PartitionKey),
cancellationToken : this.cancellationToken);
Assert.IsNotNull(response);
Assert.IsNotNull(response.Container);
Assert.IsNotNull(response.Resource);
this.Container = response;
this.jsonSerializer = new CosmosDefaultJsonSerializer();
}
