public async Task CreateDropAutoscaleDatabaseStreamApi()
{
string databaseId = Guid.NewGuid().ToString();
using (ResponseMessage response = await this.cosmosClient.CreateDatabaseStreamAsync(
new DatabaseProperties(databaseId),
ThroughputProperties.CreateAutoscaleProvionedThroughput(5000)))
{
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
}
DatabaseCore database = (DatabaseInlineCore)this.cosmosClient.GetDatabase(databaseId);
ThroughputResponse autoscale = await database.ReadThroughputAsync(requestOptions : null);
Assert.IsNotNull(autoscale);
Assert.AreEqual(5000, autoscale.Resource.MaxAutoscaleThroughput);
ThroughputResponse autoscaleReplaced = await database.ReplaceThroughputAsync(
ThroughputProperties.CreateAutoscaleProvionedThroughput(10000));
Assert.IsNotNull(autoscaleReplaced);
Assert.AreEqual(10000, autoscaleReplaced.Resource.MaxAutoscaleThroughput);
await database.DeleteAsync();
}
[TestCategory("Quarantine")] // Not currently working with emulator
public async Task CreateDropAutoscaleContainerStreamApi()
{
DatabaseCore database = (DatabaseInlineCore)await this.cosmosClient.CreateDatabaseAsync(
Guid.NewGuid().ToString());
ThroughputResponse databaseThroughput = await database.ReadThroughputIfExistsAsync(requestOptions : null);
Assert.IsNotNull(databaseThroughput);
Assert.AreEqual(HttpStatusCode.NotFound, databaseThroughput.StatusCode);
string streamContainerId = Guid.NewGuid().ToString();
using (ResponseMessage response = await database.CreateContainerStreamAsync(
new ContainerProperties(streamContainerId, "/pk"),
ThroughputProperties.CreateAutoscaleProvionedThroughput(5000)))
{
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
ContainerCore streamContainer = (ContainerInlineCore)database.GetContainer(streamContainerId);
ThroughputResponse autoscaleIfExists = await streamContainer.ReadThroughputIfExistsAsync(requestOptions : null);
Assert.IsNotNull(autoscaleIfExists);
Assert.AreEqual(5000, autoscaleIfExists.Resource.MaxAutoscaleThroughput);
}
}
public async Task CreateDropAutoscaleAutoUpgradeDatabase()
{
DatabaseCore database = (DatabaseInlineCore)await this.cosmosClient.CreateDatabaseAsync(
nameof(CreateDropAutoscaleAutoUpgradeDatabase) + Guid.NewGuid(),
ThroughputProperties.CreateAutoscaleProvionedThroughput(
maxAutoscaleThroughput: 5000,
autoUpgradeMaxThroughputIncrementPercentage: 10));
// Container is required to validate database throughput upgrade scenarios
Container container = await database.CreateContainerAsync("Test", "/id");
ThroughputResponse autoscale = await database.ReadThroughputAsync(requestOptions : null);
Assert.IsNotNull(autoscale);
Assert.AreEqual(5000, autoscale.Resource.MaxAutoscaleThroughput);
Assert.AreEqual(10, autoscale.Resource.AutoUpgradeMaxThroughputIncrementPercentage);
ThroughputResponse autoscaleReplaced = await database.ReplaceThroughputAsync(
ThroughputProperties.CreateAutoscaleProvionedThroughput(6000));
Assert.IsNotNull(autoscaleReplaced);
Assert.AreEqual(6000, autoscaleReplaced.Resource.MaxAutoscaleThroughput);
Assert.IsNull(autoscaleReplaced.Resource.AutoUpgradeMaxThroughputIncrementPercentage);
ThroughputResponse autoUpgradeReplace = await database.ReplaceThroughputAsync(
ThroughputProperties.CreateAutoscaleProvionedThroughput(
maxAutoscaleThroughput: 7000,
autoUpgradeMaxThroughputIncrementPercentage: 20));
Assert.IsNotNull(autoUpgradeReplace);
Assert.AreEqual(7000, autoUpgradeReplace.Resource.MaxAutoscaleThroughput);
Assert.AreEqual(20, autoUpgradeReplace.Resource.AutoUpgradeMaxThroughputIncrementPercentage);
await database.DeleteAsync();
}
[Ignore] // Not currently working with emulator
public async Task CreateDropAutoscaleContainer()
{
DatabaseCore database = (DatabaseInlineCore)await this.cosmosClient.CreateDatabaseAsync(
Guid.NewGuid().ToString());
ThroughputResponse databaseThroughput = await database.ReadThroughputIfExistsAsync(requestOptions : null);
Assert.IsNotNull(databaseThroughput);
Assert.AreEqual(HttpStatusCode.NotFound, databaseThroughput.StatusCode);
ContainerCore container = (ContainerInlineCore)await database.CreateContainerAsync(
new ContainerProperties(Guid.NewGuid().ToString(), "/pk"),
ThroughputProperties.CreateAutoscaleProvionedThroughput(5000));
Assert.IsNotNull(container);
ThroughputResponse autoscale = await container.ReadThroughputAsync(requestOptions : null);
Assert.IsNotNull(autoscale);
Assert.AreEqual(5000, autoscale.Resource.MaxAutoscaleThroughput);
ThroughputResponse autoscaleReplaced = await container.ReplaceThroughputPropertiesAsync(
ThroughputProperties.CreateAutoscaleProvionedThroughput(10000));
Assert.IsNotNull(autoscaleReplaced);
Assert.AreEqual(10000, autoscaleReplaced.Resource.MaxAutoscaleThroughput);
await database.DeleteAsync();
}
[TestCategory("Quarantine")] // Not currently working with emulator
public async Task ReadFixedWithAutoscaleTests()
{
DatabaseCore database = (DatabaseInlineCore)await this.cosmosClient.CreateDatabaseAsync(
Guid.NewGuid().ToString());
ContainerCore autoscaleContainer = (ContainerInlineCore)await database.CreateContainerAsync(
new ContainerProperties(Guid.NewGuid().ToString(), "/pk"),
ThroughputProperties.CreateAutoscaleProvionedThroughput(5000));
Assert.IsNotNull(autoscaleContainer);
// Reading a autoscale container with fixed results
int?throughput = await autoscaleContainer.ReadThroughputAsync();
Assert.IsNotNull(throughput);
await database.DeleteAsync();
}
public async Task CreateDropAutoscaleDatabase()
{
DatabaseCore database = (DatabaseInlineCore)await this.cosmosClient.CreateDatabaseAsync(
nameof(CreateDropAutoscaleDatabase) + Guid.NewGuid().ToString(),
ThroughputProperties.CreateAutoscaleProvionedThroughput(5000));
ThroughputResponse autoscale = await database.ReadThroughputAsync(requestOptions : null);
Assert.IsNotNull(autoscale);
Assert.AreEqual(5000, autoscale.Resource.MaxAutoscaleThroughput);
ThroughputResponse autoscaleReplaced = await database.ReplaceThroughputAsync(
ThroughputProperties.CreateAutoscaleProvionedThroughput(10000));
Assert.IsNotNull(autoscaleReplaced);
Assert.AreEqual(10000, autoscaleReplaced.Resource.MaxAutoscaleThroughput);
await database.DeleteAsync();
}
[TestCategory("Quarantine")] // Not currently working with emulator
public async Task ContainerAutoscaleIfExistsTest()
{
DatabaseCore database = (DatabaseInlineCore)await this.cosmosClient.CreateDatabaseAsync(
nameof(CreateDropAutoscaleDatabase) + Guid.NewGuid().ToString());
Container container = await database.CreateContainerAsync(
containerProperties : new ContainerProperties("Test", "/id"),
throughputProperties : ThroughputProperties.CreateAutoscaleProvionedThroughput(5000));
ContainerCore containerCore = (ContainerInlineCore)container;
ThroughputResponse throughputResponse = await database.ReadThroughputIfExistsAsync(requestOptions : null);
Assert.IsNotNull(throughputResponse);
Assert.AreEqual(HttpStatusCode.NotFound, throughputResponse.StatusCode);
Assert.IsNull(throughputResponse.Resource);
throughputResponse = await database.ReplaceThroughputPropertiesIfExistsAsync(
ThroughputProperties.CreateAutoscaleProvionedThroughput(6000));
Assert.IsNotNull(throughputResponse);
Assert.AreEqual(HttpStatusCode.NotFound, throughputResponse.StatusCode);
Assert.IsNull(throughputResponse.Resource);
throughputResponse = await containerCore.ReadThroughputIfExistsAsync(requestOptions : null);
Assert.IsNotNull(throughputResponse);
Assert.IsTrue(throughputResponse.Resource.Throughput > 400);
Assert.AreEqual(5000, throughputResponse.Resource.MaxAutoscaleThroughput);
throughputResponse = await containerCore.ReplaceThroughputPropertiesIfExistsAsync(
ThroughputProperties.CreateAutoscaleProvionedThroughput(6000));
Assert.IsNotNull(throughputResponse);
Assert.IsTrue(throughputResponse.Resource.Throughput > 400);
Assert.AreEqual(6000, throughputResponse.Resource.MaxAutoscaleThroughput);
await database.DeleteAsync();
}
[TestCategory("Quarantine")] // Not currently working with emulator
public async Task CreateDropAutoscaleContainer()
{
DatabaseCore database = (DatabaseInlineCore)await this.cosmosClient.CreateDatabaseAsync(
Guid.NewGuid().ToString());
ContainerCore container = (ContainerInlineCore)await database.CreateContainerAsync(
new ContainerProperties(Guid.NewGuid().ToString(), "/pk"),
ThroughputProperties.CreateAutoscaleProvionedThroughput(5000));
Assert.IsNotNull(container);
ThroughputResponse throughputResponse = await container.ReadThroughputAsync(requestOptions : null);
Assert.IsNotNull(throughputResponse);
Assert.AreEqual(5000, throughputResponse.Resource.MaxAutoscaleThroughput);
throughputResponse = await container.ReplaceThroughputAsync(
ThroughputProperties.CreateAutoscaleProvionedThroughput(6000));
Assert.IsNotNull(throughputResponse);
Assert.AreEqual(6000, throughputResponse.Resource.MaxAutoscaleThroughput);
await database.DeleteAsync();
}
public async Task AutoscaleThroughputSerializationTest()
{
ThroughputProperties autoscaleThroughputProperties = ThroughputProperties.CreateAutoscaleProvionedThroughput(1000);
Assert.AreEqual(1000, autoscaleThroughputProperties.MaxAutoscaleThroughput);
Assert.IsNull(autoscaleThroughputProperties.Throughput);
using (Stream stream = MockCosmosUtil.Serializer.ToStream <ThroughputProperties>(autoscaleThroughputProperties))
{
using (StreamReader reader = new StreamReader(stream))
{
string output = await reader.ReadToEndAsync();
Assert.IsNotNull(output);
Assert.AreEqual("{\"content\":{\"offerAutopilotSettings\":{\"maxThroughput\":1000}},\"offerVersion\":\"V2\"}", output);
}
}
OfferAutoscaleProperties autoscaleProperties = new OfferAutoscaleProperties(
startingMaxThroughput: 1000,
autoUpgradeMaxThroughputIncrementPercentage: null);
using (Stream stream = MockCosmosUtil.Serializer.ToStream <OfferAutoscaleProperties>(autoscaleProperties))
{
using (StreamReader reader = new StreamReader(stream))
{
string output = await reader.ReadToEndAsync();
Assert.IsNotNull(output);
Assert.AreEqual("{\"maxThroughput\":1000}", output);
}
}
using (Stream stream = MockCosmosUtil.Serializer.ToStream <OfferAutoscaleProperties>(autoscaleProperties))
{
OfferAutoscaleProperties fromStream = MockCosmosUtil.Serializer.FromStream <OfferAutoscaleProperties>(stream);
Assert.IsNotNull(fromStream);
Assert.AreEqual(1000, fromStream.MaxThroughput);
}
OfferContentProperties content = OfferContentProperties.CreateAutoscaleOfferConent(
startingMaxThroughput: 1000,
autoUpgradeMaxThroughputIncrementPercentage: null);
using (Stream stream = MockCosmosUtil.Serializer.ToStream <OfferContentProperties>(content))
{
using (StreamReader reader = new StreamReader(stream))
{
string output = await reader.ReadToEndAsync();
Assert.IsNotNull(output);
Assert.AreEqual("{\"offerAutopilotSettings\":{\"maxThroughput\":1000}}", output);
}
}
using (Stream stream = MockCosmosUtil.Serializer.ToStream <OfferContentProperties>(content))
{
OfferContentProperties fromStream = MockCosmosUtil.Serializer.FromStream <OfferContentProperties>(stream);
Assert.IsNotNull(fromStream.OfferAutoscaleSettings);
Assert.AreEqual(1000, fromStream.OfferAutoscaleSettings.MaxThroughput);
Assert.IsNull(fromStream.OfferThroughput);
}
using (Stream stream = MockCosmosUtil.Serializer.ToStream <ThroughputProperties>(autoscaleThroughputProperties))
{
ThroughputProperties fromStream = MockCosmosUtil.Serializer.FromStream <ThroughputProperties>(stream);
Assert.AreEqual(1000, fromStream.MaxAutoscaleThroughput);
Assert.IsNull(fromStream.Throughput);;
}
}