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