public async Task SetUp()
{
// need to overwrite with the resource group fetched by ArmClient, otherwise it won't be recorded
_resourceGroup = await ArmClient.GetResourceGroupResource(_resourceGroupIdentifier).GetAsync();
_databaseAccount = await ArmClient.GetDatabaseAccountResource(_databaseAccountIdentifier).GetAsync();
}
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,
};
DatabaseAccountResource 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);
}
private void VerifyCosmosDBAccount(DatabaseAccountResource databaseAccount, DatabaseAccountUpdateParameters parameters)
{
Assert.True(databaseAccount.Tags.SequenceEqual(parameters.Tags));
Assert.AreEqual(databaseAccount.IsVirtualNetworkFilterEnabled, parameters.IsVirtualNetworkFilterEnabled);
Assert.AreEqual(databaseAccount.EnableAutomaticFailover, parameters.EnableAutomaticFailover);
Assert.AreEqual(databaseAccount.DisableKeyBasedMetadataWriteAccess, parameters.DisableKeyBasedMetadataWriteAccess);
}
private void VerifyCosmosDBAccount(DatabaseAccountResource expectedValue, DatabaseAccountResource actualValue)
{
Assert.AreEqual(expectedValue.Name, actualValue.Name);
Assert.AreEqual(expectedValue.Location, actualValue.Location);
Assert.True(expectedValue.Tags.SequenceEqual(actualValue.Tags));
Assert.AreEqual(expectedValue.Kind, actualValue.Kind);
Assert.AreEqual(expectedValue.ProvisioningState, actualValue.ProvisioningState);
Assert.AreEqual(expectedValue.DocumentEndpoint, actualValue.DocumentEndpoint);
Assert.AreEqual(expectedValue.DatabaseAccountOfferType, actualValue.DatabaseAccountOfferType);
Assert.AreEqual(expectedValue.IpRules.Count, actualValue.IpRules.Count);
Assert.AreEqual(expectedValue.IpRules[0].IpAddressOrRangeValue, actualValue.IpRules[0].IpAddressOrRangeValue);
Assert.AreEqual(expectedValue.IsVirtualNetworkFilterEnabled, actualValue.IsVirtualNetworkFilterEnabled);
Assert.AreEqual(expectedValue.EnableAutomaticFailover, actualValue.EnableAutomaticFailover);
VerifyConsistencyPolicy(expectedValue.ConsistencyPolicy, actualValue.ConsistencyPolicy);
Assert.AreEqual(expectedValue.Capabilities.Count, actualValue.Capabilities.Count);
VerifyLocations(expectedValue.WriteLocations, actualValue.WriteLocations);
VerifyLocations(expectedValue.ReadLocations, actualValue.ReadLocations);
VerifyLocations(expectedValue.Locations, actualValue.Locations);
VerifyFailoverPolicies(expectedValue.FailoverPolicies, actualValue.FailoverPolicies);
Assert.AreEqual(expectedValue.VirtualNetworkRules.Count, actualValue.VirtualNetworkRules.Count);
Assert.AreEqual(expectedValue.PrivateEndpointConnections.Count, actualValue.PrivateEndpointConnections.Count);
Assert.AreEqual(expectedValue.EnableMultipleWriteLocations, actualValue.EnableMultipleWriteLocations);
Assert.AreEqual(expectedValue.EnableCassandraConnector, actualValue.EnableCassandraConnector);
Assert.AreEqual(expectedValue.ConnectorOffer, actualValue.ConnectorOffer);
Assert.AreEqual(expectedValue.DisableKeyBasedMetadataWriteAccess, actualValue.DisableKeyBasedMetadataWriteAccess);
Assert.AreEqual(expectedValue.KeyVaultKeyUri, actualValue.KeyVaultKeyUri);
Assert.AreEqual(expectedValue.PublicNetworkAccess, actualValue.PublicNetworkAccess);
Assert.AreEqual(expectedValue.EnableFreeTier, actualValue.EnableFreeTier);
Assert.AreEqual(expectedValue.ApiProperties.ServerVersion.ToString(), actualValue.ApiProperties.ServerVersion.ToString());
Assert.AreEqual(expectedValue.EnableAnalyticalStorage, actualValue.EnableAnalyticalStorage);
Assert.AreEqual(expectedValue.Cors.Count, actualValue.Cors.Count);
}
public async Task RestorableDatabaseAccountList()
{
_restorableDatabaseAccount = await CreateRestorableDatabaseAccount(Recording.GenerateAssetName("r-database-account-"));
var restorableAccounts = await(await ArmClient.GetDefaultSubscriptionAsync()).GetRestorableDatabaseAccountsAsync().ToEnumerableAsync();
Assert.That(restorableAccounts.Any(account => account.Data.AccountName == _restorableDatabaseAccount.Data.Name));
}
public async Task RestorableDatabaseAccountListByLocation()
{
_restorableDatabaseAccount = await CreateRestorableDatabaseAccount(Recording.GenerateAssetName("r-database-account-"));
CosmosDBLocationResource location = await(await ArmClient.GetDefaultSubscriptionAsync()).GetCosmosDBLocations().GetAsync(AzureLocation.WestUS);
var restorableAccounts = await location.GetRestorableDatabaseAccounts().GetAllAsync().ToEnumerableAsync();
Assert.That(restorableAccounts.Any(account => account.Data.AccountName == _restorableDatabaseAccount.Data.Name));
}
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;
DatabaseAccountResource databaseAccount1 =
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);
DatabaseAccountResource databaseAccount2 = await CosmosDBManagementClient.DatabaseAccounts.GetAsync(resourceGroupName, databaseAccountName);
VerifyCosmosDBAccount(databaseAccount1, databaseAccount2);
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));
DatabaseAccountResource databaseAccount3 = await CosmosDBManagementClient.DatabaseAccounts.GetAsync(resourceGroupName, databaseAccountName);
VerifyCosmosDBAccount(databaseAccount3, databaseAccountUpdateParameters);
VerifyFailoverPolicies(failoverPolicyList, databaseAccount3.FailoverPolicies);
}
public async Task GlobalSetup()
{
_resourceGroup = await GlobalClient.GetResourceGroupResource(_resourceGroupIdentifier).GetAsync();
_databaseAccount = await CreateDatabaseAccount(SessionRecording.GenerateAssetName("dbaccount-"), DatabaseAccountKind.MongoDB);
_mongoDBDatabaseId = (await MongoDBDatabaseTests.CreateMongoDBDatabase(SessionRecording.GenerateAssetName("mongodb-"), null, _databaseAccount.GetMongoDBDatabases())).Id;
await StopSessionRecordingAsync();
}
public async Task GlobalSetup()
{
_resourceGroup = await GlobalClient.GetResourceGroupResource(_resourceGroupIdentifier).GetAsync();
_databaseAccount = await CreateDatabaseAccount(SessionRecording.GenerateAssetName("dbaccount-"), DatabaseAccountKind.GlobalDocumentDB, new DatabaseAccountCapability("EnableCassandra"));
_cassandraKeyspaceId = (await CassandraKeyspaceTests.CreateCassandraKeyspace(SessionRecording.GenerateAssetName("cassandra-keyspace-"), null, _databaseAccount.GetCassandraKeyspaces())).Id;
await StopSessionRecordingAsync();
}
public async Task DatabaseAccountListByResourceGroupTest()
{
List <DatabaseAccountResource> databaseAccounts = await CosmosDBManagementClient.DatabaseAccounts.ListByResourceGroupAsync(resourceGroupName).ToEnumerableAsync();
Assert.IsNotNull(databaseAccounts);
Assert.AreEqual(1, databaseAccounts.Count);
DatabaseAccountResource expectedDatabaseAccount = await CosmosDBManagementClient.DatabaseAccounts.GetAsync(resourceGroupName, databaseAccountName);
VerifyCosmosDBAccount(expectedDatabaseAccount, databaseAccounts[0]);
}
public async Task TestTearDown()
{
if (await DatabaseAccountCollection.ExistsAsync(_databaseAccountName))
{
var id = DatabaseAccountCollection.Id;
id = DatabaseAccountResource.CreateResourceIdentifier(id.SubscriptionId, id.ResourceGroupName, _databaseAccountName);
DatabaseAccountResource account = this.ArmClient.GetDatabaseAccountResource(id);
await account.DeleteAsync(WaitUntil.Completed);
}
}
public async Task GlobalSetup()
{
_resourceGroup = await GlobalClient.GetResourceGroupResource(_resourceGroupIdentifier).GetAsync();
_databaseAccount = await CreateDatabaseAccount(SessionRecording.GenerateAssetName("dbaccount-"), DatabaseAccountKind.GlobalDocumentDB);
_sqlDatabase = await SqlDatabaseTests.CreateSqlDatabase(SessionRecording.GenerateAssetName("sql-db-"), null, _databaseAccount.GetSqlDatabases());
_sqlContainerId = (await SqlContainerTests.CreateSqlContainer(SessionRecording.GenerateAssetName("sql-container-"), null, _sqlDatabase.GetSqlContainers())).Id;
await StopSessionRecordingAsync();
}
public async Task DatabaseAccountListBySubscriptionTest()
{
List <DatabaseAccountResource> databaseAccounts = await CosmosDBManagementClient.DatabaseAccounts.ListAsync().ToEnumerableAsync();
Assert.IsNotNull(databaseAccounts);
bool databaseAccountFound = false;
DatabaseAccountResource actualDatabaseAccount = null;
foreach (DatabaseAccountResource databaseAccount in databaseAccounts)
{
if (databaseAccount.Name == databaseAccountName)
{
databaseAccountFound = true;
actualDatabaseAccount = databaseAccount;
}
}
Assert.AreEqual(true, databaseAccountFound);
DatabaseAccountResource expectedDatabaseAccount = await CosmosDBManagementClient.DatabaseAccounts.GetAsync(resourceGroupName, databaseAccountName);
VerifyCosmosDBAccount(expectedDatabaseAccount, actualDatabaseAccount);
}
public async Task DatabaseAccountCreateAndUpdateTest()
{
var account = await CreateDatabaseAccount(Recording.GenerateAssetName("dbaccount-"), DatabaseAccountKind.MongoDB);
bool ifExists = await DatabaseAccountCollection.ExistsAsync(_databaseAccountName);
Assert.AreEqual(true, ifExists);
DatabaseAccountResource account2 = await DatabaseAccountCollection.GetAsync(_databaseAccountName);
VerifyCosmosDBAccount(account, account2);
var updateOptions = new DatabaseAccountPatch()
{
IsVirtualNetworkFilterEnabled = false,
EnableAutomaticFailover = true,
DisableKeyBasedMetadataWriteAccess = true,
};
updateOptions.Tags.Add("key3", "value3");
updateOptions.Tags.Add("key4", "value4");
await account2.UpdateAsync(WaitUntil.Completed, updateOptions);
var failoverPolicyList = new List <FailoverPolicy>
{
new FailoverPolicy()
{
LocationName = AzureLocation.WestUS,
FailoverPriority = 0
}
};
FailoverPolicies failoverPolicies = new FailoverPolicies(failoverPolicyList);
await account2.FailoverPriorityChangeAsync(WaitUntil.Completed, failoverPolicies);
DatabaseAccountResource account3 = await DatabaseAccountCollection.GetAsync(_databaseAccountName);
VerifyCosmosDBAccount(account3, updateOptions);
VerifyFailoverPolicies(failoverPolicyList, account3.Data.FailoverPolicies);
}
public async Task SetUp()
{
_databaseAccount = await ArmClient.GetDatabaseAccountResource(_databaseAccountIdentifier).GetAsync();
}
