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 DeleteUDF(string udfName)
        {
            string message = "Delete UserDefinedFunction";

            Printer.PrintLine(message: message);
            Scripts scripts = _container.Scripts;
            UserDefinedFunctionResponse udfResponse = await scripts.DeleteUserDefinedFunctionAsync(udfName);

            WriteLine($"{udfName} -- UDF Deleted");
            Printer.PrintLine(noOfTimes: (100 + message.Length));
        }
        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;

            CosmosUserDefinedFunctionSettings settings = new CosmosUserDefinedFunctionSettings
            {
                Id   = id,
                Body = function,
            };

            //Create a user defined function
            UserDefinedFunctionResponse createResponse = await this.scripts.CreateUserDefinedFunctionAsync(
                userDefinedFunctionSettings : settings,
                cancellationToken : this.cancellationToken);

            ValidateUserDefinedFunctionSettings(settings, createResponse);

            return(createResponse);
        }
        public async Task CRUDTest()
        {
            CosmosUserDefinedFunctionSettings settings = new CosmosUserDefinedFunctionSettings
            {
                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);
            UserDefinedFunctionsTests.ValidateUserDefinedFunctionSettings(settings, response);

            response = await this.scripts.ReadUserDefinedFunctionAsync(settings.Id);

            reqeustCharge = response.RequestCharge;
            Assert.IsTrue(reqeustCharge > 0);
            Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
            UserDefinedFunctionsTests.ValidateUserDefinedFunctionSettings(settings, response);

            CosmosUserDefinedFunctionSettings 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.AreEqual(HttpStatusCode.OK, replaceResponse.StatusCode);

            replaceResponse = await this.scripts.DeleteUserDefinedFunctionAsync(settings.Id);

            reqeustCharge = replaceResponse.RequestCharge;
            Assert.IsTrue(reqeustCharge > 0);
            Assert.AreEqual(HttpStatusCode.NoContent, replaceResponse.StatusCode);
        }
        private static void ValidateUserDefinedFunctionSettings(CosmosUserDefinedFunctionSettings udfSettings, UserDefinedFunctionResponse cosmosResponse)
        {
            CosmosUserDefinedFunctionSettings 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);
        }
        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));
            SelflinkValidator.ValidateUdfSelfLink(cosmosResponse.Resource.SelfLink);
        }