public async Task TestStoredProcJsonSerializerSettings()
{
JsonSerializerSettings serializerSettings = new JsonSerializerSettings
{
MissingMemberHandling = MissingMemberHandling.Error,
};
CosmosStoredProcedureSettings storedProcedureDef = new CosmosStoredProcedureSettings();
storedProcedureDef.Id = "testStoredProcJsonSerializerSettings" + Guid.NewGuid().ToString("N");
storedProcedureDef.Body = @"function() {
var docToReturn = {
id: 1
};
__.response.setBody(docToReturn);
}";
DocumentClient client = new DocumentClient(this.hostUri, this.masterKey, serializerSettings);
CosmosStoredProcedureSettings sproc = await client.CreateStoredProcedureAsync(this.collectionUri, storedProcedureDef);
try
{
await client.ExecuteStoredProcedureAsync <SprocTestPayload>(sproc.SelfLink);
Assert.Fail();
}
catch (SerializationException e)
{
Assert.IsTrue(e.Message.Contains("Could not find member 'id' on object of type"));
}
}
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 CosmosStoredProcedureSettings(sprocId, sprocBody));
double requestCharge = storedProcedureResponse.RequestCharge;
Assert.IsTrue(requestCharge > 0);
Assert.AreEqual(HttpStatusCode.Created, storedProcedureResponse.StatusCode);
StoredProcedureTests.ValidateStoredProcedureSettings(sprocId, sprocBody, storedProcedureResponse);
CosmosStoredProcedureSettings 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 + "}";
CosmosStoredProcedureSettings deserializedPayload =
JsonConvert.DeserializeObject <CosmosStoredProcedureSettings>(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 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 CosmosStoredProcedureSettings(sprocId, sprocBody));
double requestCharge = storedProcedureResponse.RequestCharge;
Assert.IsTrue(requestCharge > 0);
Assert.AreEqual(HttpStatusCode.Created, storedProcedureResponse.StatusCode);
StoredProcedureTests.ValidateStoredProcedureSettings(sprocId, sprocBody, storedProcedureResponse);
CosmosStoredProcedureSettings 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"]));
}
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 void StoredProecdureSettingsDefaults()
{
CosmosStoredProcedureSettings dbSettings = new CosmosStoredProcedureSettings();
Assert.IsNull(dbSettings.LastModified);
Assert.IsNull(dbSettings.ResourceId);
Assert.IsNull(dbSettings.Id);
Assert.IsNull(dbSettings.ETag);
SettingsContractTests.TypeAccessorGuard(typeof(CosmosStoredProcedureSettings), "Id", "Body");
}
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);
}
internal static async Task <CosmosStoredProcedureSettings> GetOrCreateStoredProcedureAsync(
DocumentClient client,
CosmosContainerSettings collection,
CosmosStoredProcedureSettings newStoredProcedure)
{
var result = (from proc in client.CreateStoredProcedureQuery(collection)
where proc.Id == newStoredProcedure.Id
select proc).AsEnumerable().FirstOrDefault();
if (result != null)
{
return(result);
}
return(await client.CreateStoredProcedureAsync(collection, newStoredProcedure));
}
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 CosmosStoredProcedureSettings(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);
CosmosStoredProcedureSettings 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 CosmosStoredProcedureSettings(sprocId, sprocBody));
CosmosStoredProcedureSettings cosmosStoredProcedure = storedProcedureResponse;
CosmosStoredProcedureSettings 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 void TestDateParseHandling()
{
const string jsonProperty = "jsonString";
DocumentClient client;
Document originalDocument, createdDocument, partitionedDocument;
JsonSerializerSettings serializerSettings = new JsonSerializerSettings
{
DateParseHandling = DateParseHandling.None
};
SetupDateTimeScenario(serializerSettings, jsonProperty, out client, out originalDocument, out createdDocument, out partitionedDocument);
// Verify with stored procedure
CosmosStoredProcedureSettings storedProcedure = new CosmosStoredProcedureSettings();
storedProcedure.Id = "storeProcedure1";
storedProcedure.Body = @"function ReadAll(prefix) {
var collection = getContext().getCollection();
var responseBody = {
createdDocuments: []
}
// Query documents and take 1st item.
var isAccepted = collection.queryDocuments(
collection.getSelfLink(),
'select * from root r',
function(err, feed, options) {
if (err) throw err;
responseBody.createdDocuments.push(feed[0]);
getContext().getResponse().setBody(responseBody);
});
if (!isAccepted) throw new Error('The query was not accepted by the server.');
} ";
RequestOptions applyRequestOptions = this.ApplyRequestOptions(new RequestOptions(), serializerSettings);
this.AssertPropertyOnStoredProc(client, this.collectionUri, storedProcedure, applyRequestOptions, originalDocument, jsonProperty);
this.AssertPropertyOnStoredProc(client, this.partitionedCollectionUri, storedProcedure, applyRequestOptions, originalDocument, jsonProperty);
}
public async Task SprocContractTest()
{
string sprocId = Guid.NewGuid().ToString();
string sprocBody = "function() { { var x = 42; } }";
StoredProcedureResponse storedProcedureResponse =
await this.scripts.CreateStoredProcedureAsync(new CosmosStoredProcedureSettings(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());
}
private void AssertPropertyOnStoredProc(
DocumentClient client,
Uri targetCollectionUri,
CosmosStoredProcedureSettings storedProcedure,
RequestOptions requestOptions,
Document originalDocument,
string jsonProperty)
{
requestOptions.PartitionKey = targetCollectionUri == this.partitionedCollectionUri ? new PartitionKey(originalDocument.GetPropertyValue <string>(CustomSerializationTests.PartitionKeyProperty)) : null;
CosmosStoredProcedureSettings sproc = client.CreateStoredProcedureAsync(targetCollectionUri, storedProcedure).Result;
var spResult = client.ExecuteStoredProcedureAsync <Document>(sproc.SelfLink, requestOptions)
.Result.Response.GetPropertyValue <IEnumerable <Document> >("createdDocuments");
foreach (Document d in spResult)
{
var playDoc = (PlayDocument)(dynamic)d;
Assert.AreEqual(originalDocument.GetValue <string>(jsonProperty), playDoc.jsonString);
}
}
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 StoredProcedureResponse <string> CreateDocumentScript(DocumentClient client, INameValueCollection headers)
{
var headersIterator = headers.AllKeys().SelectMany(headers.GetValues, (k, v) => new { key = k, value = v });
var scriptOptions = "{";
var headerIndex = 0;
foreach (var header in headersIterator)
{
if (headerIndex != 0)
{
scriptOptions += ", ";
}
headerIndex++;
scriptOptions += header.key + ":" + header.value;
}
scriptOptions += "}";
var guid = Guid.NewGuid().ToString();
var script = @" function() {
var client = getContext().getCollection();
client.createDocument(client.getSelfLink(), { id: Math.random() + """" }," + scriptOptions + @", function(err, docCreated, options) {
if(err) throw new Error('Error while creating document: ' + err.message);
else {
getContext().getResponse().setBody(JSON.stringify(docCreated));
}
});}";
var collection = TestCommon.CreateOrGetDocumentCollection(client);
var sproc = new CosmosStoredProcedureSettings()
{
Id = Guid.NewGuid().ToString(), Body = script
};
var createdSproc = client.CreateStoredProcedureAsync(collection, sproc).Result.Resource;
var result = client.ExecuteStoredProcedureAsync <string>(createdSproc).Result;
return(result);
}
private StoredProcedureResponse <string> ReadFeedScript(DocumentClient client, INameValueCollection headers)
{
var headersIterator = headers.AllKeys().SelectMany(headers.GetValues, (k, v) => new { key = k, value = v });
var scriptOptions = "{";
var headerIndex = 0;
foreach (var header in headersIterator)
{
if (headerIndex != 0)
{
scriptOptions += ", ";
}
headerIndex++;
scriptOptions += header.key + ":" + header.value;
}
scriptOptions += "}";
var script = @"function() {
var client = getContext().getCollection();
function callback(err, docFeed, responseOptions) {
if(err) throw 'Error while reading documents';
docFeed.forEach(function(doc, i, arr) { getContext().getResponse().appendBody(JSON.stringify(doc)); });
};
client.readDocuments(client.getSelfLink()," + scriptOptions + @", callback);}";
var collection = TestCommon.CreateOrGetDocumentCollection(client);
var sproc = new CosmosStoredProcedureSettings()
{
Id = Guid.NewGuid().ToString(), Body = script
};
var createdSproc = client.CreateStoredProcedureAsync(collection, sproc).Result.Resource;
var result = client.ExecuteStoredProcedureAsync <string>(createdSproc).Result;
return(result);
}
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
CosmosContainerSettings containerSettings = new CosmosContainerSettings("mockId", "/pk");
CosmosDatabaseSettings databaseSettings = new CosmosDatabaseSettings()
{
Id = "mock"
};
CosmosStoredProcedureSettings cosmosStoredProcedureSettings = new CosmosStoredProcedureSettings()
{
Id = "mock"
};
CosmosTriggerSettings cosmosTriggerSettings = new CosmosTriggerSettings()
{
Id = "mock"
};
CosmosUserDefinedFunctionSettings cosmosUserDefinedFunctionSettings = new CosmosUserDefinedFunctionSettings()
{
Id = "mock"
};
mockDefaultJsonSerializer.Setup(x => x.FromStream <CosmosDatabaseSettings>(databaseResponse.Content)).Returns(databaseSettings);
mockDefaultJsonSerializer.Setup(x => x.FromStream <CosmosContainerSettings>(containerResponse.Content)).Returns(containerSettings);
mockDefaultJsonSerializer.Setup(x => x.FromStream <CosmosStoredProcedureSettings>(storedProcedureResponse.Content)).Returns(cosmosStoredProcedureSettings);
mockDefaultJsonSerializer.Setup(x => x.FromStream <CosmosTriggerSettings>(triggerResponse.Content)).Returns(cosmosTriggerSettings);
mockDefaultJsonSerializer.Setup(x => x.FromStream <CosmosUserDefinedFunctionSettings>(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();
}
internal static async Task PartitionedCollectionSmokeTest(DocumentClient client, bool sharedOffer = false, bool sharedThroughputCollections = false, int numberOfCollections = 1)
{
if (!sharedOffer && sharedThroughputCollections)
{
throw new ArgumentException("Shared throughput collections are not supported without shared offer");
}
string uniqDatabaseName = string.Format("SmokeTest_{0}", Guid.NewGuid().ToString("N"));
RequestOptions options = new RequestOptions {
OfferThroughput = 50000
};
CosmosDatabaseSettings database = sharedOffer ? await client.CreateDatabaseAsync(new CosmosDatabaseSettings { Id = uniqDatabaseName }, options) : await client.CreateDatabaseAsync(new CosmosDatabaseSettings { Id = uniqDatabaseName });
Assert.AreEqual(database.AltLink, ClientTestsUtils.GenerateAltLink(uniqDatabaseName));
CosmosDatabaseSettings readbackdatabase = await client.ReadDatabaseAsync(database.SelfLink);
List <dynamic> results = await ClientTestsUtils.SqlQueryDatabases(client, string.Format(@"select r._rid from root r where r.id = ""{0}""", uniqDatabaseName), 10);
Assert.AreEqual(1, results.Count, "Should have queried and found 1 document");
Assert.AreEqual(database.ResourceId, ((QueryResult)results[0]).ResourceId);
Assert.IsTrue((await ClientTestsUtils.ReadFeedDatabases(client)).Any((db) => db.Id == uniqDatabaseName));
results = await ClientTestsUtils.SqlQueryDatabases(client, string.Format(@"select r._rid, r.id from root r where r.id = ""{0}""", uniqDatabaseName), 10);
Assert.AreEqual(1, results.Count, "Should have queried and found 1 database");
Assert.AreEqual(database.ResourceId, ((QueryResult)results[0]).ResourceId);
Assert.AreEqual(database.ResourceId, (await client.ReadDatabaseAsync(database.SelfLink)).Resource.ResourceId);
Assert.AreEqual(((CosmosDatabaseSettings)results[0]).AltLink, ClientTestsUtils.GenerateAltLink(uniqDatabaseName));
ArrayList testCollections = new ArrayList();
for (int i = 0; i < numberOfCollections; i++)
{
string uniqCollectionName = "SmokeTestCollection" + Guid.NewGuid().ToString("N");
var partitionKeyDefinition = new PartitionKeyDefinition
{
Paths = new System.Collections.ObjectModel.Collection <string> {
"/id"
},
Kind = PartitionKind.Hash
};
CosmosContainerSettings collection;
if (sharedThroughputCollections)
{
collection = await TestCommon.CreateCollectionAsync(client, database.SelfLink, new CosmosContainerSettings { Id = uniqCollectionName, PartitionKey = partitionKeyDefinition });
}
else
{
collection = await TestCommon.CreateCollectionAsync(client, database.SelfLink, new CosmosContainerSettings { Id = uniqCollectionName, PartitionKey = partitionKeyDefinition }, options);
}
Assert.AreEqual(collection.AltLink, ClientTestsUtils.GenerateAltLink(uniqDatabaseName, uniqCollectionName, typeof(CosmosContainerSettings)));
results = await SqlQueryCollections(client, database.SelfLink, string.Format(@"select r._rid from root r where r.id = ""{0}""", uniqCollectionName), 10); // query through database link
Assert.AreEqual(1, results.Count, "Should have queried and found 1 collection");
Assert.AreEqual(collection.ResourceId, ((QueryResult)results[0]).ResourceId);
results = await SqlQueryCollections(client, database.CollectionsLink, string.Format(@"select r._rid, r.id from root r where r.id = ""{0}""", uniqCollectionName), 10); // query through CollectionsLink
Assert.AreEqual(1, results.Count, "Should have queried and found 1 collection");
Assert.AreEqual(collection.ResourceId, ((QueryResult)results[0]).ResourceId);
Assert.AreEqual(1, (await ReadFeedCollections(client, database.SelfLink)).Count(item => item.Id == uniqCollectionName)); // read through database link
Assert.AreEqual(1, (await ReadFeedCollections(client, database.CollectionsLink)).Count(item => item.Id == uniqCollectionName)); // read through CollectionsLink
Assert.AreEqual(collection.ResourceId, (await client.ReadDocumentCollectionAsync(collection.SelfLink)).Resource.ResourceId);
Assert.AreEqual(((CosmosContainerSettings)results[0]).AltLink, ClientTestsUtils.GenerateAltLink(uniqDatabaseName, uniqCollectionName, typeof(CosmosContainerSettings)));
testCollections.Add(collection);
string uniqDocumentName = "SmokeTestDocument" + Guid.NewGuid().ToString("N");
LinqGeneralBaselineTests.Book myDocument = new LinqGeneralBaselineTests.Book();
myDocument.Id = uniqDocumentName;
myDocument.Title = "My Book"; //Simple Property.
myDocument.Languages = new LinqGeneralBaselineTests.Language[] { new LinqGeneralBaselineTests.Language {
Name = "English", Copyright = "London Publication"
}, new LinqGeneralBaselineTests.Language {
Name = "French", Copyright = "Paris Publication"
} }; //Array Property
myDocument.Author = new LinqGeneralBaselineTests.Author {
Name = "Don", Location = "France"
}; //Complex Property
myDocument.Price = 9.99;
myDocument.Editions = new List <LinqGeneralBaselineTests.Edition>()
{
new LinqGeneralBaselineTests.Edition()
{
Name = "First", Year = 2001
}, new LinqGeneralBaselineTests.Edition()
{
Name = "Second", Year = 2005
}
};
Document document = await client.CreateDocumentAsync(collection.SelfLink, myDocument);
Assert.AreEqual(document.AltLink, ClientTestsUtils.GenerateAltLink(uniqDatabaseName, uniqCollectionName, uniqDocumentName, typeof(Document)));
results = await SqlQueryDocuments(client, collection.SelfLink, string.Format(@"select r._rid from root r where r.id = ""{0}""", uniqDocumentName), 10); // query through collection link
Assert.AreEqual(1, results.Count, "Should have queried and found 1 document");
Assert.AreEqual(document.ResourceId, ((QueryResult)results[0]).ResourceId);
results = await SqlQueryDocuments(client, collection.DocumentsLink, string.Format(@"select r._rid from root r where r.id = ""{0}""", uniqDocumentName), 10); // query through DocumentsLink
Assert.AreEqual(1, results.Count, "Should have queried and found 1 document");
Assert.AreEqual(document.ResourceId, ((QueryResult)results[0]).ResourceId);
Assert.AreEqual(1, (await ReadFeedDocuments(client, collection.SelfLink)).Count(item => item.Id == uniqDocumentName)); // read through collection link
Assert.AreEqual(1, (await ReadFeedDocuments(client, collection.DocumentsLink)).Count(item => item.Id == uniqDocumentName)); // read through DocumentsLink
if (client.QueryCompatibilityMode != QueryCompatibilityMode.SqlQuery)
{
//Test query with parameters
results = await SqlQueryDocuments(client, collection.SelfLink,
new SqlQuerySpec
{
QueryText = @"select r._rid from root r where r.id = @id",
Parameters = new SqlParameterCollection()
{
new SqlParameter("@id", uniqDocumentName)
}
}, 10); // query through collection link
Assert.AreEqual(1, results.Count, "Should have queried and found 1 document");
Assert.AreEqual(document.ResourceId, ((QueryResult)results[0]).ResourceId);
}
RequestOptions docReplaceRequestOptions = new RequestOptions {
PartitionKey = new PartitionKey(document.Id)
};
FeedOptions docReplaceFeedOptions = new FeedOptions {
EnableCrossPartitionQuery = true, PartitionKey = new PartitionKey(document.Id)
};
myDocument.Title = "My_Book_v2";
document = await client.ReplaceDocumentAsync(document.AltLink, myDocument);
results = await SqlQueryDocuments(client, collection.SelfLink, string.Format(@"select r._rid from root r where r.id = ""{0}""", uniqDocumentName), 10, docReplaceFeedOptions);
Assert.AreEqual(1, results.Count, "Should have queried and found 1 document");
Assert.AreEqual(document.ResourceId, ((QueryResult)results[0]).ResourceId);
results = await SqlQueryDocuments(client, collection.SelfLink, string.Format(@"SELECT r.id, r._rid FROM root r WHERE r.id=""{0}""", uniqDocumentName), 10); // query through collection
Assert.AreEqual(1, results.Count, "Should have queried and found 1 document");
results = await SqlQueryDocuments(client, collection.DocumentsLink, string.Format(@"SELECT r.id, r._rid FROM root r WHERE r.id=""{0}""", uniqDocumentName), 10); // query through DocumentsLink
Assert.AreEqual(1, results.Count, "Should have queried and found 1 document");
Assert.AreEqual(((Document)results[0]).AltLink, ClientTestsUtils.GenerateAltLink(uniqDatabaseName, uniqCollectionName, uniqDocumentName, typeof(Document)));
// No Range Index on ts - override with scan
FeedOptions queryFeedOptions1 = new FeedOptions()
{
EnableScanInQuery = true, EnableCrossPartitionQuery = true
};
results = await SqlQueryDocuments(client, collection.SelfLink, string.Format(@"SELECT r.name FROM root r WHERE r.Price>0"), 10, queryFeedOptions1);
Assert.AreEqual(1, results.Count, "Should have queried and found 1 document");
FeedOptions queryFeedOptions2 = new FeedOptions()
{
EmitVerboseTracesInQuery = true, EnableCrossPartitionQuery = true
};
results = await SqlQueryDocuments(client, collection.SelfLink, string.Format(@"SELECT r.name FROM root r WHERE r.Price=9.99"), 10, queryFeedOptions2);
Assert.AreEqual(1, results.Count, "Should have queried and found 1 document");
FeedOptions queryFeedOptions3 = new FeedOptions()
{
EmitVerboseTracesInQuery = false, EnableCrossPartitionQuery = true
};
results = await SqlQueryDocuments(client, collection.SelfLink, string.Format(@"SELECT r.name FROM root r WHERE r.Price=9.99"), 10, queryFeedOptions3);
Assert.AreEqual(1, results.Count, "Should have queried and found 1 document");
string uniqStoredProcedureName = "SmokeTestStoredProcedure" + Guid.NewGuid().ToString();
CosmosStoredProcedureSettings storedProcedure = await client.CreateStoredProcedureAsync(collection.SelfLink, new CosmosStoredProcedureSettings { Id = uniqStoredProcedureName, Body = "function f() {var x = 10;}" });
results = await SqlQueryStoredProcedures(client, collection.SelfLink, string.Format(@"SELECT r.id, r._rid FROM root r WHERE r.id = ""{0}""", uniqStoredProcedureName), 10); // query through collection link
Assert.AreEqual(1, results.Count, "Should have queried and found 1 storedProcedure");
Assert.AreEqual(storedProcedure.ResourceId, ((QueryResult)results[0]).ResourceId);
results = await SqlQueryStoredProcedures(client, collection.StoredProceduresLink, string.Format(@"SELECT r.id, r._rid FROM root r WHERE r.id = ""{0}""", uniqStoredProcedureName), 10); // query through StoredProceduresLink
Assert.AreEqual(1, results.Count, "Should have queried and found 1 storedProcedure");
Assert.AreEqual(storedProcedure.ResourceId, ((QueryResult)results[0]).ResourceId);
Assert.AreEqual(1, (await ReadFeedStoredProcedures(client, collection.SelfLink)).Count(item => item.Id == uniqStoredProcedureName)); // read through collection link
Assert.AreEqual(1, (await ReadFeedStoredProcedures(client, collection.StoredProceduresLink)).Count(item => item.Id == uniqStoredProcedureName)); // read through StoredProceduresLink
storedProcedure.Body = "function f() {var x= 20;}";
storedProcedure = await client.ReplaceStoredProcedureAsync(storedProcedure);
results = await SqlQueryStoredProcedures(client, collection.StoredProceduresLink, string.Format(@"SELECT r.id, r._rid FROM root r WHERE r.id=""{0}""", storedProcedure.Id), 10); // query through StoredProceduresLink
Assert.AreEqual(1, results.Count, "Should have queried and found 1 storedProcedure");
Assert.AreEqual(storedProcedure.ResourceId, ((QueryResult)results[0]).ResourceId);
Assert.AreEqual(storedProcedure.ResourceId, (await client.ReadStoredProcedureAsync(storedProcedure.SelfLink)).Resource.ResourceId);
Assert.AreEqual(1, results.Count, "Should have queried and found 1 storedProcedure");
string uniqTriggerName = "SmokeTestTrigger" + Guid.NewGuid().ToString("N");
CosmosTriggerSettings trigger = await client.CreateTriggerAsync(collection.SelfLink, new CosmosTriggerSettings { Id = uniqTriggerName, Body = "function f() {var x = 10;}", TriggerOperation = TriggerOperation.All, TriggerType = TriggerType.Pre });
results = await SqlQueryTriggers(client, collection.SelfLink, string.Format(@"select r._rid from root r where r.id = ""{0}""", uniqTriggerName), 10); // query through collection link
Assert.AreEqual(1, results.Count, "Should have queried and found 1 trigger");
Assert.AreEqual(trigger.ResourceId, ((QueryResult)results[0]).ResourceId);
results = await SqlQueryTriggers(client, collection.TriggersLink, string.Format(@"select r._rid from root r where r.id = ""{0}""", uniqTriggerName), 10); // query through TriggersLink
Assert.AreEqual(1, results.Count, "Should have queried and found 1 trigger");
Assert.AreEqual(trigger.ResourceId, ((QueryResult)results[0]).ResourceId);
Assert.AreEqual(1, (await ReadFeedTriggers(client, collection.SelfLink)).Count(item => item.Id == uniqTriggerName)); // read through collection link
Assert.AreEqual(1, (await ReadFeedTriggers(client, collection.TriggersLink)).Count(item => item.Id == uniqTriggerName)); // read through TriggersLink
trigger.Body = "function f() {var x = 10;}";
trigger = await client.ReplaceTriggerAsync(trigger);
results = await SqlQueryTriggers(client, collection.SelfLink, string.Format(@"select r._rid from root r where r.id = ""{0}""", uniqTriggerName), 10);
Assert.AreEqual(1, results.Count, "Should have queried and found 1 trigger");
Assert.AreEqual(trigger.ResourceId, ((QueryResult)results[0]).ResourceId);
Assert.AreEqual(trigger.ResourceId, (await client.ReadTriggerAsync(trigger.SelfLink)).Resource.ResourceId);
results = await SqlQueryTriggers(client, collection.SelfLink, string.Format(@"SELECT r.id, r._rid FROM root r WHERE r.id=""{0}""", uniqTriggerName), 10); // query through collection link
Assert.AreEqual(1, results.Count, "Should have queried and found 1 trigger");
results = await SqlQueryTriggers(client, collection.TriggersLink, string.Format(@"SELECT r.id, r._rid FROM root r WHERE r.id=""{0}""", uniqTriggerName), 10); // query through TriggersLink
Assert.AreEqual(1, results.Count, "Should have queried and found 1 trigger");
string uniqUserDefinedFunctionName = "SmokeTestUserDefinedFunction" + Guid.NewGuid().ToString("N");
CosmosUserDefinedFunctionSettings userDefinedFunction = await client.CreateUserDefinedFunctionAsync(collection.SelfLink, new CosmosUserDefinedFunctionSettings { Id = uniqUserDefinedFunctionName, Body = "function (){ var x = 10;}" });
results = await SqlQueryUserDefinedFunctions(client, collection.SelfLink, string.Format(@"select r._rid from root r where r.id = ""{0}""", uniqUserDefinedFunctionName), 10); // query through collection link
Assert.AreEqual(1, results.Count, "Should have queried and found 1 userDefinedFunction");
Assert.AreEqual(userDefinedFunction.ResourceId, ((QueryResult)results[0]).ResourceId);
results = await SqlQueryUserDefinedFunctions(client, collection.UserDefinedFunctionsLink, string.Format(@"select r._rid from root r where r.id = ""{0}""", uniqUserDefinedFunctionName), 10); // query through UserDefinedFunctionsLink
Assert.AreEqual(1, results.Count, "Should have queried and found 1 userDefinedFunction");
Assert.AreEqual(userDefinedFunction.ResourceId, ((QueryResult)results[0]).ResourceId);
Assert.AreEqual(1, (await ReadFeedUserDefinedFunctions(client, collection.SelfLink)).Count(item => item.Id == uniqUserDefinedFunctionName)); // read through collection link
Assert.AreEqual(1, (await ReadFeedUserDefinedFunctions(client, collection.UserDefinedFunctionsLink)).Count(item => item.Id == uniqUserDefinedFunctionName)); // read through UserDefinedFunctionsLink
userDefinedFunction.Body = "function (){ var x = 10;}";
userDefinedFunction = await client.ReplaceUserDefinedFunctionAsync(userDefinedFunction);
results = await SqlQueryUserDefinedFunctions(client, collection.SelfLink, string.Format(@"select r._rid from root r where r.id = ""{0}""", uniqUserDefinedFunctionName), 10);
Assert.AreEqual(1, results.Count, "Should have queried and found 1 userDefinedFunction");
Assert.AreEqual(userDefinedFunction.ResourceId, ((QueryResult)results[0]).ResourceId);
Assert.AreEqual(userDefinedFunction.ResourceId, (await client.ReadUserDefinedFunctionAsync(userDefinedFunction.SelfLink)).Resource.ResourceId);
results = await SqlQueryUserDefinedFunctions(client, collection.SelfLink, string.Format(@"SELECT r.id, r._rid FROM root r WHERE r.id=""{0}""", uniqUserDefinedFunctionName), 10); // query through collection link
Assert.AreEqual(1, results.Count, "Should have queried and found 1 userDefinedFunction");
results = await SqlQueryUserDefinedFunctions(client, collection.UserDefinedFunctionsLink, string.Format(@"SELECT r.id, r._rid FROM root r WHERE r.id=""{0}""", uniqUserDefinedFunctionName), 10); // query through UserDefinedFunctionsLink
Assert.AreEqual(1, results.Count, "Should have queried and found 1 userDefinedFunction");
//Test select array
var queryArray = client.CreateDocumentQuery(collection.SelfLink, "SELECT VALUE [1, 2, 3, 4]").AsDocumentQuery();
JArray result = queryArray.ExecuteNextAsync().Result.FirstOrDefault();
Assert.AreEqual(result[0], 1);
Assert.AreEqual(result[1], 2);
Assert.AreEqual(result[2], 3);
Assert.AreEqual(result[3], 4);
RequestOptions requestOptions = new RequestOptions {
PartitionKey = new PartitionKey(document.Id)
};
await client.DeleteDocumentAsync(document.SelfLink, requestOptions);
}
foreach (CosmosContainerSettings collection in testCollections)
{
await client.DeleteDocumentCollectionAsync(collection.SelfLink);
}
await client.DeleteDatabaseAsync(database.SelfLink);
}
public void TestStoredProcedure()
{
// Create a document client with a customer json serializer settings
JsonSerializerSettings serializerSettings = new JsonSerializerSettings();
serializerSettings.Converters.Add(new ObjectStringJsonConverter <SerializedObject>(_ => _.Name, _ => SerializedObject.Parse(_)));
ConnectionPolicy connectionPolicy = new ConnectionPolicy {
ConnectionMode = ConnectionMode.Gateway
};
ConsistencyLevel defaultConsistencyLevel = ConsistencyLevel.Session;
DocumentClient client = CreateDocumentClient(
this.hostUri,
this.masterKey,
serializerSettings,
connectionPolicy,
defaultConsistencyLevel);
// Create a simple stored procedure
var scriptId = "bulkImportScript";
var sproc = new CosmosStoredProcedureSettings
{
Id = scriptId,
Body = @"
function bulkImport(docs) {
var collection = getContext().getCollection();
var collectionLink = collection.getSelfLink();
// The count of imported docs, also used as current doc index.
var count = 0;
// Validate input.
if (!docs) throw new Error(""The array is undefined or null."");
var docsLength = docs.length;
if (docsLength == 0)
{
getContext().getResponse().setBody(0);
}
// Call the CRUD API to create a document.
tryCreate(docs[count], callback);
// Note that there are 2 exit conditions:
// 1) The createDocument request was not accepted.
// In this case the callback will not be called, we just call setBody and we are done.
// 2) The callback was called docs.length times.
// In this case all documents were created and we don't need to call tryCreate anymore. Just call setBody and we are done.
function tryCreate(doc, callback) {
// If you are sure that every document will contain its own (unique) id field then
// disable the option to auto generate ids.
// by leaving this on, the entire document is parsed to check if there is an id field or not
// by disabling this, parsing of the document is skipped because you're telling DocumentDB
// that you are providing your own ids.
// depending on the size of your documents making this change can have a significant
// improvement on document creation.
var options = {
disableAutomaticIdGeneration: true
};
var isAccepted = collection.createDocument(collectionLink, doc, options, callback);
// If the request was accepted, callback will be called.
// Otherwise report current count back to the client,
// which will call the script again with remaining set of docs.
// This condition will happen when this stored procedure has been running too long
// and is about to get cancelled by the server. This will allow the calling client
// to resume this batch from the point we got to before isAccepted was set to false
if (!isAccepted) getContext().getResponse().setBody(count);
}
// This is called when collection.createDocument is done and the document has been persisted.
function callback(err, doc, options)
{
if (err) throw err;
// One more document has been inserted, increment the count.
count++;
if (count >= docsLength)
{
// If we have created all documents, we are done. Just set the response.
getContext().getResponse().setBody(count);
}
else
{
// Create next document.
tryCreate(docs[count], callback);
}
}
}
"
};
sproc = client.CreateStoredProcedureAsync(collectionUri, sproc).Result.Resource;
var doc = new MyObject(1);
var args = new dynamic[] { new dynamic[] { doc } };
RequestOptions requestOptions = ApplyRequestOptions(new RequestOptions(), serializerSettings);
StoredProcedureResponse <int> scriptResult = client.ExecuteStoredProcedureAsync <int>(
sproc.SelfLink,
requestOptions,
args).Result;
var docUri = UriFactory.CreateDocumentUri(databaseName, collectionName, doc.id);
var readDoc = client.ReadDocumentAsync <MyObject>(docUri, requestOptions).Result.Document;
Assert.IsNotNull(readDoc.SerializedObject);
Assert.AreEqual(doc.SerializedObject.Name, readDoc.SerializedObject.Name);
}
