private void VerifyEqualMongoDBDatabases(MongoDBDatabaseGetResults expectedValue, MongoDBDatabaseGetResults actualValue)
{
Assert.Equal(expectedValue.Resource.Id, actualValue.Resource.Id);
Assert.Equal(expectedValue.Resource._rid, actualValue.Resource._rid);
Assert.Equal(expectedValue.Resource._ts, actualValue.Resource._ts);
Assert.Equal(expectedValue.Resource._etag, actualValue.Resource._etag);
}
public override void ExecuteCmdlet()
{
if (ParameterSetName.Equals(ParentObjectParameterSet, StringComparison.Ordinal))
{
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(InputObject.Id);
ResourceGroupName = resourceIdentifier.ResourceGroupName;
AccountName = resourceIdentifier.ResourceName;
}
CreateUpdateOptions options = new CreateUpdateOptions();
if (Throughput != null)
{
options.Throughput = Throughput.ToString();
}
MongoDBDatabaseCreateUpdateParameters mongoDBDatabaseCreateUpdateParameters = new MongoDBDatabaseCreateUpdateParameters
{
Resource = new MongoDBDatabaseResource
{
Id = Name
},
Options = options
};
if (ShouldProcess(Name, "Setting CosmosDB MongoDB Database"))
{
MongoDBDatabaseGetResults mongoDBDatabaseGetResults = CosmosDBManagementClient.MongoDBResources.CreateUpdateMongoDBDatabaseWithHttpMessagesAsync(ResourceGroupName, AccountName, Name, mongoDBDatabaseCreateUpdateParameters).GetAwaiter().GetResult().Body;
WriteObject(new PSMongoDBDatabaseGetResults(mongoDBDatabaseGetResults));
}
return;
}
private MongoDBCollectionGetResults CreateMongoDBResources(CosmosDBManagementClient cosmosDBManagementClient, string databaseAccountName, string databaseName, string collectionName)
{
MongoDBDatabaseGetResults databaseGetResults = null;
try
{
databaseGetResults = cosmosDBManagementClient.MongoDBResources.GetMongoDBDatabase(this.fixture.ResourceGroupName, databaseAccountName, databaseName);
}
catch (Exception) { }
if (databaseGetResults == null)
{
MongoDBDatabaseCreateUpdateParameters mongoDBDatabaseCreateUpdateParameters = new MongoDBDatabaseCreateUpdateParameters
{
Resource = new MongoDBDatabaseResource {
Id = databaseName
},
Options = new CreateUpdateOptions()
};
databaseGetResults = cosmosDBManagementClient.MongoDBResources.CreateUpdateMongoDBDatabase(
this.fixture.ResourceGroupName,
databaseAccountName,
databaseName,
mongoDBDatabaseCreateUpdateParameters);
}
MongoDBCollectionGetResults collectionGetResult = null;
try
{
collectionGetResult = cosmosDBManagementClient.MongoDBResources.GetMongoDBCollection(this.fixture.ResourceGroupName, databaseAccountName, databaseName, collectionName);
}
catch (Exception) { }
if (collectionGetResult == null)
{
Dictionary <string, string> dict = new Dictionary <string, string>();
dict.Add("partitionKey", PartitionKind.Hash.ToString());
MongoDBCollectionCreateUpdateParameters collectionCreateParams = new MongoDBCollectionCreateUpdateParameters()
{
Resource = new MongoDBCollectionResource
{
Id = collectionName,
ShardKey = dict
},
Options = new CreateUpdateOptions()
{
Throughput = 30000
}
};
collectionGetResult = cosmosDBManagementClient.MongoDBResources.CreateUpdateMongoDBCollection(
this.fixture.ResourceGroupName,
databaseAccountName,
databaseName,
collectionName,
collectionCreateParams);
}
return(collectionGetResult);
}
public override void ExecuteCmdlet()
{
if (ParameterSetName.Equals(ObjectParameterSet, StringComparison.Ordinal))
{
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(ParentObject.Id);
AccountName = resourceIdentifier.ResourceName;
ResourceGroupName = resourceIdentifier.ResourceGroupName;
}
if (!string.IsNullOrEmpty(Name))
{
MongoDBDatabaseGetResults mongoDBDatabaseGetResults = CosmosDBManagementClient.MongoDBResources.GetMongoDBDatabaseWithHttpMessagesAsync(ResourceGroupName, AccountName, Name).GetAwaiter().GetResult().Body;
WriteObject(new PSMongoDBDatabaseGetResults(mongoDBDatabaseGetResults));
}
else
{
IEnumerable <MongoDBDatabaseGetResults> mongoDBDatabases = CosmosDBManagementClient.MongoDBResources.ListMongoDBDatabasesWithHttpMessagesAsync(ResourceGroupName, AccountName).GetAwaiter().GetResult().Body;
foreach (MongoDBDatabaseGetResults mongoDBDatabase in mongoDBDatabases)
{
WriteObject(new PSMongoDBDatabaseGetResults(mongoDBDatabase));
}
}
return;
}
public PSMongoDBDatabaseGetResults(MongoDBDatabaseGetResults mongoDBDatabaseGetResults)
{
Name = mongoDBDatabaseGetResults.Name;
Id = mongoDBDatabaseGetResults.Id;
Location = mongoDBDatabaseGetResults.Location;
Tags = mongoDBDatabaseGetResults.Tags;
Resource = new PSMongoDBDatabaseGetPropertiesResource(mongoDBDatabaseGetResults.Resource);
}
private void VerifyMongoDBDatases(MongoDBDatabaseGetResults expectedValue, MongoDBDatabaseGetResults 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 void MongoPartitionMergeTests()
{
using (var context = MockContext.Start(this.GetType()))
{
fixture.Init(context);
this.fixture.ResourceGroupName = "canary-sdk-test";
var databaseAccountName = "canary-sdk-test-mongo-account";
var mongoClient = this.fixture.CosmosDBManagementClient.MongoDBResources;
string databaseName = TestUtilities.GenerateName(prefix: "mongoDb");
string collectionName = TestUtilities.GenerateName(prefix: "mongoCollection");
MongoDBDatabaseCreateUpdateParameters mongoDBDatabaseCreateUpdateParameters = new MongoDBDatabaseCreateUpdateParameters
{
Resource = new MongoDBDatabaseResource {
Id = databaseName
},
Options = new CreateUpdateOptions()
};
MongoDBDatabaseGetResults mongoDBDatabaseGetResults = mongoClient.CreateUpdateMongoDBDatabaseWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName, mongoDBDatabaseCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.Equal(databaseName, mongoDBDatabaseGetResults.Name);
Assert.NotNull(mongoDBDatabaseGetResults);
Dictionary <string, string> dict = new Dictionary <string, string>();
dict.Add("partitionKey", PartitionKind.Hash.ToString());
MongoDBCollectionCreateUpdateParameters mongoDBCollectionCreateUpdateParameters = new MongoDBCollectionCreateUpdateParameters
{
Resource = new MongoDBCollectionResource
{
Id = collectionName,
ShardKey = dict
},
Options = new CreateUpdateOptions()
{
Throughput = 14000
}
};
MongoDBCollectionGetResults mongoDBCollectionGetResults = mongoClient.CreateUpdateMongoDBCollectionWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName, collectionName, mongoDBCollectionCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoDBCollectionGetResults);
VerfiyMongoCollectionCreation(mongoDBCollectionGetResults, mongoDBCollectionCreateUpdateParameters);
IEnumerable <MongoDBCollectionGetResults> mongoDBCollections = mongoClient.ListMongoDBCollectionsWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoDBCollections);
PhysicalPartitionStorageInfoCollection physicalPartitionStorageInfoCollection =
mongoClient.ListMongoDBCollectionPartitionMerge(fixture.ResourceGroupName, databaseAccountName, databaseName, collectionName, new MergeParameters(isDryRun: true));
Assert.Equal(2, physicalPartitionStorageInfoCollection.PhysicalPartitionStorageInfoCollectionProperty.Count);
mongoClient.DeleteMongoDBCollectionWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName, collectionName);
mongoClient.DeleteMongoDBDatabaseWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName);
}
}
public override void ExecuteCmdlet()
{
if (ParameterSetName.Equals(ParentObjectParameterSet, StringComparison.Ordinal))
{
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(ParentObject.Id);
ResourceGroupName = resourceIdentifier.ResourceGroupName;
AccountName = resourceIdentifier.ResourceName;
}
else if (ParameterSetName.Equals(ObjectParameterSet, StringComparison.Ordinal))
{
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(InputObject.Id);
ResourceGroupName = resourceIdentifier.ResourceGroupName;
Name = resourceIdentifier.ResourceName;
AccountName = ResourceIdentifierExtensions.GetDatabaseAccountName(resourceIdentifier);
}
MongoDBDatabaseGetResults readMongoDBDatabaseGetResults = null;
try
{
readMongoDBDatabaseGetResults = CosmosDBManagementClient.MongoDBResources.GetMongoDBDatabase(ResourceGroupName, AccountName, Name);
}
catch (CloudException e)
{
if (e.Response.StatusCode == System.Net.HttpStatusCode.NotFound)
{
throw new ResourceNotFoundException(message: string.Format(ExceptionMessage.NotFound, Name), innerException: e);
}
}
CreateUpdateOptions options = new CreateUpdateOptions();
if (Throughput != null)
{
options.Throughput = Throughput.ToString();
}
MongoDBDatabaseCreateUpdateParameters mongoDBDatabaseCreateUpdateParameters = new MongoDBDatabaseCreateUpdateParameters
{
Resource = new MongoDBDatabaseResource
{
Id = Name
},
Options = options
};
if (ShouldProcess(Name, "Updating an existing CosmosDB MongoDB Database"))
{
MongoDBDatabaseGetResults mongoDBDatabaseGetResults = CosmosDBManagementClient.MongoDBResources.CreateUpdateMongoDBDatabaseWithHttpMessagesAsync(ResourceGroupName, AccountName, Name, mongoDBDatabaseCreateUpdateParameters).GetAwaiter().GetResult().Body;
WriteObject(new PSMongoDBDatabaseGetResults(mongoDBDatabaseGetResults));
}
return;
}
public async Task MongoDBDatabaseListTest()
{
List <MongoDBDatabaseGetResults> mongoDBDatabases =
await CosmosDBManagementClient.MongoDBResources.ListMongoDBDatabasesAsync(resourceGroupName, databaseAccountName).ToEnumerableAsync();
Assert.IsNotNull(mongoDBDatabases);
Assert.AreEqual(1, mongoDBDatabases.Count);
MongoDBDatabaseGetResults mongoDBDatabaseGetResults =
await CosmosDBManagementClient.MongoDBResources.GetMongoDBDatabaseAsync(resourceGroupName, databaseAccountName, databaseName);
Assert.IsNotNull(mongoDBDatabaseGetResults);
VerifyMongoDBDatases(mongoDBDatabaseGetResults, mongoDBDatabases[0]);
}
public override void ExecuteCmdlet()
{
if (ParameterSetName.Equals(ParentObjectParameterSet, StringComparison.Ordinal))
{
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(ParentObject.Id);
ResourceGroupName = resourceIdentifier.ResourceGroupName;
AccountName = resourceIdentifier.ResourceName;
}
MongoDBDatabaseGetResults readMongoDatabaseGetResults = null;
try
{
readMongoDatabaseGetResults = CosmosDBManagementClient.MongoDBResources.GetMongoDBDatabase(ResourceGroupName, AccountName, Name);
}
catch (CloudException e)
{
if (e.Response.StatusCode != System.Net.HttpStatusCode.NotFound)
{
throw;
}
}
if (readMongoDatabaseGetResults != null)
{
throw new ConflictingResourceException(message: string.Format(ExceptionMessage.Conflict, Name));
}
CreateUpdateOptions options = ThroughputHelper.PopulateCreateUpdateOptions(Throughput, AutoscaleMaxThroughput);
MongoDBDatabaseCreateUpdateParameters mongoDBDatabaseCreateUpdateParameters = new MongoDBDatabaseCreateUpdateParameters
{
Resource = new MongoDBDatabaseResource
{
Id = Name
},
Options = options
};
if (ShouldProcess(Name, "Creating a new CosmosDB MongoDB Database"))
{
MongoDBDatabaseGetResults mongoDBDatabaseGetResults = CosmosDBManagementClient.MongoDBResources.CreateUpdateMongoDBDatabaseWithHttpMessagesAsync(ResourceGroupName, AccountName, Name, mongoDBDatabaseCreateUpdateParameters).GetAwaiter().GetResult().Body;
WriteObject(new PSMongoDBDatabaseGetResults(mongoDBDatabaseGetResults));
}
return;
}
public async Task MongoDBDatabaseCreateAndUpdateTest()
{
MongoDBDatabaseGetResults mongoDBDatabaseGetResults1 = await WaitForCompletionAsync(
await CosmosDBManagementClient.MongoDBResources.StartCreateUpdateMongoDBDatabaseAsync(
resourceGroupName,
databaseAccountName,
databaseName,
new MongoDBDatabaseCreateUpdateParameters(
new MongoDBDatabaseResource(databaseAccountName), new CreateUpdateOptions(sampleThroughput1, new AutoscaleSettings()))));
Assert.IsNotNull(mongoDBDatabaseGetResults1);
Assert.AreEqual(databaseName, mongoDBDatabaseGetResults1.Resource.Id);
ThroughputSettingsGetResults throughputSettingsGetResults1 =
await CosmosDBManagementClient.MongoDBResources.GetMongoDBDatabaseThroughputAsync(resourceGroupName, databaseAccountName, databaseName);
Assert.IsNotNull(throughputSettingsGetResults1);
Assert.AreEqual(sampleThroughput1, throughputSettingsGetResults1.Resource.Throughput);
Assert.AreEqual(mongoDBDatabasesThroughputType, throughputSettingsGetResults1.Type);
MongoDBDatabaseGetResults mongoDBDatabaseGetResults =
await CosmosDBManagementClient.MongoDBResources.GetMongoDBDatabaseAsync(resourceGroupName, databaseAccountName, databaseName);
Assert.IsNotNull(mongoDBDatabaseGetResults);
VerifyMongoDBDatases(mongoDBDatabaseGetResults1, mongoDBDatabaseGetResults);
MongoDBDatabaseGetResults mongoDBDatabaseGetResults2 = await WaitForCompletionAsync(
await CosmosDBManagementClient.MongoDBResources.StartCreateUpdateMongoDBDatabaseAsync(
resourceGroupName,
databaseAccountName,
databaseName,
new MongoDBDatabaseCreateUpdateParameters(
new MongoDBDatabaseResource(databaseAccountName), new CreateUpdateOptions(sampleThroughput2, new AutoscaleSettings()))));
Assert.IsNotNull(mongoDBDatabaseGetResults2);
Assert.AreEqual(databaseName, mongoDBDatabaseGetResults2.Resource.Id);
ThroughputSettingsGetResults throughputSettingsGetResults2 =
await CosmosDBManagementClient.MongoDBResources.GetMongoDBDatabaseThroughputAsync(resourceGroupName, databaseAccountName, databaseName);
Assert.IsNotNull(throughputSettingsGetResults2);
Assert.AreEqual(sampleThroughput2, throughputSettingsGetResults2.Resource.Throughput);
Assert.AreEqual(mongoDBDatabasesThroughputType, throughputSettingsGetResults2.Type);
mongoDBDatabaseGetResults = await CosmosDBManagementClient.MongoDBResources.GetMongoDBDatabaseAsync(resourceGroupName, databaseAccountName, databaseName);
Assert.IsNotNull(mongoDBDatabaseGetResults);
VerifyMongoDBDatases(mongoDBDatabaseGetResults2, mongoDBDatabaseGetResults);
}
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 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 void MongoCRUDTests()
{
using (var context = MockContext.Start(this.GetType()))
{
fixture.Init(context);
string databaseAccountName = this.fixture.GetDatabaseAccountName(TestFixture.AccountType.Mongo36);
var mongoClient = this.fixture.CosmosDBManagementClient.MongoDBResources;
string databaseName = TestUtilities.GenerateName(prefix: "mongoDb");
string databaseName2 = TestUtilities.GenerateName(prefix: "mongoDb");
string collectionName = TestUtilities.GenerateName(prefix: "mongoCollection");
const string mongoDatabaseThroughputType = "Microsoft.DocumentDB/databaseAccounts/mongodbDatabases/throughputSettings";
const int sampleThroughput = 700;
Dictionary <string, string> additionalProperties = new Dictionary <string, string>
{
{ "foo", "bar" }
};
Dictionary <string, string> tags = new Dictionary <string, string>
{
{ "key3", "value3" },
{ "key4", "value4" }
};
MongoDBDatabaseCreateUpdateParameters mongoDBDatabaseCreateUpdateParameters = new MongoDBDatabaseCreateUpdateParameters
{
Resource = new MongoDBDatabaseResource {
Id = databaseName
},
Options = new CreateUpdateOptions()
};
MongoDBDatabaseGetResults mongoDBDatabaseGetResults = mongoClient.CreateUpdateMongoDBDatabaseWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName, mongoDBDatabaseCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.Equal(databaseName, mongoDBDatabaseGetResults.Name);
Assert.NotNull(mongoDBDatabaseGetResults);
MongoDBDatabaseGetResults mongoDBDatabaseGetResults1 = mongoClient.GetMongoDBDatabaseWithHttpMessagesAsync(this.fixture.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 = mongoClient.CreateUpdateMongoDBDatabaseWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName2, mongoDBDatabaseCreateUpdateParameters2).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoDBDatabaseGetResults2);
Assert.Equal(databaseName2, mongoDBDatabaseGetResults2.Name);
IEnumerable <MongoDBDatabaseGetResults> mongoDBDatabases = mongoClient.ListMongoDBDatabasesWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoDBDatabases);
ThroughputSettingsGetResults throughputSettingsGetResults = mongoClient.GetMongoDBDatabaseThroughputWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName2).GetAwaiter().GetResult().Body;
Assert.NotNull(throughputSettingsGetResults);
Assert.NotNull(throughputSettingsGetResults.Name);
Assert.Equal(throughputSettingsGetResults.Resource.Throughput, sampleThroughput);
Assert.Equal(mongoDatabaseThroughputType, throughputSettingsGetResults.Type);
Dictionary <string, string> dict = new Dictionary <string, string>();
dict.Add("partitionKey", PartitionKind.Hash.ToString());
MongoDBCollectionCreateUpdateParameters mongoDBCollectionCreateUpdateParameters = new MongoDBCollectionCreateUpdateParameters
{
Resource = new MongoDBCollectionResource
{
Id = collectionName,
ShardKey = dict
},
Options = new CreateUpdateOptions()
};
MongoDBCollectionGetResults mongoDBCollectionGetResults = mongoClient.CreateUpdateMongoDBCollectionWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName, collectionName, mongoDBCollectionCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoDBCollectionGetResults);
VerfiyMongoCollectionCreation(mongoDBCollectionGetResults, mongoDBCollectionCreateUpdateParameters);
IEnumerable <MongoDBCollectionGetResults> mongoDBCollections = mongoClient.ListMongoDBCollectionsWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoDBCollections);
foreach (MongoDBCollectionGetResults mongoDBCollection in mongoDBCollections)
{
mongoClient.DeleteMongoDBCollectionWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName, mongoDBCollection.Name);
}
foreach (MongoDBDatabaseGetResults mongoDBDatabase in mongoDBDatabases)
{
mongoClient.DeleteMongoDBDatabaseWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, mongoDBDatabase.Name);
}
}
}
public void MongoUsersAndRolesTests()
{
using (var context = MockContext.Start(this.GetType()))
{
fixture.Location = "west us 2";
fixture.Init(context);
string databaseAccountName = this.fixture.GetDatabaseAccountName(TestFixture.AccountType.Mongo36);
var mongoClient = this.fixture.CosmosDBManagementClient.MongoDBResources;
string databaseName = TestUtilities.GenerateName(prefix: "mongoDb");
string databaseName2 = TestUtilities.GenerateName(prefix: "mongoDb");
string collectionName = TestUtilities.GenerateName(prefix: "mongoCollection");
string roleName1 = "role1";
string roleName2 = "role2";
string roleId1 = databaseName + "." + roleName1;
string roleId2 = databaseName + "." + roleName2;
string userName1 = "testuser1";
Dictionary <string, string> additionalProperties = new Dictionary <string, string>
{
{ "foo", "bar" }
};
Dictionary <string, string> tags = new Dictionary <string, string>
{
{ "key3", "value3" },
{ "key4", "value4" }
};
MongoDBDatabaseCreateUpdateParameters mongoDBDatabaseCreateUpdateParameters = new MongoDBDatabaseCreateUpdateParameters
{
Resource = new MongoDBDatabaseResource {
Id = databaseName
},
Options = new CreateUpdateOptions(),
Location = "west us 2"
};
MongoDBDatabaseGetResults mongoDBDatabaseGetResults = mongoClient.CreateUpdateMongoDBDatabaseWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName, mongoDBDatabaseCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.Equal(databaseName, mongoDBDatabaseGetResults.Name);
Assert.NotNull(mongoDBDatabaseGetResults);
MongoRoleDefinitionCreateUpdateParameters mongoRoleDefinitionCreateUpdateParameters1 = new MongoRoleDefinitionCreateUpdateParameters
{
RoleName = roleName1,
DatabaseName = databaseName,
Type = MongoRoleDefinitionType.CustomRole,
Privileges = new List <Privilege>
{
new Privilege
{
Resource = new PrivilegeResource
{
Db = databaseName,
Collection = "test"
},
Actions = new List <string>
{
"insert"
}
}
}
};
// Create Role Definition
MongoRoleDefinitionGetResults mongoRoleDefinitionGetResults = mongoClient.CreateUpdateMongoRoleDefinitionWithHttpMessagesAsync(roleId1, this.fixture.ResourceGroupName, databaseAccountName, mongoRoleDefinitionCreateUpdateParameters1).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoRoleDefinitionGetResults);
Assert.Equal(roleName1, mongoRoleDefinitionGetResults.Name);
VerifyCreateUpdateRoleDefinition(mongoRoleDefinitionCreateUpdateParameters1, mongoRoleDefinitionGetResults);
// Get Role Definition
MongoRoleDefinitionGetResults mongoRoleDefinitionGetResults2 = mongoClient.GetMongoRoleDefinitionWithHttpMessagesAsync(roleId1, this.fixture.ResourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoRoleDefinitionGetResults2);
Assert.Equal(roleName1, mongoRoleDefinitionGetResults2.Name);
VerifyEqualMongoRoleDefinitions(mongoRoleDefinitionGetResults, mongoRoleDefinitionGetResults2);
// Create role definition using inherited role
MongoRoleDefinitionCreateUpdateParameters mongoRoleDefinitionCreateUpdateParameters2 = new MongoRoleDefinitionCreateUpdateParameters
{
RoleName = roleName2,
DatabaseName = databaseName,
Type = MongoRoleDefinitionType.CustomRole,
Privileges = new List <Privilege>
{
new Privilege
{
Resource = new PrivilegeResource
{
Db = databaseName,
Collection = "test"
},
Actions = new List <string>
{
"find"
}
}
},
Roles = new List <Role>
{
new Role
{
Db = databaseName,
RoleProperty = roleName1
}
}
};
MongoRoleDefinitionGetResults mongoRoleDefinitionGetResults3 = mongoClient.CreateUpdateMongoRoleDefinitionWithHttpMessagesAsync(roleId2, this.fixture.ResourceGroupName, databaseAccountName, mongoRoleDefinitionCreateUpdateParameters2).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoRoleDefinitionGetResults3);
Assert.Equal(roleName2, mongoRoleDefinitionGetResults3.Name);
VerifyCreateUpdateRoleDefinition(mongoRoleDefinitionCreateUpdateParameters2, mongoRoleDefinitionGetResults3);
MongoRoleDefinitionGetResults mongoRoleDefinitionGetResults4 = mongoClient.GetMongoRoleDefinitionWithHttpMessagesAsync(roleId2, this.fixture.ResourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoRoleDefinitionGetResults4);
Assert.Equal(roleName2, mongoRoleDefinitionGetResults4.Name);
VerifyEqualMongoRoleDefinitions(mongoRoleDefinitionGetResults3, mongoRoleDefinitionGetResults4);
// Update existing role definition
mongoRoleDefinitionCreateUpdateParameters2.Privileges[0].Actions.Add("remove");
mongoRoleDefinitionGetResults3 = mongoClient.CreateUpdateMongoRoleDefinitionWithHttpMessagesAsync(roleId2, this.fixture.ResourceGroupName, databaseAccountName, mongoRoleDefinitionCreateUpdateParameters2).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoRoleDefinitionGetResults3);
Assert.Equal(roleName2, mongoRoleDefinitionGetResults3.Name);
VerifyCreateUpdateRoleDefinition(mongoRoleDefinitionCreateUpdateParameters2, mongoRoleDefinitionGetResults3);
// List Role Definition
IEnumerable <MongoRoleDefinitionGetResults> mongoRoleDefinitionList = mongoClient.ListMongoRoleDefinitionsWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoRoleDefinitionList);
List <string> roleDefNames = new List <string>();
roleDefNames.Add(roleName1);
roleDefNames.Add(roleName2);
verifyRoleDefinitionListResponse(mongoRoleDefinitionList, roleDefNames);
// User Definition
MongoUserDefinitionCreateUpdateParameters mongoUserDefinitionCreateUpdateParameters1 = new MongoUserDefinitionCreateUpdateParameters
{
UserName = "******",
Password = "******",
DatabaseName = databaseName,
CustomData = "test",
Mechanisms = "SCRAM-SHA-256",
Roles = new List <Role>
{
new Role
{
Db = databaseName,
RoleProperty = roleName1
}
}
};
MongoUserDefinitionGetResults mongoUserDefinitionGetResults = mongoClient.CreateUpdateMongoUserDefinitionWithHttpMessagesAsync(databaseName + ".testuser1", this.fixture.ResourceGroupName, databaseAccountName, mongoUserDefinitionCreateUpdateParameters1).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoUserDefinitionGetResults);
Assert.Equal("testuser1", mongoUserDefinitionGetResults.UserName);
Assert.Equal(mongoUserDefinitionCreateUpdateParameters1.Roles.Count, mongoUserDefinitionGetResults.Roles.Count);
Assert.Equal(roleName1, mongoUserDefinitionGetResults.Roles[0].RoleProperty);
MongoUserDefinitionGetResults mongoUserDefinitionGetResults2 = mongoClient.GetMongoUserDefinitionWithHttpMessagesAsync(databaseName + ".testuser1", this.fixture.ResourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoUserDefinitionGetResults2);
Assert.Equal("testuser1", mongoUserDefinitionGetResults2.UserName);
Assert.Equal(mongoUserDefinitionGetResults2.Roles.Count, mongoUserDefinitionGetResults.Roles.Count);
// Update existing user definition
mongoUserDefinitionCreateUpdateParameters1.Roles[0].RoleProperty = roleName2;
mongoUserDefinitionGetResults = mongoClient.CreateUpdateMongoUserDefinitionWithHttpMessagesAsync(databaseName + ".testuser1", this.fixture.ResourceGroupName, databaseAccountName, mongoUserDefinitionCreateUpdateParameters1).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoUserDefinitionGetResults);
Assert.Equal("testuser1", mongoUserDefinitionGetResults.UserName);
Assert.Equal(mongoUserDefinitionCreateUpdateParameters1.Roles.Count, mongoUserDefinitionGetResults.Roles.Count);
Assert.Equal(roleName2, mongoUserDefinitionGetResults.Roles[0].RoleProperty);
// List User Definition
IEnumerable <MongoUserDefinitionGetResults> mongoUserDefinitionList = mongoClient.ListMongoUserDefinitionsWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoUserDefinitionList);
List <string> userNames = new List <string>();
userNames.Add(userName1);
verifyUserDefinitionListResponse(mongoUserDefinitionList, userNames);
// Delete User Definition
mongoClient.DeleteMongoUserDefinitionWithHttpMessagesAsync(databaseName + "." + userName1, this.fixture.ResourceGroupName, databaseAccountName).GetAwaiter().GetResult();
mongoUserDefinitionList = mongoClient.ListMongoUserDefinitionsWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoUserDefinitionList);
Assert.True(mongoUserDefinitionList.Count() == 0);
// Delete Role Definition
mongoClient.DeleteMongoRoleDefinitionWithHttpMessagesAsync(roleId2, this.fixture.ResourceGroupName, databaseAccountName).GetAwaiter().GetResult();
mongoRoleDefinitionList = mongoClient.ListMongoRoleDefinitionsWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoRoleDefinitionList);
Assert.True(mongoRoleDefinitionList.Count() == 1);
mongoClient.DeleteMongoRoleDefinitionWithHttpMessagesAsync(roleId1, this.fixture.ResourceGroupName, databaseAccountName).GetAwaiter().GetResult();
mongoRoleDefinitionList = mongoClient.ListMongoRoleDefinitionsWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoRoleDefinitionList);
Assert.True(mongoRoleDefinitionList.Count() == 0);
IEnumerable <MongoDBDatabaseGetResults> mongoDBDatabases = mongoClient.ListMongoDBDatabasesWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoDBDatabases);
IEnumerable <MongoDBCollectionGetResults> mongoDBCollections = mongoClient.ListMongoDBCollectionsWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoDBCollections);
foreach (MongoDBCollectionGetResults mongoDBCollection in mongoDBCollections)
{
mongoClient.DeleteMongoDBCollectionWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName, mongoDBCollection.Name);
}
foreach (MongoDBDatabaseGetResults mongoDBDatabase in mongoDBDatabases)
{
mongoClient.DeleteMongoDBDatabaseWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, mongoDBDatabase.Name);
}
}
}
public void MongoPartitionRedistributionTests()
{
using (var context = MockContext.Start(this.GetType()))
{
fixture.Init(context);
var mongoClient = this.fixture.CosmosDBManagementClient.MongoDBResources;
this.fixture.ResourceGroupName = "cosmosTest";
var databaseAccountName = "adrutest3";
string databaseName = TestUtilities.GenerateName(prefix: "mongoDb");
string collectionName = TestUtilities.GenerateName(prefix: "mongoCollection");
MongoDBDatabaseCreateUpdateParameters mongoDBDatabaseCreateUpdateParameters = new MongoDBDatabaseCreateUpdateParameters
{
Resource = new MongoDBDatabaseResource {
Id = databaseName
},
Options = new CreateUpdateOptions()
};
MongoDBDatabaseGetResults mongoDBDatabaseGetResults = mongoClient.CreateUpdateMongoDBDatabaseWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
databaseName,
mongoDBDatabaseCreateUpdateParameters
).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoDBDatabaseGetResults);
Assert.Equal(databaseName, mongoDBDatabaseGetResults.Name);
Dictionary <string, string> dict = new Dictionary <string, string>();
dict.Add("partitionKey", PartitionKind.Hash.ToString());
MongoDBCollectionCreateUpdateParameters mongoDBCollectionCreateUpdateParameters = new MongoDBCollectionCreateUpdateParameters
{
Resource = new MongoDBCollectionResource
{
Id = collectionName,
ShardKey = dict
},
Options = new CreateUpdateOptions()
{
Throughput = 15000
}
};
MongoDBCollectionGetResults mongoDBCollectionGetResults = mongoClient.CreateUpdateMongoDBCollectionWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName, collectionName, mongoDBCollectionCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoDBCollectionGetResults);
VerfiyMongoCollectionCreation(mongoDBCollectionGetResults, mongoDBCollectionCreateUpdateParameters);
IEnumerable <MongoDBCollectionGetResults> mongoDBCollections = mongoClient.ListMongoDBCollectionsWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName).GetAwaiter().GetResult().Body;
Assert.NotNull(mongoDBCollections);
RetrieveThroughputParameters retrieveThroughputParameters = new RetrieveThroughputParameters();
var retrieveThroughputPropertiesResource = new RetrieveThroughputPropertiesResource();
retrieveThroughputPropertiesResource.PhysicalPartitionIds = new List <PhysicalPartitionId>();
for (int j = 0; j < 3; j++)
{
PhysicalPartitionId physicalPartitionId = new PhysicalPartitionId()
{
Id = j.ToString()
};
retrieveThroughputPropertiesResource.PhysicalPartitionIds.Add(physicalPartitionId);
}
retrieveThroughputParameters.Resource = retrieveThroughputPropertiesResource;
PhysicalPartitionThroughputInfoResult physicalPartitionThroughputInfoResult = mongoClient.MongoDBContainerRetrieveThroughputDistribution(
this.fixture.ResourceGroupName,
databaseAccountName,
databaseName,
collectionName,
retrieveThroughputParameters);
Assert.Equal(3, physicalPartitionThroughputInfoResult.Resource.PhysicalPartitionThroughputInfo.Count);
for (int j = 0; j < 3; j++)
{
if (physicalPartitionThroughputInfoResult.Resource.PhysicalPartitionThroughputInfo[j].Id == "0")
{
Assert.Equal(5000, physicalPartitionThroughputInfoResult.Resource.PhysicalPartitionThroughputInfo[j].Throughput);
}
else if (physicalPartitionThroughputInfoResult.Resource.PhysicalPartitionThroughputInfo[j].Id == "1")
{
Assert.Equal(5000, physicalPartitionThroughputInfoResult.Resource.PhysicalPartitionThroughputInfo[j].Throughput);
}
else if (physicalPartitionThroughputInfoResult.Resource.PhysicalPartitionThroughputInfo[j].Id == "2")
{
Assert.Equal(5000, physicalPartitionThroughputInfoResult.Resource.PhysicalPartitionThroughputInfo[j].Throughput);
}
else
{
Assert.True(false, "unexpected id");
}
}
RedistributeThroughputParameters redistributeThroughputParameters = new RedistributeThroughputParameters();
redistributeThroughputParameters.Resource = new RedistributeThroughputPropertiesResource();
redistributeThroughputParameters.Resource.ThroughputPolicy = ThroughputPolicyType.Custom;
redistributeThroughputParameters.Resource.SourcePhysicalPartitionThroughputInfo = new List <PhysicalPartitionThroughputInfoResource>();
redistributeThroughputParameters.Resource.SourcePhysicalPartitionThroughputInfo.Add(new PhysicalPartitionThroughputInfoResource("0", 0));
redistributeThroughputParameters.Resource.TargetPhysicalPartitionThroughputInfo = new List <PhysicalPartitionThroughputInfoResource>();
redistributeThroughputParameters.Resource.TargetPhysicalPartitionThroughputInfo.Add(new PhysicalPartitionThroughputInfoResource("1", 7000));
physicalPartitionThroughputInfoResult = mongoClient.MongoDBContainerRedistributeThroughput(
this.fixture.ResourceGroupName,
databaseAccountName,
databaseName,
collectionName,
redistributeThroughputParameters);
Assert.Equal(2, physicalPartitionThroughputInfoResult.Resource.PhysicalPartitionThroughputInfo.Count);
for (int j = 0; j < 2; j++)
{
if (physicalPartitionThroughputInfoResult.Resource.PhysicalPartitionThroughputInfo[j].Id == "0")
{
Assert.Equal(3000, Math.Round((double)physicalPartitionThroughputInfoResult.Resource.PhysicalPartitionThroughputInfo[j].Throughput));
}
else if (physicalPartitionThroughputInfoResult.Resource.PhysicalPartitionThroughputInfo[j].Id == "1")
{
Assert.Equal(7000, Math.Round((double)physicalPartitionThroughputInfoResult.Resource.PhysicalPartitionThroughputInfo[0].Throughput));
}
else
{
Assert.True(false, "unexpected id");
}
}
physicalPartitionThroughputInfoResult = mongoClient.MongoDBContainerRetrieveThroughputDistribution(
this.fixture.ResourceGroupName,
databaseAccountName,
databaseName,
collectionName,
retrieveThroughputParameters);
Assert.Equal(3, physicalPartitionThroughputInfoResult.Resource.PhysicalPartitionThroughputInfo.Count);
for (int j = 0; j < 3; j++)
{
if (physicalPartitionThroughputInfoResult.Resource.PhysicalPartitionThroughputInfo[j].Id == "0")
{
Assert.Equal(3000, Math.Round((double)physicalPartitionThroughputInfoResult.Resource.PhysicalPartitionThroughputInfo[j].Throughput));
}
else if (physicalPartitionThroughputInfoResult.Resource.PhysicalPartitionThroughputInfo[j].Id == "1")
{
Assert.Equal(7000, Math.Round((double)physicalPartitionThroughputInfoResult.Resource.PhysicalPartitionThroughputInfo[j].Throughput));
}
else if (physicalPartitionThroughputInfoResult.Resource.PhysicalPartitionThroughputInfo[j].Id == "2")
{
Assert.Equal(5000, Math.Round((double)physicalPartitionThroughputInfoResult.Resource.PhysicalPartitionThroughputInfo[j].Throughput));
}
else
{
Assert.True(false, "unexpected id");
}
}
mongoClient.DeleteMongoDBCollectionWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName, collectionName).Wait();
mongoClient.DeleteMongoDBDatabaseWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName, databaseName).Wait();
}
}
