public override void ExecuteCmdlet()
{
if (ParameterSetName.Equals(ParentObjectParameterSet, StringComparison.Ordinal))
{
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(InputObject.Id);
ResourceGroupName = resourceIdentifier.ResourceGroupName;
AccountName = resourceIdentifier.ResourceName;
}
IDictionary <string, string> options = new Dictionary <string, string>();
if (Throughput != null)
{
options.Add("Throughput", Throughput.ToString());
}
SqlDatabaseCreateUpdateParameters sqlDatabaseCreateUpdateParameters = new SqlDatabaseCreateUpdateParameters
{
Resource = new SqlDatabaseResource
{
Id = Name
},
Options = options
};
if (ShouldProcess(Name, "Creating or Updating CosmosDB Sql Database"))
{
SqlDatabaseGetResults sqlDatabaseGetResults = CosmosDBManagementClient.SqlResources.CreateUpdateSqlDatabaseWithHttpMessagesAsync(ResourceGroupName, AccountName, Name, sqlDatabaseCreateUpdateParameters).GetAwaiter().GetResult().Body;
WriteObject(new PSSqlDatabaseGetResults(sqlDatabaseGetResults));
}
return;
}
private SqlContainerGetResults CreateSQLResources(CosmosDBManagementClient cosmosDBManagementClient, string databaseAccountName, string databaseName, string containerName)
{
SqlDatabaseGetResults databaseGetResults = null;
try
{
databaseGetResults = cosmosDBManagementClient.SqlResources.GetSqlDatabase(this.fixture.ResourceGroupName, databaseAccountName, databaseName);
}
catch (Exception) { }
if (databaseGetResults == null)
{
SqlDatabaseCreateUpdateParameters sqlDatabaseCreateUpdateParameters = new SqlDatabaseCreateUpdateParameters
{
Resource = new SqlDatabaseResource {
Id = databaseName
},
Options = new CreateUpdateOptions()
};
databaseGetResults = cosmosDBManagementClient.SqlResources.CreateUpdateSqlDatabase(
this.fixture.ResourceGroupName,
databaseAccountName,
databaseName,
sqlDatabaseCreateUpdateParameters);
}
SqlContainerGetResults collectionGetResult = null;
try
{
collectionGetResult = cosmosDBManagementClient.SqlResources.GetSqlContainer(this.fixture.ResourceGroupName, databaseAccountName, databaseName, containerName);
}
catch (Exception) { }
if (collectionGetResult == null)
{
SqlContainerCreateUpdateParameters collectionCreateParams = new SqlContainerCreateUpdateParameters()
{
Resource = new SqlContainerResource(containerName, partitionKey: new ContainerPartitionKey(new List <String>()
{
"/id"
})),
Options = new CreateUpdateOptions()
{
Throughput = 30000
}
};
collectionGetResult = cosmosDBManagementClient.SqlResources.CreateUpdateSqlContainer(
this.fixture.ResourceGroupName,
databaseAccountName,
databaseName,
containerName,
collectionCreateParams);
}
return(collectionGetResult);
}
private void InitializeCreateUpdateParameters()
{
this.createUpdateParameters = new SqlDatabaseCreateUpdateParameters()
{
Location = Parent.Inner.Location,
Resource = new SqlDatabaseResource(id: this.Name()),
Options = new CreateUpdateOptions(),
};
}
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);
}
SqlDatabaseGetResults readSqlDatabaseGetResults = null;
try
{
readSqlDatabaseGetResults = CosmosDBManagementClient.SqlResources.GetSqlDatabase(ResourceGroupName, AccountName, Name);
}
catch (CloudException e)
{
if (e.Response.StatusCode == System.Net.HttpStatusCode.NotFound)
{
throw new ResourceNotFoundException(message: string.Format(ExceptionMessage.NotFound, Name), innerException: e);
}
}
CreateUpdateOptions options = new CreateUpdateOptions();
if (Throughput != null)
{
options.Throughput = Throughput.ToString();
}
SqlDatabaseCreateUpdateParameters sqlDatabaseCreateUpdateParameters = new SqlDatabaseCreateUpdateParameters
{
Resource = new SqlDatabaseResource
{
Id = Name
},
Options = options
};
if (ShouldProcess(Name, "Updating an existing CosmosDB Sql Database"))
{
SqlDatabaseGetResults sqlDatabaseGetResults = CosmosDBManagementClient.SqlResources.CreateUpdateSqlDatabaseWithHttpMessagesAsync(ResourceGroupName, AccountName, Name, sqlDatabaseCreateUpdateParameters).GetAwaiter().GetResult().Body;
WriteObject(new PSSqlDatabaseGetResults(sqlDatabaseGetResults));
}
return;
}
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 override void ExecuteCmdlet()
{
if (ParameterSetName.Equals(ParentObjectParameterSet, StringComparison.Ordinal))
{
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(ParentObject.Id);
ResourceGroupName = resourceIdentifier.ResourceGroupName;
AccountName = resourceIdentifier.ResourceName;
}
SqlDatabaseGetResults readSqlDatabaseGetResults = null;
try
{
readSqlDatabaseGetResults = CosmosDBManagementClient.SqlResources.GetSqlDatabase(ResourceGroupName, AccountName, Name);
}
catch (CloudException e)
{
if (e.Response.StatusCode != System.Net.HttpStatusCode.NotFound)
{
throw;
}
}
if (readSqlDatabaseGetResults != null)
{
throw new ConflictingResourceException(message: string.Format(ExceptionMessage.Conflict, Name));
}
CreateUpdateOptions options = ThroughputHelper.PopulateCreateUpdateOptions(Throughput, AutoscaleMaxThroughput);
SqlDatabaseCreateUpdateParameters sqlDatabaseCreateUpdateParameters = new SqlDatabaseCreateUpdateParameters
{
Resource = new SqlDatabaseResource
{
Id = Name
},
Options = options
};
if (ShouldProcess(Name, "Creating a new CosmosDB Sql Database"))
{
SqlDatabaseGetResults sqlDatabaseGetResults = CosmosDBManagementClient.SqlResources.CreateUpdateSqlDatabaseWithHttpMessagesAsync(ResourceGroupName, AccountName, Name, sqlDatabaseCreateUpdateParameters).GetAwaiter().GetResult().Body;
WriteObject(new PSSqlDatabaseGetResults(sqlDatabaseGetResults));
}
return;
}
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);
}
}
}
public async Task SqlCRUDTests()
{
CosmosDBManagementClient cosmosDBManagementClient = GetCosmosDBManagementClient();
DatabaseAccountGetResults databaseAccount = null;
var locations = new List <Location>()
{
{ new Location(id: default(string), locationName: location, documentEndpoint: default(string), provisioningState: default(string), failoverPriority: default(int?), isZoneRedundant: default(bool?)) }
};
DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters(locations)
{
Location = location,
Kind = DatabaseAccountKind.GlobalDocumentDB,
};
databaseAccount = await WaitForCompletionAsync(await cosmosDBManagementClient.DatabaseAccounts.StartCreateOrUpdateAsync(resourceGroupName, databaseAccountName, databaseAccountCreateUpdateParameters));
Assert.AreEqual(databaseAccount.Name, databaseAccountName);
Response isDatabaseNameExists = await cosmosDBManagementClient.DatabaseAccounts.CheckNameExistsAsync(databaseAccountName);
Assert.AreEqual(200, isDatabaseNameExists.Status);
//Create sql database
SqlDatabaseCreateUpdateParameters sqlDatabaseCreateUpdateParameters = new SqlDatabaseCreateUpdateParameters(new SqlDatabaseResource(databaseName), new CreateUpdateOptions());
SqlDatabaseGetResults sqlDatabaseGetResults = await WaitForCompletionAsync(await cosmosDBManagementClient.SqlResources.StartCreateUpdateSqlDatabaseAsync(resourceGroupName, databaseAccountName, databaseName, sqlDatabaseCreateUpdateParameters));
Assert.NotNull(sqlDatabaseGetResults);
Assert.AreEqual(databaseName, sqlDatabaseGetResults.Name);
SqlDatabaseGetResults sqlDatabaseGetResults2 = (await cosmosDBManagementClient.SqlResources.GetSqlDatabaseAsync(resourceGroupName, databaseAccountName, databaseName)).Value;
Assert.NotNull(sqlDatabaseGetResults2);
Assert.AreEqual(databaseName, sqlDatabaseGetResults2.Name);
VerifyEqualSqlDatabases(sqlDatabaseGetResults, sqlDatabaseGetResults2);
SqlDatabaseCreateUpdateParameters sqlDatabaseCreateUpdateParameters2 = new SqlDatabaseCreateUpdateParameters(id: default(string), name: default(string), type: default(string), location: location, tags: tags, resource: new SqlDatabaseResource(databaseName2), options: new CreateUpdateOptions {
Throughput = sampleThroughput
});
SqlDatabaseGetResults sqlDatabaseGetResults3 = await WaitForCompletionAsync(await cosmosDBManagementClient.SqlResources.StartCreateUpdateSqlDatabaseAsync(resourceGroupName, databaseAccountName, databaseName2, sqlDatabaseCreateUpdateParameters2));
Assert.NotNull(sqlDatabaseGetResults3);
Assert.AreEqual(databaseName2, sqlDatabaseGetResults3.Name);
IAsyncEnumerable <SqlDatabaseGetResults> sqlDatabases = cosmosDBManagementClient.SqlResources.ListSqlDatabasesAsync(resourceGroupName, databaseAccountName);
Assert.NotNull(sqlDatabases);
ThroughputSettingsGetResults throughputSettingsGetResults = (await cosmosDBManagementClient.SqlResources.GetSqlDatabaseThroughputAsync(resourceGroupName, databaseAccountName, databaseName2)).Value;
Assert.NotNull(throughputSettingsGetResults);
Assert.NotNull(throughputSettingsGetResults.Name);
Assert.AreEqual(sqlThroughputType, throughputSettingsGetResults.Type);
//Create sql container
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 <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 = sampleThroughput
}
);
SqlContainerGetResults sqlContainerGetResults = await WaitForCompletionAsync(await cosmosDBManagementClient.SqlResources.StartCreateUpdateSqlContainerAsync(resourceGroupName, databaseAccountName, databaseName, containerName, sqlContainerCreateUpdateParameters));
Assert.NotNull(sqlContainerGetResults);
VerifySqlContainerCreation(sqlContainerGetResults, sqlContainerCreateUpdateParameters);
IAsyncEnumerable <SqlContainerGetResults> sqlContainers = cosmosDBManagementClient.SqlResources.ListSqlContainersAsync(resourceGroupName, databaseAccountName, databaseName);
Assert.NotNull(sqlContainers);
//Create stored procedure
SqlStoredProcedureCreateUpdateParameters sqlStoredProcedureCreateUpdateParameters = new SqlStoredProcedureCreateUpdateParameters(
new SqlStoredProcedureResource(storedProcedureName)
{
Body = "function () { var context = getContext(); " +
"var response = context.getResponse();" +
"response.setBody('Hello, World');" +
"}"
},
new CreateUpdateOptions()
);
SqlStoredProcedureGetResults sqlStoredProcedureGetResults = await WaitForCompletionAsync(await cosmosDBManagementClient.SqlResources.StartCreateUpdateSqlStoredProcedureAsync(resourceGroupName, databaseAccountName, databaseName, containerName, storedProcedureName, sqlStoredProcedureCreateUpdateParameters));
Assert.NotNull(sqlStoredProcedureGetResults);
Assert.AreEqual(sqlStoredProcedureGetResults.Resource.Body, sqlStoredProcedureGetResults.Resource.Body);
IAsyncEnumerable <SqlStoredProcedureGetResults> sqlStoredProcedures = cosmosDBManagementClient.SqlResources.ListSqlStoredProceduresAsync(resourceGroupName, databaseAccountName, databaseName, containerName);
Assert.NotNull(sqlStoredProcedures);
//Create defined function
SqlUserDefinedFunctionCreateUpdateParameters sqlUserDefinedFunctionCreateUpdateParameters = new SqlUserDefinedFunctionCreateUpdateParameters(
resource: new SqlUserDefinedFunctionResource(userDefinedFunctionName)
{
Body = "function () { var context = getContext(); " +
"var response = context.getResponse();" +
"response.setBody('Hello, World');" +
"}"
},
options: new CreateUpdateOptions()
);
SqlUserDefinedFunctionGetResults sqlUserDefinedFunctionGetResults = await WaitForCompletionAsync(await cosmosDBManagementClient.SqlResources.StartCreateUpdateSqlUserDefinedFunctionAsync(resourceGroupName, databaseAccountName, databaseName, containerName, userDefinedFunctionName, sqlUserDefinedFunctionCreateUpdateParameters));
Assert.NotNull(sqlUserDefinedFunctionGetResults);
Assert.AreEqual(sqlUserDefinedFunctionGetResults.Resource.Body, sqlUserDefinedFunctionGetResults.Resource.Body);
IAsyncEnumerable <SqlUserDefinedFunctionGetResults> sqlUserDefinedFunctions = cosmosDBManagementClient.SqlResources.ListSqlUserDefinedFunctionsAsync(resourceGroupName, databaseAccountName, databaseName, containerName);
Assert.NotNull(sqlUserDefinedFunctions);
//Create trigger
SqlTriggerCreateUpdateParameters sqlTriggerCreateUpdateParameters = new SqlTriggerCreateUpdateParameters(
resource: new SqlTriggerResource(triggerName)
{
TriggerOperation = "All",
TriggerType = "Pre",
Body = "function () { var context = getContext(); " +
"var response = context.getResponse();" +
"response.setBody('Hello, World');" +
"}"
},
options: new CreateUpdateOptions()
);
SqlTriggerGetResults sqlTriggerGetResults = await WaitForCompletionAsync(await cosmosDBManagementClient.SqlResources.StartCreateUpdateSqlTriggerAsync(resourceGroupName, databaseAccountName, databaseName, containerName, triggerName, sqlTriggerCreateUpdateParameters));
Assert.NotNull(sqlTriggerGetResults);
Assert.AreEqual(sqlTriggerGetResults.Resource.TriggerType, sqlTriggerCreateUpdateParameters.Resource.TriggerType);
Assert.AreEqual(sqlTriggerGetResults.Resource.TriggerOperation, sqlTriggerCreateUpdateParameters.Resource.TriggerOperation);
Assert.AreEqual(sqlTriggerGetResults.Resource.Body, sqlTriggerCreateUpdateParameters.Resource.Body);
IAsyncEnumerable <SqlTriggerGetResults> sqlTriggers = cosmosDBManagementClient.SqlResources.ListSqlTriggersAsync(resourceGroupName, databaseAccountName, databaseName, containerName);
Assert.NotNull(sqlTriggers);
//Delete operations
await foreach (SqlStoredProcedureGetResults sqlStoredProcedure in sqlStoredProcedures)
{
await cosmosDBManagementClient.SqlResources.StartDeleteSqlStoredProcedureAsync(resourceGroupName, databaseAccountName, databaseName, containerName, sqlStoredProcedure.Name);
}
await foreach (SqlUserDefinedFunctionGetResults sqlUserDefinedFunction in sqlUserDefinedFunctions)
{
await cosmosDBManagementClient.SqlResources.StartDeleteSqlStoredProcedureAsync(resourceGroupName, databaseAccountName, databaseName, containerName, sqlUserDefinedFunction.Name);
}
await foreach (SqlTriggerGetResults sqlTrigger in sqlTriggers)
{
await cosmosDBManagementClient.SqlResources.StartDeleteSqlTriggerAsync(resourceGroupName, databaseAccountName, databaseName, containerName, sqlTrigger.Name);
}
await foreach (SqlContainerGetResults sqlContainer in sqlContainers)
{
await cosmosDBManagementClient.SqlResources.StartDeleteSqlContainerAsync(resourceGroupName, databaseAccountName, databaseName, sqlContainer.Name);
}
await foreach (SqlDatabaseGetResults sqlDatabase in sqlDatabases)
{
await cosmosDBManagementClient.SqlResources.StartDeleteSqlDatabaseAsync(resourceGroupName, databaseAccountName, sqlDatabase.Name);
}
}
public void SqlCRUDTests()
{
using (var context = MockContext.Start(this.GetType()))
{
fixture.Init(context);
var client = this.fixture.CosmosDBManagementClient.SqlResources;
var databaseAccountName = this.fixture.GetDatabaseAccountName(TestFixture.AccountType.PitrSql);
var databaseName = TestUtilities.GenerateName("database");
SqlDatabaseCreateUpdateParameters sqlDatabaseCreateUpdateParameters = new SqlDatabaseCreateUpdateParameters
{
Resource = new SqlDatabaseResource {
Id = databaseName
},
Options = new CreateUpdateOptions()
};
SqlDatabaseGetResults sqlDatabaseGetResults = client.CreateUpdateSqlDatabaseWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
databaseName,
sqlDatabaseCreateUpdateParameters
).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlDatabaseGetResults);
Assert.Equal(databaseName, sqlDatabaseGetResults.Name);
SqlDatabaseGetResults sqlDatabaseGetResults2 = client.GetSqlDatabaseWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
databaseName
).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlDatabaseGetResults2);
Assert.Equal(databaseName, sqlDatabaseGetResults2.Name);
VerifyEqualSqlDatabases(sqlDatabaseGetResults, sqlDatabaseGetResults2);
var databaseName2 = TestUtilities.GenerateName("database");
SqlDatabaseCreateUpdateParameters sqlDatabaseCreateUpdateParameters2 = new SqlDatabaseCreateUpdateParameters
{
Location = this.fixture.Location,
Tags = tags,
Resource = new SqlDatabaseResource {
Id = databaseName2
},
Options = new CreateUpdateOptions
{
Throughput = sampleThroughput
}
};
SqlDatabaseGetResults sqlDatabaseGetResults3 = client.CreateUpdateSqlDatabaseWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
databaseName2,
sqlDatabaseCreateUpdateParameters2
).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlDatabaseGetResults3);
Assert.Equal(databaseName2, sqlDatabaseGetResults3.Name);
IEnumerable <SqlDatabaseGetResults> sqlDatabases = client.ListSqlDatabasesWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlDatabases);
ThroughputSettingsGetResults throughputSettingsGetResults = client.GetSqlDatabaseThroughputWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName2).GetAwaiter().GetResult().Body;
Assert.NotNull(throughputSettingsGetResults);
Assert.NotNull(throughputSettingsGetResults.Name);
Assert.Equal(sqlThroughputType, throughputSettingsGetResults.Type);
var containerName = TestUtilities.GenerateName("container");
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 = client.CreateUpdateSqlContainerWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName, containerName, sqlContainerCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlContainerGetResults);
IEnumerable <SqlContainerGetResults> sqlContainers = client.ListSqlContainersWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlContainers);
var storedProcedureName = TestUtilities.GenerateName("storedproc");
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 = client.CreateUpdateSqlStoredProcedureWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName, containerName, storedProcedureName, sqlStoredProcedureCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlStoredProcedureGetResults);
Assert.Equal(sqlStoredProcedureGetResults.Resource.Body, sqlStoredProcedureGetResults.Resource.Body);
IEnumerable <SqlStoredProcedureGetResults> sqlStoredProcedures = client.ListSqlStoredProceduresWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName, containerName).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlStoredProcedures);
foreach (SqlStoredProcedureGetResults sqlStoredProcedure in sqlStoredProcedures)
{
client.DeleteSqlStoredProcedureWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName, containerName, sqlStoredProcedure.Name);
}
var userDefinedFunctionName = TestUtilities.GenerateName("udf");
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 = client.CreateUpdateSqlUserDefinedFunctionWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName, containerName, userDefinedFunctionName, sqlUserDefinedFunctionCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlUserDefinedFunctionGetResults);
Assert.Equal(sqlUserDefinedFunctionGetResults.Resource.Body, sqlUserDefinedFunctionGetResults.Resource.Body);
IEnumerable <SqlUserDefinedFunctionGetResults> sqlUserDefinedFunctions = client.ListSqlUserDefinedFunctionsWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName, containerName).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlUserDefinedFunctions);
foreach (SqlUserDefinedFunctionGetResults sqlUserDefinedFunction in sqlUserDefinedFunctions)
{
client.DeleteSqlUserDefinedFunctionWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName, containerName, sqlUserDefinedFunction.Name);
}
var triggerName = TestUtilities.GenerateName("trigger");
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 = client.CreateUpdateSqlTriggerWithHttpMessagesAsync(this.fixture.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 = client.ListSqlTriggersWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName, containerName).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlTriggers);
foreach (SqlTriggerGetResults sqlTrigger in sqlTriggers)
{
client.DeleteSqlTriggerWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName, containerName, sqlTrigger.Name);
}
foreach (SqlContainerGetResults sqlContainer in sqlContainers)
{
client.DeleteSqlContainerWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName, sqlContainer.Name);
}
foreach (SqlDatabaseGetResults sqlDatabase in sqlDatabases)
{
client.DeleteSqlDatabaseWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, sqlDatabase.Name);
}
}
}
public void SqlRoleTests()
{
using (var context = MockContext.Start(this.GetType()))
{
fixture.Init(context);
var databaseAccountName = this.fixture.GetDatabaseAccountName(TestFixture.AccountType.PitrSql);
var client = this.fixture.CosmosDBManagementClient.SqlResources;
var databaseName = TestUtilities.GenerateName("database");
SqlDatabaseCreateUpdateParameters sqlDatabaseCreateUpdateParameters2 = new SqlDatabaseCreateUpdateParameters
{
Location = this.fixture.Location,
Resource = new SqlDatabaseResource {
Id = databaseName
},
};
client.CreateUpdateSqlDatabaseWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
databaseName,
sqlDatabaseCreateUpdateParameters2
).GetAwaiter().GetResult();
SqlRoleDefinitionCreateUpdateParameters sqlRoleDefinitionCreateUpdateParameters = new SqlRoleDefinitionCreateUpdateParameters
{
RoleName = "roleName",
Type = RoleDefinitionType.CustomRole,
AssignableScopes = new List <string>
{
string.Format(
"/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.DocumentDB/databaseAccounts/{2}",
this.fixture.CosmosDBManagementClient.SubscriptionId,
this.fixture.ResourceGroupName,
databaseAccountName),
},
Permissions = new List <Permission>
{
new Permission
{
DataActions = new List <string>
{
"Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/create",
"Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/read"
}
}
}
};
SqlRoleDefinitionGetResults sqlRoleDefinitionGetResults = client.CreateUpdateSqlRoleDefinitionWithHttpMessagesAsync(roleDefinitionId, this.fixture.ResourceGroupName, databaseAccountName, sqlRoleDefinitionCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlRoleDefinitionGetResults);
Assert.Equal(roleDefinitionId, sqlRoleDefinitionGetResults.Name);
VerifyCreateUpdateRoleDefinition(sqlRoleDefinitionCreateUpdateParameters, sqlRoleDefinitionGetResults);
SqlRoleDefinitionGetResults sqlRoleDefinitionGetResults2 = client.GetSqlRoleDefinitionWithHttpMessagesAsync(roleDefinitionId, this.fixture.ResourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlRoleDefinitionGetResults2);
Assert.Equal(roleDefinitionId, sqlRoleDefinitionGetResults2.Name);
VerifyEqualSqlRoleDefinitions(sqlRoleDefinitionGetResults, sqlRoleDefinitionGetResults2);
SqlRoleDefinitionCreateUpdateParameters sqlRoleDefinitionCreateUpdateParameters2 = new SqlRoleDefinitionCreateUpdateParameters
{
RoleName = "roleName2",
Type = RoleDefinitionType.CustomRole,
AssignableScopes = new List <string>
{
string.Format(
"/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.DocumentDB/databaseAccounts/{2}",
this.fixture.CosmosDBManagementClient.SubscriptionId,
this.fixture.ResourceGroupName,
databaseAccountName
)
},
Permissions = new List <Permission>
{
new Permission
{
DataActions = new List <string>
{
"Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/create",
"Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/read",
"Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/delete",
"Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/replace"
}
}
}
};
SqlRoleDefinitionGetResults sqlRoleDefinitionGetResults3 = client.CreateUpdateSqlRoleDefinitionWithHttpMessagesAsync(
roleDefinitionId2,
this.fixture.ResourceGroupName,
databaseAccountName,
sqlRoleDefinitionCreateUpdateParameters2
).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlRoleDefinitionGetResults3);
Assert.Equal(roleDefinitionId2, sqlRoleDefinitionGetResults3.Name);
VerifyCreateUpdateRoleDefinition(sqlRoleDefinitionCreateUpdateParameters2, sqlRoleDefinitionGetResults3);
SqlRoleDefinitionCreateUpdateParameters sqlRoleDefinitionCreateUpdateParameters3 = new SqlRoleDefinitionCreateUpdateParameters
{
RoleName = "roleName3",
Type = RoleDefinitionType.CustomRole,
AssignableScopes = new List <string>
{
string.Format(
"/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.DocumentDB/databaseAccounts/{2}",
this.fixture.CosmosDBManagementClient.SubscriptionId,
this.fixture.ResourceGroupName,
databaseAccountName
)
},
Permissions = new List <Permission>
{
new Permission
{
DataActions = new List <string>
{
"Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/create",
"Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/delete",
"Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/replace"
}
}
}
};
SqlRoleDefinitionGetResults sqlRoleDefinitionGetResults4 = client.CreateUpdateSqlRoleDefinitionWithHttpMessagesAsync(roleDefinitionId, this.fixture.ResourceGroupName, databaseAccountName, sqlRoleDefinitionCreateUpdateParameters3).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlRoleDefinitionGetResults4);
Assert.Equal(roleDefinitionId, sqlRoleDefinitionGetResults4.Name);
VerifyCreateUpdateRoleDefinition(sqlRoleDefinitionCreateUpdateParameters3, sqlRoleDefinitionGetResults4);
IEnumerable <SqlRoleDefinitionGetResults> sqlRoleDefinitions = client.ListSqlRoleDefinitionsWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlRoleDefinitions);
foreach (SqlRoleDefinitionGetResults sqlRoleDefinition in sqlRoleDefinitions)
{
if (sqlRoleDefinition.Name == sqlRoleDefinitionGetResults3.Name)
{
VerifyEqualSqlRoleDefinitions(sqlRoleDefinitionGetResults3, sqlRoleDefinition);
}
if (sqlRoleDefinition.Name == sqlRoleDefinitionGetResults4.Name)
{
VerifyEqualSqlRoleDefinitions(sqlRoleDefinitionGetResults4, sqlRoleDefinition);
}
}
SqlRoleAssignmentCreateUpdateParameters sqlRoleAssignmentCreateUpdateParameters = new SqlRoleAssignmentCreateUpdateParameters
{
RoleDefinitionId = sqlRoleDefinitionGetResults.Id,
Scope = string.Format(
"/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.DocumentDB/databaseAccounts/{2}/dbs/{3}",
this.fixture.CosmosDBManagementClient.SubscriptionId,
this.fixture.ResourceGroupName,
databaseAccountName,
databaseName
),
PrincipalId = principalId
};
SqlRoleAssignmentGetResults sqlRoleAssignmentGetResults = client.CreateUpdateSqlRoleAssignmentWithHttpMessagesAsync(
roleAssignmentId,
this.fixture.ResourceGroupName,
databaseAccountName,
sqlRoleAssignmentCreateUpdateParameters
).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlRoleAssignmentGetResults);
Assert.Equal(roleAssignmentId, sqlRoleAssignmentGetResults.Name);
VerifyCreateUpdateRoleAssignment(sqlRoleAssignmentCreateUpdateParameters, sqlRoleAssignmentGetResults);
SqlRoleAssignmentGetResults sqlRoleAssignmentGetResults2 = client.GetSqlRoleAssignmentWithHttpMessagesAsync(roleAssignmentId, this.fixture.ResourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlRoleAssignmentGetResults2);
Assert.Equal(roleAssignmentId, sqlRoleAssignmentGetResults2.Name);
VerifyEqualSqlRoleAssignments(sqlRoleAssignmentGetResults, sqlRoleAssignmentGetResults2);
SqlRoleAssignmentCreateUpdateParameters sqlRoleAssignmentCreateUpdateParameters2 = new SqlRoleAssignmentCreateUpdateParameters
{
RoleDefinitionId = sqlRoleDefinitionGetResults3.Id,
Scope = string.Format("/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.DocumentDB/databaseAccounts/{2}", this.fixture.CosmosDBManagementClient.SubscriptionId, this.fixture.ResourceGroupName, databaseAccountName),
PrincipalId = principalId2
};
SqlRoleAssignmentGetResults sqlRoleAssignmentGetResults3 = client.CreateUpdateSqlRoleAssignmentWithHttpMessagesAsync(roleAssignmentId2, this.fixture.ResourceGroupName, databaseAccountName, sqlRoleAssignmentCreateUpdateParameters2).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlRoleAssignmentGetResults3);
Assert.Equal(roleAssignmentId2, sqlRoleAssignmentGetResults3.Name);
VerifyCreateUpdateRoleAssignment(sqlRoleAssignmentCreateUpdateParameters2, sqlRoleAssignmentGetResults3);
IEnumerable <SqlRoleAssignmentGetResults> sqlRoleAssignments = client.ListSqlRoleAssignmentsWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlRoleAssignments);
foreach (SqlRoleAssignmentGetResults sqlRoleAssignment in sqlRoleAssignments)
{
VerifyEqualSqlRoleAssignments(sqlRoleAssignment.Name == sqlRoleAssignmentGetResults.Name ? sqlRoleAssignmentGetResults : sqlRoleAssignmentGetResults3, sqlRoleAssignment);
}
foreach (SqlRoleAssignmentGetResults sqlRoleAssignment in sqlRoleAssignments)
{
client.DeleteSqlRoleAssignmentWithHttpMessagesAsync(sqlRoleAssignment.Name, this.fixture.ResourceGroupName, databaseAccountName).GetAwaiter().GetResult();
}
foreach (SqlRoleDefinitionGetResults sqlRoleDefinition in sqlRoleDefinitions)
{
if (sqlRoleDefinition.Name == sqlRoleDefinitionGetResults3.Name || sqlRoleDefinition.Name == sqlRoleDefinitionGetResults4.Name)
{
client.DeleteSqlRoleDefinitionWithHttpMessagesAsync(sqlRoleDefinition.Name, this.fixture.ResourceGroupName, databaseAccountName).GetAwaiter().GetResult();
}
}
const string InvalidActionName = "invalid-action-name";
SqlRoleDefinitionCreateUpdateParameters sqlRoleDefinitionCreateUpdateParameters4 = new SqlRoleDefinitionCreateUpdateParameters
{
RoleName = "roleName4",
Type = RoleDefinitionType.CustomRole,
AssignableScopes = new List <string>
{
string.Format("/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.DocumentDB/databaseAccounts/{2}", this.fixture.CosmosDBManagementClient.SubscriptionId, this.fixture.ResourceGroupName, databaseAccountName)
},
Permissions = new List <Permission>
{
new Permission
{
DataActions = new List <string>
{
InvalidActionName,
"Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/delete",
"Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/replace"
}
}
}
};
Exception exception =
Assert.ThrowsAnyAsync <Exception>(() =>
client.CreateUpdateSqlRoleDefinitionWithHttpMessagesAsync(roleDefinitionId3, this.fixture.ResourceGroupName, databaseAccountName, sqlRoleDefinitionCreateUpdateParameters4))
.GetAwaiter().GetResult();
Assert.Contains(InvalidActionName, exception.Message);
}
}
public void SqlClientEncryptionKeyTest()
{
using (var context = MockContext.Start(this.GetType()))
{
fixture.Init(context);
var client = this.fixture.CosmosDBManagementClient.SqlResources;
var databaseAccountName = this.fixture.GetDatabaseAccountName(TestFixture.AccountType.Sql);
var databaseName = TestUtilities.GenerateName("database");
SqlDatabaseCreateUpdateParameters sqlDatabaseCreateUpdateParameters = new SqlDatabaseCreateUpdateParameters
{
Resource = new SqlDatabaseResource {
Id = databaseName
},
Options = new CreateUpdateOptions()
};
SqlDatabaseGetResults sqlDatabaseGetResults = client.CreateUpdateSqlDatabaseWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
databaseName,
sqlDatabaseCreateUpdateParameters
).GetAwaiter().GetResult().Body;
Assert.NotNull(sqlDatabaseGetResults);
Assert.Equal(databaseName, sqlDatabaseGetResults.Name);
var clientEncryptionKeyName = TestUtilities.GenerateName("clientEncryptionKey");
ClientEncryptionKeyResource clientEncryptionKeyResource = new ClientEncryptionKeyResource()
{
Id = clientEncryptionKeyName,
EncryptionAlgorithm = "AEAD_AES_256_CBC_HMAC_SHA256",
KeyWrapMetadata = new KeyWrapMetadata
{
Type = "akv",
Value = "akvPath",
Name = "cmk",
Algorithm = "algo"
},
WrappedDataEncryptionKey = new byte[] { 0xab, 0x57, 0x05, 0xe9, 0x9f, 0xe2 }
};
ClientEncryptionKeyCreateUpdateParameters clientEncryptionKeyCreateUpdateParameters = new ClientEncryptionKeyCreateUpdateParameters
{
Resource = clientEncryptionKeyResource
};
client.CreateUpdateClientEncryptionKeyWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
databaseName,
clientEncryptionKeyName,
clientEncryptionKeyCreateUpdateParameters);
Thread.Sleep(10000);
ClientEncryptionKeyGetResults clientEncryptionKeyRetrieved = client.GetClientEncryptionKeyWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
databaseName,
clientEncryptionKeyName).GetAwaiter().GetResult().Body;
Assert.NotNull(clientEncryptionKeyRetrieved);
Assert.Equal(clientEncryptionKeyResource.Id, clientEncryptionKeyRetrieved.Resource.Id);
Assert.Equal(clientEncryptionKeyResource.EncryptionAlgorithm, clientEncryptionKeyRetrieved.Resource.EncryptionAlgorithm);
Assert.Equal(clientEncryptionKeyResource.KeyWrapMetadata.Name, clientEncryptionKeyRetrieved.Resource.KeyWrapMetadata.Name);
Assert.Equal(clientEncryptionKeyResource.KeyWrapMetadata.Algorithm, clientEncryptionKeyRetrieved.Resource.KeyWrapMetadata.Algorithm);
clientEncryptionKeyResource.WrappedDataEncryptionKey = new byte[] { 0xac, 0x15 };
clientEncryptionKeyCreateUpdateParameters = new ClientEncryptionKeyCreateUpdateParameters
{
Resource = clientEncryptionKeyResource
};
client.CreateUpdateClientEncryptionKeyWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
databaseName,
clientEncryptionKeyName,
clientEncryptionKeyCreateUpdateParameters);
Thread.Sleep(10000);
clientEncryptionKeyRetrieved = client.GetClientEncryptionKeyWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
databaseName,
clientEncryptionKeyName).GetAwaiter().GetResult().Body;
Assert.NotNull(clientEncryptionKeyRetrieved);
Assert.Equal(clientEncryptionKeyResource.Id, clientEncryptionKeyRetrieved.Resource.Id);
Assert.Equal(clientEncryptionKeyName, clientEncryptionKeyRetrieved.Name);
Assert.Equal(clientEncryptionKeyResource.WrappedDataEncryptionKey.Length, clientEncryptionKeyRetrieved.Resource.WrappedDataEncryptionKey.Length);
var clientEncryptionKeyName2 = TestUtilities.GenerateName("clientEncryptionKey");
ClientEncryptionKeyResource clientEncryptionKeyResource2 = new ClientEncryptionKeyResource()
{
Id = clientEncryptionKeyName2,
EncryptionAlgorithm = "AEAD_AES_256_CBC_HMAC_SHA256",
KeyWrapMetadata = new KeyWrapMetadata
{
Type = "akv",
Value = "akvPath2",
Name = "cmk",
Algorithm = "algo"
},
WrappedDataEncryptionKey = new byte[] { 0x11, 0x54, 0x10, 0xa9, 0x1f, 0x24 }
};
clientEncryptionKeyCreateUpdateParameters = new ClientEncryptionKeyCreateUpdateParameters
{
Resource = clientEncryptionKeyResource2
};
client.CreateUpdateClientEncryptionKeyWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
databaseName,
clientEncryptionKeyName2,
clientEncryptionKeyCreateUpdateParameters);
Thread.Sleep(10000);
IEnumerable <ClientEncryptionKeyGetResults> clientEncryptionKeyList = client.ListClientEncryptionKeysWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
databaseName).GetAwaiter().GetResult().Body;
Assert.NotNull(clientEncryptionKeyList);
int count = 0;
foreach (ClientEncryptionKeyGetResults clientEncryptionKeyListElement in clientEncryptionKeyList)
{
count++;
Assert.True(clientEncryptionKeyListElement.Name == clientEncryptionKeyName || clientEncryptionKeyListElement.Name == clientEncryptionKeyName2);
}
Assert.Equal(2, count);
client.DeleteSqlDatabaseWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, sqlDatabaseGetResults.Name);
}
}
public async Task RestoreDatabaseAccountTests()
{
using (var context = MockContext.Start(this.GetType()))
{
fixture.Init(context);
var databaseAccountName = this.fixture.GetDatabaseAccountName(TestFixture.AccountType.PitrSql);
var restorableAccounts = (await this.fixture.CosmosDBManagementClient.RestorableDatabaseAccounts.ListByLocationAsync(this.fixture.Location)).ToList();
var restorableDatabaseAccount = restorableAccounts.
SingleOrDefault(account => account.AccountName.Equals(databaseAccountName, StringComparison.OrdinalIgnoreCase));
var databaseName = TestUtilities.GenerateName("database");
SqlDatabaseCreateUpdateParameters sqlDatabaseCreateUpdateParameters = new SqlDatabaseCreateUpdateParameters
{
Resource = new SqlDatabaseResource {
Id = databaseName
},
Options = new CreateUpdateOptions()
};
await this.fixture.CosmosDBManagementClient.SqlResources.BeginCreateUpdateSqlDatabaseAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
databaseName,
sqlDatabaseCreateUpdateParameters
);
var containerName = TestUtilities.GenerateName("container");
SqlContainerCreateUpdateParameters collectionCreateParams = new SqlContainerCreateUpdateParameters()
{
Resource = new SqlContainerResource(containerName, partitionKey: new ContainerPartitionKey(new List <String>()
{
"/id"
})),
Options = new CreateUpdateOptions()
{
Throughput = 30000
}
};
var containerResults = await this.fixture.CosmosDBManagementClient.SqlResources.CreateUpdateSqlContainerAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
databaseName,
containerName,
collectionCreateParams
);
var ts = DateTimeOffset.FromUnixTimeSeconds((int)containerResults.Resource._ts).DateTime;
TestUtilities.Wait(10000);
DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters
{
Location = this.fixture.Location,
Tags = new Dictionary <string, string>
{
{ "key1", "value1" },
{ "key2", "value2" }
},
Kind = "GlobalDocumentDB",
Locations = new List <Location>
{
new Location(locationName: this.fixture.Location)
},
CreateMode = CreateMode.Restore,
RestoreParameters = new RestoreParameters()
{
RestoreMode = "PointInTime",
RestoreTimestampInUtc = ts.AddSeconds(1),
RestoreSource = restorableDatabaseAccount.Id
}
};
var restoredAccountName = TestUtilities.GenerateName("restoredaccount");
DatabaseAccountGetResults restoredDatabaseAccount = (await this.fixture.CosmosDBManagementClient.DatabaseAccounts.CreateOrUpdateWithHttpMessagesAsync(
this.fixture.ResourceGroupName, restoredAccountName, databaseAccountCreateUpdateParameters)).Body;
Assert.NotNull(restoredDatabaseAccount);
Assert.NotNull(restoredDatabaseAccount.RestoreParameters);
Assert.Equal(restoredDatabaseAccount.RestoreParameters.RestoreSource.ToLower(), restorableDatabaseAccount.Id.ToLower());
Assert.True(restoredDatabaseAccount.BackupPolicy is ContinuousModeBackupPolicy);
}
}
