public async Task UserDefinedFunctionsIteratorTest()
{
using (CosmosClient cosmosClient = TestCommon.CreateCosmosClient(new CosmosClientOptions()
{
Serializer = new FaultySerializer()
}))
{
// Should not use the custom serializer for these operations
Scripts scripts = cosmosClient.GetContainer(this.database.Id, this.container.Id).Scripts;
UserDefinedFunctionProperties cosmosUserDefinedFunction = await this.CreateRandomUdf();
HashSet <string> settings = new HashSet <string>();
FeedIterator <UserDefinedFunctionProperties> iter = scripts.GetUserDefinedFunctionQueryIterator <UserDefinedFunctionProperties>();;
while (iter.HasMoreResults)
{
foreach (UserDefinedFunctionProperties storedProcedureSettingsEntry in await iter.ReadNextAsync())
{
settings.Add(storedProcedureSettingsEntry.Id);
}
}
Assert.IsTrue(settings.Contains(cosmosUserDefinedFunction.Id), "The iterator did not return the user defined function definition.");
// Delete existing user defined functions.
await scripts.DeleteUserDefinedFunctionAsync(cosmosUserDefinedFunction.Id);
}
}
private static CosmosUserDefinedFunction MakeScript(UserDefinedFunctionProperties props) =>
new CosmosUserDefinedFunction
{
Id = props.Id,
Body = props.Body,
ETag = props.ETag
};
public async Task CRUDTest()
{
UserDefinedFunctionProperties settings = new UserDefinedFunctionProperties
{
Id = Guid.NewGuid().ToString(),
Body = UserDefinedFunctionsTests.function,
};
UserDefinedFunctionResponse response =
await this.scripts.CreateUserDefinedFunctionAsync(settings);
double reqeustCharge = response.RequestCharge;
Assert.IsTrue(reqeustCharge > 0);
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
Assert.IsNotNull(response.Diagnostics);
string diagnostics = response.Diagnostics.ToString();
Assert.IsFalse(string.IsNullOrEmpty(diagnostics));
Assert.IsTrue(diagnostics.Contains("StatusCode"));
UserDefinedFunctionsTests.ValidateUserDefinedFunctionSettings(settings, response);
response = await this.scripts.ReadUserDefinedFunctionAsync(settings.Id);
reqeustCharge = response.RequestCharge;
Assert.IsTrue(reqeustCharge > 0);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.IsNotNull(response.Diagnostics);
diagnostics = response.Diagnostics.ToString();
Assert.IsFalse(string.IsNullOrEmpty(diagnostics));
Assert.IsTrue(diagnostics.Contains("StatusCode"));
UserDefinedFunctionsTests.ValidateUserDefinedFunctionSettings(settings, response);
UserDefinedFunctionProperties updatedSettings = response.Resource;
updatedSettings.Body = @"function(amt) { return amt * 0.42; }";
UserDefinedFunctionResponse replaceResponse = await this.scripts.ReplaceUserDefinedFunctionAsync(updatedSettings);
UserDefinedFunctionsTests.ValidateUserDefinedFunctionSettings(updatedSettings, replaceResponse);
reqeustCharge = replaceResponse.RequestCharge;
Assert.IsTrue(reqeustCharge > 0);
Assert.IsNotNull(replaceResponse.Diagnostics);
diagnostics = replaceResponse.Diagnostics.ToString();
Assert.IsFalse(string.IsNullOrEmpty(diagnostics));
Assert.IsTrue(diagnostics.Contains("StatusCode"));
Assert.AreEqual(HttpStatusCode.OK, replaceResponse.StatusCode);
replaceResponse = await this.scripts.DeleteUserDefinedFunctionAsync(settings.Id);
reqeustCharge = replaceResponse.RequestCharge;
Assert.IsTrue(reqeustCharge > 0);
Assert.IsNotNull(replaceResponse.Diagnostics);
diagnostics = replaceResponse.Diagnostics.ToString();
Assert.IsFalse(string.IsNullOrEmpty(diagnostics));
Assert.IsTrue(diagnostics.Contains("StatusCode"));
Assert.AreEqual(HttpStatusCode.NoContent, replaceResponse.StatusCode);
}
public async Task ValidateUserDefinedFunctionsTest()
{
try
{
// Prevent failures if previous test did not clean up correctly
await this.scripts.DeleteUserDefinedFunctionAsync("calculateTax");
}
catch (CosmosException ex) when(ex.StatusCode == HttpStatusCode.NotFound)
{
//swallow
}
ToDoActivity item = new ToDoActivity()
{
id = Guid.NewGuid().ToString(),
cost = 9001,
description = "udf_test_item",
status = "Done",
taskNum = 1
};
await this.container.CreateItemAsync <ToDoActivity>(item);
UserDefinedFunctionProperties cosmosUserDefinedFunction = await this.scripts.CreateUserDefinedFunctionAsync(
new UserDefinedFunctionProperties
{
Id = "calculateTax",
Body = @"function(amt) { return amt * 0.05; }"
});
QueryDefinition sqlQuery = new QueryDefinition(
"SELECT t.id, t.status, t.cost, udf.calculateTax(t.cost) as total FROM toDoActivity t where t.cost > @expensive and t.status = @status")
.WithParameter("@expensive", 9000)
.WithParameter("@status", "Done");
FeedIterator <dynamic> feedIterator = this.container.GetItemQueryIterator <dynamic>(
queryDefinition: sqlQuery);
HashSet <string> iterIds = new HashSet <string>();
while (feedIterator.HasMoreResults)
{
foreach (var response in await feedIterator.ReadNextAsync())
{
Assert.IsTrue(response.cost > 9000);
Assert.AreEqual(response.cost * .05, response.total);
iterIds.Add(response.id.Value);
}
}
Assert.IsTrue(iterIds.Count > 0);
Assert.IsTrue(iterIds.Contains(item.id));
// Delete existing user defined functions.
await this.scripts.DeleteUserDefinedFunctionAsync(cosmosUserDefinedFunction.Id);
}
internal Task <UserDefinedFunctionResponse> CreateUserDefinedFunctionResponseAsync(Task <ResponseMessage> cosmosResponseMessageTask)
{
return(this.ProcessMessageAsync(cosmosResponseMessageTask, (cosmosResponseMessage) =>
{
UserDefinedFunctionProperties settings = this.ToObjectInternal <UserDefinedFunctionProperties>(cosmosResponseMessage, this.propertiesSerializer);
return new UserDefinedFunctionResponse(
cosmosResponseMessage.StatusCode,
cosmosResponseMessage.Headers,
settings);
}));
}
private static void ValidateUserDefinedFunctionSettings(UserDefinedFunctionProperties udfSettings, UserDefinedFunctionResponse cosmosResponse)
{
UserDefinedFunctionProperties settings = cosmosResponse.Resource;
Assert.AreEqual(udfSettings.Body, settings.Body,
"User defined function do not match");
Assert.AreEqual(udfSettings.Id, settings.Id,
"User defined function 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));
}
private static void ValidateUserDefinedFunctionSettings(UserDefinedFunctionProperties udfSettings, UserDefinedFunctionResponse cosmosResponse)
{
UserDefinedFunctionProperties settings = cosmosResponse.Resource;
Assert.AreEqual(udfSettings.Body, settings.Body,
"User defined function do not match");
Assert.AreEqual(udfSettings.Id, settings.Id,
"User defined function id do not match");
Assert.IsTrue(cosmosResponse.RequestCharge > 0);
Assert.IsNotNull(cosmosResponse.MaxResourceQuota);
Assert.IsNotNull(cosmosResponse.CurrentResourceQuotaUsage);
}
public override UserDefinedFunctionResponse CreateUserDefinedFunctionResponse(
ResponseMessage responseMessage)
{
return(this.ProcessMessage(responseMessage, (cosmosResponseMessage) =>
{
UserDefinedFunctionProperties settings = this.ToObjectpublic <UserDefinedFunctionProperties>(cosmosResponseMessage);
return new UserDefinedFunctionResponse(
cosmosResponseMessage.StatusCode,
cosmosResponseMessage.Headers,
settings,
cosmosResponseMessage.Diagnostics);
}));
}
public async Task ScriptsUserDefinedFunctionTest(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>()
{
"BasicQueryUdf1",
"BasicQueryUdf2",
"BasicQueryUdf3"
};
//Basic query
List <UserDefinedFunctionProperties> queryResults = await this.ToListAsync(
scripts.GetUserDefinedFunctionQueryStreamIterator,
scripts.GetUserDefinedFunctionQueryIterator <UserDefinedFunctionProperties>,
"select * from T where STARTSWITH(T.id, \"BasicQueryUdf\")",
CosmosBasicQueryTests.RequestOptions);
if (queryResults.Count < 3)
{
foreach (string id in createdIds)
{
UserDefinedFunctionProperties properties = await scripts.CreateUserDefinedFunctionAsync(new UserDefinedFunctionProperties()
{
Id = id,
Body = "function() {var x = 10;}"
});
}
queryResults = await this.ToListAsync(
scripts.GetUserDefinedFunctionQueryStreamIterator,
scripts.GetUserDefinedFunctionQueryIterator <UserDefinedFunctionProperties>,
"select * from T where STARTSWITH(T.id, \"BasicQueryUdf\")",
CosmosBasicQueryTests.RequestOptions);
}
CollectionAssert.AreEquivalent(createdIds, queryResults.Select(x => x.Id).ToList());
//Read All
List <UserDefinedFunctionProperties> results = await this.ToListAsync(
scripts.GetUserDefinedFunctionQueryStreamIterator,
scripts.GetUserDefinedFunctionQueryIterator <UserDefinedFunctionProperties>,
null,
CosmosBasicQueryTests.RequestOptions);
CollectionAssert.IsSubsetOf(createdIds, results.Select(x => x.Id).ToList());
}
private async static Task CreateUserDefinedFunction(string udfId)
{
var udfBody = File.ReadAllText($@"Server\{udfId}.js");
var udfProps = new UserDefinedFunctionProperties
{
Id = udfId,
Body = udfBody
};
var container = Shared.Client.GetContainer("mydb", "mystore");
var result = await container.Scripts.CreateUserDefinedFunctionAsync(udfProps);
Console.WriteLine($"Created user defined function {udfId} ({result.RequestCharge} RUs);");
}
public async Task CreateUDF(string udfName)
{
var udf = File.ReadAllText($@"UserDefinedFunctions/{udfName}.js");
string message = "Cerate new UserDefinedFunction";
Printer.PrintLine(message: message);
Scripts scripts = _container.Scripts;
UserDefinedFunctionProperties udfProperties = new UserDefinedFunctionProperties
{
Id = udfName,
Body = udf
};
UserDefinedFunctionResponse udfResponse = await scripts.CreateUserDefinedFunctionAsync(udfProperties);
WriteLine($"EDF Created with the Id: {udfResponse.ActivityId}");
Printer.PrintLine(noOfTimes: (100 + message.Length));
}
private async Task <UserDefinedFunctionResponse> CreateRandomUdf()
{
string id = Guid.NewGuid().ToString();
string function = UserDefinedFunctionsTests.function;
UserDefinedFunctionProperties settings = new UserDefinedFunctionProperties
{
Id = id,
Body = function,
};
//Create a user defined function
UserDefinedFunctionResponse createResponse = await this.scripts.CreateUserDefinedFunctionAsync(
userDefinedFunctionProperties : settings,
cancellationToken : this.cancellationToken);
ValidateUserDefinedFunctionSettings(settings, createResponse);
return(createResponse);
}
public async Task UserDefinedFunctionsIteratorTest()
{
UserDefinedFunctionProperties cosmosUserDefinedFunction = await CreateRandomUdf();
HashSet <string> settings = new HashSet <string>();
FeedIterator <UserDefinedFunctionProperties> iter = this.scripts.GetUserDefinedFunctionsIterator();;
while (iter.HasMoreResults)
{
foreach (UserDefinedFunctionProperties storedProcedureSettingsEntry in await iter.ReadNextAsync())
{
settings.Add(storedProcedureSettingsEntry.Id);
}
}
Assert.IsTrue(settings.Contains(cosmosUserDefinedFunction.Id), "The iterator did not return the user defined function definition.");
// Delete existing user defined functions.
await this.scripts.DeleteUserDefinedFunctionAsync(cosmosUserDefinedFunction.Id);
}
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);
}
