public async Task MongoDBDatabaseCreateAndUpdate()
{
var database = await CreateMongoDBDatabase(null);
Assert.AreEqual(_databaseName, database.Data.Resource.Id);
// Seems bug in swagger definition
//Assert.AreEqual(TestThroughput1, database.Data.Options.Throughput);
bool ifExists = await MongoDBDatabaseCollection.ExistsAsync(_databaseName);
Assert.True(ifExists);
// NOT WORKING API
//ThroughputSettingsData throughtput = await database.GetMongoDBCollectionThroughputAsync();
MongoDBDatabase database2 = await MongoDBDatabaseCollection.GetAsync(_databaseName);
Assert.AreEqual(_databaseName, database2.Data.Resource.Id);
//Assert.AreEqual(TestThroughput1, database2.Data.Options.Throughput);
VerifyMongoDBDatabases(database, database2);
// TODO: use original tags see defect: https://github.com/Azure/autorest.csharp/issues/1590
MongoDBDatabaseCreateUpdateData updateOptions = new MongoDBDatabaseCreateUpdateData(AzureLocation.WestUS, database.Data.Resource)
{
Options = new CreateUpdateOptions {
Throughput = TestThroughput2
}
};
database = (await MongoDBDatabaseCollection.CreateOrUpdateAsync(WaitUntil.Completed, _databaseName, updateOptions)).Value;
Assert.AreEqual(_databaseName, database.Data.Resource.Id);
database2 = await MongoDBDatabaseCollection.GetAsync(_databaseName);
VerifyMongoDBDatabases(database, database2);
}
private void VerifyMongoDBDatases(MongoDBDatabase expectedValue, MongoDBDatabase 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);
}
public async Task TearDown()
{
MongoDBDatabase database = await MongoDBDatabaseCollection.GetIfExistsAsync(_databaseName);
if (database != null)
{
await database.DeleteAsync(WaitUntil.Completed);
}
}
public async Task MongoDBDatabaseListTest()
{
List <MongoDBDatabase> mongoDBDatabases =
await CosmosDBManagementClient.MongoDBResources.ListMongoDBDatabasesAsync(resourceGroupName, databaseAccountName).ToEnumerableAsync();
Assert.IsNotNull(mongoDBDatabases);
Assert.AreEqual(1, mongoDBDatabases.Count);
MongoDBDatabase mongoDBDatabase =
await CosmosDBManagementClient.MongoDBResources.GetMongoDBDatabaseAsync(resourceGroupName, databaseAccountName, databaseName);
Assert.IsNotNull(mongoDBDatabase);
VerifyMongoDBDatases(mongoDBDatabase, mongoDBDatabases[0]);
}
//private void listBox_DoubleClick(object sender, EventArgs e)
//{
// if (!string.IsNullOrEmpty(listBox.SelectedItem as string))
// {
// DialogResult = DialogResult.OK;
// this.Close();
// }
//}
private void btnOK_Click(object sender, EventArgs e)
{
if (!(txtFileName.Text.Equals(String.Empty)))
{
MongoDBDatabase mongoDBDatabase = new MongoDBDatabase();
mongoDBDatabase.SetDataSourceFilePath(this.txtFileName.Text);
this.DialogResult = DialogResult.OK;
this.Close();
}
else
{
MessageBox.Show("Please choose a server.");
}
}
//Devuelve una base de datos MongoDB cargandola desde un nodo de <Databases>
static private MongoDBDatabase MongoDBdatabaseCreator(XmlNode databaseXml)
{
MongoDBDatabase db = new MongoDBDatabase();
if (databaseXml["Name"] == null)
{
throw new GeneralORMException("El fichero XML no define el nombre interno de una base de datos MySQL");
}
if (databaseXml["Server"] == null)
{
throw new GeneralORMException("El fichero XML no define el servidor de una base de datos MySQL");
}
if (databaseXml["UserName"] == null)
{
throw new GeneralORMException("El fichero XML no define la UID de una base de datos MySQL");
}
if (databaseXml["Port"] == null)
{
throw new GeneralORMException("El fichero XML no define el puerto de una base de datos MySQL");
}
if (databaseXml["SSLMode"] == null)
{
throw new GeneralORMException("El fichero XML no define el modo ssl de una base de datos MySQL");
}
db.Name = databaseXml["Name"].InnerText;
db.Server = databaseXml["Server"].InnerText;
db.UserName = databaseXml["UserName"].InnerText;
db.Port = databaseXml["Port"].InnerText;
db.SSLMode = Convert.ToBoolean(databaseXml["SSLMode"].InnerText);
if (databaseXml["Password"] == null)
{
db.Password = null;
}
else
{
db.Password = databaseXml["Password"].InnerText;
}
if (databaseXml["DatabaseName"] == null)
{
db.DatabaseName = null;
}
else
{
db.DatabaseName = databaseXml["DatabaseName"].InnerText;
}
return(db);
}
public async Task MongoDBDatabaseCreateAndUpdateTest()
{
MongoDBDatabase mongoDBDatabase1 = await WaitForCompletionAsync(
await CosmosDBManagementClient.MongoDBResources.StartCreateUpdateMongoDBDatabaseAsync(
resourceGroupName,
databaseAccountName,
databaseName,
new MongoDBDatabaseCreateUpdateParameters(
new MongoDBDatabaseResource(databaseName), new CreateUpdateOptions(sampleThroughput1, new AutoscaleSettings()))));
Assert.IsNotNull(mongoDBDatabase1);
Assert.AreEqual(databaseName, mongoDBDatabase1.Resource.Id);
ThroughputSettingsData throughputSettings1 =
await CosmosDBManagementClient.MongoDBResources.GetMongoDBDatabaseThroughputAsync(resourceGroupName, databaseAccountName, databaseName);
Assert.IsNotNull(throughputSettings1);
Assert.AreEqual(sampleThroughput1, throughputSettings1.Resource.Throughput);
Assert.AreEqual(mongoDBDatabasesThroughputType, throughputSettings1.Type);
MongoDBDatabase mongoDBDatabase =
await CosmosDBManagementClient.MongoDBResources.GetMongoDBDatabaseAsync(resourceGroupName, databaseAccountName, databaseName);
Assert.IsNotNull(mongoDBDatabase);
VerifyMongoDBDatases(mongoDBDatabase1, mongoDBDatabase);
MongoDBDatabase mongoDBDatabase2 = await WaitForCompletionAsync(
await CosmosDBManagementClient.MongoDBResources.StartCreateUpdateMongoDBDatabaseAsync(
resourceGroupName,
databaseAccountName,
databaseName,
new MongoDBDatabaseCreateUpdateParameters(
new MongoDBDatabaseResource(databaseName), new CreateUpdateOptions(sampleThroughput2, new AutoscaleSettings()))));
Assert.IsNotNull(mongoDBDatabase2);
Assert.AreEqual(databaseName, mongoDBDatabase2.Resource.Id);
ThroughputSettingsData throughputSettings2 =
await CosmosDBManagementClient.MongoDBResources.GetMongoDBDatabaseThroughputAsync(resourceGroupName, databaseAccountName, databaseName);
Assert.IsNotNull(throughputSettings2);
Assert.AreEqual(sampleThroughput2, throughputSettings2.Resource.Throughput);
Assert.AreEqual(mongoDBDatabasesThroughputType, throughputSettings2.Type);
mongoDBDatabase = await CosmosDBManagementClient.MongoDBResources.GetMongoDBDatabaseAsync(resourceGroupName, databaseAccountName, databaseName);
Assert.IsNotNull(mongoDBDatabase);
VerifyMongoDBDatases(mongoDBDatabase2, mongoDBDatabase);
}
private void InitDatabases()
{
// CHECK IF CONNECTION IS LIVE
if (_config.ObjectsDbConnection.DatabaseVendor == DatabaseVendors.PGSQL)
{
ObjectsDB = new PGSQLDatabase(_config.ObjectsDbConnection);
}
if (_config.DataDbConnection.DatabaseVendor == DatabaseVendors.PGSQL)
{
DataDB = new PGSQLDatabase(_config.DataDbConnection);
}
//To be Done
if (_config.DataDbConnection.DatabaseVendor == DatabaseVendors.PGSQL)
{
DataDBRO = new PGSQLDatabase(_config.DataDbConnection);
}
FilesDB = new MongoDBDatabase(this.TenantId, _config.FilesDbConnection);
LogsDB = new PGSQLDatabase(_config.LogsDbConnection);
}
public async Task SetUp()
{
_mongoDBDatabase = await ArmClient.GetMongoDBDatabase(_mongoDBDatabaseId).GetAsync();
}
public UserMongoDBRepository(MongoDBDatabase mongoDBDatabase)
{
usersCollection = mongoDBDatabase.GetUsersCollection();
}
