public async Task ExecutionLogsAsStreamTests()
{
const string testLogsText = "this is a test";
const string testPartitionId = "1";
string sprocId = Guid.NewGuid().ToString();
string sprocBody = @"function(name) { var context = getContext(); console.log('" + testLogsText + "'); var response = context.getResponse(); response.setBody('hello there ' + name); }";
StoredProcedureResponse storedProcedureResponse =
await this.scripts.CreateStoredProcedureAsync(new CosmosStoredProcedureProperties(sprocId, sprocBody));
double requestCharge = storedProcedureResponse.RequestCharge;
Assert.IsTrue(requestCharge > 0);
Assert.AreEqual(HttpStatusCode.Created, storedProcedureResponse.StatusCode);
StoredProcedureTests.ValidateStoredProcedureSettings(sprocId, sprocBody, storedProcedureResponse);
CosmosStoredProcedureProperties storedProcedure = storedProcedureResponse;
CosmosResponseMessage sprocResponse = await this.scripts.ExecuteStoredProcedureStreamAsync(
new Cosmos.PartitionKey(testPartitionId),
sprocId,
cosmosJsonSerializer.ToStream(new string[] { Guid.NewGuid().ToString() }),
new StoredProcedureRequestOptions()
{
EnableScriptLogging = true
});
Assert.AreEqual(HttpStatusCode.OK, sprocResponse.StatusCode);
Assert.AreEqual(testLogsText, Uri.UnescapeDataString(sprocResponse.Headers["x-ms-documentdb-script-log-results"]));
}
public async Task ExecutionLogsTests()
{
const string testLogsText = "this is a test";
const string testPartitionId = "1";
string sprocId = Guid.NewGuid().ToString();
string sprocBody = @"function(name) { var context = getContext(); console.log('" + testLogsText + "'); var response = context.getResponse(); response.setBody('hello there ' + name); }";
StoredProcedureResponse storedProcedureResponse =
await this.scripts.CreateStoredProcedureAsync(new CosmosStoredProcedureProperties(sprocId, sprocBody));
double requestCharge = storedProcedureResponse.RequestCharge;
Assert.IsTrue(requestCharge > 0);
Assert.AreEqual(HttpStatusCode.Created, storedProcedureResponse.StatusCode);
StoredProcedureTests.ValidateStoredProcedureSettings(sprocId, sprocBody, storedProcedureResponse);
CosmosStoredProcedureProperties storedProcedure = storedProcedureResponse;
StoredProcedureExecuteResponse <string> sprocResponse = await this.scripts.ExecuteStoredProcedureAsync <string, string>(
new Cosmos.PartitionKey(testPartitionId),
sprocId,
Guid.NewGuid().ToString(),
new StoredProcedureRequestOptions()
{
EnableScriptLogging = true
});
Assert.AreEqual(HttpStatusCode.OK, sprocResponse.StatusCode);
Assert.AreEqual(testLogsText, sprocResponse.ScriptLog);
}
public void StoredProcedureDeserialzieTest()
{
string colId = "946ad017-14d9-4cee-8619-0cbc62414157";
string rid = "vu9cAA==";
string self = "dbs\\/vu9cAA==\\/cols\\/abc==\\/sprocs\\/def==\\/";
string etag = "00000000-0000-0000-f8ea-31d6e5f701d4";
double ts = 1555923784;
DateTime UnixStartTime = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
DateTime expected = UnixStartTime.AddSeconds(ts);
string testPyaload = "{\"id\":\"" + colId
+ "\",\"_rid\":\"" + rid
+ "\",\"_self\":\"" + self
+ "\",\"_etag\":\"" + etag
+ "\",\"_colls\":\"colls\\/\",\"_users\":\"users\\/\",\"_ts\":" + ts + "}";
CosmosStoredProcedureProperties deserializedPayload =
JsonConvert.DeserializeObject <CosmosStoredProcedureProperties>(testPyaload);
Assert.IsTrue(deserializedPayload.LastModified.HasValue);
Assert.AreEqual(expected, deserializedPayload.LastModified.Value);
Assert.AreEqual(colId, deserializedPayload.Id);
Assert.AreEqual(rid, deserializedPayload.ResourceId);
Assert.AreEqual(etag, deserializedPayload.ETag);
}
private static void ValidateStoredProcedureSettings(string id, string body, StoredProcedureResponse cosmosResponse)
{
CosmosStoredProcedureProperties 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");
}
internal Task <StoredProcedureResponse> CreateStoredProcedureResponseAsync(Task <CosmosResponseMessage> cosmosResponseMessageTask)
{
return(this.ProcessMessageAsync(cosmosResponseMessageTask, (cosmosResponseMessage) =>
{
CosmosStoredProcedureProperties cosmosStoredProcedure = this.ToObjectInternal <CosmosStoredProcedureProperties>(cosmosResponseMessage, this.settingsSerializer);
return new StoredProcedureResponse(
cosmosResponseMessage.StatusCode,
cosmosResponseMessage.Headers,
cosmosStoredProcedure);
}));
}
public void StoredProecdureSettingsDefaults()
{
CosmosStoredProcedureProperties dbSettings = new CosmosStoredProcedureProperties();
Assert.IsNull(dbSettings.LastModified);
Assert.IsNull(dbSettings.ResourceId);
Assert.IsNull(dbSettings.Id);
Assert.IsNull(dbSettings.ETag);
SettingsContractTests.TypeAccessorGuard(typeof(CosmosStoredProcedureProperties), "Id", "Body");
}
public override Task <StoredProcedureResponse> ReplaceStoredProcedureAsync(
CosmosStoredProcedureProperties storedProcedureSettings,
RequestOptions requestOptions = null,
CancellationToken cancellationToken = default(CancellationToken))
{
return(this.ProcessStoredProcedureOperationAsync(
id: storedProcedureSettings.Id,
operationType: OperationType.Replace,
streamPayload: CosmosResource.ToStream(storedProcedureSettings),
requestOptions: requestOptions,
cancellationToken: cancellationToken));
}
public override Task <StoredProcedureResponse> CreateStoredProcedureAsync(
CosmosStoredProcedureProperties storedProcedureSettings,
RequestOptions requestOptions = null,
CancellationToken cancellationToken = default(CancellationToken))
{
return(this.ProcessStoredProcedureOperationAsync(
linkUri: this.container.LinkUri,
operationType: OperationType.Create,
streamPayload: CosmosResource.ToStream(storedProcedureSettings),
requestOptions: requestOptions,
cancellationToken: cancellationToken));
}
private void ValidateStoredProcedureSettings(CosmosStoredProcedureProperties storedProcedureSettings, StoredProcedureResponse cosmosResponse)
{
CosmosStoredProcedureProperties 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 ExecuteTestAsStream()
{
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);
}
);
}";
StoredProcedureResponse storedProcedureResponse =
await this.scripts.CreateStoredProcedureAsync(new CosmosStoredProcedureProperties(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 };
ItemResponse <dynamic> createItemResponse = await this.container.CreateItemAsync <dynamic>(payload);
Assert.AreEqual(HttpStatusCode.Created, createItemResponse.StatusCode);
CosmosStoredProcedureProperties storedProcedure = storedProcedureResponse;
CosmosResponseMessage sprocResponse = await this.scripts.ExecuteStoredProcedureStreamAsync(new Cosmos.PartitionKey(testPartitionId), sprocId, null);
Assert.AreEqual(HttpStatusCode.OK, sprocResponse.StatusCode);
using (StreamReader sr = new System.IO.StreamReader(sprocResponse.Content))
{
string stringResponse = sr.ReadToEnd();
JArray jArray = JArray.Parse(stringResponse);
Assert.AreEqual(1, jArray.Count);
}
StoredProcedureResponse deleteResponse = await this.scripts.DeleteStoredProcedureAsync(sprocId);
Assert.AreEqual(HttpStatusCode.NoContent, deleteResponse.StatusCode);
}
public async Task ImplicitConversionTest()
{
string sprocId = Guid.NewGuid().ToString();
string sprocBody = "function() { { var x = 42; } }";
StoredProcedureResponse storedProcedureResponse =
await this.scripts.CreateStoredProcedureAsync(new CosmosStoredProcedureProperties(sprocId, sprocBody));
CosmosStoredProcedureProperties cosmosStoredProcedure = storedProcedureResponse;
CosmosStoredProcedureProperties cosmosStoredProcedureSettings = storedProcedureResponse;
Assert.AreEqual(HttpStatusCode.Created, storedProcedureResponse.StatusCode);
Assert.IsNotNull(cosmosStoredProcedure);
Assert.IsNotNull(cosmosStoredProcedureSettings);
StoredProcedureResponse deleteResponse = await this.scripts.DeleteStoredProcedureAsync(sprocId);
Assert.AreEqual(HttpStatusCode.NoContent, deleteResponse.StatusCode);
}
public async Task SprocContractTest()
{
string sprocId = Guid.NewGuid().ToString();
string sprocBody = "function() { { var x = 42; } }";
StoredProcedureResponse storedProcedureResponse =
await this.scripts.CreateStoredProcedureAsync(new CosmosStoredProcedureProperties(sprocId, sprocBody));
Assert.AreEqual(HttpStatusCode.Created, storedProcedureResponse.StatusCode);
Assert.IsTrue(storedProcedureResponse.RequestCharge > 0);
CosmosStoredProcedureProperties 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 ValidateResponseFactoryJsonSerializer()
{
CosmosResponseMessage databaseResponse = this.CreateResponse();
CosmosResponseMessage containerResponse = this.CreateResponse();
CosmosResponseMessage storedProcedureExecuteResponse = this.CreateResponse();
CosmosResponseMessage storedProcedureResponse = this.CreateResponse();
CosmosResponseMessage triggerResponse = this.CreateResponse();
CosmosResponseMessage udfResponse = this.CreateResponse();
CosmosResponseMessage itemResponse = this.CreateResponse();
CosmosResponseMessage feedResponse = this.CreateResponse();
Mock <CosmosJsonSerializer> mockUserJsonSerializer = new Mock <CosmosJsonSerializer>();
Mock <CosmosJsonSerializer> mockDefaultJsonSerializer = new Mock <CosmosJsonSerializer>();
CosmosResponseFactory cosmosResponseFactory = new CosmosResponseFactory(
defaultJsonSerializer: mockDefaultJsonSerializer.Object,
userJsonSerializer: mockUserJsonSerializer.Object);
// Test the user specified response
mockUserJsonSerializer.Setup(x => x.FromStream <ToDoActivity>(itemResponse.Content)).Returns(new ToDoActivity());
mockUserJsonSerializer.Setup(x => x.FromStream <ToDoActivity>(storedProcedureExecuteResponse.Content)).Returns(new ToDoActivity());
mockUserJsonSerializer.Setup(x => x.FromStream <CosmosFeedResponseUtil <ToDoActivity> >(feedResponse.Content)).Returns(new CosmosFeedResponseUtil <ToDoActivity>()
{
Data = new Collection <ToDoActivity>()
});
// Verify all the user types use the user specified version
await cosmosResponseFactory.CreateItemResponseAsync <ToDoActivity>(Task.FromResult(itemResponse));
await cosmosResponseFactory.CreateStoredProcedureExecuteResponseAsync <ToDoActivity>(Task.FromResult(storedProcedureExecuteResponse));
cosmosResponseFactory.CreateResultSetQueryResponse <ToDoActivity>(feedResponse);
// Throw if the setups were not called
mockUserJsonSerializer.VerifyAll();
// Test the system specified response
CosmosContainerProperties containerSettings = new CosmosContainerProperties("mockId", "/pk");
CosmosDatabaseProperties databaseSettings = new CosmosDatabaseProperties()
{
Id = "mock"
};
CosmosStoredProcedureProperties cosmosStoredProcedureSettings = new CosmosStoredProcedureProperties()
{
Id = "mock"
};
CosmosTriggerProperties cosmosTriggerSettings = new CosmosTriggerProperties()
{
Id = "mock"
};
CosmosUserDefinedFunctionProperties cosmosUserDefinedFunctionSettings = new CosmosUserDefinedFunctionProperties()
{
Id = "mock"
};
mockDefaultJsonSerializer.Setup(x => x.FromStream <CosmosDatabaseProperties>(databaseResponse.Content)).Returns(databaseSettings);
mockDefaultJsonSerializer.Setup(x => x.FromStream <CosmosContainerProperties>(containerResponse.Content)).Returns(containerSettings);
mockDefaultJsonSerializer.Setup(x => x.FromStream <CosmosStoredProcedureProperties>(storedProcedureResponse.Content)).Returns(cosmosStoredProcedureSettings);
mockDefaultJsonSerializer.Setup(x => x.FromStream <CosmosTriggerProperties>(triggerResponse.Content)).Returns(cosmosTriggerSettings);
mockDefaultJsonSerializer.Setup(x => x.FromStream <CosmosUserDefinedFunctionProperties>(udfResponse.Content)).Returns(cosmosUserDefinedFunctionSettings);
Mock <CosmosContainer> mockContainer = new Mock <CosmosContainer>();
Mock <CosmosDatabase> mockDatabase = new Mock <CosmosDatabase>();
// Verify all the system types that should always use default
await cosmosResponseFactory.CreateContainerResponseAsync(mockContainer.Object, Task.FromResult(containerResponse));
await cosmosResponseFactory.CreateDatabaseResponseAsync(mockDatabase.Object, Task.FromResult(databaseResponse));
await cosmosResponseFactory.CreateStoredProcedureResponseAsync(Task.FromResult(storedProcedureResponse));
await cosmosResponseFactory.CreateTriggerResponseAsync(Task.FromResult(triggerResponse));
await cosmosResponseFactory.CreateUserDefinedFunctionResponseAsync(Task.FromResult(udfResponse));
// Throw if the setups were not called
mockDefaultJsonSerializer.VerifyAll();
}
/// <summary>
/// Creates a stored procedure as an asynchronous operation in the Azure Cosmos DB service.
/// </summary>
/// <param name="storedProcedureSettings">The Stored Procedure to create</param>
/// <param name="requestOptions">(Optional) The options for the stored procedure request <see cref="RequestOptions"/></param>
/// <param name="cancellationToken">(Optional) <see cref="CancellationToken"/> representing request cancellation.</param>
/// <returns>The <see cref="CosmosStoredProcedureProperties"/> that was created contained within a <see cref="Task"/> object representing the service response for the asynchronous operation.</returns>
/// <exception cref="ArgumentNullException">If <paramref name="storedProcedureSettings"/> is not set.</exception>
/// <exception cref="System.AggregateException">Represents a consolidation of failures that occurred during async processing. Look within InnerExceptions to find the actual exception(s)</exception>
/// <exception cref="CosmosException">This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:
/// <list type="table">
/// <listheader>
/// <term>StatusCode</term><description>Reason for exception</description>
/// </listheader>
/// <item>
/// <term>400</term><description>BadRequest - This means something was wrong with the request supplied. It is likely that an Id was not supplied for the stored procedure or the Body was malformed.</description>
/// </item>
/// <item>
/// <term>403</term><description>Forbidden - You have reached your quota of stored procedures for the collection supplied. Contact support to have this quota increased.</description>
/// </item>
/// <item>
/// <term>409</term><description>Conflict - This means a <see cref="CosmosStoredProcedureProperties"/> with an id matching the id you supplied already existed.</description>
/// </item>
/// <item>
/// <term>413</term><description>RequestEntityTooLarge - This means the body of the <see cref="CosmosStoredProcedureProperties"/> you tried to create was too large.</description>
/// </item>
/// </list>
/// </exception>
/// <example>
/// This creates and executes a stored procedure that appends a string to the first item returned from the query.
/// <code language="c#">
/// <![CDATA[
/// string sprocBody = @"function simple(prefix)
/// {
/// var collection = getContext().getCollection();
///
/// // Query documents and take 1st item.
/// var isAccepted = collection.queryDocuments(
/// collection.getSelfLink(),
/// 'SELECT * FROM root r',
/// function(err, feed, options) {
/// if (err)throw err;
///
/// // Check the feed and if it's empty, set the body to 'no docs found',
/// // Otherwise just take 1st element from the feed.
/// if (!feed || !feed.length) getContext().getResponse().setBody(""no docs found"");
/// else getContext().getResponse().setBody(prefix + JSON.stringify(feed[0]));
/// });
///
/// if (!isAccepted) throw new Error(""The query wasn't accepted by the server. Try again/use continuation token between API and script."");
/// }";
///
/// CosmosScripts scripts = this.container.GetScripts();
/// CosmosStoredProcedureSettings storedProcedure = new CosmosStoredProcedureSettings(id, sprocBody);
/// CosmosStoredProcedure cosmosStoredProcedure = await scripts.CreateStoredProcedureAsync(storedProcedure);
///
/// // Execute the stored procedure
/// CosmosItemResponse<string> sprocResponse = await scripts.ExecuteStoredProcedureAsync<string, string>(testPartitionId, "appendString", "Item as a string: ");
/// Console.WriteLine("sprocResponse.Resource");
/// ]]>
/// </code>
/// </example>
public abstract Task <StoredProcedureResponse> CreateStoredProcedureAsync(
CosmosStoredProcedureProperties storedProcedureSettings,
RequestOptions requestOptions = null,
CancellationToken cancellationToken = default(CancellationToken));
