public async Task GremlinDatabaseCreateUpdateTests()
{
GremlinDatabaseCreateUpdateParameters gremlinDatabaseCreateUpdateParameters = new GremlinDatabaseCreateUpdateParameters(new GremlinDatabaseResource(databaseName), new CreateUpdateOptions(sampleThroughput, new AutoscaleSettings()));
var gremlinDatabaseResponse = await WaitForCompletionAsync(await CosmosDBManagementClient.GremlinResources.StartCreateUpdateGremlinDatabaseAsync(resourceGroupName, databaseAccountName, databaseName, gremlinDatabaseCreateUpdateParameters));
Assert.NotNull(gremlinDatabaseResponse);
GremlinDatabaseGetResults gremlinDatabaseGetResults = gremlinDatabaseResponse.Value;
Assert.NotNull(gremlinDatabaseGetResults);
Assert.AreEqual(databaseName, gremlinDatabaseGetResults.Name);
var gremlinDatabaseResponse1 = await WaitForCompletionAsync(await CosmosDBManagementClient.GremlinResources.StartCreateUpdateGremlinDatabaseAsync(resourceGroupName, databaseAccountName, databaseName, gremlinDatabaseCreateUpdateParameters));
Assert.NotNull(gremlinDatabaseResponse1);
GremlinDatabaseGetResults gremlinDatabaseGetResults1 = gremlinDatabaseResponse1.Value;
Assert.NotNull(gremlinDatabaseGetResults);
Assert.AreEqual(databaseName, gremlinDatabaseGetResults1.Name);
VerifyEqualGremlinDatabases(gremlinDatabaseGetResults, gremlinDatabaseGetResults1);
var throughputResponse = CosmosDBManagementClient.GremlinResources.GetGremlinDatabaseThroughputAsync(resourceGroupName, databaseAccountName, databaseName);
ThroughputSettingsGetResults throughputSettingsGetResults = throughputResponse.ConfigureAwait(false).GetAwaiter().GetResult();
Assert.NotNull(throughputSettingsGetResults);
Assert.NotNull(throughputSettingsGetResults.Name);
Assert.AreEqual(throughputSettingsGetResults.Resource.Throughput, sampleThroughput);
Assert.AreEqual(gremlinDatabasesThroughputType, throughputSettingsGetResults.Type);
}
public override void ExecuteCmdlet()
{
if (ParameterSetName.Equals(ParentObjectParameterSet, StringComparison.Ordinal))
{
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(InputObject.Id);
AccountName = resourceIdentifier.ResourceName;
ResourceGroupName = resourceIdentifier.ResourceGroupName;
}
if (!string.IsNullOrEmpty(Name))
{
CassandraKeyspaceGetResults cassandraKeyspaceGetResults = CosmosDBManagementClient.CassandraResources.GetCassandraKeyspaceWithHttpMessagesAsync(ResourceGroupName, AccountName, Name).GetAwaiter().GetResult().Body;
WriteObject(new PSCassandraKeyspaceGetResults(cassandraKeyspaceGetResults));
if (Detailed)
{
ThroughputSettingsGetResults throughputSettingsGetResults = CosmosDBManagementClient.CassandraResources.GetCassandraKeyspaceThroughputWithHttpMessagesAsync(ResourceGroupName, AccountName, Name).GetAwaiter().GetResult().Body;
WriteObject(throughputSettingsGetResults);
}
}
else
{
IEnumerable <CassandraKeyspaceGetResults> cassandraKeyspaces = CosmosDBManagementClient.CassandraResources.ListCassandraKeyspacesWithHttpMessagesAsync(ResourceGroupName, AccountName).GetAwaiter().GetResult().Body;
foreach (CassandraKeyspaceGetResults cassandraKeyspace in cassandraKeyspaces)
{
WriteObject(new PSCassandraKeyspaceGetResults(cassandraKeyspace));
}
}
return;
}
public async Task CassandraKeyspaceCreateUpdateTests()
{
Response responseIsDatabaseNameExists = await CosmosDBManagementClient.DatabaseAccounts.CheckNameExistsAsync(databaseAccountName);
Assert.AreEqual(200, responseIsDatabaseNameExists.Status);
CassandraKeyspaceCreateUpdateParameters cassandraKeyspaceCreateUpdateParameters = new CassandraKeyspaceCreateUpdateParameters(new CassandraKeyspaceResource(keyspaceName), new CreateUpdateOptions(sampleThroughput, new AutoscaleSettings()));
var cassandraKeyspaceResponse = await WaitForCompletionAsync(await CosmosDBManagementClient.CassandraResources.StartCreateUpdateCassandraKeyspaceAsync(resourceGroupName, databaseAccountName, keyspaceName, cassandraKeyspaceCreateUpdateParameters));
CassandraKeyspaceGetResults cassandraKeyspaceGetResults = cassandraKeyspaceResponse.Value;
Assert.NotNull(cassandraKeyspaceGetResults);
Assert.AreEqual(keyspaceName, cassandraKeyspaceGetResults.Name);
var cassandraKeyspaceResponse1 = await WaitForCompletionAsync(await CosmosDBManagementClient.CassandraResources.StartCreateUpdateCassandraKeyspaceAsync(resourceGroupName, databaseAccountName, keyspaceName, cassandraKeyspaceCreateUpdateParameters));
CassandraKeyspaceGetResults cassandraKeyspaceGetResults1 = cassandraKeyspaceResponse1.Value;
Assert.NotNull(cassandraKeyspaceGetResults1);
Assert.AreEqual(keyspaceName, cassandraKeyspaceGetResults1.Name);
VerifyEqualCassandraDatabases(cassandraKeyspaceGetResults, cassandraKeyspaceGetResults1);
var throughputResponse = CosmosDBManagementClient.CassandraResources.GetCassandraKeyspaceThroughputAsync(resourceGroupName, databaseAccountName, keyspaceName);
ThroughputSettingsGetResults throughputSettingsGetResults = throughputResponse.ConfigureAwait(false).GetAwaiter().GetResult();
Assert.NotNull(throughputSettingsGetResults);
Assert.NotNull(throughputSettingsGetResults.Name);
Assert.AreEqual(throughputSettingsGetResults.Resource.Throughput, sampleThroughput);
Assert.AreEqual(cassandraKeyspacesThroughputType, throughputSettingsGetResults.Type);
}
public override void ExecuteCmdlet()
{
if (ParameterSetName.Equals(ParentObjectParameterSet, StringComparison.Ordinal))
{
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(ParentObject.Id);
ResourceGroupName = resourceIdentifier.ResourceGroupName;
DatabaseName = resourceIdentifier.ResourceName;
AccountName = ResourceIdentifierExtensions.GetDatabaseAccountName(resourceIdentifier);
}
if (!string.IsNullOrEmpty(Name))
{
GremlinGraphGetResults gremlinGraphGetResults = CosmosDBManagementClient.GremlinResources.GetGremlinGraphWithHttpMessagesAsync(ResourceGroupName, AccountName, DatabaseName, Name).GetAwaiter().GetResult().Body;
WriteObject(new PSGremlinGraphGetResults(gremlinGraphGetResults));
if (Detailed)
{
ThroughputSettingsGetResults throughputSettingsGetResults = CosmosDBManagementClient.GremlinResources.GetGremlinGraphThroughputWithHttpMessagesAsync(ResourceGroupName, AccountName, DatabaseName, Name).GetAwaiter().GetResult().Body;
WriteObject(throughputSettingsGetResults);
}
}
else
{
IEnumerable <GremlinGraphGetResults> gremlinGraphs = CosmosDBManagementClient.GremlinResources.ListGremlinGraphsWithHttpMessagesAsync(ResourceGroupName, AccountName, DatabaseName).GetAwaiter().GetResult().Body;
foreach (GremlinGraphGetResults gremlinGraph in gremlinGraphs)
{
WriteObject(new PSGremlinGraphGetResults(gremlinGraph));
}
}
return;
}
public override void ExecuteCmdlet()
{
if (ParameterSetName.Equals(ParentObjectParameterSet, StringComparison.Ordinal))
{
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(ParentObject.Id);
ResourceGroupName = resourceIdentifier.ResourceGroupName;
AccountName = resourceIdentifier.ResourceName;
}
else if (ParameterSetName.Equals(ObjectParameterSet, StringComparison.Ordinal))
{
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(InputObject.Id);
ResourceGroupName = resourceIdentifier.ResourceGroupName;
Name = resourceIdentifier.ResourceName;
AccountName = ResourceIdentifierExtensions.GetDatabaseAccountName(resourceIdentifier);
}
ThroughputSettingsUpdateParameters throughputSettingsUpdateParameters = new ThroughputSettingsUpdateParameters
{
Resource = new ThroughputSettingsResource
{
Throughput = Throughput
}
};
if (ShouldProcess(Name, "Updating the throughput value of a CosmosDB Gremlin Database"))
{
ThroughputSettingsGetResults throughputSettingsGetResults = CosmosDBManagementClient.GremlinResources.UpdateGremlinDatabaseThroughputWithHttpMessagesAsync(ResourceGroupName, AccountName, Name, throughputSettingsUpdateParameters).GetAwaiter().GetResult().Body;
WriteObject(new PSThroughputSettingsGetResults(throughputSettingsGetResults));
}
return;
}
public override void ExecuteCmdlet()
{
if (ParameterSetName.Equals(ParentObjectParameterSet, StringComparison.Ordinal))
{
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(InputObject.Id);
ResourceGroupName = resourceIdentifier.ResourceGroupName;
DatabaseName = resourceIdentifier.ResourceName;
AccountName = ResourceIdentifierExtensions.GetDatabaseAccountName(resourceIdentifier);
}
if (!string.IsNullOrEmpty(Name))
{
MongoDBCollectionGetResults mongoDBCollectionGetResults = CosmosDBManagementClient.MongoDBResources.GetMongoDBCollectionWithHttpMessagesAsync(ResourceGroupName, AccountName, DatabaseName, Name).GetAwaiter().GetResult().Body;
WriteObject(new PSMongoDBCollectionGetResults(mongoDBCollectionGetResults));
if (Detailed)
{
ThroughputSettingsGetResults throughputSettingsGetResults = CosmosDBManagementClient.MongoDBResources.GetMongoDBCollectionThroughputWithHttpMessagesAsync(ResourceGroupName, AccountName, DatabaseName, Name).GetAwaiter().GetResult().Body;
WriteObject(throughputSettingsGetResults);
}
}
else
{
IEnumerable <MongoDBCollectionGetResults> mongoDBCollections = CosmosDBManagementClient.MongoDBResources.ListMongoDBCollectionsWithHttpMessagesAsync(ResourceGroupName, AccountName, DatabaseName).GetAwaiter().GetResult().Body;
foreach (MongoDBCollectionGetResults mongoDBCollection in mongoDBCollections)
{
WriteObject(new PSMongoDBCollectionGetResults(mongoDBCollection));
}
}
return;
}
public override void ExecuteCmdlet()
{
if (ParameterSetName.Equals(ParentObjectParameterSet, StringComparison.Ordinal))
{
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(ParentObject.Id);
ResourceGroupName = resourceIdentifier.ResourceGroupName;
DatabaseName = resourceIdentifier.ResourceName;
AccountName = ResourceIdentifierExtensions.GetDatabaseAccountName(resourceIdentifier);
}
if (!string.IsNullOrEmpty(Name))
{
SqlContainerGetResults sqlContainerGetResults = CosmosDBManagementClient.SqlResources.GetSqlContainerWithHttpMessagesAsync(ResourceGroupName, AccountName, DatabaseName, Name).GetAwaiter().GetResult().Body;
WriteObject(new PSSqlContainerGetResults(sqlContainerGetResults));
if (Detailed)
{
ThroughputSettingsGetResults throughputSettingsGetResults = CosmosDBManagementClient.SqlResources.GetSqlContainerThroughputWithHttpMessagesAsync(ResourceGroupName, AccountName, DatabaseName, Name).GetAwaiter().GetResult().Body;
WriteObject(new PSThroughputSettingsGetResults(throughputSettingsGetResults));
}
}
else
{
IEnumerable <SqlContainerGetResults> sqlContainers = CosmosDBManagementClient.SqlResources.ListSqlContainersWithHttpMessagesAsync(ResourceGroupName, AccountName, DatabaseName).GetAwaiter().GetResult().Body;
foreach (SqlContainerGetResults sqlContainer in sqlContainers)
{
WriteObject(new PSSqlContainerGetResults(sqlContainer));
}
}
return;
}
public async Task CassandraKeyspaceMigrateToManualTests()
{
ThroughputSettingsGetResults throughputSettingsGetResults = await WaitForCompletionAsync(await CosmosDBManagementClient.CassandraResources.StartMigrateCassandraKeyspaceToManualThroughputAsync(resourceGroupName, databaseAccountName, keyspaceName));
Assert.IsNotNull(throughputSettingsGetResults);
Assert.IsNull(throughputSettingsGetResults.Resource.AutoscaleSettings);
Assert.AreEqual(maxThroughput, throughputSettingsGetResults.Resource.Throughput);
}
public override void CallSDKMethod(ThroughputSettingsUpdateParameters throughputSettingsUpdateParameters)
{
if (ShouldProcess(Name, "Updating the throughput value of a CosmosDB Cassandra Keyspace"))
{
ThroughputSettingsGetResults throughputSettingsGetResults = CosmosDBManagementClient.CassandraResources.UpdateCassandraKeyspaceThroughputWithHttpMessagesAsync(ResourceGroupName, AccountName, Name, throughputSettingsUpdateParameters).GetAwaiter().GetResult().Body;
WriteObject(new PSThroughputSettingsGetResults(throughputSettingsGetResults));
}
}
public async Task GremlinGraphMigrateToManualTests()
{
ThroughputSettingsGetResults throughputSettingsGetResults = await WaitForCompletionAsync(await CosmosDBManagementClient.GremlinResources.StartMigrateGremlinGraphToManualThroughputAsync(resourceGroupName, databaseAccountName, databaseName, gremlinGraphName));
Assert.IsNotNull(throughputSettingsGetResults);
Assert.IsNull(throughputSettingsGetResults.Resource.AutoscaleSettings);
Assert.AreEqual(maxThroughput, throughputSettingsGetResults.Resource.Throughput);
}
public PSThroughputSettingsGetResults(ThroughputSettingsGetResults throughputSettingsGetResults)
{
Name = throughputSettingsGetResults.Name;
Id = throughputSettingsGetResults.Id;
Throughput = throughputSettingsGetResults.Resource.Throughput.Value;
MinimumThroughput = throughputSettingsGetResults.Resource.MinimumThroughput;
OfferReplacePending = throughputSettingsGetResults.Resource.OfferReplacePending;
}
public async Task MongoDBDatabaseMigrateToManualThroughputTest()
{
ThroughputSettingsGetResults throughputSettingsGetResults = await WaitForCompletionAsync(
await CosmosDBManagementClient.MongoDBResources.StartMigrateMongoDBDatabaseToManualThroughputAsync(resourceGroupName, databaseAccountName, databaseName));
Assert.IsNotNull(throughputSettingsGetResults);
Assert.IsNull(throughputSettingsGetResults.Resource.AutoscaleSettings);
Assert.AreEqual(defaultMaxThroughput, throughputSettingsGetResults.Resource.Throughput);
}
public async Task SqlContainerMigrateToAutoscaleTest()
{
ThroughputSettingsGetResults throughputSettingsGetResults = await WaitForCompletionAsync(
await CosmosDBManagementClient.SqlResources.StartMigrateSqlContainerToAutoscaleAsync(
resourceGroupName, databaseAccountName, databaseName, containerName));
Assert.NotNull(throughputSettingsGetResults);
Assert.NotNull(throughputSettingsGetResults.Resource.AutoscaleSettings);
Assert.AreEqual(defaultMaxThroughput, throughputSettingsGetResults.Resource.AutoscaleSettings.MaxThroughput);
Assert.AreEqual(defaultThroughput, throughputSettingsGetResults.Resource.Throughput);
}
public async Task CassandraKeyspaceUpdateThroughputTests()
{
ThroughputSettingsUpdateParameters throughputSettingsUpdateParameters = new ThroughputSettingsUpdateParameters(new ThroughputSettingsResource(maxThroughput, null, null, null));
var throughputResponse = await WaitForCompletionAsync(await CosmosDBManagementClient.CassandraResources.StartUpdateCassandraKeyspaceThroughputAsync(resourceGroupName, databaseAccountName, keyspaceName, throughputSettingsUpdateParameters));
ThroughputSettingsGetResults throughputSettingsGetResults = throughputResponse.Value;
Assert.NotNull(throughputSettingsGetResults);
Assert.NotNull(throughputSettingsGetResults.Name);
Assert.AreEqual(throughputSettingsGetResults.Resource.Throughput, maxThroughput);
Assert.AreEqual(cassandraKeyspacesThroughputType, throughputSettingsGetResults.Type);
}
public async Task MongoDBDatabaseUpdateThroughputTest()
{
ThroughputSettingsGetResults throughputSettingsGetResults = (await WaitForCompletionAsync(
await CosmosDBManagementClient.MongoDBResources.StartUpdateMongoDBDatabaseThroughputAsync(
resourceGroupName,
databaseAccountName,
databaseName,
new ThroughputSettingsUpdateParameters(new ThroughputSettingsResource(sampleThroughput1, null, null, null))))).Value;
Assert.IsNotNull(throughputSettingsGetResults);
Assert.AreEqual(sampleThroughput1, throughputSettingsGetResults.Resource.Throughput);
}
public async Task SqlDatabaseThroughputUpdateTest()
{
ThroughputSettingsGetResults throughputSettingsGetResults = await WaitForCompletionAsync(
await CosmosDBManagementClient.SqlResources.StartUpdateSqlDatabaseThroughputAsync(
resourceGroupName,
databaseAccountName,
databaseName,
new ThroughputSettingsUpdateParameters(new ThroughputSettingsResource(sampleThroughput2, null, null, null))));
Assert.NotNull(throughputSettingsGetResults);
Assert.AreEqual(sampleThroughput2, throughputSettingsGetResults.Resource.Throughput);
}
public async Task TableUpdateThroughputTest()
{
ThroughputSettingsGetResults throughputSettingsGetResults = await WaitForCompletionAsync(
await CosmosDBManagementClient.TableResources.StartUpdateTableThroughputAsync(
resourceGroupName,
databaseAccountName,
tableName,
new ThroughputSettingsUpdateParameters(new ThroughputSettingsResource(defaultThroughput, null, null, null))));
Assert.IsNotNull(throughputSettingsGetResults);
Assert.AreEqual(defaultThroughput, throughputSettingsGetResults.Resource.Throughput);
}
public override void MigrateToManualSDKMethod()
{
if (ShouldProcess(Name, "Migrating the CosmosDB Gremlin Database throughput to Manual Provisioning Policy."))
{
ThroughputSettingsGetResults throughputSettingsGetResults =
CosmosDBManagementClient.GremlinResources.MigrateGremlinDatabaseToManualThroughput(
ResourceGroupName,
AccountName,
Name);
WriteObject(new PSThroughputSettingsGetResults(throughputSettingsGetResults));
}
}
public override void MigrateToAutoscaleSDKMethod()
{
if (ShouldProcess(Name, "Migrating the CosmosDB Cassandra Keyspace throughput to Autoscale Provisioning Policy."))
{
ThroughputSettingsGetResults throughputSettingsGetResults =
CosmosDBManagementClient.CassandraResources.MigrateCassandraKeyspaceToAutoscale(
ResourceGroupName,
AccountName,
Name);
WriteObject(new PSThroughputSettingsGetResults(throughputSettingsGetResults));
}
}
public override void MigrateToAutoscaleSDKMethod()
{
if (ShouldProcess(Name, "Migrating the CosmosDB Sql Container throughput to Autoscale Provisioning Policy."))
{
ThroughputSettingsGetResults throughputSettingsGetResults = CosmosDBManagementClient.SqlResources.MigrateSqlContainerToAutoscale(
ResourceGroupName,
AccountName,
DatabaseName,
Name);
WriteObject(new PSThroughputSettingsGetResults(throughputSettingsGetResults));
}
}
public async Task SqlDatabaseCreateAndUpdateTest()
{
SqlDatabaseCreateUpdateParameters sqlDatabaseCreateUpdateParameters1 = new SqlDatabaseCreateUpdateParameters(
new SqlDatabaseResource(databaseName), new CreateUpdateOptions(sampleThroughput1, new AutoscaleSettings()));
SqlDatabaseGetResults sqlDatabaseGetResults1 = await WaitForCompletionAsync(
await CosmosDBManagementClient.SqlResources.StartCreateUpdateSqlDatabaseAsync(
resourceGroupName, databaseAccountName, databaseName, sqlDatabaseCreateUpdateParameters1));
Assert.NotNull(sqlDatabaseGetResults1);
SqlDatabaseGetResults sqlDatabaseGetResults2 = await CosmosDBManagementClient.SqlResources.GetSqlDatabaseAsync(
resourceGroupName, databaseAccountName, databaseName);
Assert.NotNull(sqlDatabaseGetResults2);
VerifySqlDatabases(sqlDatabaseGetResults1, sqlDatabaseGetResults2);
ThroughputSettingsGetResults throughputSettingsGetResults1 =
await CosmosDBManagementClient.SqlResources.GetSqlDatabaseThroughputAsync(resourceGroupName, databaseAccountName, databaseName);
Assert.NotNull(throughputSettingsGetResults1);
Assert.NotNull(throughputSettingsGetResults1.Name);
Assert.AreEqual(sqlDatabasesThroughputType, throughputSettingsGetResults1.Type);
Assert.AreEqual(sampleThroughput1, throughputSettingsGetResults1.Resource.Throughput);
SqlDatabaseCreateUpdateParameters sqlDatabaseCreateUpdateParameters2 =
new SqlDatabaseCreateUpdateParameters(
id: default(string),
name: default(string),
type: default(string),
location: location,
tags: tags,
resource: new SqlDatabaseResource(databaseName),
options: new CreateUpdateOptions {
Throughput = sampleThroughput2
});
SqlDatabaseGetResults sqlDatabaseGetResults3 = await WaitForCompletionAsync(
await CosmosDBManagementClient.SqlResources.StartCreateUpdateSqlDatabaseAsync(
resourceGroupName, databaseAccountName, databaseName, sqlDatabaseCreateUpdateParameters2));
Assert.NotNull(sqlDatabaseGetResults3);
SqlDatabaseGetResults sqlDatabaseGetResults4 = await CosmosDBManagementClient.SqlResources.GetSqlDatabaseAsync(
resourceGroupName, databaseAccountName, databaseName);
Assert.NotNull(sqlDatabaseGetResults4);
VerifySqlDatabases(sqlDatabaseGetResults3, sqlDatabaseGetResults4);
ThroughputSettingsGetResults throughputSettingsGetResults2 =
await CosmosDBManagementClient.SqlResources.GetSqlDatabaseThroughputAsync(resourceGroupName, databaseAccountName, databaseName);
Assert.NotNull(throughputSettingsGetResults2);
Assert.NotNull(throughputSettingsGetResults2.Name);
Assert.AreEqual(sqlDatabasesThroughputType, throughputSettingsGetResults2.Type);
Assert.AreEqual(sampleThroughput2, throughputSettingsGetResults2.Resource.Throughput);
}
public async Task MongoDBCollectionCreateAndUpdateTest()
{
MongoDBCollectionGetResults mongoDBCollectionGetResults1 = await WaitForCompletionAsync(
await CosmosDBManagementClient.MongoDBResources.StartCreateUpdateMongoDBCollectionAsync(
resourceGroupName,
databaseAccountName,
databaseName,
collectionName,
new MongoDBCollectionCreateUpdateParameters(
new MongoDBCollectionResource(collectionName), new CreateUpdateOptions(sampleThroughput1, new AutoscaleSettings()))));
Assert.IsNotNull(mongoDBCollectionGetResults1);
Assert.AreEqual(collectionName, mongoDBCollectionGetResults1.Resource.Id);
ThroughputSettingsGetResults throughputSettingsGetResults1 =
await CosmosDBManagementClient.MongoDBResources.GetMongoDBCollectionThroughputAsync(resourceGroupName, databaseAccountName, databaseName, collectionName);
Assert.IsNotNull(throughputSettingsGetResults1);
Assert.AreEqual(sampleThroughput1, throughputSettingsGetResults1.Resource.Throughput);
Assert.AreEqual(mongoDBCollectionsThroughputType, throughputSettingsGetResults1.Type);
MongoDBCollectionGetResults mongoDBCollectionGetResults =
await CosmosDBManagementClient.MongoDBResources.GetMongoDBCollectionAsync(resourceGroupName, databaseAccountName, databaseName, collectionName);
Assert.IsNotNull(mongoDBCollectionGetResults);
VerifyMongoDBCollections(mongoDBCollectionGetResults1, mongoDBCollectionGetResults);
MongoDBCollectionGetResults mongoDBCollectionGetResults2 = await WaitForCompletionAsync(
await CosmosDBManagementClient.MongoDBResources.StartCreateUpdateMongoDBCollectionAsync(
resourceGroupName,
databaseAccountName,
databaseName,
collectionName,
new MongoDBCollectionCreateUpdateParameters(
new MongoDBCollectionResource(collectionName), new CreateUpdateOptions(sampleThroughput2, new AutoscaleSettings()))));
Assert.IsNotNull(mongoDBCollectionGetResults2);
Assert.AreEqual(collectionName, mongoDBCollectionGetResults2.Resource.Id);
ThroughputSettingsGetResults throughputSettingsGetResults2 =
await CosmosDBManagementClient.MongoDBResources.GetMongoDBCollectionThroughputAsync(resourceGroupName, databaseAccountName, databaseName, collectionName);
Assert.IsNotNull(throughputSettingsGetResults2);
Assert.AreEqual(sampleThroughput2, throughputSettingsGetResults2.Resource.Throughput);
Assert.AreEqual(mongoDBCollectionsThroughputType, throughputSettingsGetResults2.Type);
mongoDBCollectionGetResults =
await CosmosDBManagementClient.MongoDBResources.GetMongoDBCollectionAsync(resourceGroupName, databaseAccountName, databaseName, collectionName);
Assert.IsNotNull(mongoDBCollectionGetResults);
VerifyMongoDBCollections(mongoDBCollectionGetResults2, mongoDBCollectionGetResults);
}
public PSThroughputSettingsGetResults(ThroughputSettingsGetResults throughputSettingsGetResults)
{
if (throughputSettingsGetResults == null || throughputSettingsGetResults.Resource == null)
{
return;
}
Name = throughputSettingsGetResults.Name;
Id = throughputSettingsGetResults.Id;
Throughput = throughputSettingsGetResults.Resource.Throughput.Value;
MinimumThroughput = throughputSettingsGetResults.Resource.MinimumThroughput;
OfferReplacePending = throughputSettingsGetResults.Resource.OfferReplacePending;
AutoscaleSettings = new PSAutoscaleSettingsResource(throughputSettingsGetResults.Resource.AutoscaleSettings);
}
public override void ExecuteCmdlet()
{
if (ParameterSetName.Equals(ParentObjectParameterSet, StringComparison.Ordinal))
{
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(InputObject.Id);
AccountName = resourceIdentifier.ResourceName;
ResourceGroupName = resourceIdentifier.ResourceGroupName;
}
ThroughputSettingsGetResults throughputSettingsGetResults = CosmosDBManagementClient.CassandraResources.GetCassandraKeyspaceThroughputWithHttpMessagesAsync(ResourceGroupName, AccountName, Name).GetAwaiter().GetResult().Body;
WriteObject(new PSThroughputSettingsGetResults(throughputSettingsGetResults));
return;
}
public override void ExecuteCmdlet()
{
if (ParameterSetName.Equals(ParentObjectParameterSet, StringComparison.Ordinal))
{
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(InputObject.Id);
ResourceGroupName = resourceIdentifier.ResourceGroupName;
Name = resourceIdentifier.ResourceName;
DatabaseName = ResourceIdentifierExtensions.GetMongoDBDatabaseName(resourceIdentifier);
AccountName = ResourceIdentifierExtensions.GetDatabaseAccountName(resourceIdentifier);
}
ThroughputSettingsGetResults throughputSettingsGetResults = CosmosDBManagementClient.MongoDBResources.GetMongoDBCollectionThroughputWithHttpMessagesAsync(ResourceGroupName, AccountName, DatabaseName, Name).GetAwaiter().GetResult().Body;
WriteObject(new PSThroughputSettingsGetResults(throughputSettingsGetResults));
return;
}
public async Task TableCreateAndUpdateTest()
{
TableGetResults tableGetResults1 = await WaitForCompletionAsync(
await CosmosDBManagementClient.TableResources.StartCreateUpdateTableAsync(
resourceGroupName,
databaseAccountName,
tableName,
new TableCreateUpdateParameters(new TableResource(tableName), new CreateUpdateOptions())));
Assert.IsNotNull(tableGetResults1);
Assert.AreEqual(tableName, tableGetResults1.Resource.Id);
ThroughputSettingsGetResults throughputSettingsGetResults1 =
await CosmosDBManagementClient.TableResources.GetTableThroughputAsync(resourceGroupName, databaseAccountName, tableName);
Assert.IsNotNull(throughputSettingsGetResults1);
Assert.AreEqual(defaultThroughput, throughputSettingsGetResults1.Resource.Throughput);
Assert.AreEqual(tableThroughputType, throughputSettingsGetResults1.Type);
TableGetResults tableGetResults2 = await CosmosDBManagementClient.TableResources.GetTableAsync(resourceGroupName, databaseAccountName, tableName);
Assert.IsNotNull(tableGetResults2);
VerifyTables(tableGetResults1, tableGetResults2);
TableGetResults tableGetResults3 = await WaitForCompletionAsync(
await CosmosDBManagementClient.TableResources.StartCreateUpdateTableAsync(
resourceGroupName,
databaseAccountName,
tableName,
new TableCreateUpdateParameters(new TableResource(tableName), new CreateUpdateOptions(sampleThroughput, new AutoscaleSettings()))));
Assert.IsNotNull(tableGetResults3);
Assert.AreEqual(tableName, tableGetResults3.Resource.Id);
ThroughputSettingsGetResults throughputSettingsGetResults2 =
await CosmosDBManagementClient.TableResources.GetTableThroughputAsync(resourceGroupName, databaseAccountName, tableName);
Assert.IsNotNull(throughputSettingsGetResults2);
Assert.AreEqual(sampleThroughput, throughputSettingsGetResults2.Resource.Throughput);
Assert.AreEqual(tableThroughputType, throughputSettingsGetResults2.Type);
TableGetResults tableGetResults4 = await CosmosDBManagementClient.TableResources.GetTableAsync(resourceGroupName, databaseAccountName, tableName);
Assert.IsNotNull(tableGetResults4);
VerifyTables(tableGetResults3, tableGetResults4);
}
public void MongoCRUDTests()
{
var handler1 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
using (MockContext context = MockContext.Start(this.GetType()))
{
// Create client
CosmosDBManagementClient cosmosDBManagementClient = CosmosDBTestUtilities.GetCosmosDBClient(context, handler1);
bool isDatabaseNameExists = cosmosDBManagementClient.DatabaseAccounts.CheckNameExistsWithHttpMessagesAsync(databaseAccountName).GetAwaiter().GetResult().Body;
DatabaseAccountGetResults databaseAccount = null;
if (!isDatabaseNameExists)
{
DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters
{
Location = location,
Kind = DatabaseAccountKind.MongoDB,
Properties = new DefaultRequestDatabaseAccountCreateUpdateProperties
{
Locations = new List <Location>
{
{ new Location(locationName: location) }
}
}
};
databaseAccount = cosmosDBManagementClient.DatabaseAccounts.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseAccountCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.Equal(databaseAccount.Name, databaseAccountName);
}
MongoDBDatabaseCreateUpdateParameters mongoDBDatabaseCreateUpdateParameters = new MongoDBDatabaseCreateUpdateParameters
{
Resource = new MongoDBDatabaseResource {
Id = databaseName
},
Options = new CreateUpdateOptions()
};
MongoDBDatabaseGetResults mongoDBDatabaseGetResults = cosmosDBManagementClient.MongoDBResources.CreateUpdateMongoDBDatabaseWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, mongoDBDatabaseCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.Equal(databaseName, mongoDBDatabaseGetResults.Name);
Assert.NotNull(mongoDBDatabaseGetResults);
MongoDBDatabaseGetResults mongoDBDatabaseGetResults1 = cosmosDBManagementClient.MongoDBResources.GetMongoDBDatabaseWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoDBDatabaseGetResults1);
Assert.Equal(databaseName, mongoDBDatabaseGetResults1.Name);
VerifyEqualMongoDBDatabases(mongoDBDatabaseGetResults, mongoDBDatabaseGetResults1);
MongoDBDatabaseCreateUpdateParameters mongoDBDatabaseCreateUpdateParameters2 = new MongoDBDatabaseCreateUpdateParameters
{
Resource = new MongoDBDatabaseResource {
Id = databaseName2
},
Options = new CreateUpdateOptions
{
Throughput = sampleThroughput
}
};
MongoDBDatabaseGetResults mongoDBDatabaseGetResults2 = cosmosDBManagementClient.MongoDBResources.CreateUpdateMongoDBDatabaseWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName2, mongoDBDatabaseCreateUpdateParameters2).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoDBDatabaseGetResults2);
Assert.Equal(databaseName2, mongoDBDatabaseGetResults2.Name);
IEnumerable <MongoDBDatabaseGetResults> mongoDBDatabases = cosmosDBManagementClient.MongoDBResources.ListMongoDBDatabasesWithHttpMessagesAsync(resourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoDBDatabases);
ThroughputSettingsGetResults throughputSettingsGetResults = cosmosDBManagementClient.MongoDBResources.GetMongoDBDatabaseThroughputWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName2).GetAwaiter().GetResult().Body;
Assert.NotNull(throughputSettingsGetResults);
Assert.NotNull(throughputSettingsGetResults.Name);
Assert.Equal(throughputSettingsGetResults.Resource.Throughput, sampleThroughput);
Assert.Equal(mongoDatabaseThroughputType, throughputSettingsGetResults.Type);
MongoDBCollectionCreateUpdateParameters mongoDBCollectionCreateUpdateParameters = new MongoDBCollectionCreateUpdateParameters
{
Resource = new MongoDBCollectionResource
{
Id = collectionName,
},
Options = new CreateUpdateOptions()
};
MongoDBCollectionGetResults mongoDBCollectionGetResults = cosmosDBManagementClient.MongoDBResources.CreateUpdateMongoDBCollectionWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, collectionName, mongoDBCollectionCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoDBCollectionGetResults);
VerfiyMongoCollectionCreation(mongoDBCollectionGetResults, mongoDBCollectionCreateUpdateParameters);
IEnumerable <MongoDBCollectionGetResults> mongoDBCollections = cosmosDBManagementClient.MongoDBResources.ListMongoDBCollectionsWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoDBCollections);
foreach (MongoDBCollectionGetResults mongoDBCollection in mongoDBCollections)
{
cosmosDBManagementClient.MongoDBResources.DeleteMongoDBCollectionWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, mongoDBCollection.Name);
}
foreach (MongoDBDatabaseGetResults mongoDBDatabase in mongoDBDatabases)
{
cosmosDBManagementClient.MongoDBResources.DeleteMongoDBDatabaseWithHttpMessagesAsync(resourceGroupName, databaseAccountName, mongoDBDatabase.Name);
}
}
}
public void MongoCRUDTests()
{
var handler1 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
var handler2 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
using (MockContext context = MockContext.Start(this.GetType()))
{
// Create client
CosmosDBManagementClient cosmosDBManagementClient = CosmosDBTestUtilities.GetCosmosDBClient(context, handler1);
ResourceManagementClient resourcesClient = CosmosDBTestUtilities.GetResourceManagementClient(context, handler2);
string resourceGroupName = "CosmosDBResourceGroup3668";
string databaseAccountName = "db001";
bool isDatabaseNameExists = cosmosDBManagementClient.DatabaseAccounts.CheckNameExistsWithHttpMessagesAsync(databaseAccountName).GetAwaiter().GetResult().Body;
DatabaseAccountGetResults databaseAccount = null;
if (!isDatabaseNameExists)
{
List <Location> locations = new List <Location>();
locations.Add(new Location(locationName: "East US"));
DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters
{
Location = "EAST US",
Kind = "MongoDB",
Locations = locations
};
databaseAccount = cosmosDBManagementClient.DatabaseAccounts.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseAccountCreateUpdateParameters).GetAwaiter().GetResult().Body;
}
string databaseName = "databaseName3668";
string databaseName2 = "databaseName23668";
MongoDBDatabaseCreateUpdateParameters mongoDBDatabaseCreateUpdateParameters = new MongoDBDatabaseCreateUpdateParameters
{
Resource = new MongoDBDatabaseResource {
Id = databaseName
},
Options = new Dictionary <string, string>()
{
{ "foo", "bar" }
}
};
MongoDBDatabaseGetResults mongoDBDatabaseGetResults = cosmosDBManagementClient.MongoDBResources.CreateUpdateMongoDBDatabaseWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, mongoDBDatabaseCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.Equal(databaseName, mongoDBDatabaseGetResults.Name);
Assert.NotNull(mongoDBDatabaseGetResults);
Assert.Equal("Microsoft.DocumentDB/databaseAccounts/mongodbDatabases", mongoDBDatabaseGetResults.Type);
MongoDBDatabaseGetResults mongoDBDatabaseGetResults1 = cosmosDBManagementClient.MongoDBResources.GetMongoDBDatabaseWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoDBDatabaseGetResults1);
Assert.Equal(databaseName, mongoDBDatabaseGetResults1.Name);
Assert.Equal("Microsoft.DocumentDB/databaseAccounts/mongodbDatabases", mongoDBDatabaseGetResults1.Type);
VerifyEqualMongoDBDatabases(mongoDBDatabaseGetResults, mongoDBDatabaseGetResults1);
MongoDBDatabaseCreateUpdateParameters mongoDBDatabaseCreateUpdateParameters2 = new MongoDBDatabaseCreateUpdateParameters
{
Resource = new MongoDBDatabaseResource {
Id = databaseName2
},
Options = new Dictionary <string, string>()
{
{ "Throughput", "700" }
}
};
MongoDBDatabaseGetResults mongoDBDatabaseGetResults2 = cosmosDBManagementClient.MongoDBResources.CreateUpdateMongoDBDatabaseWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName2, mongoDBDatabaseCreateUpdateParameters2).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoDBDatabaseGetResults2);
Assert.Equal(databaseName2, mongoDBDatabaseGetResults2.Name);
Assert.Equal("Microsoft.DocumentDB/databaseAccounts/mongodbDatabases", mongoDBDatabaseGetResults2.Type);
IEnumerable <MongoDBDatabaseGetResults> mongoDBDatabases = cosmosDBManagementClient.MongoDBResources.ListMongoDBDatabasesWithHttpMessagesAsync(resourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoDBDatabases);
ThroughputSettingsGetResults throughputSettingsGetResults = cosmosDBManagementClient.MongoDBResources.GetMongoDBDatabaseThroughputWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName2).GetAwaiter().GetResult().Body;
Assert.NotNull(throughputSettingsGetResults);
Assert.NotNull(throughputSettingsGetResults.Name);
Assert.Equal("Microsoft.DocumentDB/databaseAccounts/mongodbDatabases/throughputSettings", throughputSettingsGetResults.Type);
string collectionName = "collectionName3668";
MongoDBCollectionCreateUpdateParameters mongoDBCollectionCreateUpdateParameters = new MongoDBCollectionCreateUpdateParameters
{
Resource = new MongoDBCollectionResource
{
Id = collectionName,
},
Options = new Dictionary <string, string>()
{
{ "foo", "bar" },
}
};
MongoDBCollectionGetResults mongoDBCollectionGetResults = cosmosDBManagementClient.MongoDBResources.CreateUpdateMongoDBCollectionWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, collectionName, mongoDBCollectionCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoDBCollectionGetResults);
IEnumerable <MongoDBCollectionGetResults> mongoDBCollections = cosmosDBManagementClient.MongoDBResources.ListMongoDBCollectionsWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoDBCollections);
foreach (MongoDBCollectionGetResults mongoDBCollection in mongoDBCollections)
{
cosmosDBManagementClient.MongoDBResources.DeleteMongoDBCollectionWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, mongoDBCollection.Name);
}
foreach (MongoDBDatabaseGetResults mongoDBDatabase in mongoDBDatabases)
{
cosmosDBManagementClient.MongoDBResources.DeleteMongoDBDatabaseWithHttpMessagesAsync(resourceGroupName, databaseAccountName, mongoDBDatabase.Name);
}
}
}
public void SqlCRUDTests()
{
var handler1 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
using (MockContext context = MockContext.Start(this.GetType()))
{
// Create client
CosmosDBManagementClient cosmosDBManagementClient = CosmosDBTestUtilities.GetCosmosDBClient(context, handler1);
bool isDatabaseNameExists = cosmosDBManagementClient.DatabaseAccounts.CheckNameExistsWithHttpMessagesAsync(databaseAccountName).GetAwaiter().GetResult().Body;
DatabaseAccountGetResults databaseAccount = null;
if (!isDatabaseNameExists)
{
DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters
{
Location = location,
Kind = DatabaseAccountKind.GlobalDocumentDB,
Locations = new List <Location>()
{
{ new Location(locationName: location) }
}
};
databaseAccount = cosmosDBManagementClient.DatabaseAccounts.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseAccountCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.Equal(databaseAccount.Name, databaseAccountName);
}
SqlDatabaseCreateUpdateParameters sqlDatabaseCreateUpdateParameters = new SqlDatabaseCreateUpdateParameters
{
Resource = new SqlDatabaseResource {
Id = databaseName
},
Options = new CreateUpdateOptions()
};
SqlDatabaseGetResults sqlDatabaseGetResults = cosmosDBManagementClient.SqlResources.CreateUpdateSqlDatabaseWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, sqlDatabaseCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlDatabaseGetResults);
Assert.Equal(databaseName, sqlDatabaseGetResults.Name);
SqlDatabaseGetResults sqlDatabaseGetResults2 = cosmosDBManagementClient.SqlResources.GetSqlDatabaseWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlDatabaseGetResults2);
Assert.Equal(databaseName, sqlDatabaseGetResults2.Name);
VerifyEqualSqlDatabases(sqlDatabaseGetResults, sqlDatabaseGetResults2);
SqlDatabaseCreateUpdateParameters sqlDatabaseCreateUpdateParameters2 = new SqlDatabaseCreateUpdateParameters
{
Location = location,
Tags = tags,
Resource = new SqlDatabaseResource {
Id = databaseName2
},
Options = new CreateUpdateOptions
{
Throughput = sampleThroughput
}
};
SqlDatabaseGetResults sqlDatabaseGetResults3 = cosmosDBManagementClient.SqlResources.CreateUpdateSqlDatabaseWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName2, sqlDatabaseCreateUpdateParameters2).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlDatabaseGetResults3);
Assert.Equal(databaseName2, sqlDatabaseGetResults3.Name);
IEnumerable <SqlDatabaseGetResults> sqlDatabases = cosmosDBManagementClient.SqlResources.ListSqlDatabasesWithHttpMessagesAsync(resourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlDatabases);
ThroughputSettingsGetResults throughputSettingsGetResults = cosmosDBManagementClient.SqlResources.GetSqlDatabaseThroughputWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName2).GetAwaiter().GetResult().Body;
Assert.NotNull(throughputSettingsGetResults);
Assert.NotNull(throughputSettingsGetResults.Name);
Assert.Equal(sqlThroughputType, throughputSettingsGetResults.Type);
SqlContainerCreateUpdateParameters sqlContainerCreateUpdateParameters = new SqlContainerCreateUpdateParameters
{
Resource = new SqlContainerResource {
Id = containerName,
PartitionKey = new ContainerPartitionKey
{
Kind = "Hash",
Paths = new List <string> {
"/address/zipCode"
}
},
IndexingPolicy = new IndexingPolicy
{
Automatic = true,
IndexingMode = IndexingMode.Consistent,
IncludedPaths = new List <IncludedPath>
{
new IncludedPath {
Path = "/*"
}
},
ExcludedPaths = new List <ExcludedPath>
{
new ExcludedPath {
Path = "/pathToNotIndex/*"
}
},
CompositeIndexes = new List <IList <CompositePath> >
{
new List <CompositePath>
{
new CompositePath {
Path = "/orderByPath1", Order = CompositePathSortOrder.Ascending
},
new CompositePath {
Path = "/orderByPath2", Order = CompositePathSortOrder.Descending
}
},
new List <CompositePath>
{
new CompositePath {
Path = "/orderByPath3", Order = CompositePathSortOrder.Ascending
},
new CompositePath {
Path = "/orderByPath4", Order = CompositePathSortOrder.Descending
}
}
}
}
},
Options = new CreateUpdateOptions
{
Throughput = sampleThroughput
}
};
SqlContainerGetResults sqlContainerGetResults = cosmosDBManagementClient.SqlResources.CreateUpdateSqlContainerWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, containerName, sqlContainerCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlContainerGetResults);
IEnumerable <SqlContainerGetResults> sqlContainers = cosmosDBManagementClient.SqlResources.ListSqlContainersWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlContainers);
SqlStoredProcedureCreateUpdateParameters sqlStoredProcedureCreateUpdateParameters = new SqlStoredProcedureCreateUpdateParameters
{
Resource = new SqlStoredProcedureResource
{
Id = storedProcedureName,
Body = "function () { var context = getContext(); " +
"var response = context.getResponse();" +
"response.setBody('Hello, World');" +
"}"
},
Options = new CreateUpdateOptions()
};
SqlStoredProcedureGetResults sqlStoredProcedureGetResults = cosmosDBManagementClient.SqlResources.CreateUpdateSqlStoredProcedureWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, containerName, storedProcedureName, sqlStoredProcedureCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlStoredProcedureGetResults);
Assert.Equal(sqlStoredProcedureGetResults.Resource.Body, sqlStoredProcedureGetResults.Resource.Body);
IEnumerable <SqlStoredProcedureGetResults> sqlStoredProcedures = cosmosDBManagementClient.SqlResources.ListSqlStoredProceduresWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, containerName).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlStoredProcedures);
foreach (SqlStoredProcedureGetResults sqlStoredProcedure in sqlStoredProcedures)
{
cosmosDBManagementClient.SqlResources.DeleteSqlStoredProcedureWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, containerName, sqlStoredProcedure.Name);
}
SqlUserDefinedFunctionCreateUpdateParameters sqlUserDefinedFunctionCreateUpdateParameters = new SqlUserDefinedFunctionCreateUpdateParameters
{
Resource = new SqlUserDefinedFunctionResource
{
Id = userDefinedFunctionName,
Body = "function () { var context = getContext(); " +
"var response = context.getResponse();" +
"response.setBody('Hello, World');" +
"}"
},
Options = new CreateUpdateOptions()
};
SqlUserDefinedFunctionGetResults sqlUserDefinedFunctionGetResults = cosmosDBManagementClient.SqlResources.CreateUpdateSqlUserDefinedFunctionWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, containerName, userDefinedFunctionName, sqlUserDefinedFunctionCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlUserDefinedFunctionGetResults);
Assert.Equal(sqlUserDefinedFunctionGetResults.Resource.Body, sqlUserDefinedFunctionGetResults.Resource.Body);
IEnumerable <SqlUserDefinedFunctionGetResults> sqlUserDefinedFunctions = cosmosDBManagementClient.SqlResources.ListSqlUserDefinedFunctionsWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, containerName).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlUserDefinedFunctions);
foreach (SqlUserDefinedFunctionGetResults sqlUserDefinedFunction in sqlUserDefinedFunctions)
{
cosmosDBManagementClient.SqlResources.DeleteSqlUserDefinedFunctionWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, containerName, sqlUserDefinedFunction.Name);
}
SqlTriggerCreateUpdateParameters sqlTriggerCreateUpdateParameters = new SqlTriggerCreateUpdateParameters
{
Resource = new SqlTriggerResource
{
Id = triggerName,
TriggerOperation = "All",
TriggerType = "Pre",
Body = "function () { var context = getContext(); " +
"var response = context.getResponse();" +
"response.setBody('Hello, World');" +
"}"
},
Options = new CreateUpdateOptions()
};
SqlTriggerGetResults sqlTriggerGetResults = cosmosDBManagementClient.SqlResources.CreateUpdateSqlTriggerWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, containerName, triggerName, sqlTriggerCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlTriggerGetResults);
Assert.Equal(sqlTriggerGetResults.Resource.TriggerType, sqlTriggerCreateUpdateParameters.Resource.TriggerType);
Assert.Equal(sqlTriggerGetResults.Resource.TriggerOperation, sqlTriggerCreateUpdateParameters.Resource.TriggerOperation);
Assert.Equal(sqlTriggerGetResults.Resource.Body, sqlTriggerCreateUpdateParameters.Resource.Body);
IEnumerable <SqlTriggerGetResults> sqlTriggers = cosmosDBManagementClient.SqlResources.ListSqlTriggersWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, containerName).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlTriggers);
foreach (SqlTriggerGetResults sqlTrigger in sqlTriggers)
{
cosmosDBManagementClient.SqlResources.DeleteSqlTriggerWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, containerName, sqlTrigger.Name);
}
foreach (SqlContainerGetResults sqlContainer in sqlContainers)
{
cosmosDBManagementClient.SqlResources.DeleteSqlContainerWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, sqlContainer.Name);
}
foreach (SqlDatabaseGetResults sqlDatabase in sqlDatabases)
{
cosmosDBManagementClient.SqlResources.DeleteSqlDatabaseWithHttpMessagesAsync(resourceGroupName, databaseAccountName, sqlDatabase.Name);
}
}
}
public void SqlCRUDTests()
{
var handler1 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
var handler2 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
using (MockContext context = MockContext.Start(this.GetType()))
{
// Create client
CosmosDBManagementClient cosmosDBManagementClient = CosmosDBTestUtilities.GetCosmosDBClient(context, handler1);
ResourceManagementClient resourcesClient = CosmosDBTestUtilities.GetResourceManagementClient(context, handler2);
string resourceGroupName = "CosmosDBResourceGroup822"; // Using a pre-existing ResourceGroup and DatabaseAccount, because Database Account provisioning takes some time
string databaseAccountName = "db9934";
bool isDatabaseNameExists = cosmosDBManagementClient.DatabaseAccounts.CheckNameExistsWithHttpMessagesAsync(databaseAccountName).GetAwaiter().GetResult().Body;
DatabaseAccountGetResults databaseAccount = null;
if (!isDatabaseNameExists)
{
List <Location> locations = new List <Location>();
locations.Add(new Location(locationName: "East US"));
DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters
{
Location = "EAST US",
Kind = "GlobalDocumentDB",
Locations = locations
};
databaseAccount = cosmosDBManagementClient.DatabaseAccounts.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseAccountCreateUpdateParameters).GetAwaiter().GetResult().Body;
}
string databaseName = "databaseName822";
string databaseName2 = "databaseName2822";
SqlDatabaseCreateUpdateParameters sqlDatabaseCreateUpdateParameters = new SqlDatabaseCreateUpdateParameters
{
Resource = new SqlDatabaseResource {
Id = databaseName
},
Options = new Dictionary <string, string>()
{
{ "foo", "bar" }
}
};
SqlDatabaseGetResults sqlDatabaseGetResults = cosmosDBManagementClient.SqlResources.CreateUpdateSqlDatabaseWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, sqlDatabaseCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlDatabaseGetResults);
Assert.Equal(databaseName, sqlDatabaseGetResults.Name);
SqlDatabaseGetResults sqlDatabaseGetResults2 = cosmosDBManagementClient.SqlResources.GetSqlDatabaseWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlDatabaseGetResults2);
Assert.Equal(databaseName, sqlDatabaseGetResults2.Name);
VerifyEqualSqlDatabases(sqlDatabaseGetResults, sqlDatabaseGetResults2);
SqlDatabaseCreateUpdateParameters sqlDatabaseCreateUpdateParameters2 = new SqlDatabaseCreateUpdateParameters
{
Location = "EAST US",
Tags = new Dictionary <string, string>
{
{ "key3", "value3" },
{ "key4", "value4" }
},
Resource = new SqlDatabaseResource {
Id = databaseName2
},
Options = new Dictionary <string, string>()
{
{ "Throughput", "700" }
}
};
SqlDatabaseGetResults sqlDatabaseGetResults3 = cosmosDBManagementClient.SqlResources.CreateUpdateSqlDatabaseWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName2, sqlDatabaseCreateUpdateParameters2).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlDatabaseGetResults3);
Assert.Equal(databaseName2, sqlDatabaseGetResults3.Name);
IEnumerable <SqlDatabaseGetResults> sqlDatabases = cosmosDBManagementClient.SqlResources.ListSqlDatabasesWithHttpMessagesAsync(resourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlDatabases);
ThroughputSettingsGetResults throughputSettingsGetResults = cosmosDBManagementClient.SqlResources.GetSqlDatabaseThroughputWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName2).GetAwaiter().GetResult().Body;
Assert.NotNull(throughputSettingsGetResults);
Assert.NotNull(throughputSettingsGetResults.Name);
Assert.Equal("Microsoft.DocumentDB/databaseAccounts/sqlDatabases/throughputSettings", throughputSettingsGetResults.Type);
string containerName = "containerName822";
SqlContainerCreateUpdateParameters sqlContainerCreateUpdateParameters = new SqlContainerCreateUpdateParameters
{
Resource = new SqlContainerResource {
Id = containerName,
PartitionKey = new ContainerPartitionKey
{
Kind = "Hash",
Paths = new List <string> {
"/address/zipCode"
}
}
},
Options = new Dictionary <string, string>()
{
{ "Throughput", "700" }
}
};
SqlContainerGetResults sqlContainerGetResults = cosmosDBManagementClient.SqlResources.CreateUpdateSqlContainerWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, containerName, sqlContainerCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlContainerGetResults);
IEnumerable <SqlContainerGetResults> sqlContainers = cosmosDBManagementClient.SqlResources.ListSqlContainersWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlContainers);
string storedProcedureName = "storedProcedureName822";
SqlStoredProcedureCreateUpdateParameters sqlStoredProcedureCreateUpdateParameters = new SqlStoredProcedureCreateUpdateParameters
{
Resource = new SqlStoredProcedureResource
{
Id = storedProcedureName,
Body = "function () { var context = getContext(); " +
"var response = context.getResponse();" +
"response.setBody('Hello, World');" +
"}"
},
Options = new Dictionary <string, string>()
{
{ "foo", "bar" }
}
};
SqlStoredProcedureGetResults sqlStoredProcedureGetResults = cosmosDBManagementClient.SqlResources.CreateUpdateSqlStoredProcedureWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, containerName, storedProcedureName, sqlStoredProcedureCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlStoredProcedureGetResults);
IEnumerable <SqlStoredProcedureGetResults> sqlStoredProcedures = cosmosDBManagementClient.SqlResources.ListSqlStoredProceduresWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, containerName).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlStoredProcedures);
foreach (SqlStoredProcedureGetResults sqlStoredProcedure in sqlStoredProcedures)
{
cosmosDBManagementClient.SqlResources.DeleteSqlStoredProcedureWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, containerName, sqlStoredProcedure.Name);
}
string userDefinedFunctionName = "userDefinedFunctionName822";
SqlUserDefinedFunctionCreateUpdateParameters sqlUserDefinedFunctionCreateUpdateParameters = new SqlUserDefinedFunctionCreateUpdateParameters
{
Resource = new SqlUserDefinedFunctionResource
{
Id = userDefinedFunctionName,
Body = "function () { var context = getContext(); " +
"var response = context.getResponse();" +
"response.setBody('Hello, World');" +
"}"
},
Options = new Dictionary <string, string>()
{
{ "foo", "bar" }
}
};
SqlUserDefinedFunctionGetResults sqlUserDefinedFunctionGetResults = cosmosDBManagementClient.SqlResources.CreateUpdateSqlUserDefinedFunctionWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, containerName, userDefinedFunctionName, sqlUserDefinedFunctionCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlStoredProcedureGetResults);
IEnumerable <SqlUserDefinedFunctionGetResults> sqlUserDefinedFunctions = cosmosDBManagementClient.SqlResources.ListSqlUserDefinedFunctionsWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, containerName).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlUserDefinedFunctions);
foreach (SqlUserDefinedFunctionGetResults sqlUserDefinedFunction in sqlUserDefinedFunctions)
{
cosmosDBManagementClient.SqlResources.DeleteSqlUserDefinedFunctionWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, containerName, sqlUserDefinedFunction.Name);
}
string triggerName = "triggerName822";
SqlTriggerCreateUpdateParameters sqlTriggerCreateUpdateParameters = new SqlTriggerCreateUpdateParameters
{
Resource = new SqlTriggerResource
{
Id = triggerName,
TriggerOperation = "All",
TriggerType = "Pre",
Body = "function () { var context = getContext(); " +
"var response = context.getResponse();" +
"response.setBody('Hello, World');" +
"}"
},
Options = new Dictionary <string, string>()
{
{ "foo", "bar" }
}
};
SqlTriggerGetResults sqlTriggerGetResults = cosmosDBManagementClient.SqlResources.CreateUpdateSqlTriggerWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, containerName, triggerName, sqlTriggerCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlTriggerGetResults);
IEnumerable <SqlTriggerGetResults> sqlTriggers = cosmosDBManagementClient.SqlResources.ListSqlTriggersWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, containerName).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlTriggers);
foreach (SqlTriggerGetResults sqlTrigger in sqlTriggers)
{
cosmosDBManagementClient.SqlResources.DeleteSqlTriggerWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, containerName, sqlTrigger.Name);
}
foreach (SqlContainerGetResults sqlContainer in sqlContainers)
{
cosmosDBManagementClient.SqlResources.DeleteSqlContainerWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, sqlContainer.Name);
}
foreach (SqlDatabaseGetResults sqlDatabase in sqlDatabases)
{
cosmosDBManagementClient.SqlResources.DeleteSqlDatabaseWithHttpMessagesAsync(resourceGroupName, databaseAccountName, sqlDatabase.Name);
}
}
}
