public async Task ImplicitConversion()
{
string databaseName = Guid.NewGuid().ToString();
CosmosDatabaseResponse cosmosDatabaseResponse = await this.cosmosClient.Databases[databaseName].ReadAsync(cancellationToken: this.cancellationToken);
CosmosDatabase cosmosDatabase = cosmosDatabaseResponse;
CosmosDatabaseSettings cosmosDatabaseSettings = cosmosDatabaseResponse;
Assert.IsNotNull(cosmosDatabase);
Assert.IsNull(cosmosDatabaseSettings);
cosmosDatabaseResponse = await this.CreateDatabaseHelper();
cosmosDatabase = cosmosDatabaseResponse;
cosmosDatabaseSettings = cosmosDatabaseResponse;
Assert.IsNotNull(cosmosDatabase);
Assert.IsNotNull(cosmosDatabaseSettings);
cosmosDatabaseResponse = await cosmosDatabase.DeleteAsync(cancellationToken : this.cancellationToken);
cosmosDatabase = cosmosDatabaseResponse;
cosmosDatabaseSettings = cosmosDatabaseResponse;
Assert.IsNotNull(cosmosDatabase);
Assert.IsNull(cosmosDatabaseSettings);
}
public async Task SharedThroughputTests()
{
string databaseId = Guid.NewGuid().ToString();
int throughput = 10000;
CosmosDatabaseResponse createResponse = await this.CreateDatabaseHelper(databaseId, databaseExists : false, throughput : throughput);
Assert.AreEqual(HttpStatusCode.Created, createResponse.StatusCode);
CosmosDatabase cosmosDatabase = createResponse;
int? readThroughput = await cosmosDatabase.ReadProvisionedThroughputAsync();
Assert.AreEqual(throughput, readThroughput);
string containerId = Guid.NewGuid().ToString();
string partitionPath = "/users";
CosmosContainerResponse containerResponse = await cosmosDatabase.Containers.CreateContainerAsync(containerId, partitionPath);
Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode);
CosmosContainer container = containerResponse;
readThroughput = await container.ReadProvisionedThroughputAsync();
Assert.IsNull(readThroughput);
await container.DeleteAsync();
await cosmosDatabase.DeleteAsync();
}
private async Task <CosmosDatabaseResponse> CreateDatabaseHelper(
string databaseId,
int?throughput = null,
bool databaseExists = false)
{
CosmosDatabaseResponse response = null;
if (databaseExists)
{
response = await this.cosmosClient.Databases.CreateDatabaseIfNotExistsAsync(
databaseId,
throughput,
cancellationToken : this.cancellationToken);
}
else
{
response = await this.cosmosClient.Databases.CreateDatabaseAsync(
databaseId,
throughput,
cancellationToken : this.cancellationToken);
}
Assert.IsNotNull(response);
Assert.IsNotNull(response.Database);
Assert.IsNotNull(response.Resource);
Assert.AreEqual(databaseId, response.Resource.Id);
Assert.AreEqual(databaseId, response.Database.Id);
ValidateHeaders(response);
Assert.IsTrue(response.StatusCode == HttpStatusCode.OK || (response.StatusCode == HttpStatusCode.Created && !databaseExists));
return(response);
}
/// <summary>
/// Initialize a static instance of the <see cref="CosmosClient"/>.
/// </summary>
/// <returns></returns>
private static CosmosClient InitializeCosmosClient()
{
string endpoint = configuration["EndPointUrl"];
if (string.IsNullOrEmpty(endpoint))
{
throw new ArgumentNullException("Please specify a valid endpoint in the appSettings.json");
}
string authKey = configuration["AuthorizationKey"];
if (string.IsNullOrEmpty(authKey) || string.Equals(authKey, "Super secret key"))
{
throw new ArgumentException("Please specify a valid AuthorizationKey in the appSettings.json");
}
var cosmosConfiguration = new CosmosConfiguration(endpoint,
authKey);
// Customize client configuration
var cosmosClient = new CosmosClient(cosmosConfiguration);
// Optional. Initialize container
CosmosDatabaseResponse databaseResponse = cosmosClient.Databases.CreateDatabaseIfNotExistsAsync("mydb").Result;
CosmosDatabase database = databaseResponse.Database;
var containerResponse = database.Containers.CreateContainerIfNotExistsAsync("mycoll", "/id").Result;
return(cosmosClient);
}
public async Task DropNonExistingDatabase()
{
CosmosDatabaseResponse response = await this.cosmosClient.Databases[Guid.NewGuid().ToString()].DeleteAsync(cancellationToken: this.cancellationToken);
string activityId = response.ActivityId;
double?ru = response.RequestCharge;
Assert.AreEqual(HttpStatusCode.NotFound, response.StatusCode);
}
public async Task TestInit()
{
this.cosmosClient = TestCommon.CreateCosmosClient();
string databaseName = Guid.NewGuid().ToString();
CosmosDatabaseResponse cosmosDatabaseResponse = await this.cosmosClient.Databases.CreateDatabaseIfNotExistsAsync(databaseName);
this.cosmosDatabase = cosmosDatabaseResponse;
}
public async Task CreateIfNotExists()
{
CosmosDatabaseResponse createResponse = await this.CreateDatabaseHelper();
Assert.AreEqual(HttpStatusCode.Created, createResponse.StatusCode);
createResponse = await this.CreateDatabaseHelper(createResponse.Resource.Id, databaseExists : true);
Assert.AreEqual(HttpStatusCode.OK, createResponse.StatusCode);
}
public async Task CreateDropDatabase()
{
CosmosDatabaseResponse response = await this.CreateDatabaseHelper();
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
response = await response.Database.DeleteAsync(cancellationToken : this.cancellationToken);
Assert.AreEqual(HttpStatusCode.NoContent, response.StatusCode);
}
/*
* Delete the database and dispose of the Cosmos Client instance
*/
private async Task DeleteDatabaseAndCleanup()
{
CosmosDatabaseResponse databaseResourceResponse = await this.database.DeleteAsync();
// Also valid: await this.cosmosClient.Databases["FamilyDatabase"].DeleteAsync();
Console.WriteLine("Deleted Database: {0}\n", this.databaseId);
//Dispose of CosmosClient
this.cosmosClient.Dispose();
}
public async Task ReadDatabase()
{
CosmosDatabaseResponse createResponse = await this.CreateDatabaseHelper();
CosmosDatabaseResponse readResponse = await createResponse.Database.ReadAsync(cancellationToken : this.cancellationToken);
Assert.AreEqual(createResponse.Database.Id, readResponse.Database.Id);
Assert.AreEqual(createResponse.Resource.Id, readResponse.Resource.Id);
Assert.AreNotEqual(createResponse.ActivityId, readResponse.ActivityId);
ValidateHeaders(readResponse);
await createResponse.Database.DeleteAsync(cancellationToken : this.cancellationToken);
}
public async Task CreateDropDatabase()
{
CosmosDatabaseResponse response = await this.CreateDatabaseHelper();
Assert.IsNotNull(response);
Assert.IsTrue(response.RequestCharge > 0);
Assert.IsNotNull(response.Headers);
Assert.IsNotNull(response.Headers.ActivityId);
response = await response.Database.DeleteAsync(cancellationToken : this.cancellationToken);
Assert.AreEqual(HttpStatusCode.NoContent, response.StatusCode);
}
public async Task NoThroughputTests()
{
string databaseId = Guid.NewGuid().ToString();
CosmosDatabaseResponse createResponse = await this.CreateDatabaseHelper(databaseId, databaseExists : false);
Assert.AreEqual(HttpStatusCode.Created, createResponse.StatusCode);
CosmosDatabase cosmosDatabase = createResponse;
int? readThroughput = await cosmosDatabase.ReadProvisionedThroughputAsync();
Assert.IsNull(readThroughput);
await cosmosDatabase.DeleteAsync();
}
/// <summary>
/// Run basic database meta data operations as a console application.
/// </summary>
/// <returns></returns>
private static async Task RunDatabaseDemo(CosmosClient client)
{
// An object containing relevant information about the response
CosmosDatabaseResponse databaseResponse = await client.Databases.CreateDatabaseIfNotExistsAsync(databaseId, 10000);
// A client side reference object that allows additional operations like ReadAsync
CosmosDatabase database = databaseResponse;
// The response from Azure Cosmos
CosmosDatabaseSettings settings = databaseResponse;
Console.WriteLine($"\n1. Create a database resource with id: {settings.Id} and last modified time stamp: {settings.LastModified}");
Console.WriteLine($"\n2. Create a database resource request charge: {databaseResponse.RequestCharge} and Activity Id: {databaseResponse.ActivityId}");
// Read the database from Azure Cosmos
CosmosDatabaseResponse readResponse = await database.ReadAsync();
Console.WriteLine($"\n3. Read a database: {readResponse.Resource.Id}");
await readResponse.Database.Containers.CreateContainerAsync("testContainer", "/pk");
// Get the current throughput for the database
int?throughput = await database.ReadProvisionedThroughputAsync();
if (throughput.HasValue)
{
Console.WriteLine($"\n4. Read a database throughput: {throughput.Value}");
// Update the current throughput for the database
await database.ReplaceProvisionedThroughputAsync(11000);
}
Console.WriteLine("\n5. Reading all databases resources for an account");
CosmosResultSetIterator <CosmosDatabaseSettings> iterator = client.Databases.GetDatabaseIterator();
do
{
foreach (CosmosDatabaseSettings db in await iterator.FetchNextSetAsync())
{
Console.WriteLine(db.Id);
}
} while (iterator.HasMoreResults);
// Delete the database from Azure Cosmos.
await database.DeleteAsync();
Console.WriteLine($"\n6. Database {database.Id} deleted.");
}
public async Task DatabaseIterator()
{
List <CosmosDatabase> deleteList = new List <CosmosDatabase>();
HashSet <string> databaseIds = new HashSet <string>();
try
{
for (int i = 0; i < 3; i++)
{
CosmosDatabaseResponse createResponse = await this.CreateDatabaseHelper();
deleteList.Add(createResponse.Database);
databaseIds.Add(createResponse.Resource.Id);
}
CosmosResultSetIterator <CosmosDatabaseSettings> setIterator =
this.cosmosClient.Databases.GetDatabaseIterator();
while (setIterator.HasMoreResults)
{
CosmosQueryResponse <CosmosDatabaseSettings> iterator =
await setIterator.FetchNextSetAsync(this.cancellationToken);
foreach (CosmosDatabaseSettings databaseSettings in iterator)
{
if (databaseIds.Contains(databaseSettings.Id))
{
databaseIds.Remove(databaseSettings.Id);
}
}
}
}
finally
{
foreach (CosmosDatabase database in deleteList)
{
await database.DeleteAsync(cancellationToken : this.cancellationToken);
}
}
Assert.AreEqual(0, databaseIds.Count);
}
public async Task CreateConflict()
{
CosmosDatabaseResponse response = await this.CreateDatabaseHelper();
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
try
{
response = await this.CreateDatabaseHelper(response.Resource.Id);
Assert.Fail($"Unexpected success status code {response.StatusCode}");
}
catch (CosmosException hre)
{
DefaultTrace.TraceInformation(hre.ToString());
}
response = await response.Database.DeleteAsync(cancellationToken : this.cancellationToken);
Assert.AreEqual(HttpStatusCode.NoContent, response.StatusCode);
}
public async Task DatabaseContractTest()
{
CosmosDatabaseResponse response = await this.CreateDatabaseHelper();
Assert.IsNotNull(response);
Assert.IsTrue(response.RequestCharge > 0);
Assert.IsNotNull(response.Headers);
Assert.IsNotNull(response.Headers.ActivityId);
CosmosDatabaseSettings databaseSettings = response.Resource;
Assert.IsNotNull(databaseSettings.Id);
Assert.IsNotNull(databaseSettings.ResourceId);
Assert.IsNotNull(databaseSettings.ETag);
Assert.IsTrue(databaseSettings.LastModified.HasValue);
Assert.IsTrue(databaseSettings.LastModified.Value > new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc), databaseSettings.LastModified.Value.ToString());
response = await response.Database.DeleteAsync(cancellationToken : this.cancellationToken);
Assert.AreEqual(HttpStatusCode.NoContent, response.StatusCode);
}
// Async main requires c# 7.1 which is set in the csproj with the LangVersion attribute
public static async Task Main(string[] args)
{
IConfigurationRoot configuration = new ConfigurationBuilder()
.AddJsonFile("appSettings.json")
.Build();
string endpoint = configuration["EndPointUrl"];
if (string.IsNullOrEmpty(endpoint))
{
throw new ArgumentNullException("Please specify a valid endpoint in the appSettings.json");
}
string authKey = configuration["AuthorizationKey"];
if (string.IsNullOrEmpty(authKey) || string.Equals(authKey, "Super secret key"))
{
throw new ArgumentException("Please specify a valid AuthorizationKey in the appSettings.json");
}
// Connecting to Emulator. Change if you want a live account
CosmosConfiguration cosmosConfiguration = new CosmosConfiguration(endpoint,
authKey);
cosmosConfiguration.AddCustomHandlers(
new LoggingHandler(),
new ConcurrencyHandler(),
new ThrottlingHandler()
);
CosmosClient client = new CosmosClient(cosmosConfiguration);
CosmosDatabaseResponse databaseResponse = await client.Databases.CreateDatabaseIfNotExistsAsync("mydb");
CosmosDatabase database = databaseResponse.Database;
CosmosContainerResponse containerResponse = await database.Containers.CreateContainerIfNotExistsAsync("mycoll", "/id");
CosmosContainer container = containerResponse.Container;
Item item = new Item()
{
Id = Guid.NewGuid().ToString(),
Name = "Test Item",
Description = "Some random test item",
Completed = false
};
// Create
await container.Items.CreateItemAsync <Item>(item.Id, item);
item.Completed = true;
// Replace
await container.Items.ReplaceItemAsync <Item>(item.Id, item.Id, item);
// Querying
CosmosResultSetIterator <Item> query = container.Items.CreateItemQuery <Item>(new CosmosSqlQueryDefinition("SELECT * FROM c"), maxConcurrency: 1);
List <Item> results = new List <Item>();
while (query.HasMoreResults)
{
CosmosQueryResponse <Item> response = await query.FetchNextSetAsync();
results.AddRange(response.ToList());
}
// Read Item
CosmosItemResponse <Item> cosmosItemResponse = await container.Items.ReadItemAsync <Item>(item.Id, item.Id);
AccessCondition accessCondition = new AccessCondition
{
Condition = cosmosItemResponse.ETag,
Type = AccessConditionType.IfMatch
};
// Concurrency
List <Task <CosmosItemResponse <Item> > > tasks = new List <Task <CosmosItemResponse <Item> > >();
tasks.Add(UpdateItemForConcurrency(container, accessCondition, item));
tasks.Add(UpdateItemForConcurrency(container, accessCondition, item));
try
{
await Task.WhenAll(tasks);
}
catch (CosmosException ex)
{
// Verify that our custom handler catched the scenario
Debug.Assert(999.Equals(ex.SubStatusCode));
}
// Delete
await container.Items.DeleteItemAsync <Item>(item.Id, item.Id);
}
private void ValidateHeaders(CosmosDatabaseResponse cosmosDatabaseResponse)
{
Assert.IsNotNull(cosmosDatabaseResponse.MaxResourceQuota);
Assert.IsNotNull(cosmosDatabaseResponse.CurrentResourceQuotaUsage);
}
