public async Task SqlDatabaseCreateAndUpdate()
{
var database = await CreateSqlDatabase(null);
Assert.AreEqual(_databaseName, database.Data.Resource.Id);
// Seems bug in swagger definition
//Assert.AreEqual(TestThroughput1, database.Data.Options.Throughput);
bool ifExists = await SqlDatabaseContainer.ExistsAsync(_databaseName);
Assert.True(ifExists);
// NOT WORKING API
//ThroughputSettingsData throughtput = await database.GetMongoDBCollectionThroughputAsync();
SqlDatabaseResource database2 = await SqlDatabaseContainer.GetAsync(_databaseName);
Assert.AreEqual(_databaseName, database2.Data.Resource.Id);
//Assert.AreEqual(TestThroughput1, database2.Data.Options.Throughput);
VerifyDatabases(database, database2);
SqlDatabaseCreateUpdateData updateOptions = new SqlDatabaseCreateUpdateData(database.Id, _databaseName, database.Data.ResourceType, null,
new Dictionary <string, string>(),// TODO: use original tags see defect: https://github.com/Azure/autorest.csharp/issues/1590
AzureLocation.WestUS, database.Data.Resource, new CreateUpdateOptions {
Throughput = TestThroughput2
});
database = (await SqlDatabaseContainer.CreateOrUpdateAsync(WaitUntil.Completed, _databaseName, updateOptions)).Value;
Assert.AreEqual(_databaseName, database.Data.Resource.Id);
database2 = await SqlDatabaseContainer.GetAsync(_databaseName);
VerifyDatabases(database, database2);
}
public async Task TearDown()
{
if (await SqlDatabaseContainer.ExistsAsync(_databaseName))
{
var id = SqlDatabaseContainer.Id;
id = SqlDatabaseResource.CreateResourceIdentifier(id.SubscriptionId, id.ResourceGroupName, id.Name, _databaseName);
SqlDatabaseResource database = this.ArmClient.GetSqlDatabaseResource(id);
await database.DeleteAsync(WaitUntil.Completed);
}
}
private void VerifySqlDatabases(SqlDatabaseResource expectedValue, SqlDatabaseResource actualValue)
{
Assert.AreEqual(expectedValue.Id, actualValue.Id);
Assert.AreEqual(expectedValue.Name, actualValue.Name);
Assert.AreEqual(expectedValue.Resource.Id, actualValue.Resource.Id);
Assert.AreEqual(expectedValue.Resource.Rid, actualValue.Resource.Rid);
Assert.AreEqual(expectedValue.Resource.Ts, actualValue.Resource.Ts);
Assert.AreEqual(expectedValue.Resource.Etag, actualValue.Resource.Etag);
Assert.AreEqual(expectedValue.Resource.Colls, actualValue.Resource.Colls);
Assert.AreEqual(expectedValue.Resource.Users, actualValue.Resource.Users);
}
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 SqlDatabaseCreateAndUpdateTest()
{
SqlDatabaseCreateUpdateParameters sqlDatabaseCreateUpdateParameters1 = new SqlDatabaseCreateUpdateParameters(
new SqlDatabaseResource(databaseName), new CreateUpdateOptions(sampleThroughput1, new AutoscaleSettings()));
SqlDatabaseResource sqlDatabase1 = await WaitForCompletionAsync(
await CosmosDBManagementClient.SqlResources.StartCreateUpdateSqlDatabaseAsync(
resourceGroupName, databaseAccountName, databaseName, sqlDatabaseCreateUpdateParameters1));
Assert.NotNull(sqlDatabase1);
SqlDatabaseResource sqlDatabase2 = await CosmosDBManagementClient.SqlResources.GetSqlDatabaseAsync(
resourceGroupName, databaseAccountName, databaseName);
Assert.NotNull(sqlDatabase2);
VerifySqlDatabases(sqlDatabase1, sqlDatabase2);
ThroughputSettingsData throughputSettings1 =
await CosmosDBManagementClient.SqlResources.GetSqlDatabaseThroughputAsync(resourceGroupName, databaseAccountName, databaseName);
Assert.NotNull(throughputSettings1);
Assert.NotNull(throughputSettings1.Name);
Assert.AreEqual(sqlDatabasesThroughputType, throughputSettings1.Type);
Assert.AreEqual(sampleThroughput1, throughputSettings1.Resource.Throughput);
SqlDatabaseCreateUpdateParameters sqlDatabaseCreateUpdateParameters2 =
new SqlDatabaseCreateUpdateParameters(
id: default(string),
name: default(string),
type: default(string),
location: location,
tags: tags,
resource: new SqlDatabaseResource(databaseName),
options: new CreateUpdateOptions {
Throughput = sampleThroughput2
});
SqlDatabaseResource sqlDatabase3 = await WaitForCompletionAsync(
await CosmosDBManagementClient.SqlResources.StartCreateUpdateSqlDatabaseAsync(
resourceGroupName, databaseAccountName, databaseName, sqlDatabaseCreateUpdateParameters2));
Assert.NotNull(sqlDatabase3);
SqlDatabaseResource sqlDatabase4 = await CosmosDBManagementClient.SqlResources.GetSqlDatabaseAsync(
resourceGroupName, databaseAccountName, databaseName);
Assert.NotNull(sqlDatabase4);
VerifySqlDatabases(sqlDatabase3, sqlDatabase4);
ThroughputSettingsData throughputSettings2 =
await CosmosDBManagementClient.SqlResources.GetSqlDatabaseThroughputAsync(resourceGroupName, databaseAccountName, databaseName);
Assert.NotNull(throughputSettings2);
Assert.NotNull(throughputSettings2.Name);
Assert.AreEqual(sqlDatabasesThroughputType, throughputSettings2.Type);
Assert.AreEqual(sampleThroughput2, throughputSettings2.Resource.Throughput);
}
public async Task SqlDatabaseListTest()
{
List <SqlDatabaseResource> sqlDatabases = await CosmosDBManagementClient.SqlResources.ListSqlDatabasesAsync(
resourceGroupName, databaseAccountName).ToEnumerableAsync();
Assert.NotNull(sqlDatabases);
Assert.AreEqual(1, sqlDatabases.Count);
SqlDatabaseResource sqlDatabase = await CosmosDBManagementClient.SqlResources.GetSqlDatabaseAsync(
resourceGroupName, databaseAccountName, databaseName);
Assert.NotNull(sqlDatabase);
Assert.AreEqual(sqlDatabase.Name, sqlDatabases[0].Name);
VerifySqlDatabases(sqlDatabase, sqlDatabases[0]);
}
public async Task SetUp()
{
_sqlDatabase = await ArmClient.GetSqlDatabaseResource(_sqlDatabaseId).GetAsync();
}
public async Task WebAppSqlConnectionCRUD()
{
string resourceGroupName = Recording.GenerateAssetName("SdkRg");
string webAppName = Recording.GenerateAssetName("SdkWeb");
string sqlServerName = Recording.GenerateAssetName("SdkSql");
string sqlDatabaseName = Recording.GenerateAssetName("SdkSql");
string sqlUserName = Recording.GenerateAssetName("SdkSql");
string sqlPassword = Recording.GenerateAssetName("SdkPa5$");
string linkerName = Recording.GenerateAssetName("SdkLinker");
// create resource group
await ResourceGroups.CreateOrUpdateAsync(WaitUntil.Completed, resourceGroupName, new Resources.ResourceGroupData(DefaultLocation));
ResourceGroupResource resourceGroup = await ResourceGroups.GetAsync(resourceGroupName);
// // create web app
WebSiteCollection webSites = resourceGroup.GetWebSites();
await webSites.CreateOrUpdateAsync(WaitUntil.Completed, webAppName, new WebSiteData(DefaultLocation));
WebSiteResource webapp = await webSites.GetAsync(webAppName);
// create sql database
SqlServerCollection sqlServers = resourceGroup.GetSqlServers();
SqlServerData sqlServerData = new SqlServerData(DefaultLocation)
{
AdministratorLogin = sqlUserName,
AdministratorLoginPassword = sqlPassword,
};
await sqlServers.CreateOrUpdateAsync(WaitUntil.Completed, sqlServerName, sqlServerData);
SqlServerResource sqlServer = await sqlServers.GetAsync(sqlServerName);
SqlDatabaseCollection sqlDatabases = sqlServer.GetSqlDatabases();
await sqlDatabases.CreateOrUpdateAsync(WaitUntil.Completed, sqlDatabaseName, new SqlDatabaseData(DefaultLocation));
SqlDatabaseResource sqlDatabase = await sqlDatabases.GetAsync(sqlDatabaseName);
// create service linker
LinkerResourceCollection linkers = webapp.GetLinkerResources();
var linkerData = new LinkerResourceData
{
TargetService = new Models.AzureResource
{
Id = sqlDatabase.Id,
},
AuthInfo = new SecretAuthInfo
{
Name = sqlUserName,
SecretInfo = new ValueSecretInfo
{
Value = sqlPassword,
},
},
ClientType = ClientType.Dotnet,
};
await linkers.CreateOrUpdateAsync(WaitUntil.Completed, linkerName, linkerData);
// list service linker
var linkerResources = await linkers.GetAllAsync().ToEnumerableAsync();
Assert.AreEqual(1, linkerResources.Count);
Assert.AreEqual(linkerName, linkerResources[0].Data.Name);
// get service linker
LinkerResource linker = await linkers.GetAsync(linkerName);
Assert.IsTrue(linker.Id.ToString().StartsWith(webapp.Id.ToString(), StringComparison.InvariantCultureIgnoreCase));
Assert.AreEqual(sqlDatabase.Id.ToString(), (linker.Data.TargetService as AzureResource).Id);
Assert.AreEqual(AuthType.Secret, linker.Data.AuthInfo.AuthType);
// get service linker configurations
SourceConfigurationResult configurations = await linker.GetConfigurationsAsync();
foreach (var configuration in configurations.Configurations)
{
Assert.IsNotNull(configuration.Name);
Assert.IsNotNull(configuration.Value);
}
// delete service linker
var operation = await linker.DeleteAsync(WaitUntil.Completed);
Assert.IsTrue(operation.HasCompleted);
}
