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 StoredProcedureProperties(sprocId, sprocBody)); double requestCharge = storedProcedureResponse.RequestCharge; Assert.IsTrue(requestCharge > 0); Assert.AreEqual(HttpStatusCode.Created, storedProcedureResponse.StatusCode); StoredProcedureTests.ValidateStoredProcedureSettings(sprocId, sprocBody, storedProcedureResponse); StoredProcedureProperties storedProcedure = storedProcedureResponse; ResponseMessage sprocResponse = await this.scripts.ExecuteStoredProcedureStreamAsync( sprocId, new Cosmos.PartitionKey(testPartitionId), new dynamic[] { 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 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 + "}"; StoredProcedureProperties deserializedPayload = JsonConvert.DeserializeObject <StoredProcedureProperties>(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); }
public async Task RegisterStoredProcedures() { string[] sources = { "util", "replicache", "mutators" }; string utilSource = ""; foreach (var source in sources) { var path = $"js/{source}.js"; utilSource += $"\n// {path}\n{File.ReadAllText(path)}"; } string[] ids = { "spProcessMutation", "spGetMutationID" }; foreach (string id in ids) { var props = new StoredProcedureProperties { Id = id, Body = File.ReadAllText($"js/{id}.js") + "\n" + utilSource, }; try { await Items.Scripts.ReplaceStoredProcedureAsync(props); } catch (CosmosException ex) { if (ex.Status == 404) { await Items.Scripts.CreateStoredProcedureAsync(props); } else { throw; } } } }
private static CosmosStoredProcedure MakeScript(StoredProcedureProperties props) => new CosmosStoredProcedure { Id = props.Id, Body = props.Body, ETag = props.ETag };
public async Task SC00_MigrateDB() { CosmosClient client = new CosmosClient(EndpointUrl, AuthorizationKey); await client.CreateDatabaseIfNotExistsAsync(DatabaseId, ThroughputProperties.CreateManualThroughput(400)); Database database = client.GetDatabase(DatabaseId); await database.DefineContainer("events", "/stream/id").CreateIfNotExistsAsync(); await database.DefineContainer("leases", "/id").CreateIfNotExistsAsync(); await database.DefineContainer("views", "/id").CreateIfNotExistsAsync(); await database.DefineContainer("snapshots", "/id").CreateIfNotExistsAsync(); StoredProcedureProperties storedProcedureProperties = new StoredProcedureProperties { Id = "spAppendToStream", Body = File.ReadAllText("js/spAppendToStream.js") }; Container eventsContainer = database.GetContainer("events"); try { await eventsContainer.Scripts.DeleteStoredProcedureAsync("spAppendToStream"); } catch (CosmosException ex) when(ex.StatusCode == HttpStatusCode.NotFound) { // Stored procedure didn't exist yet. } await eventsContainer.Scripts.CreateStoredProcedureAsync(storedProcedureProperties); }
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 StoredProcedureProperties(sprocId, sprocBody)); double requestCharge = storedProcedureResponse.RequestCharge; Assert.IsTrue(requestCharge > 0); Assert.AreEqual(HttpStatusCode.Created, storedProcedureResponse.StatusCode); StoredProcedureTests.ValidateStoredProcedureSettings(sprocId, sprocBody, storedProcedureResponse); StoredProcedureProperties 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); }
private static void ValidateStoredProcedureSettings(string id, string body, StoredProcedureResponse cosmosResponse) { StoredProcedureProperties 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 void StoredProecdureSettingsDefaults() { StoredProcedureProperties dbSettings = new StoredProcedureProperties(); Assert.IsNull(dbSettings.LastModified); Assert.IsNull(dbSettings.ResourceId); Assert.IsNull(dbSettings.Id); Assert.IsNull(dbSettings.ETag); SettingsContractTests.TypeAccessorGuard(typeof(StoredProcedureProperties), "Id", "Body"); }
public async Task ExecuteNonePkTest() { // Create a container in v2 without a partition key string containerId = "SprocPkNone" + Guid.NewGuid().ToString(); ContainerInternal containerNonePk = await NonPartitionedContainerHelper.CreateNonPartitionedContainer(this.database, containerId); Scripts scriptsNonePk = containerNonePk.Scripts; 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 scriptsNonePk.CreateStoredProcedureAsync(new StoredProcedureProperties(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 containerNonePk.CreateItemAsync <dynamic>(payload); Assert.AreEqual(HttpStatusCode.Created, createItemResponse.StatusCode); StoredProcedureProperties storedProcedure = storedProcedureResponse; StoredProcedureExecuteResponse <JArray> sprocResponse = await scriptsNonePk.ExecuteStoredProcedureAsync <JArray>( sprocId, Cosmos.PartitionKey.None, parameters : null); Assert.AreEqual(HttpStatusCode.OK, sprocResponse.StatusCode); JArray jArray = sprocResponse; Assert.AreEqual(1, jArray.Count); Assert.AreEqual(testPartitionId, jArray[0]["id"]); StoredProcedureResponse deleteResponse = await scriptsNonePk.DeleteStoredProcedureAsync(sprocId); Assert.AreEqual(HttpStatusCode.NoContent, deleteResponse.StatusCode); }
private void ValidateStoredProcedureSettings(StoredProcedureProperties storedProcedureSettings, StoredProcedureResponse cosmosResponse) { StoredProcedureProperties 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.Headers.GetHeaderValue<string>(Documents.HttpConstants.HttpHeaders.MaxResourceQuota)); Assert.IsNotNull(cosmosResponse.Headers.GetHeaderValue<string>(Documents.HttpConstants.HttpHeaders.CurrentResourceQuotaUsage)); }
internal Task <StoredProcedureResponse> CreateStoredProcedureResponseAsync(Task <ResponseMessage> cosmosResponseMessageTask) { return(this.ProcessMessageAsync(cosmosResponseMessageTask, (cosmosResponseMessage) => { StoredProcedureProperties cosmosStoredProcedure = this.ToObjectInternal <StoredProcedureProperties>(cosmosResponseMessage, this.propertiesSerializer); return new StoredProcedureResponse( cosmosResponseMessage.StatusCode, cosmosResponseMessage.Headers, cosmosStoredProcedure); })); }
public override StoredProcedureResponse CreateStoredProcedureResponse(ResponseMessage responseMessage) { return(this.ProcessMessage(responseMessage, (cosmosResponseMessage) => { StoredProcedureProperties cosmosStoredProcedure = this.ToObjectpublic <StoredProcedureProperties>(cosmosResponseMessage); return new StoredProcedureResponse( cosmosResponseMessage.StatusCode, cosmosResponseMessage.Headers, cosmosStoredProcedure, cosmosResponseMessage.Diagnostics); })); }
private void ValidateStoredProcedureSettings(StoredProcedureProperties storedProcedureSettings, StoredProcedureResponse cosmosResponse) { StoredProcedureProperties 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 ScriptsStoredProcedureTest(bool directMode) { CosmosClient client = directMode ? DirectCosmosClient : GatewayCosmosClient; Database database = client.GetDatabase(DatabaseId); Container container = await database.CreateContainerAsync(Guid.NewGuid().ToString(), "/pk"); Scripts scripts = container.Scripts; List <string> createdIds = new List <string>() { "BasicQuerySp1", "BasicQuerySp2", "BasicQuerySp3" }; //Basic query List <StoredProcedureProperties> queryResults = await this.ToListAsync( scripts.GetStoredProcedureQueryStreamIterator, scripts.GetStoredProcedureQueryIterator <StoredProcedureProperties>, "select * from T where STARTSWITH(T.id, \"BasicQuerySp\")", CosmosBasicQueryTests.RequestOptions); if (queryResults.Count < 3) { foreach (string id in createdIds) { StoredProcedureProperties properties = await scripts.CreateStoredProcedureAsync(new StoredProcedureProperties() { Id = id, Body = "function() {var x = 10;}" }); } queryResults = await this.ToListAsync( scripts.GetStoredProcedureQueryStreamIterator, scripts.GetStoredProcedureQueryIterator <StoredProcedureProperties>, "select * from T where STARTSWITH(T.id, \"BasicQuerySp\")", CosmosBasicQueryTests.RequestOptions); } CollectionAssert.AreEquivalent(createdIds, queryResults.Select(x => x.Id).ToList()); //Read All List <StoredProcedureProperties> results = await this.ToListAsync( scripts.GetStoredProcedureQueryStreamIterator, scripts.GetStoredProcedureQueryIterator <StoredProcedureProperties>, null, CosmosBasicQueryTests.RequestOptions); CollectionAssert.IsSubsetOf(createdIds, results.Select(x => x.Id).ToList()); }
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 StoredProcedureProperties(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); StoredProcedureProperties storedProcedure = storedProcedureResponse; ResponseMessage sprocResponse = await this.scripts.ExecuteStoredProcedureStreamAsync( sprocId, new Cosmos.PartitionKey(testPartitionId), 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); }
private async static Task CreateStoredProcedure(string sprocId) { var sprocBody = File.ReadAllText($@"Server\{sprocId}.js"); var sprocProps = new StoredProcedureProperties { Id = sprocId, Body = sprocBody }; var container = Shared.Client.GetContainer("mydb", "mystore"); var result = await container.Scripts.CreateStoredProcedureAsync(sprocProps); Console.WriteLine($"Created stored procedure {sprocId} ({result.RequestCharge} RUs);"); }
public async Task ImplicitConversionTest() { string sprocId = Guid.NewGuid().ToString(); string sprocBody = "function() { { var x = 42; } }"; StoredProcedureResponse storedProcedureResponse = await this.scripts.CreateStoredProcedureAsync(new StoredProcedureProperties(sprocId, sprocBody)); StoredProcedureProperties cosmosStoredProcedure = storedProcedureResponse; StoredProcedureProperties 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 StoredProcedureProperties(sprocId, sprocBody)); Assert.AreEqual(HttpStatusCode.Created, storedProcedureResponse.StatusCode); Assert.IsTrue(storedProcedureResponse.RequestCharge > 0); StoredProcedureProperties 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()); }
private async Task AddStoredProc(Database database, string containerId) { StoredProcedureProperties storedProcedureProperties = new StoredProcedureProperties { Id = "spAppendToStream", Body = File.ReadAllText("js/spAppendToStream.js") }; Container eventsContainer = database.GetContainer(containerId); try { await eventsContainer.Scripts.DeleteStoredProcedureAsync("spAppendToStream"); } catch (CosmosException ex) when(ex.StatusCode == HttpStatusCode.NotFound) { // Stored procedure didn't exist yet. } await eventsContainer.Scripts.CreateStoredProcedureAsync(storedProcedureProperties); }
public async Task CreateStoredProcedure(string spName) { var spBody = File.ReadAllText($"StoredProcedures/{spName}.js"); Scripts scripts = _container.Scripts; StoredProcedureProperties storedProcedure = new StoredProcedureProperties { Id = spName, Body = spBody }; StoredProcedureResponse storedProcedureResponse = await scripts.CreateStoredProcedureAsync(storedProcedure); var spResult = storedProcedureResponse.Resource; string message = "Create StoredProcedure"; Printer.PrintLine(message: message); WriteLine($"SP Created, Id: {spResult.Id}, \n\tSelfLink: {spResult.SelfLink}"); Printer.PrintLine(noOfTimes: (101 + message.Length)); }
private async Task CreateStoredProcedure(string procedureId, string procedureFileName) { using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(typeof(EventStore), $"StoredProcedures.{procedureFileName}.js")) using (var reader = new StreamReader(stream)) { var properties = new StoredProcedureProperties { Id = procedureId, Body = await reader.ReadToEndAsync() }; try { await this.Container.Scripts.ReadStoredProcedureAsync(procedureId); await this.Container.Scripts.ReplaceStoredProcedureAsync(properties); } catch (CosmosException ex) when(ex.StatusCode == System.Net.HttpStatusCode.NotFound) { await this.Container.Scripts.CreateStoredProcedureAsync(properties); } } }
private async Task CreateStoredProcedure(string procedureId, string procedureFileName, CancellationToken cancellationToken = default) { using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(typeof(EventStore), $"StoredProcedures.{procedureFileName}.js")) using (var reader = new StreamReader(stream)) { var properties = new StoredProcedureProperties { Id = procedureId, Body = await reader.ReadToEndAsync() }; try { await this.RetryPolicy.ExecuteAsync(token => this.Container.Scripts.ReadStoredProcedureAsync(procedureId, cancellationToken: token), cancellationToken, continueOnCapturedContext : true); await this.RetryPolicy.ExecuteAsync(token => this.Container.Scripts.ReplaceStoredProcedureAsync(properties, cancellationToken: token), cancellationToken, continueOnCapturedContext : true); } catch (CosmosException ex) when(ex.StatusCode == System.Net.HttpStatusCode.NotFound) { await this.RetryPolicy.ExecuteAsync(token => this.Container.Scripts.CreateStoredProcedureAsync(properties, cancellationToken: token), cancellationToken, continueOnCapturedContext : true); } } }
private async Task RegisterStoredProcedure(Container container) { var storedProcedureProperties = new StoredProcedureProperties { Id = StoredProcedureId, Body = await File.ReadAllTextAsync($@".\js\{StoredProcedureId}.js") }; try { var storedProcedureResponse = await container .Scripts .CreateStoredProcedureAsync(storedProcedureProperties); var serializedResponse = JsonConvert.SerializeObject(storedProcedureResponse); this.logger.LogInformation(serializedResponse); } catch (CosmosException cosmosException) when(cosmosException.StatusCode == HttpStatusCode.Conflict) { var storedProcedureResponse = await container.Scripts.ReplaceStoredProcedureAsync(storedProcedureProperties); var serializedResponse = JsonConvert.SerializeObject(storedProcedureResponse); this.logger.LogInformation(serializedResponse); } catch (CosmosException cosmosException) { this.logger.LogError(cosmosException.ResponseBody); this.logger.LogError(cosmosException.SubStatusCode.ToString()); this.logger.LogError(cosmosException.Message); } catch (Exception e) { this.logger.LogCritical(e.Message); } }
public async Task ValidateResponseFactoryJsonSerializer() { ResponseMessage databaseResponse = this.CreateResponse(); ResponseMessage containerResponse = this.CreateResponse(); ResponseMessage storedProcedureExecuteResponse = this.CreateResponse(); ResponseMessage storedProcedureResponse = this.CreateResponse(); ResponseMessage triggerResponse = this.CreateResponse(); ResponseMessage udfResponse = this.CreateResponse(); ResponseMessage itemResponse = this.CreateResponse(); ResponseMessage feedResponse = this.CreateResponse(); Mock <CosmosSerializer> mockUserJsonSerializer = new Mock <CosmosSerializer>(); Mock <CosmosSerializer> mockDefaultJsonSerializer = new Mock <CosmosSerializer>(); 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 ContainerProperties containerSettings = new ContainerProperties("mockId", "/pk"); DatabaseProperties databaseSettings = new DatabaseProperties() { Id = "mock" }; StoredProcedureProperties cosmosStoredProcedureSettings = new StoredProcedureProperties() { Id = "mock" }; TriggerProperties cosmosTriggerSettings = new TriggerProperties() { Id = "mock" }; UserDefinedFunctionProperties cosmosUserDefinedFunctionSettings = new UserDefinedFunctionProperties() { Id = "mock" }; mockDefaultJsonSerializer.Setup(x => x.FromStream <DatabaseProperties>(databaseResponse.Content)).Returns(databaseSettings); mockDefaultJsonSerializer.Setup(x => x.FromStream <ContainerProperties>(containerResponse.Content)).Returns(containerSettings); mockDefaultJsonSerializer.Setup(x => x.FromStream <StoredProcedureProperties>(storedProcedureResponse.Content)).Returns(cosmosStoredProcedureSettings); mockDefaultJsonSerializer.Setup(x => x.FromStream <TriggerProperties>(triggerResponse.Content)).Returns(cosmosTriggerSettings); mockDefaultJsonSerializer.Setup(x => x.FromStream <UserDefinedFunctionProperties>(udfResponse.Content)).Returns(cosmosUserDefinedFunctionSettings); Mock <Container> mockContainer = new Mock <Container>(); Mock <Database> mockDatabase = new Mock <Database>(); // 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(); }
public void ValidateResponseFactoryJsonSerializer() { ResponseMessage databaseResponse = this.CreateResponse(); ResponseMessage containerResponse = this.CreateResponse(); ResponseMessage storedProcedureExecuteResponse = this.CreateResponse(); ResponseMessage storedProcedureResponse = this.CreateResponse(); ResponseMessage triggerResponse = this.CreateResponse(); ResponseMessage udfResponse = this.CreateResponse(); ResponseMessage itemResponse = this.CreateResponse(); Mock <CosmosSerializer> mockUserJsonSerializer = new Mock <CosmosSerializer>(); CosmosSerializerCore serializerCore = new CosmosSerializerCore(mockUserJsonSerializer.Object); CosmosResponseFactoryInternal cosmosResponseFactory = new CosmosResponseFactoryCore( serializerCore); // Test the user specified response mockUserJsonSerializer.Setup(x => x.FromStream <ToDoActivity>(itemResponse.Content)).Callback <Stream>(input => input.Dispose()).Returns(new ToDoActivity()); mockUserJsonSerializer.Setup(x => x.FromStream <ToDoActivity>(storedProcedureExecuteResponse.Content)).Callback <Stream>(input => input.Dispose()).Returns(new ToDoActivity()); // Verify all the user types use the user specified version cosmosResponseFactory.CreateItemResponse <ToDoActivity>(itemResponse); cosmosResponseFactory.CreateStoredProcedureExecuteResponse <ToDoActivity>(storedProcedureExecuteResponse); // Throw if the setups were not called mockUserJsonSerializer.VerifyAll(); // Test read feed scenario ResponseMessage readFeedResponse = this.CreateReadFeedResponse(); mockUserJsonSerializer.Setup(x => x.FromStream <ToDoActivity[]>(It.IsAny <Stream>())) .Callback <Stream>(input => input.Dispose()) .Returns(new ToDoActivity[] { new ToDoActivity() }); FeedResponse <ToDoActivity> feedResponse = cosmosResponseFactory.CreateItemFeedResponse <ToDoActivity>(readFeedResponse); foreach (ToDoActivity toDoActivity in feedResponse) { Assert.IsNotNull(toDoActivity); } mockUserJsonSerializer.VerifyAll(); ResponseMessage changeFeedResponseMessage = this.CreateChangeFeedNotModifiedResponse(); FeedResponse <ToDoActivity> changeFeedResponse = cosmosResponseFactory.CreateItemFeedResponse <ToDoActivity>(changeFeedResponseMessage); Assert.AreEqual(HttpStatusCode.NotModified, changeFeedResponse.StatusCode); Assert.IsFalse(changeFeedResponse.Resource.Any()); ResponseMessage queryResponse = this.CreateReadFeedResponse(); mockUserJsonSerializer.Setup(x => x.FromStream <ToDoActivity[]>(It.IsAny <Stream>())).Callback <Stream>(input => input.Dispose()).Returns(new ToDoActivity[] { new ToDoActivity() }); FeedResponse <ToDoActivity> queryFeedResponse = cosmosResponseFactory.CreateItemFeedResponse <ToDoActivity>(queryResponse); foreach (ToDoActivity toDoActivity in queryFeedResponse) { Assert.IsNotNull(toDoActivity); } mockUserJsonSerializer.VerifyAll(); // Test the system specified response ContainerProperties containerSettings = new ContainerProperties("mockId", "/pk"); DatabaseProperties databaseSettings = new DatabaseProperties() { Id = "mock" }; StoredProcedureProperties cosmosStoredProcedureSettings = new StoredProcedureProperties() { Id = "mock" }; TriggerProperties cosmosTriggerSettings = new TriggerProperties() { Id = "mock" }; UserDefinedFunctionProperties cosmosUserDefinedFunctionSettings = new UserDefinedFunctionProperties() { Id = "mock" }; Mock <Container> mockContainer = new Mock <Container>(); Mock <Database> mockDatabase = new Mock <Database>(); // Verify all the system types that should always use default cosmosResponseFactory.CreateContainerResponse(mockContainer.Object, containerResponse); cosmosResponseFactory.CreateDatabaseResponse(mockDatabase.Object, databaseResponse); cosmosResponseFactory.CreateStoredProcedureResponse(storedProcedureResponse); cosmosResponseFactory.CreateTriggerResponse(triggerResponse); cosmosResponseFactory.CreateUserDefinedFunctionResponse(udfResponse); }