public async Task GremlinDatabaseCreateUpdateTests()
{
GremlinDatabaseCreateUpdateParameters gremlinDatabaseCreateUpdateParameters = new GremlinDatabaseCreateUpdateParameters(new GremlinDatabaseResource(databaseName), new CreateUpdateOptions(sampleThroughput, new AutoscaleSettings()));
var gremlinDatabaseResponse1 = await WaitForCompletionAsync(await CosmosDBManagementClient.GremlinResources.StartCreateUpdateGremlinDatabaseAsync(resourceGroupName, databaseAccountName, databaseName, gremlinDatabaseCreateUpdateParameters));
Assert.NotNull(gremlinDatabaseResponse1);
GremlinDatabase gremlinDatabase1 = gremlinDatabaseResponse1.Value;
Assert.NotNull(gremlinDatabase1);
Assert.AreEqual(databaseName, gremlinDatabase1.Name);
var gremlinDatabaseResponse2 = await CosmosDBManagementClient.GremlinResources.GetGremlinDatabaseAsync(resourceGroupName, databaseAccountName, databaseName);
Assert.NotNull(gremlinDatabaseResponse2);
GremlinDatabase gremlinDatabase2 = gremlinDatabaseResponse2.Value;
Assert.NotNull(gremlinDatabase2);
Assert.AreEqual(databaseName, gremlinDatabase2.Name);
VerifyEqualGremlinDatabases(gremlinDatabase1, gremlinDatabase2);
var throughputResponse = CosmosDBManagementClient.GremlinResources.GetGremlinDatabaseThroughputAsync(resourceGroupName, databaseAccountName, databaseName);
ThroughputSettingsData ThroughputSettingsData = throughputResponse.ConfigureAwait(false).GetAwaiter().GetResult();
Assert.NotNull(throughputSettings);
Assert.NotNull(throughputSettings.Name);
Assert.AreEqual(throughputSettings.Resource.Throughput, sampleThroughput);
Assert.AreEqual(gremlinDatabasesThroughputType, throughputSettings.Type);
GremlinDatabaseCreateUpdateParameters gremlinDatabaseCreateUpdateParameters2 = new GremlinDatabaseCreateUpdateParameters(new GremlinDatabaseResource(databaseName), new CreateUpdateOptions(sampleThroughput2, new AutoscaleSettings()));
var gremlinDatabaseResponse3 = await WaitForCompletionAsync(await CosmosDBManagementClient.GremlinResources.StartCreateUpdateGremlinDatabaseAsync(resourceGroupName, databaseAccountName, databaseName, gremlinDatabaseCreateUpdateParameters2));
Assert.NotNull(gremlinDatabaseResponse3);
GremlinDatabase gremlinDatabase3 = gremlinDatabaseResponse3.Value;
Assert.NotNull(gremlinDatabase3);
Assert.AreEqual(databaseName, gremlinDatabase3.Name);
var gremlinDatabaseResponse4 = await CosmosDBManagementClient.GremlinResources.GetGremlinDatabaseAsync(resourceGroupName, databaseAccountName, databaseName);
Assert.NotNull(gremlinDatabaseResponse4);
GremlinDatabase gremlinDatabase4 = gremlinDatabaseResponse4.Value;
Assert.NotNull(gremlinDatabase4);
Assert.AreEqual(databaseName, gremlinDatabase4.Name);
VerifyEqualGremlinDatabases(gremlinDatabase3, gremlinDatabase4);
var throughputResponse2 = CosmosDBManagementClient.GremlinResources.GetGremlinDatabaseThroughputAsync(resourceGroupName, databaseAccountName, databaseName);
ThroughputSettingsData throughputSettings2 = throughputResponse2.ConfigureAwait(false).GetAwaiter().GetResult();
Assert.NotNull(throughputSettings2);
Assert.NotNull(throughputSettings2.Name);
Assert.AreEqual(throughputSettings2.Resource.Throughput, sampleThroughput2);
Assert.AreEqual(gremlinDatabasesThroughputType, throughputSettings2.Type);
}
public async Task SqlContainerMigrateToManualThroughputTest()
{
ThroughputSettingsData ThroughputSettingsData = await WaitForCompletionAsync(
await CosmosDBManagementClient.SqlResources.StartMigrateSqlContainerToManualThroughputAsync(
resourceGroupName, databaseAccountName, databaseName, containerName));
Assert.NotNull(throughputSettings);
Assert.IsNull(throughputSettings.Resource.AutoscaleSettings);
Assert.AreEqual(defaultMaxThroughput, throughputSettings.Resource.Throughput);
}
public async Task TableMigrateToAutoscaleTest()
{
ThroughputSettingsData ThroughputSettingsData = await WaitForCompletionAsync(
await CosmosDBManagementClient.TableResources.StartMigrateTableToAutoscaleAsync(resourceGroupName, databaseAccountName, tableName));
Assert.IsNotNull(throughputSettings);
Assert.IsNotNull(throughputSettings.Resource.AutoscaleSettings);
Assert.AreEqual(defaultMaxThroughput, throughputSettings.Resource.AutoscaleSettings.MaxThroughput);
Assert.AreEqual(defaultThroughput, throughputSettings.Resource.Throughput);
}
public async Task SqlDatabaseThroughputUpdateTest()
{
ThroughputSettingsData ThroughputSettingsData = await WaitForCompletionAsync(
await CosmosDBManagementClient.SqlResources.StartUpdateSqlDatabaseThroughputAsync(
resourceGroupName,
databaseAccountName,
databaseName,
new ThroughputSettingsUpdateParameters(new ThroughputSettingsResource(sampleThroughput2, null, null, null))));
Assert.NotNull(throughputSettings);
Assert.AreEqual(sampleThroughput2, throughputSettings.Resource.Throughput);
}
public async Task TableUpdateThroughputTest()
{
ThroughputSettingsData ThroughputSettingsData = await WaitForCompletionAsync(
await CosmosDBManagementClient.TableResources.StartUpdateTableThroughputAsync(
resourceGroupName,
databaseAccountName,
tableName,
new ThroughputSettingsUpdateParameters(new ThroughputSettingsResource(defaultThroughput, null, null, null))));
Assert.IsNotNull(throughputSettings);
Assert.AreEqual(defaultThroughput, throughputSettings.Resource.Throughput);
}
public async Task SqlContainerMigrateToAutoscale()
{
var container = await CreateSqlContainer(null);
DatabaseAccountSqlDatabaseContainerThroughputSettingResource throughput = await container.GetDatabaseAccountSqlDatabaseContainerThroughputSetting().GetAsync();
AssertManualThroughput(throughput.Data);
ThroughputSettingsData throughputData = (await throughput.MigrateSqlContainerToAutoscaleAsync(WaitUntil.Completed)).Value.Data;
AssertAutoscale(throughputData);
}
public async Task GremlinDatabaseMigrateToAutoscale()
{
var database = await CreateGremlinDatabase(null);
DatabaseAccountGremlinDatabaseThroughputSettingResource throughput = await database.GetDatabaseAccountGremlinDatabaseThroughputSetting().GetAsync();
AssertManualThroughput(throughput.Data);
ThroughputSettingsData throughputData = (await throughput.MigrateGremlinDatabaseToAutoscaleAsync(WaitUntil.Completed)).Value.Data;
AssertAutoscale(throughputData);
}
public async Task MongoDBCollectionMigrateToAutoscale()
{
var collection = await CreateMongoDBCollection(null);
DatabaseAccountMongodbDatabaseCollectionThroughputSettingResource throughput = await collection.GetDatabaseAccountMongodbDatabaseCollectionThroughputSetting().GetAsync();
AssertManualThroughput(throughput.Data);
ThroughputSettingsData throughputData = (await throughput.MigrateMongoDBCollectionToAutoscaleAsync(WaitUntil.Completed)).Value.Data;
AssertAutoscale(throughputData);
}
public async Task GremlinGraphUpdateThroughputTests()
{
ThroughputSettingsUpdateParameters throughputSettingsUpdateParameters = new ThroughputSettingsUpdateParameters(new ThroughputSettingsResource(maxThroughput, null, null, null));
var throughputResponse = await WaitForCompletionAsync(await CosmosDBManagementClient.GremlinResources.StartUpdateGremlinGraphThroughputAsync(resourceGroupName, databaseAccountName, databaseName, gremlinGraphName, throughputSettingsUpdateParameters));
ThroughputSettingsData ThroughputSettingsData = throughputResponse.Value;
Assert.NotNull(throughputSettings);
Assert.NotNull(throughputSettings.Name);
Assert.AreEqual(throughputSettings.Resource.Throughput, maxThroughput);
Assert.AreEqual(gremlinGraphsThroughputType, throughputSettings.Type);
}
public async Task MongoDBDatabaseUpdateThroughputTest()
{
ThroughputSettingsData ThroughputSettingsData = (await WaitForCompletionAsync(
await CosmosDBManagementClient.MongoDBResources.StartUpdateMongoDBDatabaseThroughputAsync(
resourceGroupName,
databaseAccountName,
databaseName,
new ThroughputSettingsUpdateParameters(new ThroughputSettingsResource(sampleThroughput1, null, null, null))))).Value;
Assert.IsNotNull(throughputSettings);
Assert.AreEqual(sampleThroughput1, throughputSettings.Resource.Throughput);
}
public async Task CassandraTableMigrateToAutoscale()
{
var table = await CreateCassandraTable(null);
DatabaseAccountCassandraKeyspaceTableThroughputSettingResource throughput = await table.GetDatabaseAccountCassandraKeyspaceTableThroughputSetting().GetAsync();
AssertManualThroughput(throughput.Data);
ThroughputSettingsData throughputData = (await throughput.MigrateCassandraTableToAutoscaleAsync(WaitUntil.Completed)).Value.Data;
AssertAutoscale(throughputData);
}
public async Task SqlDatabaseCreateAndUpdateTest()
{
SqlDatabaseCreateUpdateParameters sqlDatabaseCreateUpdateParameters1 = new SqlDatabaseCreateUpdateParameters(
new SqlDatabaseResource(databaseName), new CreateUpdateOptions(sampleThroughput1, new AutoscaleSettings()));
SqlDatabase sqlDatabase1 = await WaitForCompletionAsync(
await CosmosDBManagementClient.SqlResources.StartCreateUpdateSqlDatabaseAsync(
resourceGroupName, databaseAccountName, databaseName, sqlDatabaseCreateUpdateParameters1));
Assert.NotNull(sqlDatabase1);
SqlDatabase sqlDatabase2 = await CosmosDBManagementClient.SqlResources.GetSqlDatabaseAsync(
resourceGroupName, databaseAccountName, databaseName);
Assert.NotNull(sqlDatabase2);
VerifySqlDatabases(sqlDatabase1, sqlDatabase2);
ThroughputSettingsData throughputSettings1 =
await CosmosDBManagementClient.SqlResources.GetSqlDatabaseThroughputAsync(resourceGroupName, databaseAccountName, databaseName);
Assert.NotNull(throughputSettings1);
Assert.NotNull(throughputSettings1.Name);
Assert.AreEqual(sqlDatabasesThroughputType, throughputSettings1.Type);
Assert.AreEqual(sampleThroughput1, throughputSettings1.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
});
SqlDatabase sqlDatabase3 = await WaitForCompletionAsync(
await CosmosDBManagementClient.SqlResources.StartCreateUpdateSqlDatabaseAsync(
resourceGroupName, databaseAccountName, databaseName, sqlDatabaseCreateUpdateParameters2));
Assert.NotNull(sqlDatabase3);
SqlDatabase sqlDatabase4 = await CosmosDBManagementClient.SqlResources.GetSqlDatabaseAsync(
resourceGroupName, databaseAccountName, databaseName);
Assert.NotNull(sqlDatabase4);
VerifySqlDatabases(sqlDatabase3, sqlDatabase4);
ThroughputSettingsData throughputSettings2 =
await CosmosDBManagementClient.SqlResources.GetSqlDatabaseThroughputAsync(resourceGroupName, databaseAccountName, databaseName);
Assert.NotNull(throughputSettings2);
Assert.NotNull(throughputSettings2.Name);
Assert.AreEqual(sqlDatabasesThroughputType, throughputSettings2.Type);
Assert.AreEqual(sampleThroughput2, throughputSettings2.Resource.Throughput);
}
public async Task MongoDBCollectionCreateAndUpdateTest()
{
MongoDBCollection mongoDBCollection1 = await WaitForCompletionAsync(
await CosmosDBManagementClient.MongoDBResources.StartCreateUpdateMongoDBCollectionAsync(
resourceGroupName,
databaseAccountName,
databaseName,
collectionName,
new MongoDBCollectionCreateUpdateParameters(
new MongoDBCollectionResource(collectionName), new CreateUpdateOptions(sampleThroughput1, new AutoscaleSettings()))));
Assert.IsNotNull(mongoDBCollection1);
Assert.AreEqual(collectionName, mongoDBCollection1.Resource.Id);
ThroughputSettingsData throughputSettings1 =
await CosmosDBManagementClient.MongoDBResources.GetMongoDBCollectionThroughputAsync(resourceGroupName, databaseAccountName, databaseName, collectionName);
Assert.IsNotNull(throughputSettings1);
Assert.AreEqual(sampleThroughput1, throughputSettings1.Resource.Throughput);
Assert.AreEqual(mongoDBCollectionsThroughputType, throughputSettings1.Type);
MongoDBCollection mongoDBCollection =
await CosmosDBManagementClient.MongoDBResources.GetMongoDBCollectionAsync(resourceGroupName, databaseAccountName, databaseName, collectionName);
Assert.IsNotNull(mongoDBCollection);
VerifyMongoDBCollections(mongoDBCollection1, mongoDBCollection);
MongoDBCollection mongoDBCollection2 = await WaitForCompletionAsync(
await CosmosDBManagementClient.MongoDBResources.StartCreateUpdateMongoDBCollectionAsync(
resourceGroupName,
databaseAccountName,
databaseName,
collectionName,
new MongoDBCollectionCreateUpdateParameters(
new MongoDBCollectionResource(collectionName), new CreateUpdateOptions(sampleThroughput2, new AutoscaleSettings()))));
Assert.IsNotNull(mongoDBCollection2);
Assert.AreEqual(collectionName, mongoDBCollection2.Resource.Id);
ThroughputSettingsData throughputSettings2 =
await CosmosDBManagementClient.MongoDBResources.GetMongoDBCollectionThroughputAsync(resourceGroupName, databaseAccountName, databaseName, collectionName);
Assert.IsNotNull(throughputSettings2);
Assert.AreEqual(sampleThroughput2, throughputSettings2.Resource.Throughput);
Assert.AreEqual(mongoDBCollectionsThroughputType, throughputSettings2.Type);
mongoDBCollection =
await CosmosDBManagementClient.MongoDBResources.GetMongoDBCollectionAsync(resourceGroupName, databaseAccountName, databaseName, collectionName);
Assert.IsNotNull(mongoDBCollection);
VerifyMongoDBCollections(mongoDBCollection2, mongoDBCollection);
}
public async Task SqlContainerMigrateToManual()
{
var container = await CreateSqlContainer(new AutoscaleSettings()
{
MaxThroughput = DefaultMaxThroughput,
});
DatabaseAccountSqlDatabaseContainerThroughputSetting throughput = await container.GetDatabaseAccountSqlDatabaseContainerThroughputSetting().GetAsync();
AssertAutoscale(throughput.Data);
ThroughputSettingsData throughputData = (await throughput.MigrateSqlContainerToManualThroughputAsync(WaitUntil.Completed)).Value.Data;
AssertManualThroughput(throughputData);
}
public async Task TableMigrateToManual()
{
var database = await CreateTable(new AutoscaleSettings()
{
MaxThroughput = DefaultMaxThroughput,
});
DatabaseAccountTableThroughputSettingResource throughput = await database.GetDatabaseAccountTableThroughputSetting().GetAsync();
AssertAutoscale(throughput.Data);
ThroughputSettingsData throughputData = (await throughput.MigrateTableToManualThroughputAsync(WaitUntil.Completed)).Value.Data;
AssertManualThroughput(throughputData);
}
public async Task MongoDBCollectionMigrateToManual()
{
var collection = await CreateMongoDBCollection(new AutoscaleSettings()
{
MaxThroughput = DefaultMaxThroughput,
});
DatabaseAccountMongodbDatabaseCollectionThroughputSetting throughput = await collection.GetDatabaseAccountMongodbDatabaseCollectionThroughputSetting().GetAsync();
AssertAutoscale(throughput.Data);
ThroughputSettingsData throughputData = (await throughput.MigrateMongoDBCollectionToManualThroughputAsync(WaitUntil.Completed)).Value.Data;
AssertManualThroughput(throughputData);
}
public async Task CassandraKeyspaceMigrateToManual()
{
var keyspace = await CreateCassandraKeyspace(new AutoscaleSettings()
{
MaxThroughput = DefaultMaxThroughput,
});
DatabaseAccountCassandraKeyspaceThroughputSetting throughput = await keyspace.GetDatabaseAccountCassandraKeyspaceThroughputSetting().GetAsync();
AssertAutoscale(throughput.Data);
ThroughputSettingsData throughputData = (await throughput.MigrateCassandraKeyspaceToManualThroughputAsync(WaitUntil.Completed)).Value.Data;
AssertManualThroughput(throughputData);
}
public async Task CassandraTableMigrateToManual()
{
var parameters = BuildCreateUpdateOptions(new AutoscaleSettings()
{
MaxThroughput = DefaultMaxThroughput,
});
var table = await CreateCassandraTable(parameters);
DatabaseAccountCassandraKeyspaceTableThroughputSettingResource throughput = await table.GetDatabaseAccountCassandraKeyspaceTableThroughputSetting().GetAsync();
AssertAutoscale(throughput.Data);
ThroughputSettingsData throughputData = (await throughput.MigrateCassandraTableToManualThroughputAsync(WaitUntil.Completed)).Value.Data;
AssertManualThroughput(throughputData);
}
public async Task TableCreateAndUpdateTest()
{
Table table1 = await WaitForCompletionAsync(
await CosmosDBManagementClient.TableResources.StartCreateUpdateTableAsync(
resourceGroupName,
databaseAccountName,
tableName,
new TableCreateUpdateParameters(new TableResource(tableName), new CreateUpdateOptions())));
Assert.IsNotNull(table1);
Assert.AreEqual(tableName, table1.Resource.Id);
ThroughputSettingsData throughputSettings1 =
await CosmosDBManagementClient.TableResources.GetTableThroughputAsync(resourceGroupName, databaseAccountName, tableName);
Assert.IsNotNull(throughputSettings1);
Assert.AreEqual(defaultThroughput, throughputSettings1.Resource.Throughput);
Assert.AreEqual(tableThroughputType, throughputSettings1.Type);
Table table2 = await CosmosDBManagementClient.TableResources.GetTableAsync(resourceGroupName, databaseAccountName, tableName);
Assert.IsNotNull(table2);
VerifyTables(table1, table2);
Table table3 = await WaitForCompletionAsync(
await CosmosDBManagementClient.TableResources.StartCreateUpdateTableAsync(
resourceGroupName,
databaseAccountName,
tableName,
new TableCreateUpdateParameters(new TableResource(tableName), new CreateUpdateOptions(sampleThroughput, new AutoscaleSettings()))));
Assert.IsNotNull(table3);
Assert.AreEqual(tableName, table3.Resource.Id);
ThroughputSettingsData throughputSettings2 =
await CosmosDBManagementClient.TableResources.GetTableThroughputAsync(resourceGroupName, databaseAccountName, tableName);
Assert.IsNotNull(throughputSettings2);
Assert.AreEqual(sampleThroughput, throughputSettings2.Resource.Throughput);
Assert.AreEqual(tableThroughputType, throughputSettings2.Type);
Table table4 = await CosmosDBManagementClient.TableResources.GetTableAsync(resourceGroupName, databaseAccountName, tableName);
Assert.IsNotNull(table4);
VerifyTables(table3, table4);
}
DatabaseAccountGremlinDatabaseThroughputSetting IOperationSource <DatabaseAccountGremlinDatabaseThroughputSetting> .CreateResult(Response response, CancellationToken cancellationToken)
{
using var document = JsonDocument.Parse(response.ContentStream);
return(new DatabaseAccountGremlinDatabaseThroughputSetting(_operationBase, ThroughputSettingsData.DeserializeThroughputSettingsData(document.RootElement)));
}
public async Task GremlinGraphCreateUpdateTests()
{
IList <IncludedPath> includedPath = new List <IncludedPath> {
new IncludedPath {
Path = "/*"
}
};
IList <ExcludedPath> excludedPaths = new List <ExcludedPath> {
new ExcludedPath {
Path = "/pathToNotIndex/*"
}
};
IList <IList <CompositePath> > 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
}
}
};
IList <SpatialSpec> spatialIndexes = new List <SpatialSpec> {
new SpatialSpec("/*", new List <SpatialType> {
new SpatialType("Point")
})
};
IndexingPolicy indexingPolicy = new IndexingPolicy(true, IndexingMode.Consistent, includedPath, excludedPaths, compositeIndexes, spatialIndexes);
ContainerPartitionKey containerPartitionKey = new ContainerPartitionKey(new List <string> {
"/address"
}, "Hash", null);
IList <string> paths = new List <string>()
{
"/testpath"
};
UniqueKey uk = new UniqueKey(paths);
IList <UniqueKey> uniqueKeys = new List <UniqueKey>();
uniqueKeys.Add(uk);
UniqueKeyPolicy uniqueKeyPolicy = new UniqueKeyPolicy(uniqueKeys);
ConflictResolutionPolicy conflictResolutionPolicy = new ConflictResolutionPolicy(new ConflictResolutionMode("LastWriterWins"), "/path", "");
CreateUpdateOptions createUpdateOptions = new CreateUpdateOptions(sampleThroughput, new AutoscaleSettings());
GremlinGraphCreateUpdateParameters gremlinGraphCreateUpdateParameters = new GremlinGraphCreateUpdateParameters(new GremlinGraphResource(gremlinGraphName, indexingPolicy, containerPartitionKey, -1, uniqueKeyPolicy, conflictResolutionPolicy), createUpdateOptions);
Response <GremlinGraph> gremlinResponse = await WaitForCompletionAsync(await CosmosDBManagementClient.GremlinResources.StartCreateUpdateGremlinGraphAsync(resourceGroupName, databaseAccountName, databaseName, gremlinGraphName, gremlinGraphCreateUpdateParameters));
Assert.NotNull(gremlinResponse);
GremlinGraph gremlinGraph = gremlinResponse.Value;
Assert.NotNull(gremlinGraph);
VerifyGremlinGraphCreation(gremlinGraph, gremlinGraphCreateUpdateParameters);
var throughputResponse = CosmosDBManagementClient.GremlinResources.GetGremlinGraphThroughputAsync(resourceGroupName, databaseAccountName, databaseName, gremlinGraphName);
ThroughputSettingsData ThroughputSettingsData = throughputResponse.ConfigureAwait(false).GetAwaiter().GetResult();
Assert.NotNull(throughputSettings);
Assert.NotNull(throughputSettings.Name);
Assert.AreEqual(throughputSettings.Resource.Throughput, sampleThroughput);
Assert.AreEqual(gremlinGraphsThroughputType, throughputSettings.Type);
CreateUpdateOptions createUpdateOptions2 = new CreateUpdateOptions(sampleThroughput2, new AutoscaleSettings());
GremlinGraphCreateUpdateParameters gremlinGraphCreateUpdateParameters2 = new GremlinGraphCreateUpdateParameters(new GremlinGraphResource(gremlinGraphName, indexingPolicy, containerPartitionKey, -1, uniqueKeyPolicy, conflictResolutionPolicy), createUpdateOptions2);
Response <GremlinGraph> gremlinResponse2 = await WaitForCompletionAsync(await CosmosDBManagementClient.GremlinResources.StartCreateUpdateGremlinGraphAsync(resourceGroupName, databaseAccountName, databaseName, gremlinGraphName, gremlinGraphCreateUpdateParameters2));
Assert.NotNull(gremlinResponse2);
GremlinGraph gremlinGraph2 = gremlinResponse2.Value;
Assert.NotNull(gremlinGraph2);
VerifyGremlinGraphCreation(gremlinGraph2, gremlinGraphCreateUpdateParameters2);
var throughputResponse2 = CosmosDBManagementClient.GremlinResources.GetGremlinGraphThroughputAsync(resourceGroupName, databaseAccountName, databaseName, gremlinGraphName);
ThroughputSettingsData throughputSettings2 = throughputResponse2.ConfigureAwait(false).GetAwaiter().GetResult();
Assert.NotNull(throughputSettings2);
Assert.NotNull(throughputSettings2.Name);
Assert.AreEqual(throughputSettings2.Resource.Throughput, sampleThroughput2);
Assert.AreEqual(gremlinGraphsThroughputType, throughputSettings2.Type);
}
public async Task SqlContainerCreateAndUpdateTest()
{
SqlContainerCreateUpdateParameters sqlContainerCreateUpdateParameters = new SqlContainerCreateUpdateParameters(
resource: new SqlContainerResource(containerName)
{
PartitionKey = new ContainerPartitionKey(new List <string> {
"/address/zipCode"
}, null, null)
{
Kind = new PartitionKind("Hash")
},
IndexingPolicy = new IndexingPolicy(
true,
IndexingMode.Consistent,
new List <IncludedPath>
{
new IncludedPath {
Path = "/*"
}
},
new List <ExcludedPath>
{
new ExcludedPath {
Path = "/pathToNotIndex/*"
}
},
new List <IList <CompositePath> >
{
new List <CompositePath>
{
new CompositePath {
Path = "/orderByPath1", Order = CompositePathSortOrder.Ascending
},
new CompositePath {
Path = "/orderByPath2", Order = CompositePathSortOrder.Descending
}
}
},
new List <SpatialSpec>
{
new SpatialSpec
(
"/*",
new List <SpatialType>
{
new SpatialType("Point")
}
),
}
)
},
options: new CreateUpdateOptions
{
Throughput = sampleThroughput1
}
);
SqlContainer sqlContainer1 = await WaitForCompletionAsync(
await CosmosDBManagementClient.SqlResources.StartCreateUpdateSqlContainerAsync(
resourceGroupName, databaseAccountName, databaseName, containerName, sqlContainerCreateUpdateParameters));
Assert.NotNull(sqlContainer1);
SqlContainer sqlContainer2 = await CosmosDBManagementClient.SqlResources.GetSqlContainerAsync(
resourceGroupName, databaseAccountName, databaseName, containerName);
Assert.NotNull(sqlContainer2);
VerifySqlContainers(sqlContainer1, sqlContainer2);
ThroughputSettingsData throughputSettings1 =
await CosmosDBManagementClient.SqlResources.GetSqlContainerThroughputAsync(resourceGroupName, databaseAccountName, databaseName, containerName);
Assert.NotNull(throughputSettings1);
Assert.NotNull(throughputSettings1.Name);
Assert.AreEqual(sqlContainersThroughputType, throughputSettings1.Type);
Assert.AreEqual(sampleThroughput1, throughputSettings1.Resource.Throughput);
sqlContainerCreateUpdateParameters = new SqlContainerCreateUpdateParameters(
resource: new SqlContainerResource(containerName)
{
PartitionKey = new ContainerPartitionKey(new List <string> {
"/address/zipCode"
}, null, null)
{
Kind = new PartitionKind("Hash")
},
IndexingPolicy = new IndexingPolicy(
true,
IndexingMode.Consistent,
new List <IncludedPath>
{
new IncludedPath {
Path = "/*"
}
},
new List <ExcludedPath>
{
new ExcludedPath {
Path = "/pathToNotIndex/*"
}
},
new List <IList <CompositePath> >
{
new List <CompositePath>
{
new CompositePath {
Path = "/orderByPath3", Order = CompositePathSortOrder.Ascending
},
new CompositePath {
Path = "/orderByPath4", Order = CompositePathSortOrder.Descending
}
}
},
new List <SpatialSpec>
{
new SpatialSpec
(
"/*",
new List <SpatialType>
{
new SpatialType("Point")
}
),
}
)
},
options: new CreateUpdateOptions
{
Throughput = sampleThroughput2
}
);
SqlContainer sqlContainer3 = await WaitForCompletionAsync(
await CosmosDBManagementClient.SqlResources.StartCreateUpdateSqlContainerAsync(
resourceGroupName, databaseAccountName, databaseName, containerName, sqlContainerCreateUpdateParameters));
Assert.NotNull(sqlContainer3);
SqlContainer sqlContainer4 = await CosmosDBManagementClient.SqlResources.GetSqlContainerAsync(
resourceGroupName, databaseAccountName, databaseName, containerName);
Assert.NotNull(sqlContainer4);
VerifySqlContainers(sqlContainer3, sqlContainer4);
ThroughputSettingsData throughputSettings2 =
await CosmosDBManagementClient.SqlResources.GetSqlContainerThroughputAsync(resourceGroupName, databaseAccountName, databaseName, containerName);
Assert.NotNull(throughputSettings2);
Assert.NotNull(throughputSettings2.Name);
Assert.AreEqual(sqlContainersThroughputType, throughputSettings2.Type);
Assert.AreEqual(sampleThroughput2, throughputSettings2.Resource.Throughput);
}
