private async Task PrepareDatabaseAccount()
{
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 databaseAccount = await WaitForCompletionAsync(
await CosmosDBManagementClient.DatabaseAccounts.StartCreateOrUpdateAsync(resourceGroupName, databaseAccountName, databaseAccountCreateUpdateParameters));
Assert.AreEqual(databaseAccount.Name, databaseAccountName);
var isDatabaseNameExists = await CosmosDBManagementClient.DatabaseAccounts.CheckNameExistsAsync(databaseAccountName);
Assert.AreEqual(true, isDatabaseNameExists.Value);
Assert.AreEqual(200, isDatabaseNameExists.GetRawResponse().Status);
}
public async Task RestoreDatabaseAccountTests()
{
var handler1 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
using (MockContext context = MockContext.Start(this.GetType()))
{
// Create client
CosmosDBManagementClient cosmosDBManagementClient = CosmosDBTestUtilities.GetCosmosDBClient(context, handler1);
DatabaseAccountGetResults databaseAccount = await cosmosDBManagementClient.DatabaseAccounts.GetAsync(resourceGroupName, "pitr-sql-stage-source");
DateTime restoreTs = DateTime.Parse(restoreTimestamp);
string restoredatabaseAccountName = TestUtilities.GenerateName(prefix: "restoredaccountname");
List <RestorableDatabaseAccountGetResult> restorableAccounts = (await cosmosDBManagementClient.RestorableDatabaseAccounts.ListAsync()).ToList();
RestorableDatabaseAccountGetResult restorableDatabaseAccount = restorableAccounts.
SingleOrDefault(account => account.Name.Equals(databaseAccount.InstanceId, StringComparison.OrdinalIgnoreCase));
List <Location> locations = new List <Location>
{
new Location(locationName: westus2)
};
RestoreReqeustDatabaseAccountCreateUpdateProperties databaseAccountCreateUpdateProperties = new RestoreReqeustDatabaseAccountCreateUpdateProperties
{
Locations = locations,
RestoreParameters = new RestoreParameters()
{
RestoreMode = "PointInTime",
RestoreTimestampInUtc = restoreTs,
RestoreSource = restorableDatabaseAccount.Id
}
};
DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters
{
Location = westus2,
Tags = new Dictionary <string, string>
{
{ "key1", "value1" },
{ "key2", "value2" }
},
Kind = "GlobalDocumentDB",
Properties = databaseAccountCreateUpdateProperties
};
DatabaseAccountGetResults restoredDatabaseAccount =
(await cosmosDBManagementClient.DatabaseAccounts.CreateOrUpdateWithHttpMessagesAsync(
resourceGroupName, restoredatabaseAccountName, databaseAccountCreateUpdateParameters)).Body;
Assert.NotNull(restoredDatabaseAccount);
Assert.NotNull(restoredDatabaseAccount.RestoreParameters);
Assert.Equal(restoredDatabaseAccount.RestoreParameters.RestoreSource.ToLower(), restorableDatabaseAccount.Id.ToLower());
Assert.True(restoredDatabaseAccount.BackupPolicy is ContinuousModeBackupPolicy);
}
}
public async Task DatabaseAccountCreateAndUpdateTest()
{
var locations = new List <Location>();
locations.Add(new Location(id: null, locationName: location, documentEndpoint: null, provisioningState: null, failoverPriority: null, isZoneRedundant: false));
var databaseAccountCreateOrUpdateParameters = new DatabaseAccountCreateUpdateParameters(locations);
databaseAccountCreateOrUpdateParameters.Location = location;
databaseAccountCreateOrUpdateParameters.Tags.Add("key1", "value1");
databaseAccountCreateOrUpdateParameters.Tags.Add("key2", "value2");
databaseAccountCreateOrUpdateParameters.Kind = DatabaseAccountKind.MongoDB;
databaseAccountCreateOrUpdateParameters.ConsistencyPolicy =
new ConsistencyPolicy(DefaultConsistencyLevel.BoundedStaleness, maxStalenessPrefix, maxIntervalInSeconds);
databaseAccountCreateOrUpdateParameters.IpRules.Add(new IpAddressOrRange("23.43.230.120"));
databaseAccountCreateOrUpdateParameters.IsVirtualNetworkFilterEnabled = true;
databaseAccountCreateOrUpdateParameters.EnableAutomaticFailover = false;
databaseAccountCreateOrUpdateParameters.ConnectorOffer = "Small";
databaseAccountCreateOrUpdateParameters.DisableKeyBasedMetadataWriteAccess = false;
DatabaseAccountGetResults databaseAccountGetResults1 =
await WaitForCompletionAsync(
await CosmosDBManagementClient.DatabaseAccounts.StartCreateOrUpdateAsync(resourceGroupName, databaseAccountName, databaseAccountCreateOrUpdateParameters));
var response = await CosmosDBManagementClient.DatabaseAccounts.CheckNameExistsAsync(databaseAccountName);
Assert.AreEqual(true, response.Value);
Assert.AreEqual(200, response.GetRawResponse().Status);
DatabaseAccountGetResults databaseAccountGetResults2 = await CosmosDBManagementClient.DatabaseAccounts.GetAsync(resourceGroupName, databaseAccountName);
VerifyCosmosDBAccount(databaseAccountGetResults1, databaseAccountGetResults2);
var databaseAccountUpdateParameters = new DatabaseAccountUpdateParameters();
databaseAccountUpdateParameters.Tags.Add("key3", "value3");
databaseAccountUpdateParameters.Tags.Add("key4", "value4");
databaseAccountUpdateParameters.IsVirtualNetworkFilterEnabled = false;
databaseAccountUpdateParameters.EnableAutomaticFailover = true;
databaseAccountUpdateParameters.DisableKeyBasedMetadataWriteAccess = true;
await WaitForCompletionAsync(
await CosmosDBManagementClient.DatabaseAccounts.StartUpdateAsync(resourceGroupName, databaseAccountName, databaseAccountUpdateParameters));
var failoverPolicyList = new List <FailoverPolicy>();
failoverPolicyList.Add(new FailoverPolicy()
{
LocationName = location,
FailoverPriority = 0
});
FailoverPolicies failoverPolicies = new FailoverPolicies(failoverPolicyList);
await WaitForCompletionAsync(
await CosmosDBManagementClient.DatabaseAccounts.StartFailoverPriorityChangeAsync(resourceGroupName, databaseAccountName, failoverPolicies));
DatabaseAccountGetResults databaseAccountGetResults3 = await CosmosDBManagementClient.DatabaseAccounts.GetAsync(resourceGroupName, databaseAccountName);
VerifyCosmosDBAccount(databaseAccountGetResults3, databaseAccountUpdateParameters);
VerifyFailoverPolicies(failoverPolicyList, databaseAccountGetResults3.FailoverPolicies);
}
private static async Task <DatabaseAccountGetResults> CreateDatabaseAccountIfNotExists(
CosmosDBManagementClient cosmosDBManagementClient,
string databaseAccountName,
string armLocation,
string kind)
{
bool isDatabaseNameExists = cosmosDBManagementClient.DatabaseAccounts.CheckNameExistsWithHttpMessagesAsync(databaseAccountName).GetAwaiter().GetResult().Body;
String databaseKind = null;
List <Location> locations = null;
if (kind == ApiType.Sql)
{
databaseKind = DatabaseAccountKind.GlobalDocumentDB;
locations = new List <Location> {
new Location {
LocationName = "westus"
}, new Location {
LocationName = "eastus"
}, new Location {
LocationName = "eastus2"
}
};
}
else if (kind == ApiType.MongoDB)
{
databaseKind = DatabaseAccountKind.MongoDB;
locations = new List <Location> {
new Location {
LocationName = "westus"
}, new Location {
LocationName = "eastus"
}
};
}
DatabaseAccountGetResults databaseAccount = null;
if (!isDatabaseNameExists)
{
DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters
{
Location = armLocation,
Kind = databaseKind,
Locations = locations,
BackupPolicy = new ContinuousModeBackupPolicy()
};
databaseAccount = cosmosDBManagementClient.DatabaseAccounts.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseAccountCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.Equal(databaseAccount.Name, databaseAccountName);
}
databaseAccount = await cosmosDBManagementClient.DatabaseAccounts.GetAsync(resourceGroupName, databaseAccountName);
return(databaseAccount);
}
public async Task <DatabaseAccountGetResultsInner> CreateDatabaseAccountAsync(
IResourceGroup resourceGroup,
string cosmosDBAccountName,
IDictionary <string, string> tags = null,
CancellationToken cancellationToken = default
)
{
try {
tags ??= new Dictionary <string, string>();
Log.Information($"Creating Azure CosmosDB Account: {cosmosDBAccountName} ...");
var databaseAccountParameters = new DatabaseAccountCreateUpdateParameters {
Location = resourceGroup.RegionName,
Tags = tags,
//DatabaseAccountOfferType = "Standard",
Kind = DatabaseAccountKind.GlobalDocumentDB,
ConsistencyPolicy = new ConsistencyPolicy {
DefaultConsistencyLevel = DefaultConsistencyLevel.Strong,
MaxStalenessPrefix = 10,
MaxIntervalInSeconds = 5
},
Locations = new List <Location> {
new Location {
LocationName = resourceGroup.RegionName,
FailoverPriority = 0,
IsZoneRedundant = false
}
}
};
databaseAccountParameters.Validate();
var cosmosDBAccount = await _cosmosDBManagementClient
.DatabaseAccounts
.CreateOrUpdateAsync(
resourceGroup.Name,
cosmosDBAccountName,
databaseAccountParameters,
cancellationToken
);
Log.Information($"Created Azure CosmosDB Account: {cosmosDBAccountName}");
return(cosmosDBAccount);
}
catch (Exception ex) {
Log.Error(ex, $"Failed to create Azure CosmosDB Account: {cosmosDBAccountName}");
throw;
}
}
private string CreateDatabaseAccount(
string kind = "GlobalDocumentDB",
List <Capability> capabilities = null,
string serverVersion = null,
bool enablePitr = true,
string continuousTier = ContinuousTier.Continuous30Days)
{
var databaseAccountName = TestUtilities.GenerateName("databaseaccount");
var parameters = new DatabaseAccountCreateUpdateParameters
{
Location = this.Location,
Kind = kind,
Locations = new List <Location> {
new Location(locationName: this.Location)
},
IsVirtualNetworkFilterEnabled = true,
EnableAutomaticFailover = false,
EnableMultipleWriteLocations = false,
DisableKeyBasedMetadataWriteAccess = false,
NetworkAclBypass = NetworkAclBypass.AzureServices,
CreateMode = CreateMode.Default,
Capabilities = capabilities
};
if (enablePitr)
{
ContinuousModeProperties properties = new ContinuousModeProperties()
{
Tier = continuousTier
};
parameters.BackupPolicy = new ContinuousModeBackupPolicy()
{
ContinuousModeProperties = properties
};
}
if (serverVersion != null)
{
parameters.ApiProperties = new ApiProperties
{
ServerVersion = serverVersion
};
}
var databaseAccount = this.CosmosDBManagementClient.DatabaseAccounts.CreateOrUpdateWithHttpMessagesAsync(
this.ResourceGroupName,
databaseAccountName,
parameters
).GetAwaiter().GetResult().Body;
return(databaseAccountName);
}
private async Task PrepareDatabaseAccount()
{
List <Location> locationList = new List <Location>();
locationList.Add(new Location(id: null, locationName: location, documentEndpoint: null, provisioningState: null, failoverPriority: null, isZoneRedundant: null));
var databaseAccountsCreateOrUpdateParameters = new DatabaseAccountCreateUpdateParameters(locationList);
databaseAccountsCreateOrUpdateParameters.Kind = DatabaseAccountKind.MongoDB;
databaseAccountsCreateOrUpdateParameters.Location = location;
databaseAccountsCreateOrUpdateParameters.Capabilities.Add(new Capability(capability));
await WaitForCompletionAsync(
await CosmosDBManagementClient.DatabaseAccounts.StartCreateOrUpdateAsync(resourceGroupName, databaseAccountName, databaseAccountsCreateOrUpdateParameters));
Response response = await CosmosDBManagementClient.DatabaseAccounts.CheckNameExistsAsync(databaseAccountName);
Assert.AreEqual(200, response.Status);
}
public async Task CassandraCreateDatabaseAccount()
{
var locations = new List <Location>();
Location loc = new Location();
loc.LocationName = CosmosDBTestUtilities.Location;
loc.FailoverPriority = 0;
loc.IsZoneRedundant = false;
locations.Add(loc);
DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters(locations);
databaseAccountCreateUpdateParameters.Location = CosmosDBTestUtilities.Location;
databaseAccountCreateUpdateParameters.Capabilities.Add(new Capability("EnableCassandra"));
databaseAccountCreateUpdateParameters.ConsistencyPolicy = new ConsistencyPolicy(DefaultConsistencyLevel.Eventual);
await WaitForCompletionAsync(await CosmosDBManagementClient.DatabaseAccounts.StartCreateOrUpdateAsync(resourceGroupName, databaseAccountName, databaseAccountCreateUpdateParameters));
}
public void CreateCosmosDBTest()
{
Env.Load("../../../.env");
var client = new CosmosDBManagementClient(new DefaultAzureMgmtCredential());
client.SubscriptionId = Environment.GetEnvironmentVariable("AZURE_SUBSCRIPTION_ID");
var name = Environment.GetEnvironmentVariable("COSMOSDB_NAME") + Guid.NewGuid().ToString("n").Substring(0, 8);
var parameters = new DatabaseAccountCreateUpdateParameters
{
Location = Environment.GetEnvironmentVariable("AZURE_REGION"),
Locations = new List <Location> {
new Location(locationName: Environment.GetEnvironmentVariable("AZURE_REGION"))
}
};
var results = client.DatabaseAccounts.CreateOrUpdate(Environment.GetEnvironmentVariable("AZURE_RESOURCE_GROUP"), name, parameters);
Assert.Equal(results.Name, name);
}
private DatabaseAccountGetResults CreateDatabaseAccount(CosmosDBManagementClient cosmosDBManagementClient, string databaseAccountName, string kind = DatabaseAccountKind.GlobalDocumentDB)
{
DatabaseAccountGetResults databaseAccount;
try
{
DatabaseAccountGetResults databaseAccountGetResult = cosmosDBManagementClient.DatabaseAccounts.Get(this.fixture.ResourceGroupName, databaseAccountName);
if (databaseAccountGetResult != null)
{
return(databaseAccountGetResult);
}
}
catch (Exception) { }
bool isDatabaseNameExists = cosmosDBManagementClient.DatabaseAccounts.CheckNameExistsWithHttpMessagesAsync(databaseAccountName).GetAwaiter().GetResult().Body;
if (!isDatabaseNameExists)
{
DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters1 = new DatabaseAccountCreateUpdateParameters
{
Location = this.fixture.Location,
Kind = kind,
Locations = new List <Location> {
new Location {
LocationName = this.fixture.Location
}
},
BackupPolicy = new ContinuousModeBackupPolicy(),
};
databaseAccount = cosmosDBManagementClient.DatabaseAccounts.CreateOrUpdateWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseAccountCreateUpdateParameters1).GetAwaiter().GetResult().Body;
Assert.Equal(databaseAccount.Name, databaseAccountName);
}
databaseAccount = cosmosDBManagementClient.DatabaseAccounts.Get(this.fixture.ResourceGroupName, databaseAccountName);
return(databaseAccount);
}
public async Task RestoreDatabaseAccountTests()
{
var handler1 = 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, handler1);
string restoredatabaseAccountName = TestUtilities.GenerateName(prefix: "restoredaccountname");
DatabaseAccountGetResults databaseAccount = null;
bool isDatabaseNameExists = cosmosDBManagementClient.DatabaseAccounts.CheckNameExistsWithHttpMessagesAsync(sourceDatabaseAccountName).GetAwaiter().GetResult().Body;
if (!isDatabaseNameExists)
{
DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters1 = new DatabaseAccountCreateUpdateParameters
{
Location = location,
Kind = DatabaseAccountKind.GlobalDocumentDB,
Locations = new List <Location> {
new Location {
LocationName = location
}
},
BackupPolicy = new ContinuousModeBackupPolicy(),
};
databaseAccount = cosmosDBManagementClient.DatabaseAccounts.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, sourceDatabaseAccountName, databaseAccountCreateUpdateParameters1).GetAwaiter().GetResult().Body;
Assert.Equal(databaseAccount.Name, sourceDatabaseAccountName);
}
databaseAccount = await cosmosDBManagementClient.DatabaseAccounts.GetAsync(resourceGroupName, sourceDatabaseAccountName);
DateTime restoreTs = DateTime.UtcNow;
List <RestorableDatabaseAccountGetResult> restorableAccounts = (await cosmosDBManagementClient.RestorableDatabaseAccounts.ListByLocationAsync(location)).ToList();
RestorableDatabaseAccountGetResult restorableDatabaseAccount = restorableAccounts.
SingleOrDefault(account => account.AccountName.Equals(databaseAccount.Name, StringComparison.OrdinalIgnoreCase));
DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters
{
Location = location,
Tags = new Dictionary <string, string>
{
{ "key1", "value1" },
{ "key2", "value2" }
},
Kind = "GlobalDocumentDB",
Locations = new List <Location>
{
new Location(locationName: location)
},
CreateMode = CreateMode.Restore,
RestoreParameters = new RestoreParameters()
{
RestoreMode = "PointInTime",
RestoreTimestampInUtc = restoreTs,
RestoreSource = restorableDatabaseAccount.Id
}
};
DatabaseAccountGetResults restoredDatabaseAccount = (await cosmosDBManagementClient.DatabaseAccounts.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, restoredatabaseAccountName, databaseAccountCreateUpdateParameters)).Body;
Assert.NotNull(restoredDatabaseAccount);
Assert.NotNull(restoredDatabaseAccount.RestoreParameters);
Assert.Equal(restoredDatabaseAccount.RestoreParameters.RestoreSource.ToLower(), restorableDatabaseAccount.Id.ToLower());
Assert.True(restoredDatabaseAccount.BackupPolicy is ContinuousModeBackupPolicy);
}
}
public async Task TableCRUDTest()
{
// prepare a database account
List <Location> locationList = new List <Location>();
locationList.Add(new Location(id: null, locationName: "WEST US", documentEndpoint: null, provisioningState: null, failoverPriority: null, isZoneRedundant: null));
var databaseAccountsCreateOrUpdateParameters = new DatabaseAccountCreateUpdateParameters(locationList);
databaseAccountsCreateOrUpdateParameters.Kind = DatabaseAccountKind.GlobalDocumentDB;
databaseAccountsCreateOrUpdateParameters.Location = "WEST US";
databaseAccountsCreateOrUpdateParameters.Capabilities.Add(new Capability("EnableTable"));
await WaitForCompletionAsync(
await CosmosDBManagementClient.DatabaseAccounts.StartCreateOrUpdateAsync(resourceGroupName, databaseAccountName, databaseAccountsCreateOrUpdateParameters));
Response response = await CosmosDBManagementClient.DatabaseAccounts.CheckNameExistsAsync(databaseAccountName);
Assert.AreEqual(200, response.Status);
var tableCreateUpdateParameters1 = new TableCreateUpdateParameters(new TableResource(tableName), new CreateUpdateOptions());
TableGetResults tableGetResults1 = (
await WaitForCompletionAsync(
await CosmosDBManagementClient.TableResources.StartCreateUpdateTableAsync(resourceGroupName, databaseAccountName, tableName, tableCreateUpdateParameters1))).Value;
Assert.IsNotNull(tableGetResults1);
Assert.AreEqual(tableName, tableGetResults1.Resource.Id);
TableGetResults tableGetResults2 = (await CosmosDBManagementClient.TableResources.GetTableAsync(resourceGroupName, databaseAccountName, tableName)).Value;
Assert.IsNotNull(tableGetResults2);
VerifyTables(tableGetResults1, tableGetResults2);
var actualThroughput = (
await CosmosDBManagementClient.TableResources.GetTableThroughputAsync(resourceGroupName, databaseAccountName, tableName)).Value.Resource.Throughput;
Assert.AreEqual(defaultThroughput, actualThroughput);
var tableCreateUpdateParameters2 = new TableCreateUpdateParameters(new TableResource(tableName), new CreateUpdateOptions(sampleThroughput, new AutoscaleSettings()));
TableGetResults tableGetResults3 = (
await WaitForCompletionAsync(
await CosmosDBManagementClient.TableResources.StartCreateUpdateTableAsync(resourceGroupName, databaseAccountName, tableName, tableCreateUpdateParameters2))).Value;
Assert.IsNotNull(tableGetResults3);
Assert.AreEqual(tableName, tableGetResults3.Resource.Id);
actualThroughput = (await CosmosDBManagementClient.TableResources.GetTableThroughputAsync(resourceGroupName, databaseAccountName, tableName)).Value.Resource.Throughput;
Assert.AreEqual(sampleThroughput, actualThroughput);
TableGetResults tableGetResults4 = (await CosmosDBManagementClient.TableResources.GetTableAsync(resourceGroupName, databaseAccountName, tableName)).Value;
Assert.IsNotNull(tableGetResults4);
VerifyTables(tableGetResults3, tableGetResults4);
List <TableGetResults> tables = await CosmosDBManagementClient.TableResources.ListTablesAsync(resourceGroupName, databaseAccountName).ToEnumerableAsync();
Assert.IsNotNull(tables);
Assert.AreEqual(1, tables.Count);
VerifyTables(tableGetResults4, tables[0]);
ThroughputSettingsGetResults throughputSettingsGetResults1 =
await WaitForCompletionAsync(await CosmosDBManagementClient.TableResources.StartMigrateTableToAutoscaleAsync(resourceGroupName, databaseAccountName, tableName));
Assert.IsNotNull(throughputSettingsGetResults1.Resource.AutoscaleSettings);
Assert.AreEqual(defaultMaxThroughput, throughputSettingsGetResults1.Resource.AutoscaleSettings.MaxThroughput);
Assert.AreEqual(defaultThroughput, throughputSettingsGetResults1.Resource.Throughput);
ThroughputSettingsGetResults throughputSettingsGetResults2 =
await WaitForCompletionAsync(await CosmosDBManagementClient.TableResources.StartMigrateTableToManualThroughputAsync(resourceGroupName, databaseAccountName, tableName));
Assert.IsNull(throughputSettingsGetResults2.Resource.AutoscaleSettings);
Assert.AreEqual(defaultMaxThroughput, throughputSettingsGetResults2.Resource.Throughput);
var throughputSettingsUpdateParameters = new ThroughputSettingsUpdateParameters(new ThroughputSettingsResource(defaultThroughput, null, null, null));
ThroughputSettingsGetResults throughputSettingsGetResults = (
await WaitForCompletionAsync(
await CosmosDBManagementClient.TableResources.StartUpdateTableThroughputAsync(resourceGroupName, databaseAccountName, tableName, throughputSettingsUpdateParameters))).Value;
Assert.AreEqual(defaultThroughput, throughputSettingsGetResults.Resource.Throughput);
await WaitForCompletionAsync(await CosmosDBManagementClient.TableResources.StartDeleteTableAsync(resourceGroupName, databaseAccountName, tableName));
tables = await CosmosDBManagementClient.TableResources.ListTablesAsync(resourceGroupName, databaseAccountName).ToEnumerableAsync();
Assert.IsNotNull(tables);
Assert.AreEqual(0, tables.Count);
}
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);
}
}
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 CreateUpdateLocationParameters(DatabaseAccountCreateUpdateParameters createUpdateParameters)
{
parameters = createUpdateParameters;
}
public override void ExecuteCmdlet()
{
ConsistencyPolicy consistencyPolicy = new ConsistencyPolicy();
{
switch (DefaultConsistencyLevel)
{
case "Strong":
consistencyPolicy.DefaultConsistencyLevel = Management.CosmosDB.Models.DefaultConsistencyLevel.Strong;
break;
case "Session":
consistencyPolicy.DefaultConsistencyLevel = Management.CosmosDB.Models.DefaultConsistencyLevel.Session;
break;
case "Eventual":
consistencyPolicy.DefaultConsistencyLevel = Management.CosmosDB.Models.DefaultConsistencyLevel.Eventual;
break;
case "ConsistentPrefix":
consistencyPolicy.DefaultConsistencyLevel = Management.CosmosDB.Models.DefaultConsistencyLevel.ConsistentPrefix;
break;
case "BoundedStaleness":
consistencyPolicy.DefaultConsistencyLevel = Management.CosmosDB.Models.DefaultConsistencyLevel.BoundedStaleness;
consistencyPolicy.MaxIntervalInSeconds = MaxStalenessIntervalInSeconds;
consistencyPolicy.MaxStalenessPrefix = MaxStalenessPrefix;
break;
default:
consistencyPolicy.DefaultConsistencyLevel = Management.CosmosDB.Models.DefaultConsistencyLevel.Session;
break;
}
}
string writeLocation = null;
Collection <Location> LocationCollection = new Collection <Location>();
if (Location != null && Location.Length > 0)
{
int failoverPriority = 0;
foreach (string l in Location)
{
Location loc = new Location(locationName: l, failoverPriority: failoverPriority);
LocationCollection.Add(loc);
if (failoverPriority == 0)
{
writeLocation = l;
}
failoverPriority++;
}
}
else if (LocationObject != null && LocationObject.Length > 0)
{
if (writeLocation != null)
{
WriteWarning("Cannot accept Location and LocationObject simultaneously as parameters");
return;
}
foreach (PSLocation psLocation in LocationObject)
{
LocationCollection.Add(PSLocation.ConvertPSLocationToLocation(psLocation));
if (psLocation.FailoverPriority == 0)
{
writeLocation = psLocation.LocationName;
}
}
}
if (string.IsNullOrEmpty(writeLocation))
{
WriteWarning("Cannot create Account without a Write Location.");
return;
}
Dictionary <string, string> tags = new Dictionary <string, string>();
if (Tag != null)
{
foreach (string key in Tag.Keys)
{
tags.Add(key, Tag[key].ToString());
}
}
Collection <VirtualNetworkRule> virtualNetworkRule = new Collection <VirtualNetworkRule>();
if (VirtualNetworkRule != null && VirtualNetworkRule.Length > 0)
{
foreach (string id in VirtualNetworkRule)
{
virtualNetworkRule.Add(new VirtualNetworkRule(id: id));
}
}
if (VirtualNetworkRuleObject != null && VirtualNetworkRuleObject.Length > 0)
{
foreach (PSVirtualNetworkRule psVirtualNetworkRule in VirtualNetworkRuleObject)
{
virtualNetworkRule.Add(PSVirtualNetworkRule.ConvertPSVirtualNetworkRuleToVirtualNetworkRule(psVirtualNetworkRule));
}
}
string IpRangeFilterAsString = null;
if (IpRangeFilter != null && IpRangeFilter.Length > 0)
{
IpRangeFilterAsString = IpRangeFilter?.Aggregate(string.Empty, (output, next) => string.Concat(output, (!string.IsNullOrWhiteSpace(output) && !string.IsNullOrWhiteSpace(next) ? "," : string.Empty), next)) ?? string.Empty;
}
DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters(locations: LocationCollection, location: writeLocation, name: Name, consistencyPolicy: consistencyPolicy, tags: tags, ipRangeFilter: IpRangeFilterAsString);
databaseAccountCreateUpdateParameters.EnableMultipleWriteLocations = EnableMultipleWriteLocations;
databaseAccountCreateUpdateParameters.IsVirtualNetworkFilterEnabled = EnableVirtualNetwork;
databaseAccountCreateUpdateParameters.EnableAutomaticFailover = EnableAutomaticFailover;
databaseAccountCreateUpdateParameters.VirtualNetworkRules = virtualNetworkRule;
databaseAccountCreateUpdateParameters.DisableKeyBasedMetadataWriteAccess = DisableKeyBasedMetadataWriteAccess;
databaseAccountCreateUpdateParameters.IpRangeFilter = IpRangeFilterAsString;
databaseAccountCreateUpdateParameters.PublicNetworkAccess = PublicNetworkAccess;
if (!string.IsNullOrEmpty(ApiKind))
{
if (!ApiKind.Equals("MongoDB", StringComparison.OrdinalIgnoreCase))
{
switch (ApiKind)
{
case "Cassandra":
databaseAccountCreateUpdateParameters.Capabilities = new List <Capability> {
new Capability {
Name = "EnableCassandra"
}
};
break;
case "Gremlin":
databaseAccountCreateUpdateParameters.Capabilities = new List <Capability> {
new Capability {
Name = "EnableGremlin"
}
};
break;
case "Table":
databaseAccountCreateUpdateParameters.Capabilities = new List <Capability> {
new Capability {
Name = "EnableTable"
}
};
break;
case "Sql":
break;
}
ApiKind = null;
}
}
else
{
ApiKind = "GlobalDocumentDB";
}
databaseAccountCreateUpdateParameters.Kind = ApiKind;
if (ShouldProcess(Name, "Creating Database Account"))
{
DatabaseAccountGetResults cosmosDBAccount = CosmosDBManagementClient.DatabaseAccounts.CreateOrUpdateWithHttpMessagesAsync(ResourceGroupName, Name, databaseAccountCreateUpdateParameters).GetAwaiter().GetResult().Body;
WriteObject(new PSDatabaseAccount(cosmosDBAccount));
}
return;
}
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 void SqlAccountBackupPolicyTests()
{
using (var context = MockContext.Start(this.GetType()))
{
fixture.Init(context);
CosmosDBManagementClient cosmosDBManagementClient = this.fixture.CosmosDBManagementClient;
string location = this.fixture.Location;
var databaseAccountName = this.fixture.GetDatabaseAccountName(TestFixture.AccountType.Sql);
var resourceGroupName = this.fixture.ResourceGroupName;
{
DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters
{
Location = location,
Kind = DatabaseAccountKind.GlobalDocumentDB,
Locations = new List <Location>()
{
{ new Location(locationName: location) }
},
BackupPolicy = new PeriodicModeBackupPolicy()
{
PeriodicModeProperties = new PeriodicModeProperties()
{
BackupIntervalInMinutes = 60,
BackupRetentionIntervalInHours = 8,
BackupStorageRedundancy = BackupStorageRedundancy.Geo
}
}
};
DatabaseAccountGetResults databaseAccount = cosmosDBManagementClient.DatabaseAccounts.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseAccountCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.Equal(databaseAccount.Name, databaseAccountName);
PeriodicModeBackupPolicy backupPolicy = databaseAccount.BackupPolicy as PeriodicModeBackupPolicy;
Assert.Equal(60, backupPolicy.PeriodicModeProperties.BackupIntervalInMinutes);
Assert.Equal(8, backupPolicy.PeriodicModeProperties.BackupRetentionIntervalInHours);
Assert.Equal(BackupStorageRedundancy.Geo, backupPolicy.PeriodicModeProperties.BackupStorageRedundancy);
}
{
DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters
{
Location = location,
Kind = DatabaseAccountKind.GlobalDocumentDB,
Locations = new List <Location>()
{
{ new Location(locationName: location) }
},
BackupPolicy = new PeriodicModeBackupPolicy()
{
PeriodicModeProperties = new PeriodicModeProperties()
{
BackupIntervalInMinutes = 60,
BackupRetentionIntervalInHours = 12,
BackupStorageRedundancy = BackupStorageRedundancy.Local
}
}
};
DatabaseAccountGetResults databaseAccount = cosmosDBManagementClient.DatabaseAccounts.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseAccountCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.Equal(databaseAccount.Name, databaseAccountName);
PeriodicModeBackupPolicy backupPolicy = databaseAccount.BackupPolicy as PeriodicModeBackupPolicy;
Assert.Equal(60, backupPolicy.PeriodicModeProperties.BackupIntervalInMinutes);
Assert.Equal(12, backupPolicy.PeriodicModeProperties.BackupRetentionIntervalInHours);
Assert.Equal(BackupStorageRedundancy.Local, backupPolicy.PeriodicModeProperties.BackupStorageRedundancy);
}
}
}
/// <summary>
/// Creates or updates an Azure Cosmos DB database account. The "Update" method
/// is preferred when performing updates on an account.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// Name of an Azure resource group.
/// </param>
/// <param name='accountName'>
/// Cosmos DB database account name.
/// </param>
/// <param name='createUpdateParameters'>
/// The parameters to provide for the current database account.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <DatabaseAccountGetResultsInner> CreateOrUpdateAsync(this IDatabaseAccountsOperations operations, string resourceGroupName, string accountName, DatabaseAccountCreateUpdateParameters createUpdateParameters, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, accountName, createUpdateParameters, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public override void ExecuteCmdlet()
{
ConsistencyPolicy consistencyPolicy = new ConsistencyPolicy();
{
switch (DefaultConsistencyLevel)
{
case "Strong":
consistencyPolicy.DefaultConsistencyLevel = Management.CosmosDB.Models.DefaultConsistencyLevel.Strong;
break;
case "Session":
consistencyPolicy.DefaultConsistencyLevel = Management.CosmosDB.Models.DefaultConsistencyLevel.Session;
break;
case "Eventual":
consistencyPolicy.DefaultConsistencyLevel = Management.CosmosDB.Models.DefaultConsistencyLevel.Eventual;
break;
case "ConsistentPrefix":
consistencyPolicy.DefaultConsistencyLevel = Management.CosmosDB.Models.DefaultConsistencyLevel.ConsistentPrefix;
break;
case "BoundedStaleness":
consistencyPolicy.DefaultConsistencyLevel = Management.CosmosDB.Models.DefaultConsistencyLevel.BoundedStaleness;
consistencyPolicy.MaxIntervalInSeconds = MaxStalenessIntervalInSeconds;
consistencyPolicy.MaxStalenessPrefix = MaxStalenessPrefix;
break;
default:
consistencyPolicy.DefaultConsistencyLevel = Management.CosmosDB.Models.DefaultConsistencyLevel.Session;
break;
}
}
if (!string.IsNullOrEmpty(ApiKind))
{
if (!ApiKind.Equals("GlobalDocumentDB", StringComparison.OrdinalIgnoreCase) && !ApiKind.Equals("MongoDB", StringComparison.OrdinalIgnoreCase))
{
WriteError(new ErrorRecord(new PSArgumentException("Gremlin, Cassandra and Table account creation not supported" +
"in Azure Powershell"), string.Empty, ErrorCategory.CloseError, null));
return;
}
}
else
{
ApiKind = "GlobalDocumentDB";
}
string writeLocation = null;
Collection <Location> LocationCollection = new Collection <Location>();
if (Location != null && Location.Length > 0)
{
int failoverPriority = 0;
foreach (string l in Location)
{
Location loc = new Location(locationName: l, failoverPriority: failoverPriority);
LocationCollection.Add(loc);
if (failoverPriority == 0)
{
writeLocation = l;
}
failoverPriority++;
}
}
else if (LocationObject != null && LocationObject.Length > 0)
{
if (writeLocation != null)
{
WriteError(new ErrorRecord(new PSArgumentException("Cannot accept Location and LocationObject simultaneously as parameters"), string.Empty, ErrorCategory.CloseError, null));
return;
}
foreach (PSLocation psLocation in LocationObject)
{
LocationCollection.Add(PSLocation.ConvertPSLocationToLocation(psLocation));
if (psLocation.FailoverPriority == 0)
{
writeLocation = psLocation.LocationName;
}
}
}
if (string.IsNullOrEmpty(writeLocation))
{
WriteError(new ErrorRecord(new PSArgumentException("Cannot create Account without a Write Location."), string.Empty, ErrorCategory.CloseError, null));
return;
}
Dictionary <string, string> tags = new Dictionary <string, string>();
if (Tag != null)
{
foreach (string key in Tag.Keys)
{
tags.Add(key, Tag[key].ToString());
}
}
Collection <VirtualNetworkRule> virtualNetworkRule = new Collection <VirtualNetworkRule>();
if ((VirtualNetworkRule != null && VirtualNetworkRule.Length > 0) ||
(VirtualNetworkRuleObject != null && VirtualNetworkRuleObject.Length > 0))
{
foreach (string id in VirtualNetworkRule)
{
virtualNetworkRule.Add(new VirtualNetworkRule(id: id));
}
foreach (PSVirtualNetworkRule psVirtualNetworkRule in VirtualNetworkRuleObject)
{
virtualNetworkRule.Add(PSVirtualNetworkRule.ConvertPSVirtualNetworkRuleToVirtualNetworkRule(psVirtualNetworkRule));
}
}
string IpRangeFilterAsString = null;
if (IpRangeFilter != null && IpRangeFilter.Length > 0)
{
for (int i = 0; i < IpRangeFilter.Length; i++)
{
if (i == 0)
{
IpRangeFilterAsString = IpRangeFilter[0];
}
else
{
IpRangeFilterAsString = string.Concat(IpRangeFilterAsString, ",", IpRangeFilter[i]);
}
}
}
DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters(locations: LocationCollection, location: writeLocation, name: Name, kind: ApiKind, consistencyPolicy: consistencyPolicy, tags: tags, ipRangeFilter: IpRangeFilterAsString);
databaseAccountCreateUpdateParameters.EnableMultipleWriteLocations = EnableMultipleWriteLocations;
databaseAccountCreateUpdateParameters.IsVirtualNetworkFilterEnabled = EnableVirtualNetwork;
databaseAccountCreateUpdateParameters.EnableAutomaticFailover = EnableAutomaticFailover;
databaseAccountCreateUpdateParameters.VirtualNetworkRules = virtualNetworkRule;
if (ShouldProcess(Name, "Creating Database Account"))
{
DatabaseAccountGetResults cosmosDBAccount = CosmosDBManagementClient.DatabaseAccounts.CreateOrUpdateWithHttpMessagesAsync(ResourceGroupName, Name, databaseAccountCreateUpdateParameters).GetAwaiter().GetResult().Body;
WriteObject(new PSDatabaseAccount(cosmosDBAccount));
}
return;
}
public async Task RestorableSqlDatabaseResourceFeedTest()
{
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 = CosmosDBTestUtilities.CreateResourceGroup(resourcesClient);
string databaseAccountName = TestUtilities.GenerateName(prefix: "accountname");
List <Location> locations = new List <Location>();
locations.Add(new Location(locationName: "East US 2"));
DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters
{
Location = "EAST US 2",
Tags = new Dictionary <string, string>
{
{ "key1", "value1" },
{ "key2", "value2" }
},
Kind = "MongoDB",
ConsistencyPolicy = new ConsistencyPolicy
{
DefaultConsistencyLevel = DefaultConsistencyLevel.BoundedStaleness,
MaxStalenessPrefix = 300,
MaxIntervalInSeconds = 1000
},
Locations = locations
};
DatabaseAccountGetResults databaseAccount = cosmosDBManagementClient.DatabaseAccounts.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseAccountCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccount);
List <DatabaseAccountGetResults> databaseFeedResult = (await cosmosDBManagementClient.DatabaseAccounts.ListByResourceGroupAsync(resourceGroupName)).ToList();
Assert.Single(databaseFeedResult);
DatabaseAccountUpdateParameters databaseAccountUpdateParameters = new DatabaseAccountUpdateParameters
{
Location = "EAST US 2",
Tags = new Dictionary <string, string>
{
{ "key3", "value3" },
{ "key4", "value4" }
},
ConsistencyPolicy = new ConsistencyPolicy
{
DefaultConsistencyLevel = DefaultConsistencyLevel.Session,
MaxStalenessPrefix = 1300,
MaxIntervalInSeconds = 12000
},
Locations = locations,
IpRules = new List <IpAddressOrRange>
{
new IpAddressOrRange("23.43.230.120")
},
IsVirtualNetworkFilterEnabled = false,
EnableAutomaticFailover = true,
DisableKeyBasedMetadataWriteAccess = true,
NetworkAclBypass = NetworkAclBypass.AzureServices,
NetworkAclBypassResourceIds = new List <string>
{
"/subscriptions/subId/resourcegroups/rgName/providers/Microsoft.Synapse/workspaces/workspaceName",
"/subscriptions/subId/resourcegroups/rgName/providers/Microsoft.Synapse/workspaces/workspaceName2"
}
};
DatabaseAccountGetResults updatedDatabaseAccount = cosmosDBManagementClient.DatabaseAccounts.UpdateWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseAccountUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(updatedDatabaseAccount);
databaseFeedResult = (await cosmosDBManagementClient.DatabaseAccounts.ListByResourceGroupAsync(resourceGroupName)).ToList();
Assert.Single(databaseFeedResult);
await cosmosDBManagementClient.DatabaseAccounts.DeleteWithHttpMessagesAsync(resourceGroupName, databaseAccountName);
}
}
public void DatabaseAccountCRUDTests()
{
using (var context = MockContext.Start(this.GetType()))
{
fixture.Init(context);
var databaseAccountName = TestUtilities.GenerateName(prefix: "accountname");
var accountClient = this.fixture.CosmosDBManagementClient.DatabaseAccounts;
// Create and check
var parameters = new DatabaseAccountCreateUpdateParameters
{
Location = this.fixture.Location,
Tags = new Dictionary <string, string>
{
{ "key1", "value1" },
{ "key2", "value2" }
},
Kind = "MongoDB",
ConsistencyPolicy = new ConsistencyPolicy
{
DefaultConsistencyLevel = DefaultConsistencyLevel.BoundedStaleness,
MaxStalenessPrefix = 300,
MaxIntervalInSeconds = 1000
},
Locations = new List <Location> {
new Location(locationName: this.fixture.Location)
},
IpRules = new List <IpAddressOrRange>
{
new IpAddressOrRange("23.43.230.120")
},
IsVirtualNetworkFilterEnabled = true,
EnableAutomaticFailover = false,
EnableMultipleWriteLocations = true,
DisableKeyBasedMetadataWriteAccess = false,
NetworkAclBypass = NetworkAclBypass.AzureServices,
NetworkAclBypassResourceIds = new List <string>
{
"/subscriptions/subId/resourcegroups/rgName/providers/Microsoft.Synapse/workspaces/workspaceName"
},
CreateMode = CreateMode.Default
};
var databaseAccount = accountClient.CreateOrUpdateWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
parameters
).GetAwaiter().GetResult().Body;
VerifyCosmosDBAccount(databaseAccount, parameters);
Assert.Equal(databaseAccountName, databaseAccount.Name);
// Read and check
var readDatabaseAccount = accountClient.GetWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName
).GetAwaiter().GetResult().Body;
VerifyCosmosDBAccount(readDatabaseAccount, parameters);
Assert.Equal(databaseAccountName, readDatabaseAccount.Name);
// Update and check
var databaseAccountUpdateParameters = new DatabaseAccountUpdateParameters
{
Location = this.fixture.Location,
Tags = new Dictionary <string, string>
{
{ "key3", "value3" },
{ "key4", "value4" }
},
ConsistencyPolicy = new ConsistencyPolicy
{
DefaultConsistencyLevel = DefaultConsistencyLevel.Session,
MaxStalenessPrefix = 1300,
MaxIntervalInSeconds = 12000
},
Locations = new List <Location> {
new Location(locationName: this.fixture.Location)
},
IpRules = new List <IpAddressOrRange>
{
new IpAddressOrRange("23.43.230.120")
},
IsVirtualNetworkFilterEnabled = false,
EnableAutomaticFailover = true,
DisableKeyBasedMetadataWriteAccess = true,
NetworkAclBypass = NetworkAclBypass.AzureServices,
NetworkAclBypassResourceIds = new List <string>
{
"/subscriptions/subId/resourcegroups/rgName/providers/Microsoft.Synapse/workspaces/workspaceName",
"/subscriptions/subId/resourcegroups/rgName/providers/Microsoft.Synapse/workspaces/workspaceName2"
}
};
var updatedDatabaseAccount = accountClient.UpdateWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
databaseAccountUpdateParameters
).GetAwaiter().GetResult().Body;
VerifyCosmosDBAccount(updatedDatabaseAccount, databaseAccountUpdateParameters);
Assert.Equal(databaseAccountName, databaseAccount.Name);
// List database accounts, should not be empty
var databaseAccounts = accountClient.ListWithHttpMessagesAsync().GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccounts);
var databaseAccountsByResourceGroupName = accountClient.ListByResourceGroupWithHttpMessagesAsync(
this.fixture.ResourceGroupName
).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccountsByResourceGroupName);
var databaseAccountListKeysResult = accountClient.ListKeysWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName
).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccountListKeysResult.PrimaryMasterKey);
Assert.NotNull(databaseAccountListKeysResult.SecondaryMasterKey);
Assert.NotNull(databaseAccountListKeysResult.PrimaryReadonlyMasterKey);
Assert.NotNull(databaseAccountListKeysResult.SecondaryReadonlyMasterKey);
var databaseAccountListConnectionStringsResult = accountClient.ListConnectionStringsWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName
).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccountListConnectionStringsResult);
var databaseAccountGetReadOnlyKeysResult = accountClient.GetReadOnlyKeysWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName
).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccountGetReadOnlyKeysResult);
var databaseAccountListReadOnlyKeysResult = accountClient.ListReadOnlyKeysWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName
).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccountListReadOnlyKeysResult);
accountClient.RegenerateKeyWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
new DatabaseAccountRegenerateKeyParameters {
KeyKind = "primary"
}
);
accountClient.RegenerateKeyWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
new DatabaseAccountRegenerateKeyParameters {
KeyKind = "secondary"
}
);
accountClient.RegenerateKeyWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
new DatabaseAccountRegenerateKeyParameters {
KeyKind = "primaryReadonly"
}
);
accountClient.RegenerateKeyWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
new DatabaseAccountRegenerateKeyParameters {
KeyKind = "secondaryReadonly"
}
);
var databaseAccountListRegeneratedKeysResult = accountClient.ListKeysWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName
).GetAwaiter().GetResult().Body;
accountClient.DeleteWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName);
}
}
private static void VerifyCosmosDBAccount(DatabaseAccountGetResults databaseAccount, DatabaseAccountCreateUpdateParameters parameters)
{
Assert.Equal(databaseAccount.Location.ToLower(), parameters.Location.ToLower());
Assert.Equal(databaseAccount.Tags.Count, parameters.Tags.Count);
Assert.True(databaseAccount.Tags.SequenceEqual(parameters.Tags));
Assert.Equal(databaseAccount.Kind, parameters.Kind);
VerifyConsistencyPolicy(databaseAccount.ConsistencyPolicy, parameters.Properties.ConsistencyPolicy);
Assert.Equal(databaseAccount.IsVirtualNetworkFilterEnabled, parameters.Properties.IsVirtualNetworkFilterEnabled);
Assert.Equal(databaseAccount.EnableAutomaticFailover, parameters.Properties.EnableAutomaticFailover);
Assert.Equal(databaseAccount.EnableMultipleWriteLocations, parameters.Properties.EnableMultipleWriteLocations);
Assert.Equal(databaseAccount.EnableCassandraConnector, parameters.Properties.EnableCassandraConnector);
Assert.Equal(databaseAccount.ConnectorOffer, parameters.Properties.ConnectorOffer);
Assert.Equal(databaseAccount.DisableKeyBasedMetadataWriteAccess, parameters.Properties.DisableKeyBasedMetadataWriteAccess);
}
public async Task CassandraCRUDTestsAsync()
{
var locations = new List <Location>();
Location loc = new Location();
loc.LocationName = CosmosDBTestUtilities.Location;
loc.FailoverPriority = 0;
loc.IsZoneRedundant = false;
locations.Add(loc);
DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters(locations);
databaseAccountCreateUpdateParameters.Location = CosmosDBTestUtilities.Location;
databaseAccountCreateUpdateParameters.Capabilities.Add(new Capability("EnableCassandra"));
databaseAccountCreateUpdateParameters.ConsistencyPolicy = new ConsistencyPolicy(DefaultConsistencyLevel.Eventual);
await WaitForCompletionAsync(await CosmosDBManagementClient.DatabaseAccounts.StartCreateOrUpdateAsync(resourceGroupName, databaseAccountName, databaseAccountCreateUpdateParameters));
Task <Response> taskIsDatabaseNameExists = CosmosDBManagementClient.DatabaseAccounts.CheckNameExistsAsync(databaseAccountName);
Response isDatabaseNameExists = taskIsDatabaseNameExists.ConfigureAwait(false).GetAwaiter().GetResult();
Assert.AreEqual(200, isDatabaseNameExists.Status);
CassandraKeyspaceCreateUpdateParameters cassandraKeyspaceCreateUpdateParameters = new CassandraKeyspaceCreateUpdateParameters(new CassandraKeyspaceResource(keyspaceName), new CreateUpdateOptions());
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);
CassandraKeyspaceCreateUpdateParameters cassandraKeyspaceCreateUpdateParameters2 = new CassandraKeyspaceCreateUpdateParameters(new CassandraKeyspaceResource(keyspaceName2), new CreateUpdateOptions(sampleThroughput, default));
var cassandraKeyspaceResponse2 = await WaitForCompletionAsync(await CosmosDBManagementClient.CassandraResources.StartCreateUpdateCassandraKeyspaceAsync(resourceGroupName, databaseAccountName, keyspaceName2, cassandraKeyspaceCreateUpdateParameters2));
CassandraKeyspaceGetResults cassandraKeyspaceGetResults2 = cassandraKeyspaceResponse2.Value;
Assert.NotNull(cassandraKeyspaceGetResults2);
Assert.AreEqual(keyspaceName2, cassandraKeyspaceGetResults2.Name);
var keyspacesResponseTask = CosmosDBManagementClient.CassandraResources.ListCassandraKeyspacesAsync(resourceGroupName, databaseAccountName).ToEnumerableAsync();
List <CassandraKeyspaceGetResults> cassandraKeyspaces = keyspacesResponseTask.ConfigureAwait(false).GetAwaiter().GetResult();
Assert.NotNull(cassandraKeyspaces);
var throughputResponse = CosmosDBManagementClient.CassandraResources.GetCassandraKeyspaceThroughputAsync(resourceGroupName, databaseAccountName, keyspaceName2);
ThroughputSettingsGetResults throughputSettingsGetResults = throughputResponse.ConfigureAwait(false).GetAwaiter().GetResult();
Assert.NotNull(throughputSettingsGetResults);
Assert.NotNull(throughputSettingsGetResults.Name);
Assert.AreEqual(throughputSettingsGetResults.Resource.Throughput, sampleThroughput);
Assert.AreEqual(cassandraThroughputType, throughputSettingsGetResults.Type);
//TODO: Migrate To Manual and Autoscale tests from example: https://github.com/Azure/azure-rest-api-specs/blob/master/specification/cosmos-db/resource-manager/Microsoft.DocumentDB/stable/2020-04-01/examples/CosmosDBCassandraTableMigrateToAutoscale.json
//var migrateKeyspace = await cosmosDBClient.CassandraResources.StartMigrateCassandraKeyspaceToManualThroughputAsync(resourceGroupName, databaseAccountName, keyspaceName);
//var taskResponseMigrate = migrateKeyspace.WaitForCompletionAsync();
//var responseMigrate = taskResponseMigrate.ConfigureAwait(false).GetAwaiter().GetResult();
//Assert.AreEqual(responseMigrate.Value.Resource.MinimumThroughput, responseMigrate.Value.Resource.Throughput);
CassandraSchema cassandraSchema = new CassandraSchema(new List <Column> {
new Column {
Name = "columnA", Type = "int"
}, new Column {
Name = "columnB", Type = "ascii"
}
}, new List <CassandraPartitionKey> {
new CassandraPartitionKey {
Name = "columnA"
}
}, new List <ClusterKey> {
new ClusterKey {
Name = "columnB", OrderBy = "Asc"
}
});
CassandraTableResource cassandraTableResource = new CassandraTableResource(tableName, default, cassandraSchema, default);
public void DatabaseAccountCRUDTests()
{
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 = CosmosDBTestUtilities.CreateResourceGroup(resourcesClient);
string databaseAccountName = TestUtilities.GenerateName(prefix: "accountname");
List <Location> locations = new List <Location>();
locations.Add(new Location(locationName: location));
DefaultRequestDatabaseAccountCreateUpdateProperties databaseAccountCreateUpdateProperties = new DefaultRequestDatabaseAccountCreateUpdateProperties
{
ConsistencyPolicy = new ConsistencyPolicy
{
DefaultConsistencyLevel = DefaultConsistencyLevel.BoundedStaleness,
MaxStalenessPrefix = 300,
MaxIntervalInSeconds = 1000
},
Locations = locations,
IpRules = new List <IpAddressOrRange>
{
new IpAddressOrRange("23.43.230.120")
},
IsVirtualNetworkFilterEnabled = true,
EnableAutomaticFailover = false,
EnableMultipleWriteLocations = true,
EnableCassandraConnector = true,
ConnectorOffer = "Small",
DisableKeyBasedMetadataWriteAccess = false
};
DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters
{
Location = location,
Tags = new Dictionary <string, string>
{
{ "key1", "value1" },
{ "key2", "value2" }
},
Kind = "MongoDB",
Properties = databaseAccountCreateUpdateProperties
};
DatabaseAccountGetResults databaseAccount = cosmosDBManagementClient.DatabaseAccounts.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseAccountCreateUpdateParameters).GetAwaiter().GetResult().Body;
VerifyCosmosDBAccount(databaseAccount, databaseAccountCreateUpdateParameters);
Assert.Equal(databaseAccountName, databaseAccount.Name);
DatabaseAccountGetResults readDatabaseAccount = cosmosDBManagementClient.DatabaseAccounts.GetWithHttpMessagesAsync(resourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
VerifyCosmosDBAccount(readDatabaseAccount, databaseAccountCreateUpdateParameters);
Assert.Equal(databaseAccountName, readDatabaseAccount.Name);
DatabaseAccountUpdateParameters databaseAccountUpdateParameters = new DatabaseAccountUpdateParameters
{
Location = location,
Tags = new Dictionary <string, string>
{
{ "key3", "value3" },
{ "key4", "value4" }
},
ConsistencyPolicy = new ConsistencyPolicy
{
DefaultConsistencyLevel = DefaultConsistencyLevel.Session,
MaxStalenessPrefix = 1300,
MaxIntervalInSeconds = 12000
},
Locations = locations,
IpRules = new List <IpAddressOrRange>
{
new IpAddressOrRange("23.43.230.120")
},
IsVirtualNetworkFilterEnabled = false,
EnableAutomaticFailover = true,
EnableCassandraConnector = true,
ConnectorOffer = "Small",
DisableKeyBasedMetadataWriteAccess = true
};
DatabaseAccountGetResults updatedDatabaseAccount = cosmosDBManagementClient.DatabaseAccounts.UpdateWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseAccountUpdateParameters).GetAwaiter().GetResult().Body;
VerifyCosmosDBAccount(updatedDatabaseAccount, databaseAccountUpdateParameters);
Assert.Equal(databaseAccountName, databaseAccount.Name);
IEnumerable <DatabaseAccountGetResults> databaseAccounts = cosmosDBManagementClient.DatabaseAccounts.ListWithHttpMessagesAsync().GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccounts);
IEnumerable <DatabaseAccountGetResults> databaseAccountsByResourceGroupName = cosmosDBManagementClient.DatabaseAccounts.ListByResourceGroupWithHttpMessagesAsync(resourceGroupName).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccountsByResourceGroupName);
DatabaseAccountListKeysResult databaseAccountListKeysResult = cosmosDBManagementClient.DatabaseAccounts.ListKeysWithHttpMessagesAsync(resourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccountListKeysResult.PrimaryMasterKey);
Assert.NotNull(databaseAccountListKeysResult.SecondaryMasterKey);
Assert.NotNull(databaseAccountListKeysResult.PrimaryReadonlyMasterKey);
Assert.NotNull(databaseAccountListKeysResult.SecondaryReadonlyMasterKey);
DatabaseAccountListConnectionStringsResult databaseAccountListConnectionStringsResult = cosmosDBManagementClient.DatabaseAccounts.ListConnectionStringsWithHttpMessagesAsync(resourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccountListConnectionStringsResult);
DatabaseAccountListReadOnlyKeysResult databaseAccountGetReadOnlyKeysResult = cosmosDBManagementClient.DatabaseAccounts.GetReadOnlyKeysWithHttpMessagesAsync(resourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccountGetReadOnlyKeysResult);
DatabaseAccountListReadOnlyKeysResult databaseAccountListReadOnlyKeysResult = cosmosDBManagementClient.DatabaseAccounts.ListReadOnlyKeysWithHttpMessagesAsync(resourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccountListReadOnlyKeysResult);
cosmosDBManagementClient.DatabaseAccounts.RegenerateKeyWithHttpMessagesAsync(resourceGroupName, databaseAccountName, new DatabaseAccountRegenerateKeyParameters {
KeyKind = "primary"
});
cosmosDBManagementClient.DatabaseAccounts.RegenerateKeyWithHttpMessagesAsync(resourceGroupName, databaseAccountName, new DatabaseAccountRegenerateKeyParameters {
KeyKind = "secondary"
});
cosmosDBManagementClient.DatabaseAccounts.RegenerateKeyWithHttpMessagesAsync(resourceGroupName, databaseAccountName, new DatabaseAccountRegenerateKeyParameters {
KeyKind = "primaryReadonly"
});
cosmosDBManagementClient.DatabaseAccounts.RegenerateKeyWithHttpMessagesAsync(resourceGroupName, databaseAccountName, new DatabaseAccountRegenerateKeyParameters {
KeyKind = "secondaryReadonly"
});
DatabaseAccountListKeysResult databaseAccountListRegeneratedKeysResult = cosmosDBManagementClient.DatabaseAccounts.ListKeysWithHttpMessagesAsync(resourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
cosmosDBManagementClient.DatabaseAccounts.DeleteWithHttpMessagesAsync(resourceGroupName, databaseAccountName);
}
}
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()
{
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 override void ExecuteCmdlet()
{
DatabaseAccountGetResults databaseAccountGetResults = null;
try
{
databaseAccountGetResults = CosmosDBManagementClient.DatabaseAccounts.Get(ResourceGroupName, Name);
}
catch (CloudException e)
{
if (e.Response.StatusCode != System.Net.HttpStatusCode.NotFound)
{
throw;
}
}
if (databaseAccountGetResults != null)
{
throw new ConflictingResourceException(message: string.Format(ExceptionMessage.Conflict, Name));
}
ConsistencyPolicy consistencyPolicy = base.PopoulateConsistencyPolicy(DefaultConsistencyLevel, MaxStalenessIntervalInSeconds, MaxStalenessPrefix);
string writeLocation = null;
Collection <Location> LocationCollection = new Collection <Location>();
if (Location != null && Location.Length > 0)
{
int failoverPriority = 0;
foreach (string l in Location)
{
Location loc = new Location(locationName: l, failoverPriority: failoverPriority);
LocationCollection.Add(loc);
if (failoverPriority == 0)
{
writeLocation = l;
}
failoverPriority++;
}
}
else if (LocationObject != null && LocationObject.Length > 0)
{
if (writeLocation != null)
{
WriteWarning("Cannot accept Location and LocationObject simultaneously as parameters");
return;
}
foreach (PSLocation psLocation in LocationObject)
{
LocationCollection.Add(PSLocation.ToSDKModel(psLocation));
if (psLocation.FailoverPriority == 0)
{
writeLocation = psLocation.LocationName;
}
}
}
Dictionary <string, string> tags = new Dictionary <string, string>();
if (Tag != null)
{
tags = base.PopulateTags(Tag);
}
Collection <VirtualNetworkRule> virtualNetworkRule = new Collection <VirtualNetworkRule>();
if (VirtualNetworkRule != null && VirtualNetworkRule.Length > 0)
{
foreach (string id in VirtualNetworkRule)
{
virtualNetworkRule.Add(new VirtualNetworkRule(id: id));
}
}
if (VirtualNetworkRuleObject != null && VirtualNetworkRuleObject.Length > 0)
{
foreach (PSVirtualNetworkRule psVirtualNetworkRule in VirtualNetworkRuleObject)
{
virtualNetworkRule.Add(PSVirtualNetworkRule.ToSDKModel(psVirtualNetworkRule));
}
}
DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters(locations: LocationCollection, location: writeLocation, name: Name, tags: tags);
if (FromPointInTimeBackup)
{
PSRestoreParameters restoreParameters = restoreContext.GetRestoreParameters(CosmosDBManagementClient);
if (restoreParameters == null)
{
WriteWarning("Please provide valid parameters to restore");
return;
}
databaseAccountCreateUpdateParameters.CreateMode = CreateMode.Restore;
databaseAccountCreateUpdateParameters.RestoreParameters = restoreParameters.ToSDKModel();
}
databaseAccountCreateUpdateParameters.ConsistencyPolicy = consistencyPolicy;
databaseAccountCreateUpdateParameters.EnableMultipleWriteLocations = EnableMultipleWriteLocations;
databaseAccountCreateUpdateParameters.IsVirtualNetworkFilterEnabled = EnableVirtualNetwork;
databaseAccountCreateUpdateParameters.EnableAutomaticFailover = EnableAutomaticFailover;
databaseAccountCreateUpdateParameters.VirtualNetworkRules = virtualNetworkRule;
databaseAccountCreateUpdateParameters.DisableKeyBasedMetadataWriteAccess = DisableKeyBasedMetadataWriteAccess;
databaseAccountCreateUpdateParameters.PublicNetworkAccess = PublicNetworkAccess;
databaseAccountCreateUpdateParameters.EnableFreeTier = EnableFreeTier;
databaseAccountCreateUpdateParameters.EnableAnalyticalStorage = EnableAnalyticalStorage;
Collection <string> networkAclBypassResourceId = NetworkAclBypassResourceId != null ? new Collection <string>(NetworkAclBypassResourceId) : new Collection <string>();
databaseAccountCreateUpdateParameters.NetworkAclBypassResourceIds = networkAclBypassResourceId;
if (IpRule != null && IpRule.Length > 0)
{
databaseAccountCreateUpdateParameters.IpRules = base.PopulateIpRules(IpRule);
}
if (KeyVaultKeyUri != null)
{
databaseAccountCreateUpdateParameters.KeyVaultKeyUri = KeyVaultKeyUri;
}
if (NetworkAclBypass != null)
{
databaseAccountCreateUpdateParameters.NetworkAclBypass =
NetworkAclBypass == "AzureServices" ? SDKModel.NetworkAclBypass.AzureServices : SDKModel.NetworkAclBypass.None;
}
if (!string.IsNullOrEmpty(ApiKind))
{
if (ApiKind.Equals("MongoDB", StringComparison.OrdinalIgnoreCase))
{
if (ServerVersion != null)
{
databaseAccountCreateUpdateParameters.ApiProperties = new ApiProperties
{
ServerVersion = ServerVersion
};
}
}
else
{
switch (ApiKind)
{
case "Cassandra":
databaseAccountCreateUpdateParameters.Capabilities = new List <Capability> {
new Capability {
Name = "EnableCassandra"
}
};
break;
case "Gremlin":
databaseAccountCreateUpdateParameters.Capabilities = new List <Capability> {
new Capability {
Name = "EnableGremlin"
}
};
break;
case "Table":
databaseAccountCreateUpdateParameters.Capabilities = new List <Capability> {
new Capability {
Name = "EnableTable"
}
};
break;
case "Sql":
break;
}
ApiKind = null;
}
}
else
{
ApiKind = "GlobalDocumentDB";
}
databaseAccountCreateUpdateParameters.Kind = ApiKind;
if (!string.IsNullOrEmpty(BackupPolicyType))
{
PSBackupPolicy backupPolicy = new PSBackupPolicy()
{
BackupType = BackupPolicyType,
BackupIntervalInMinutes = BackupIntervalInMinutes,
BackupRetentionIntervalInHours = BackupRetentionIntervalInHours,
BackupStorageRedundancy = BackupStorageRedundancy
};
if (BackupPolicyType.Equals(PSBackupPolicy.ContinuousModeBackupType, StringComparison.OrdinalIgnoreCase) &&
(BackupIntervalInMinutes.HasValue || BackupRetentionIntervalInHours.HasValue))
{
WriteWarning("Cannot accept BackupInterval or BackupRetention parameters for ContinuousModeBackupType");
return;
}
databaseAccountCreateUpdateParameters.BackupPolicy = backupPolicy.ToSDKModel();
}
else if (BackupIntervalInMinutes.HasValue || BackupRetentionIntervalInHours.HasValue || !string.IsNullOrEmpty(BackupStorageRedundancy))
{
databaseAccountCreateUpdateParameters.BackupPolicy = new PeriodicModeBackupPolicy()
{
PeriodicModeProperties = new PeriodicModeProperties()
{
BackupIntervalInMinutes = BackupIntervalInMinutes,
BackupRetentionIntervalInHours = BackupRetentionIntervalInHours,
BackupStorageRedundancy = BackupStorageRedundancy
}
};
}
// Update analytical storage schema type.
databaseAccountCreateUpdateParameters.AnalyticalStorageConfiguration = CreateAnalyticalStorageConfiguration(AnalyticalStorageSchemaType);
if (ShouldProcess(Name, "Creating Database Account"))
{
DatabaseAccountGetResults cosmosDBAccount = CosmosDBManagementClient.DatabaseAccounts.CreateOrUpdateWithHttpMessagesAsync(ResourceGroupName, Name, databaseAccountCreateUpdateParameters).GetAwaiter().GetResult().Body;
WriteObject(new PSDatabaseAccountGetResults(cosmosDBAccount));
}
return;
}
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 override void ExecuteCmdlet()
{
DateTime utcRestoreDateTime;
if (RestoreTimestampInUtc.Kind == DateTimeKind.Unspecified)
{
utcRestoreDateTime = RestoreTimestampInUtc;
}
else
{
utcRestoreDateTime = RestoreTimestampInUtc.ToUniversalTime();
}
// Fail if provided restoretimesamp is greater than current timestamp
if (utcRestoreDateTime > DateTime.UtcNow)
{
WriteWarning($"Restore timestamp {utcRestoreDateTime} should be less than current timestamp {DateTime.UtcNow}");
return;
}
bool isSourceRestorableAccountDeleted = false;
List <RestorableDatabaseAccountGetResult> restorableDatabaseAccounts = CosmosDBManagementClient.RestorableDatabaseAccounts.ListWithHttpMessagesAsync().GetAwaiter().GetResult().Body.ToList();
RestorableDatabaseAccountGetResult sourceAccountToRestore = null;
List <RestorableDatabaseAccountGetResult> accountsWithMatchingName = restorableDatabaseAccounts.Where(databaseAccount => databaseAccount.AccountName.Equals(SourceDatabaseAccountName, StringComparison.OrdinalIgnoreCase)).ToList();
if (accountsWithMatchingName.Count > 0)
{
foreach (RestorableDatabaseAccountGetResult restorableAccount in accountsWithMatchingName)
{
if (restorableAccount.CreationTime.HasValue &&
restorableAccount.CreationTime < utcRestoreDateTime)
{
if (!restorableAccount.DeletionTime.HasValue || restorableAccount.DeletionTime > utcRestoreDateTime)
{
sourceAccountToRestore = restorableAccount;
isSourceRestorableAccountDeleted = true;
break;
}
}
}
}
if (sourceAccountToRestore == null)
{
WriteWarning($"No database accounts found with matching account name {SourceDatabaseAccountName} that was alive at given utc-timestamp {utcRestoreDateTime}");
return;
}
// Validate if source account is empty if the source account is a live account.
if (!isSourceRestorableAccountDeleted)
{
IEnumerable <DatabaseRestoreResource> restorableResources = null;
if (sourceAccountToRestore.ApiType.Equals("Sql", StringComparison.OrdinalIgnoreCase))
{
try
{
restorableResources = CosmosDBManagementClient.RestorableSqlResources.ListWithHttpMessagesAsync(
sourceAccountToRestore.Location,
sourceAccountToRestore.Name,
Location,
utcRestoreDateTime.ToString()).GetAwaiter().GetResult().Body;
}
catch (Exception)
{
WriteWarning($"No database accounts found with matching account name {SourceDatabaseAccountName} that was alive at given utc-timestamp {utcRestoreDateTime} in location {Location}");
return;
}
}
else if (sourceAccountToRestore.ApiType.Equals("MongoDB", StringComparison.OrdinalIgnoreCase))
{
try
{
restorableResources = CosmosDBManagementClient.RestorableMongodbResources.ListWithHttpMessagesAsync(
sourceAccountToRestore.Location,
sourceAccountToRestore.Name,
Location,
utcRestoreDateTime.ToString()).GetAwaiter().GetResult().Body;
}
catch (Exception)
{
WriteWarning($"No database accounts found with matching account name {SourceDatabaseAccountName} that was alive at given utc-timestamp {utcRestoreDateTime} in location {Location}");
return;
}
}
else
{
WriteWarning($"Provided API Type {sourceAccountToRestore.ApiType} is not supported");
return;
}
if (restorableResources == null || !restorableResources.Any())
{
WriteWarning($"Database account {SourceDatabaseAccountName} contains no restorable resources in location {Location} at given restore timestamp {utcRestoreDateTime} in location {Location}");
return;
}
}
// Trigger restore
PSRestoreParameters restoreParameters = new PSRestoreParameters()
{
RestoreSource = sourceAccountToRestore.Id,
RestoreTimestampInUtc = utcRestoreDateTime,
DatabasesToRestore = DatabasesToRestore
};
Collection <Location> LocationCollection = new Collection <Location>();
Location loc = new Location(locationName: Location, failoverPriority: 0);
LocationCollection.Add(loc);
string apiKind = "GlobalDocumentDB";
if (sourceAccountToRestore.ApiType.Equals("MongoDB", StringComparison.OrdinalIgnoreCase))
{
apiKind = "MongoDB";
}
DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters(locations: LocationCollection, location: sourceAccountToRestore.Location, name: TargetDatabaseAccountName)
{
Kind = apiKind,
CreateMode = CreateMode.Restore,
RestoreParameters = restoreParameters.ToSDKModel()
};
if (ShouldProcess(TargetDatabaseAccountName,
string.Format(
"Creating Database Account by restoring Database Account with Name {0} and restorable database account Id {1} to the timestamp {2}",
SourceDatabaseAccountName,
sourceAccountToRestore.Id,
RestoreTimestampInUtc)))
{
DatabaseAccountGetResults cosmosDBAccount = CosmosDBManagementClient.DatabaseAccounts.CreateOrUpdateWithHttpMessagesAsync(TargetResourceGroupName, TargetDatabaseAccountName, databaseAccountCreateUpdateParameters).GetAwaiter().GetResult().Body;
WriteObject(new PSDatabaseAccountGetResults(cosmosDBAccount));
}
return;
}
