public async Task IteratorTest()
{
string sprocBody = "function() { { var x = 42; } }";
int numberOfSprocs = 3;
string[] sprocIds = new string[numberOfSprocs];
for (int i = 0; i < numberOfSprocs; i++)
{
string sprocId = Guid.NewGuid().ToString();
sprocIds[i] = sprocId;
CosmosStoredProcedureResponse storedProcedureResponse =
await this.container.StoredProcedures.CreateStoredProceducreAsync(sprocId, sprocBody);
Assert.AreEqual(HttpStatusCode.Created, storedProcedureResponse.StatusCode);
}
List <string> readSprocIds = new List <string>();
CosmosResultSetIterator <CosmosStoredProcedureSettings> iter = this.container.StoredProcedures.GetStoredProcedureIterator();
while (iter.HasMoreResults)
{
CosmosQueryResponse <CosmosStoredProcedureSettings> currentResultSet = await iter.FetchNextSetAsync();
{
foreach (CosmosStoredProcedureSettings storedProcedureSettingsEntry in currentResultSet)
{
readSprocIds.Add(storedProcedureSettingsEntry.Id);
}
}
}
CollectionAssert.AreEquivalent(sprocIds, readSprocIds);
}
public async Task DeleteNonExistingTest()
{
string sprocId = Guid.NewGuid().ToString();
CosmosStoredProcedure storedProcedure = this.container.StoredProcedures[sprocId];
CosmosStoredProcedureResponse storedProcedureResponse = storedProcedureResponse = await storedProcedure.DeleteAsync();
Assert.AreEqual(HttpStatusCode.NotFound, storedProcedureResponse.StatusCode);
}
private static void ValidateStoredProcedureSettings(string id, string body, CosmosStoredProcedureResponse cosmosResponse)
{
CosmosStoredProcedureSettings settings = cosmosResponse.Resource;
Assert.AreEqual(id, settings.Id,
"Stored Procedure id do not match");
Assert.AreEqual(body, settings.Body,
"Stored Procedure functions do not match");
}
public async Task ExecuteTestWithParameter()
{
string sprocId = Guid.NewGuid().ToString();
string sprocBody = @"function(param1) {
var context = getContext();
var response = context.getResponse();
response.setBody(param1);
}";
CosmosStoredProcedureResponse storedProcedureResponse =
await this.container.StoredProcedures.CreateStoredProceducreAsync(sprocId, sprocBody);
Assert.AreEqual(HttpStatusCode.Created, storedProcedureResponse.StatusCode);
StoredProcedureTests.ValidateStoredProcedureSettings(sprocId, sprocBody, storedProcedureResponse);
// Insert document and then query
string testPartitionId = Guid.NewGuid().ToString();
var payload = new { id = testPartitionId, user = testPartitionId };
CosmosItemResponse <dynamic> createItemResponse = await this.container.Items.CreateItemAsync <dynamic>(testPartitionId, payload);
Assert.AreEqual(HttpStatusCode.Created, createItemResponse.StatusCode);
CosmosStoredProcedure storedProcedure = storedProcedureResponse.StoredProcedure;
CosmosItemResponse <string> sprocResponse = await storedProcedure.ExecuteAsync <string[], string>(testPartitionId, new string[] { "one" });
Assert.AreEqual(HttpStatusCode.OK, sprocResponse.StatusCode);
string stringResponse = sprocResponse.Resource;
Assert.IsNotNull(stringResponse);
Assert.AreEqual("one", stringResponse);
CosmosItemResponse <string> sprocResponse2 = await storedProcedure.ExecuteAsync <string, string>(testPartitionId, "one");
Assert.AreEqual(HttpStatusCode.OK, sprocResponse2.StatusCode);
string stringResponse2 = sprocResponse2.Resource;
Assert.IsNotNull(stringResponse2);
Assert.AreEqual("one", stringResponse2);
storedProcedureResponse = await storedProcedureResponse.StoredProcedure.DeleteAsync();
Assert.AreEqual(HttpStatusCode.NoContent, storedProcedureResponse.StatusCode);
}
public async Task ExecuteTest()
{
string sprocId = Guid.NewGuid().ToString();
string sprocBody = @"function() {
var context = getContext();
var response = context.getResponse();
var collection = context.getCollection();
var collectionLink = collection.getSelfLink();
var filterQuery = 'SELECT * FROM c';
collection.queryDocuments(collectionLink, filterQuery, { },
function(err, documents) {
response.setBody(documents);
}
);
}";
CosmosStoredProcedureResponse storedProcedureResponse =
await this.container.StoredProcedures.CreateStoredProceducreAsync(sprocId, sprocBody);
Assert.AreEqual(HttpStatusCode.Created, storedProcedureResponse.StatusCode);
StoredProcedureTests.ValidateStoredProcedureSettings(sprocId, sprocBody, storedProcedureResponse);
// Insert document and then query
string testPartitionId = Guid.NewGuid().ToString();
var payload = new { id = testPartitionId, user = testPartitionId };
CosmosItemResponse <dynamic> createItemResponse = await this.container.Items.CreateItemAsync <dynamic>(testPartitionId, payload);
Assert.AreEqual(HttpStatusCode.Created, createItemResponse.StatusCode);
CosmosStoredProcedure storedProcedure = storedProcedureResponse;
CosmosItemResponse <JArray> sprocResponse = await storedProcedure.ExecuteAsync <object, JArray>(testPartitionId, null);
Assert.AreEqual(HttpStatusCode.OK, sprocResponse.StatusCode);
JArray jArray = sprocResponse;
Assert.AreEqual(1, jArray.Count);
storedProcedureResponse = await storedProcedureResponse.StoredProcedure.DeleteAsync();
Assert.AreEqual(HttpStatusCode.NoContent, storedProcedureResponse.StatusCode);
}
public async Task SprocContractTest()
{
string sprocId = Guid.NewGuid().ToString();
string sprocBody = "function() { { var x = 42; } }";
CosmosStoredProcedureResponse storedProcedureResponse =
await this.container.StoredProcedures.CreateStoredProcedureAsync(sprocId, sprocBody);
Assert.AreEqual(HttpStatusCode.Created, storedProcedureResponse.StatusCode);
Assert.IsTrue(storedProcedureResponse.RequestCharge > 0);
CosmosStoredProcedureSettings sprocSettings = storedProcedureResponse;
Assert.AreEqual(sprocId, sprocSettings.Id);
Assert.IsNotNull(sprocSettings.ResourceId);
Assert.IsNotNull(sprocSettings.ETag);
Assert.IsTrue(sprocSettings.LastModified.HasValue);
Assert.IsTrue(sprocSettings.LastModified.Value > new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc), sprocSettings.LastModified.Value.ToString());
}
public async Task CRUDTest()
{
string sprocId = Guid.NewGuid().ToString();
string sprocBody = "function() { { var x = 42; } }";
CosmosStoredProcedureResponse storedProcedureResponse =
await this.container.StoredProcedures.CreateStoredProceducreAsync(sprocId, sprocBody);
double requestCharge = storedProcedureResponse.RequestCharge;
Assert.IsTrue(requestCharge > 0);
Assert.AreEqual(HttpStatusCode.Created, storedProcedureResponse.StatusCode);
StoredProcedureTests.ValidateStoredProcedureSettings(sprocId, sprocBody, storedProcedureResponse);
storedProcedureResponse = await storedProcedureResponse.StoredProcedure.ReadAsync();
requestCharge = storedProcedureResponse.RequestCharge;
Assert.IsTrue(requestCharge > 0);
Assert.AreEqual(HttpStatusCode.OK, storedProcedureResponse.StatusCode);
StoredProcedureTests.ValidateStoredProcedureSettings(sprocId, sprocBody, storedProcedureResponse);
string updatedBody = @"function(name) { var context = getContext();
var response = context.getResponse();
response.setBody(""hello there "" + name);
}";
CosmosStoredProcedureResponse replaceResponse = await storedProcedureResponse.StoredProcedure.ReplaceAsync(updatedBody);
StoredProcedureTests.ValidateStoredProcedureSettings(sprocId, updatedBody, replaceResponse);
requestCharge = replaceResponse.RequestCharge;
Assert.IsTrue(requestCharge > 0);
Assert.AreEqual(HttpStatusCode.OK, replaceResponse.StatusCode);
StoredProcedureTests.ValidateStoredProcedureSettings(sprocId, updatedBody, replaceResponse);
storedProcedureResponse = await replaceResponse.StoredProcedure.DeleteAsync();
requestCharge = storedProcedureResponse.RequestCharge;
Assert.IsTrue(requestCharge > 0);
Assert.AreEqual(HttpStatusCode.NoContent, storedProcedureResponse.StatusCode);
}
public async Task ImplicitConversionTest()
{
string sprocId = Guid.NewGuid().ToString();
string sprocBody = "function() { { var x = 42; } }";
CosmosStoredProcedureResponse storedProcedureResponse =
await this.container.StoredProcedures.CreateStoredProceducreAsync(sprocId, sprocBody);
CosmosStoredProcedure cosmosStoredProcedure = storedProcedureResponse;
CosmosStoredProcedureSettings cosmosStoredProcedureSettings = storedProcedureResponse;
Assert.AreEqual(HttpStatusCode.Created, storedProcedureResponse.StatusCode);
Assert.IsNotNull(cosmosStoredProcedure);
Assert.IsNotNull(cosmosStoredProcedureSettings);
storedProcedureResponse = await storedProcedureResponse.StoredProcedure.DeleteAsync();
cosmosStoredProcedure = storedProcedureResponse;
cosmosStoredProcedureSettings = storedProcedureResponse;
Assert.IsNotNull(cosmosStoredProcedure);
Assert.IsNull(cosmosStoredProcedureSettings);
}
private void ValidateStoredProcedureSettings(CosmosStoredProcedureSettings storedProcedureSettings, CosmosStoredProcedureResponse cosmosResponse)
{
CosmosStoredProcedureSettings settings = cosmosResponse.Resource;
Assert.AreEqual(storedProcedureSettings.Body, settings.Body,
"Stored Procedure functions do not match");
Assert.AreEqual(storedProcedureSettings.Id, settings.Id,
"Stored Procedure id do not match");
Assert.IsTrue(cosmosResponse.RequestCharge > 0);
Assert.IsNotNull(cosmosResponse.MaxResourceQuota);
Assert.IsNotNull(cosmosResponse.CurrentResourceQuotaUsage);
}
public async Task TestReducePageSizeScenario()
{
int partitionKey = 0;
// Create some docs to make sure that one separate response is returned for 1st execute of query before retries.
// These are to make sure continuation token is passed along during retries.
string sprocId = "createTwoDocs";
string sprocBody = @"function(startIndex) { for (var i = 0; i < 2; ++i) __.createDocument(
__.getSelfLink(),
{ id: 'doc' + (i + startIndex).toString(), value: 'y'.repeat(1500000), pk:0 },
err => { if (err) throw err;}
);}";
CosmosStoredProcedureResponse storedProcedureResponse =
await this.Container.StoredProcedures.CreateStoredProcedureAsync(sprocId, sprocBody);
ManualResetEvent allDocsProcessed = new ManualResetEvent(false);
int processedDocCount = 0;
string accumulator = string.Empty;
ChangeFeedProcessor processor = this.Container.Items
.CreateChangeFeedProcessorBuilder("test", (IReadOnlyList <dynamic> docs, CancellationToken token) =>
{
processedDocCount += docs.Count;
foreach (var doc in docs)
{
accumulator += doc.id.ToString() + ".";
}
if (processedDocCount == 6)
{
allDocsProcessed.Set();
}
return(Task.CompletedTask);
})
.WithInstanceName("random")
.WithCosmosLeaseContainer(this.LeaseContainer).Build();
// Start the processor, insert 1 document to generate a checkpoint
await processor.StartAsync();
await Task.Delay(BaseChangeFeedClientHelper.ChangeFeedSetupTime);
await this.Container.Items.CreateItemAsync(partitionKey, new { id = "doc10", pk = 0 });
await Task.Delay(BaseChangeFeedClientHelper.ChangeFeedCleanupTime);
await processor.StopAsync();
// Generate the payload
await storedProcedureResponse.StoredProcedure.ExecuteAsync <int, object>(partitionKey, 0);
// Create 3 docs each 1.5MB. All 3 do not fit into MAX_RESPONSE_SIZE (4 MB). 2nd and 3rd are in same transaction.
var content = string.Format("{{\"id\": \"doc2\", \"value\": \"{0}\", \"pk\": 0}}", new string('x', 1500000));
await this.Container.Items.CreateItemAsync(partitionKey, JsonConvert.DeserializeObject <dynamic>(content));
await storedProcedureResponse.StoredProcedure.ExecuteAsync <int, object>(partitionKey, 3);
await processor.StartAsync();
// Letting processor initialize and pickup changes
var isStartOk = allDocsProcessed.WaitOne(10 * BaseChangeFeedClientHelper.ChangeFeedSetupTime);
await processor.StopAsync();
Assert.IsTrue(isStartOk, "Timed out waiting for docs to process");
Assert.AreEqual("doc10.doc0.doc1.doc2.doc3.doc4.", accumulator);
}
