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));