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); }