public async Task SharedThroughputTests()
{
string databaseId = Guid.NewGuid().ToString();
int throughput = 10000;
DatabaseResponse createResponse = await this.CreateDatabaseHelper(databaseId, databaseExists : false, throughput : throughput);
Assert.AreEqual(HttpStatusCode.Created, createResponse.StatusCode);
Cosmos.Database cosmosDatabase = createResponse;
int? readThroughput = await cosmosDatabase.ReadThroughputAsync();
Assert.AreEqual(throughput, readThroughput);
string containerId = Guid.NewGuid().ToString();
string partitionPath = "/users";
ContainerResponse containerResponse = await cosmosDatabase.CreateContainerAsync(containerId, partitionPath);
Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode);
Container container = containerResponse;
try
{
readThroughput = await((ContainerCore)container).ReadThroughputAsync();
Assert.Fail("Should through not found exception as throughput is not configured");
} catch (CosmosException exception)
{
Assert.AreEqual(HttpStatusCode.NotFound, exception.StatusCode);
}
await container.DeleteContainerAsync();
await cosmosDatabase.DeleteAsync();
}
public async Task ValidateCurrentWriteQuorumAndReplicaSetHeader()
{
CosmosClient client = TestCommon.CreateCosmosClient(false);
Cosmos.Database db = null;
try
{
db = await client.CreateDatabaseAsync(Guid.NewGuid().ToString());
PartitionKeyDefinition partitionKeyDefinition = new PartitionKeyDefinition {
Paths = new System.Collections.ObjectModel.Collection <string>(new[] { "/id" }), Kind = PartitionKind.Hash
};
ContainerProperties containerSetting = new ContainerProperties()
{
Id = Guid.NewGuid().ToString(),
PartitionKey = partitionKeyDefinition
};
Container coll = await db.CreateContainerAsync(containerSetting);
Document documentDefinition = new Document {
Id = Guid.NewGuid().ToString()
};
ItemResponse <Document> docResult = await coll.CreateItemAsync <Document>(documentDefinition);
Assert.IsTrue(int.Parse(docResult.Headers[WFConstants.BackendHeaders.CurrentWriteQuorum], CultureInfo.InvariantCulture) > 0);
Assert.IsTrue(int.Parse(docResult.Headers[WFConstants.BackendHeaders.CurrentReplicaSetSize], CultureInfo.InvariantCulture) > 0);
}
finally
{
await db.DeleteAsync();
}
}
public async Task ValidateUserAgentHeaderWithMacOs(bool useMacOs)
{
const string suffix = " UserApplicationName/1.0";
CosmosClientOptions clientOptions = this.SetEnvironmentInformation(useMacOs);
clientOptions.ApplicationName = suffix;
using (CosmosClient client = TestCommon.CreateCosmosClient(clientOptions))
{
Cosmos.UserAgentContainer userAgentContainer = client.ClientOptions.GetConnectionPolicy(client.ClientId).UserAgentContainer;
string userAgentString = userAgentContainer.UserAgent;
Assert.IsTrue(userAgentString.Contains(suffix));
if (useMacOs)
{
Assert.IsTrue(userAgentString.Contains("Darwin 18.0.0"));
}
Cosmos.Database db = await client.CreateDatabaseIfNotExistsAsync(Guid.NewGuid().ToString());
Assert.IsNotNull(db);
await db.DeleteAsync();
}
}
public async Task SharedThroughputTests()
{
string databaseId = Guid.NewGuid().ToString();
int throughput = 10000;
DatabaseResponse createResponse = await this.CreateDatabaseHelper(databaseId, databaseExists : false, throughput : throughput);
Assert.AreEqual(HttpStatusCode.Created, createResponse.StatusCode);
Cosmos.Database cosmosDatabase = createResponse;
int? readThroughput = await((DatabaseCore)cosmosDatabase).ReadProvisionedThroughputAsync();
Assert.AreEqual(throughput, readThroughput);
string containerId = Guid.NewGuid().ToString();
string partitionPath = "/users";
ContainerResponse containerResponse = await cosmosDatabase.CreateContainerAsync(containerId, partitionPath);
Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode);
Container container = containerResponse;
readThroughput = await((ContainerCore)container).ReadProvisionedThroughputAsync();
Assert.IsNull(readThroughput);
await container.DeleteContainerAsync();
await cosmosDatabase.DeleteAsync();
}
public async Task VerifyUserAgentWithFeatures(bool useMacOs)
{
this.SetEnvironmentInformation(useMacOs);
const string suffix = " UserApplicationName/1.0";
string features = Convert.ToString((int)CosmosClientOptionsFeatures.AllowBulkExecution, 2).PadLeft(8, '0');
using (CosmosClient client = TestCommon.CreateCosmosClient(builder => builder.WithApplicationName(suffix).WithBulkExecution(true)))
{
Cosmos.UserAgentContainer userAgentContainer = client.ClientOptions.GetConnectionPolicy().UserAgentContainer;
string userAgentString = userAgentContainer.UserAgent;
Assert.IsTrue(userAgentString.Contains(suffix));
Assert.IsTrue(userAgentString.Contains($"|F {features}"));
if (useMacOs)
{
Assert.IsTrue(userAgentString.Contains("Darwin 18.0.0"));
}
Cosmos.Database db = await client.CreateDatabaseIfNotExistsAsync(Guid.NewGuid().ToString());
Assert.IsNotNull(db);
await db.DeleteAsync();
}
using (CosmosClient client = TestCommon.CreateCosmosClient(builder => builder.WithApplicationName(suffix).WithBulkExecution(false)))
{
Cosmos.UserAgentContainer userAgentContainer = client.ClientOptions.GetConnectionPolicy().UserAgentContainer;
string userAgentString = userAgentContainer.UserAgent;
Assert.IsTrue(userAgentString.Contains(suffix));
Assert.IsFalse(userAgentString.Contains($"|F {features}"));
}
}
public async Task ImplicitConversion()
{
string databaseName = Guid.NewGuid().ToString();
DatabaseResponse cosmosDatabaseResponse = await this.cosmosClient.GetDatabase(databaseName).ReadAsync(cancellationToken: this.cancellationToken);
Cosmos.Database cosmosDatabase = cosmosDatabaseResponse;
DatabaseProperties cosmosDatabaseSettings = cosmosDatabaseResponse;
Assert.IsNotNull(cosmosDatabase);
Assert.IsNull(cosmosDatabaseSettings);
cosmosDatabaseResponse = await this.CreateDatabaseHelper();
cosmosDatabase = cosmosDatabaseResponse;
cosmosDatabaseSettings = cosmosDatabaseResponse;
Assert.IsNotNull(cosmosDatabase);
Assert.IsNotNull(cosmosDatabaseSettings);
cosmosDatabaseResponse = await cosmosDatabase.DeleteAsync(cancellationToken : this.cancellationToken);
cosmosDatabase = cosmosDatabaseResponse;
cosmosDatabaseSettings = cosmosDatabaseResponse;
Assert.IsNotNull(cosmosDatabase);
Assert.IsNull(cosmosDatabaseSettings);
}
public static void CleanUp()
{
if (testDb != null)
{
testDb.DeleteAsync().Wait();
}
}
public async Task ReadReplaceThroughputResponseTests()
{
string databaseId = Guid.NewGuid().ToString();
int throughput = 10000;
DatabaseResponse createResponse = await this.CreateDatabaseHelper(databaseId, databaseExists : false, throughput : throughput);
Assert.AreEqual(HttpStatusCode.Created, createResponse.StatusCode);
Cosmos.Database cosmosDatabase = createResponse;
ThroughputResponse readThroughputResponse = await cosmosDatabase.ReadThroughputAsync(new RequestOptions());
Assert.IsNotNull(readThroughputResponse);
Assert.IsNotNull(readThroughputResponse.Resource);
Assert.IsNotNull(readThroughputResponse.MinThroughput);
Assert.IsNotNull(readThroughputResponse.Resource.Throughput);
Assert.AreEqual(throughput, readThroughputResponse.Resource.Throughput.Value);
// Implicit
ThroughputProperties throughputProperties = await cosmosDatabase.ReadThroughputAsync(new RequestOptions());
Assert.IsNotNull(throughputProperties);
Assert.AreEqual(throughput, throughputProperties.Throughput);
// Simple API
int?readThroughput = await cosmosDatabase.ReadThroughputAsync();
Assert.AreEqual(throughput, readThroughput);
string containerId = Guid.NewGuid().ToString();
string partitionPath = "/users";
ContainerResponse containerResponse = await cosmosDatabase.CreateContainerAsync(containerId, partitionPath);
Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode);
ThroughputResponse replaceThroughputResponse = await cosmosDatabase.ReplaceThroughputAsync(readThroughputResponse.Resource.Throughput.Value + 1000);
Assert.IsNotNull(replaceThroughputResponse);
Assert.IsNotNull(replaceThroughputResponse.Resource);
Assert.AreEqual(readThroughputResponse.Resource.Throughput.Value + 1000, replaceThroughputResponse.Resource.Throughput.Value);
Container container = containerResponse;
try
{
readThroughputResponse = await container.ReadThroughputAsync(new RequestOptions());
Assert.Fail("Should through not found exception as throughput is not configured");
}
catch (CosmosException exception)
{
Assert.AreEqual(HttpStatusCode.NotFound, exception.StatusCode);
}
await container.DeleteContainerAsync();
await cosmosDatabase.DeleteAsync();
}
public async Task NoThroughputTests()
{
string databaseId = Guid.NewGuid().ToString();
DatabaseResponse createResponse = await this.CreateDatabaseHelper(databaseId, databaseExists : false);
Assert.AreEqual(HttpStatusCode.Created, createResponse.StatusCode);
Cosmos.Database cosmosDatabase = createResponse;
int? readThroughput = await((DatabaseCore)cosmosDatabase).ReadProvisionedThroughputAsync();
Assert.IsNull(readThroughput);
await cosmosDatabase.DeleteAsync();
}
public async Task HttpClientConnectionLimitTest()
{
int gatewayConnectionLimit = 1;
IReadOnlyList <string> excludeConnections = GetActiveConnections();
CosmosClient cosmosClient = new CosmosClient(
ConfigurationManager.AppSettings["GatewayEndpoint"],
ConfigurationManager.AppSettings["MasterKey"],
new CosmosClientOptions
{
ApplicationName = "test",
GatewayModeMaxConnectionLimit = gatewayConnectionLimit,
ConnectionMode = ConnectionMode.Gateway,
ConnectionProtocol = Protocol.Https
}
);
FieldInfo httpClient = cosmosClient.DocumentClient.GetType().GetField("httpClient", BindingFlags.NonPublic | BindingFlags.Instance);
CosmosHttpClient cosmosHttpClient = (CosmosHttpClient)httpClient.GetValue(cosmosClient.DocumentClient);
HttpClientHandler httpClientHandler = (HttpClientHandler)cosmosHttpClient.HttpMessageHandler;
Assert.AreEqual(gatewayConnectionLimit, httpClientHandler.MaxConnectionsPerServer);
Cosmos.Database database = await cosmosClient.CreateDatabaseAsync(Guid.NewGuid().ToString());
Container container = await database.CreateContainerAsync(
"TestConnections",
"/pk",
throughput : 20000);
List <Task> creates = new List <Task>();
for (int i = 0; i < 100; i++)
{
creates.Add(container.CreateItemAsync <dynamic>(new { id = Guid.NewGuid().ToString(), pk = Guid.NewGuid().ToString() }));
}
await Task.WhenAll(creates);
// Verify the handler still exists after client warm up
//Assert.AreEqual(gatewayConnectionLimit, httpClientHandler.MaxConnectionsPerServer);
IReadOnlyList <string> afterConnections = GetActiveConnections();
// Clean up the database and container
await database.DeleteAsync();
int connectionDiff = afterConnections.Count - excludeConnections.Count;
Assert.IsTrue(connectionDiff <= gatewayConnectionLimit, $"Connection before : {excludeConnections.Count}, after {afterConnections.Count}");
}
public async Task HttpClientConnectionLimitTest()
{
int gatewayConnectionLimit = 1;
IReadOnlyList <string> excludeConnections = GetActiveConnections();
using (CosmosClient cosmosClient = new CosmosClient(
ConfigurationManager.AppSettings["GatewayEndpoint"],
ConfigurationManager.AppSettings["MasterKey"],
new CosmosClientOptions
{
ApplicationName = "test",
GatewayModeMaxConnectionLimit = gatewayConnectionLimit,
ConnectionMode = ConnectionMode.Gateway,
ConnectionProtocol = Protocol.Https
}
))
{
CosmosHttpClient cosmosHttpClient = cosmosClient.DocumentClient.httpClient;
HttpClientHandler httpClientHandler = (HttpClientHandler)cosmosHttpClient.HttpMessageHandler;
Assert.AreEqual(gatewayConnectionLimit, httpClientHandler.MaxConnectionsPerServer);
Cosmos.Database database = await cosmosClient.CreateDatabaseAsync(Guid.NewGuid().ToString());
Container container = await database.CreateContainerAsync(
"TestConnections",
"/pk",
throughput : 20000);
List <Task> creates = new List <Task>();
for (int i = 0; i < 100; i++)
{
creates.Add(container.CreateItemAsync <dynamic>(new { id = Guid.NewGuid().ToString(), pk = Guid.NewGuid().ToString() }));
}
await Task.WhenAll(creates);
// Clean up the database and container
await database.DeleteAsync();
}
IReadOnlyList <string> afterConnections = GetActiveConnections();
int connectionDiff = afterConnections.Count - excludeConnections.Count;
Assert.IsTrue(connectionDiff <= gatewayConnectionLimit, $"Connection before : {excludeConnections.Count}, after {afterConnections.Count};" +
$"Before connections: {JsonConvert.SerializeObject(excludeConnections)}; After connections: {JsonConvert.SerializeObject(afterConnections)}");
}
public async Task ImplicitConversion()
{
DatabaseResponse cosmosDatabaseResponse = await this.CreateDatabaseHelper();
Cosmos.Database cosmosDatabase = cosmosDatabaseResponse;
DatabaseProperties cosmosDatabaseSettings = cosmosDatabaseResponse;
Assert.IsNotNull(cosmosDatabase);
Assert.IsNotNull(cosmosDatabaseSettings);
cosmosDatabaseResponse = await cosmosDatabase.DeleteAsync(cancellationToken : this.cancellationToken);
cosmosDatabase = cosmosDatabaseResponse;
cosmosDatabaseSettings = cosmosDatabaseResponse;
Assert.IsNotNull(cosmosDatabase);
Assert.IsNull(cosmosDatabaseSettings);
}
public async Task HttpClientFactorySmokeTest()
{
HttpClient client = new HttpClient();
Mock <Func <HttpClient> > factory = new Mock <Func <HttpClient> >();
factory.Setup(f => f()).Returns(client);
CosmosClient cosmosClient = new CosmosClient(
ConfigurationManager.AppSettings["GatewayEndpoint"],
ConfigurationManager.AppSettings["MasterKey"],
new CosmosClientOptions
{
ApplicationName = "test",
ConnectionMode = ConnectionMode.Gateway,
ConnectionProtocol = Protocol.Https,
HttpClientFactory = factory.Object
}
);
string someId = Guid.NewGuid().ToString();
Cosmos.Database database = null;
try
{
database = await cosmosClient.CreateDatabaseAsync(someId);
Cosmos.Container container = await database.CreateContainerAsync(Guid.NewGuid().ToString(), "/id");
await container.CreateItemAsync <dynamic>(new { id = someId });
await container.ReadItemAsync <dynamic>(someId, new Cosmos.PartitionKey(someId));
await container.DeleteItemAsync <dynamic>(someId, new Cosmos.PartitionKey(someId));
await container.DeleteContainerAsync();
Mock.Get(factory.Object).Verify(f => f(), Times.Once);
}
finally
{
if (database != null)
{
await database.DeleteAsync();
}
}
}
public async Task NoThroughputTests()
{
string databaseId = Guid.NewGuid().ToString();
DatabaseResponse createResponse = await this.CreateDatabaseHelper(databaseId, databaseExists : false);
Assert.AreEqual(HttpStatusCode.Created, createResponse.StatusCode);
Cosmos.Database cosmosDatabase = createResponse;
try
{
int?readThroughput = await((DatabaseCore)cosmosDatabase).ReadThroughputAsync();
Assert.Fail("Should through not found exception as throughput is not configured");
}
catch (CosmosException exception)
{
Assert.AreEqual(HttpStatusCode.NotFound, exception.StatusCode);
}
await cosmosDatabase.DeleteAsync();
}
public async Task ReadReplaceThroughputResponseTests()
{
string databaseId = Guid.NewGuid().ToString();
int throughput = 10000;
DatabaseResponse createResponse = await this.CreateDatabaseHelper(databaseId, databaseExists : false, throughput : throughput);
Assert.AreEqual(HttpStatusCode.Created, createResponse.StatusCode);
Cosmos.Database cosmosDatabase = createResponse;
ThroughputResponse readThroughputResponse = await cosmosDatabase.ReadThroughputAsync();
Assert.IsNotNull(readThroughputResponse);
Assert.IsNotNull(readThroughputResponse.Resource);
Assert.IsNotNull(readThroughputResponse.MinThroughput);
Assert.IsNotNull(readThroughputResponse.Resource.Throughput);
Assert.AreEqual(throughput, readThroughputResponse.Resource.Throughput.Value);
string containerId = Guid.NewGuid().ToString();
string partitionPath = "/users";
ContainerResponse containerResponse = await cosmosDatabase.CreateContainerAsync(containerId, partitionPath);
Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode);
ThroughputResponse replaceThroughputResponse = await cosmosDatabase.ReplaceThroughputAsync(readThroughputResponse.Resource.Throughput.Value + 1000);
Assert.IsNotNull(replaceThroughputResponse);
Assert.IsNotNull(replaceThroughputResponse.Resource);
Assert.AreEqual(readThroughputResponse.Resource.Throughput.Value + 1000, replaceThroughputResponse.Resource.Throughput.Value);
Container container = containerResponse;
readThroughputResponse = await container.ReadThroughputAsync();
Assert.IsNull(readThroughputResponse.Resource);
await container.DeleteContainerAsync();
await cosmosDatabase.DeleteAsync();
}
public async Task ReadReplaceThroughputResponseTests()
{
int toStreamCount = 0;
int fromStreamCount = 0;
CosmosSerializerHelper mockJsonSerializer = new CosmosSerializerHelper(
null,
(x) => fromStreamCount++,
(x) => toStreamCount++);
//Create a new cosmos client with the mocked cosmos json serializer
CosmosClient client = TestCommon.CreateCosmosClient(
(cosmosClientBuilder) => cosmosClientBuilder.WithCustomSerializer(mockJsonSerializer));
int databaseThroughput = 10000;
Cosmos.Database databaseNoThroughput = await client.CreateDatabaseAsync(Guid.NewGuid().ToString(), null);
Cosmos.Database databaseWithThroughput = await client.CreateDatabaseAsync(Guid.NewGuid().ToString(), databaseThroughput, null);
string containerId = Guid.NewGuid().ToString();
string partitionPath = "/users";
Container containerNoThroughput = await databaseWithThroughput.CreateContainerAsync(containerId, partitionPath, throughput : null);
try
{
await containerNoThroughput.ReadThroughputAsync(new RequestOptions());
Assert.Fail("Should through not found exception as throughput is not configured");
}
catch (CosmosException exception)
{
Assert.AreEqual(HttpStatusCode.NotFound, exception.StatusCode);
}
try
{
await containerNoThroughput.ReplaceThroughputAsync(2000, new RequestOptions());
Assert.Fail("Should through not found exception as throughput is not configured");
}
catch (CosmosException exception)
{
Assert.AreEqual(HttpStatusCode.NotFound, exception.StatusCode);
}
int containerThroughput = 1000;
Container container = await databaseNoThroughput.CreateContainerAsync(Guid.NewGuid().ToString(), "/id", throughput : containerThroughput);
int?containerResponseThroughput = await container.ReadThroughputAsync();
Assert.AreEqual(containerThroughput, containerResponseThroughput);
ThroughputResponse containerThroughputResponse = await container.ReadThroughputAsync(new RequestOptions());
Assert.IsNotNull(containerThroughputResponse);
Assert.IsNotNull(containerThroughputResponse.Resource);
Assert.IsNotNull(containerThroughputResponse.MinThroughput);
Assert.IsNotNull(containerThroughputResponse.Resource.Throughput);
Assert.AreEqual(containerThroughput, containerThroughputResponse.Resource.Throughput.Value);
containerThroughput += 500;
containerThroughputResponse = await container.ReplaceThroughputAsync(containerThroughput, new RequestOptions());
Assert.IsNotNull(containerThroughputResponse);
Assert.IsNotNull(containerThroughputResponse.Resource);
Assert.IsNotNull(containerThroughputResponse.Resource.Throughput);
Assert.AreEqual(containerThroughput, containerThroughputResponse.Resource.Throughput.Value);
Assert.AreEqual(0, toStreamCount, "Custom serializer to stream should not be used for offer operations");
Assert.AreEqual(0, fromStreamCount, "Custom serializer from stream should not be used for offer operations");
await databaseNoThroughput.DeleteAsync();
}
public async Task VerifyUserAgentWithFeatures(bool setApplicationName, bool useMacOs)
{
this.SetEnvironmentInformation(useMacOs);
const string suffix = " UserApplicationName/1.0";
CosmosClientOptionsFeatures featuresFlags = CosmosClientOptionsFeatures.NoFeatures;
featuresFlags |= CosmosClientOptionsFeatures.AllowBulkExecution;
featuresFlags |= CosmosClientOptionsFeatures.HttpClientFactory;
string features = Convert.ToString((int)featuresFlags, 2).PadLeft(8, '0');
Action <Fluent.CosmosClientBuilder> applicationNameBuilder = (builder) =>
{
if (setApplicationName)
{
builder.WithApplicationName(suffix);
}
};
using (CosmosClient client = TestCommon.CreateCosmosClient(builder => applicationNameBuilder(builder.WithBulkExecution(true).WithHttpClientFactory(() => new HttpClient()))))
{
Cosmos.UserAgentContainer userAgentContainer = client.ClientOptions.GetConnectionPolicy().UserAgentContainer;
string userAgentString = userAgentContainer.UserAgent;
if (setApplicationName)
{
Assert.IsTrue(userAgentString.Contains(suffix));
}
else
{
Assert.IsFalse(userAgentString.Contains(suffix));
}
Assert.IsTrue(userAgentString.Contains($"|F {features}"));
if (useMacOs)
{
Assert.IsTrue(userAgentString.Contains("Darwin 18.0.0"));
}
Cosmos.Database db = await client.CreateDatabaseIfNotExistsAsync(Guid.NewGuid().ToString());
Assert.IsNotNull(db);
await db.DeleteAsync();
}
using (CosmosClient client = TestCommon.CreateCosmosClient(builder => applicationNameBuilder(builder)))
{
Cosmos.UserAgentContainer userAgentContainer = client.ClientOptions.GetConnectionPolicy().UserAgentContainer;
string userAgentString = userAgentContainer.UserAgent;
if (setApplicationName)
{
Assert.IsTrue(userAgentString.Contains(suffix));
}
else
{
Assert.IsFalse(userAgentString.Contains(suffix));
}
Assert.IsFalse(userAgentString.Contains($"|F {features}"));
}
}
private async Task ValidateCollectionIndexProgressHeaders(CosmosClient client)
{
Cosmos.Database db = await client.CreateDatabaseAsync(Guid.NewGuid().ToString());
try
{
PartitionKeyDefinition partitionKeyDefinition = new PartitionKeyDefinition {
Paths = new System.Collections.ObjectModel.Collection <string>(new[] { "/id" }), Kind = PartitionKind.Hash
};
var lazyCollection = new ContainerProperties()
{
Id = Guid.NewGuid().ToString(), PartitionKey = partitionKeyDefinition
};
lazyCollection.IndexingPolicy.IndexingMode = Cosmos.IndexingMode.Lazy;
Container lazyContainer = await db.CreateContainerAsync(lazyCollection);
var consistentCollection = new ContainerProperties()
{
Id = Guid.NewGuid().ToString(), PartitionKey = partitionKeyDefinition
};
consistentCollection.IndexingPolicy.IndexingMode = Cosmos.IndexingMode.Consistent;
Container consistentContainer = await db.CreateContainerAsync(consistentCollection);
var noneIndexCollection = new ContainerProperties()
{
Id = Guid.NewGuid().ToString(), PartitionKey = partitionKeyDefinition
};
noneIndexCollection.IndexingPolicy.Automatic = false;
noneIndexCollection.IndexingPolicy.IndexingMode = Cosmos.IndexingMode.None;
Container noneIndexContainer = await db.CreateContainerAsync(noneIndexCollection);
var doc = new Document()
{
Id = Guid.NewGuid().ToString()
};
await lazyContainer.CreateItemAsync <Document>(doc);
await consistentContainer.CreateItemAsync <Document>(doc);
await noneIndexContainer.CreateItemAsync <Document>(doc);
// Lazy-indexing collection.
{
ContainerResponse collectionResponse = await lazyContainer.ReadContainerAsync(requestOptions : new ContainerRequestOptions {
PopulateQuotaInfo = true
});
Assert.IsTrue(int.Parse(collectionResponse.Headers[HttpConstants.HttpHeaders.CollectionLazyIndexingProgress], CultureInfo.InvariantCulture) >= 0,
"Expect lazy indexer progress when reading lazy collection.");
Assert.AreEqual(100, int.Parse(collectionResponse.Headers[HttpConstants.HttpHeaders.CollectionIndexTransformationProgress], CultureInfo.InvariantCulture),
"Expect reindexer progress when reading lazy collection.");
}
// Consistent-indexing collection.
{
ContainerResponse collectionResponse = await consistentContainer.ReadContainerAsync(requestOptions : new ContainerRequestOptions {
PopulateQuotaInfo = true
});
Assert.IsFalse(collectionResponse.Headers.AllKeys().Contains(HttpConstants.HttpHeaders.CollectionLazyIndexingProgress),
"No lazy indexer progress when reading consistent collection.");
Assert.AreEqual(100, int.Parse(collectionResponse.Headers[HttpConstants.HttpHeaders.CollectionIndexTransformationProgress], CultureInfo.InvariantCulture),
"Expect reindexer progress when reading consistent collection.");
}
// None-indexing collection.
{
ContainerResponse collectionResponse = await noneIndexContainer.ReadContainerAsync(requestOptions : new ContainerRequestOptions {
PopulateQuotaInfo = true
});
Assert.IsFalse(collectionResponse.Headers.AllKeys().Contains(HttpConstants.HttpHeaders.CollectionLazyIndexingProgress),
"No lazy indexer progress when reading none-index collection.");
Assert.AreEqual(100, int.Parse(collectionResponse.Headers[HttpConstants.HttpHeaders.CollectionIndexTransformationProgress], CultureInfo.InvariantCulture),
"Expect reindexer progress when reading none-index collection.");
}
}
finally
{
await db.DeleteAsync();
}
}
public async Task ReadReplaceThroughputResponseTests()
{
int toStreamCount = 0;
int fromStreamCount = 0;
CosmosSerializerHelper mockJsonSerializer = new CosmosSerializerHelper(
null,
(x) => fromStreamCount++,
(x) => toStreamCount++);
//Create a new cosmos client with the mocked cosmos json serializer
CosmosClient client = TestCommon.CreateCosmosClient(
(cosmosClientBuilder) => cosmosClientBuilder.WithCustomSerializer(mockJsonSerializer));
string databaseId = Guid.NewGuid().ToString();
int throughput = 10000;
DatabaseResponse createResponse = await client.CreateDatabaseAsync(databaseId, throughput, null);
Assert.AreEqual(HttpStatusCode.Created, createResponse.StatusCode);
Cosmos.Database cosmosDatabase = createResponse;
ThroughputResponse readThroughputResponse = await cosmosDatabase.ReadThroughputAsync(new RequestOptions());
Assert.IsNotNull(readThroughputResponse);
Assert.IsNotNull(readThroughputResponse.Resource);
Assert.IsNotNull(readThroughputResponse.MinThroughput);
Assert.IsNotNull(readThroughputResponse.Resource.Throughput);
Assert.AreEqual(throughput, readThroughputResponse.Resource.Throughput.Value);
// Implicit
ThroughputProperties throughputProperties = await cosmosDatabase.ReadThroughputAsync(new RequestOptions());
Assert.IsNotNull(throughputProperties);
Assert.AreEqual(throughput, throughputProperties.Throughput);
// Simple API
int?readThroughput = await cosmosDatabase.ReadThroughputAsync();
Assert.AreEqual(throughput, readThroughput);
// Database must have a container before it can be scaled
string containerId = Guid.NewGuid().ToString();
string partitionPath = "/users";
ContainerResponse containerResponse = await cosmosDatabase.CreateContainerAsync(containerId, partitionPath, throughput : null);
Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode);
ThroughputResponse replaceThroughputResponse = await cosmosDatabase.ReplaceThroughputAsync(readThroughputResponse.Resource.Throughput.Value + 1000);
Assert.IsNotNull(replaceThroughputResponse);
Assert.IsNotNull(replaceThroughputResponse.Resource);
Assert.AreEqual(readThroughputResponse.Resource.Throughput.Value + 1000, replaceThroughputResponse.Resource.Throughput.Value);
await cosmosDatabase.DeleteAsync();
Database databaseNoThroughput = await client.CreateDatabaseAsync(Guid.NewGuid().ToString(), throughput : null);
try
{
ThroughputResponse throughputResponse = await databaseNoThroughput.ReadThroughputAsync(new RequestOptions());
Assert.Fail("Should through not found exception as throughput is not configured");
}
catch (CosmosException exception)
{
Assert.AreEqual(HttpStatusCode.NotFound, exception.StatusCode);
}
try
{
ThroughputResponse throughputResponse = await databaseNoThroughput.ReplaceThroughputAsync(2000, new RequestOptions());
Assert.Fail("Should through not found exception as throughput is not configured");
}
catch (CosmosException exception)
{
Assert.AreEqual(HttpStatusCode.NotFound, exception.StatusCode);
}
int?dbThroughput = await databaseNoThroughput.ReadThroughputAsync();
Assert.IsNull(dbThroughput);
Assert.AreEqual(0, toStreamCount, "Custom serializer to stream should not be used for offer operations");
Assert.AreEqual(0, fromStreamCount, "Custom serializer from stream should not be used for offer operations");
await databaseNoThroughput.DeleteAsync();
}