public async Task FunctionOperationsTest_Scalar_JavaScript() { using (MockContext context = MockContext.Start(this.GetType())) { string resourceGroupName = TestUtilities.GenerateName("sjrg"); string jobName = TestUtilities.GenerateName("sj"); string functionName = TestUtilities.GenerateName("function"); var resourceManagementClient = this.GetResourceManagementClient(context); var streamAnalyticsManagementClient = this.GetStreamAnalyticsManagementClient(context); string expectedFunctionType = TestHelper.GetFullRestOnlyResourceType(TestHelper.FunctionsResourceType); string expectedFunctionResourceId = TestHelper.GetRestOnlyResourceId(streamAnalyticsManagementClient.SubscriptionId, resourceGroupName, jobName, TestHelper.FunctionsResourceType, functionName); resourceManagementClient.ResourceGroups.CreateOrUpdate(resourceGroupName, new ResourceGroup { Location = TestHelper.DefaultLocation }); string javaScriptFunctionCode = @"function (x, y) { return x + y; }"; var function = new Function() { Properties = new ScalarFunctionProperties() { Inputs = new List <FunctionInput>() { new FunctionInput() { DataType = @"Any", IsConfigurationParameter = null } }, Output = new FunctionOutput() { DataType = @"Any" }, Binding = new JavaScriptFunctionBinding() { Script = javaScriptFunctionCode } } }; // PUT job streamAnalyticsManagementClient.StreamingJobs.CreateOrReplace(TestHelper.GetDefaultStreamingJob(), resourceGroupName, jobName); // Retrieve default definition JavaScriptFunctionRetrieveDefaultDefinitionParameters retrieveDefaultDefinitionParameters = new JavaScriptFunctionRetrieveDefaultDefinitionParameters() { UdfType = UdfType.Scalar, Script = javaScriptFunctionCode }; CloudException cloudException = Assert.Throws <CloudException>( () => streamAnalyticsManagementClient.Functions.RetrieveDefaultDefinition(resourceGroupName, jobName, functionName, retrieveDefaultDefinitionParameters)); Assert.Equal(HttpStatusCode.InternalServerError, cloudException.Response.StatusCode); Assert.Contains(@"Retrieve default definition is not supported for function type: Microsoft.StreamAnalytics/JavascriptUdf", cloudException.Response.Content); // PUT function var putResponse = await streamAnalyticsManagementClient.Functions.CreateOrReplaceWithHttpMessagesAsync(function, resourceGroupName, jobName, functionName); ValidationHelper.ValidateFunction(function, putResponse.Body, false); Assert.Equal(expectedFunctionResourceId, putResponse.Body.Id); Assert.Equal(functionName, putResponse.Body.Name); Assert.Equal(expectedFunctionType, putResponse.Body.Type); // Verify GET request returns expected function var getResponse = await streamAnalyticsManagementClient.Functions.GetWithHttpMessagesAsync(resourceGroupName, jobName, functionName); ValidationHelper.ValidateFunction(putResponse.Body, getResponse.Body, true); // ETag should be the same Assert.Equal(putResponse.Headers.ETag, getResponse.Headers.ETag); // Test Function var testResult = streamAnalyticsManagementClient.Functions.Test(resourceGroupName, jobName, functionName); Assert.Equal("TestFailed", testResult.Status); Assert.NotNull(testResult.Error); Assert.Equal("BadRequest", testResult.Error.Code); Assert.Equal(@"Test operation is not supported for function type: Microsoft.StreamAnalytics/JavascriptUdf", testResult.Error.Message); // PATCH function var functionPatch = new Function() { Properties = new ScalarFunctionProperties() { Binding = new JavaScriptFunctionBinding() { Script = @"function (a, b) { return a * b; }" } } }; ((JavaScriptFunctionBinding)((ScalarFunctionProperties)putResponse.Body.Properties).Binding).Script = ((JavaScriptFunctionBinding)((ScalarFunctionProperties)functionPatch.Properties).Binding).Script; var patchResponse = await streamAnalyticsManagementClient.Functions.UpdateWithHttpMessagesAsync(functionPatch, resourceGroupName, jobName, functionName); ValidationHelper.ValidateFunction(putResponse.Body, patchResponse.Body, true); // ETag should be different after a PATCH operation Assert.NotEqual(putResponse.Headers.ETag, patchResponse.Headers.ETag); // Run another GET function to verify that it returns the newly updated properties as well getResponse = await streamAnalyticsManagementClient.Functions.GetWithHttpMessagesAsync(resourceGroupName, jobName, functionName); ValidationHelper.ValidateFunction(putResponse.Body, getResponse.Body, true); // ETag should be different after a PATCH operation Assert.NotEqual(putResponse.Headers.ETag, getResponse.Headers.ETag); Assert.Equal(patchResponse.Headers.ETag, getResponse.Headers.ETag); // List function and verify that the function shows up in the list var listResult = streamAnalyticsManagementClient.Functions.ListByStreamingJob(resourceGroupName, jobName); Assert.Single(listResult); ValidationHelper.ValidateFunction(putResponse.Body, listResult.Single(), true); Assert.Equal(getResponse.Headers.ETag, listResult.Single().Properties.Etag); // Get job with function expanded and verify that the function shows up var getJobResponse = streamAnalyticsManagementClient.StreamingJobs.Get(resourceGroupName, jobName, "functions"); Assert.Single(getJobResponse.Functions); ValidationHelper.ValidateFunction(putResponse.Body, getJobResponse.Functions.Single(), true); Assert.Equal(getResponse.Headers.ETag, getJobResponse.Functions.Single().Properties.Etag); // Delete function streamAnalyticsManagementClient.Functions.Delete(resourceGroupName, jobName, functionName); // Verify that list operation returns an empty list after deleting the function listResult = streamAnalyticsManagementClient.Functions.ListByStreamingJob(resourceGroupName, jobName); Assert.Empty(listResult); // Get job with function expanded and verify that there are no functions after deleting the function getJobResponse = streamAnalyticsManagementClient.StreamingJobs.Get(resourceGroupName, jobName, "functions"); Assert.Empty(getJobResponse.Functions); } }
public void Test_FunctionOperations_Scalar_JavaScript() { BasicDelegatingHandler handler = new BasicDelegatingHandler(); using (var undoContext = UndoContext.Current) { undoContext.Start(); string resourceGroupName = TestUtilities.GenerateName("StreamAnalytics"); string resourceName = TestUtilities.GenerateName("MyStreamingJobSubmittedBySDK"); string serviceLocation = TestHelper.GetDefaultLocation(); var resourceClient = TestHelper.GetResourceClient(handler); var client = TestHelper.GetStreamAnalyticsManagementClient(handler); try { ResourceGroup resourceGroup = new ResourceGroup() { Location = serviceLocation }; resourceClient.ResourceGroups.CreateOrUpdate(resourceGroupName, resourceGroup); // Construct the JobCreateProperties JobCreateOrUpdateParameters jobCreateOrUpdateParameters = new JobCreateOrUpdateParameters(TestHelper.GetDefaultJob(resourceName, serviceLocation)); // Create a streaming job JobCreateOrUpdateResponse jobCreateOrUpdateResponse = client.StreamingJobs.CreateOrUpdate(resourceGroupName, jobCreateOrUpdateParameters); Assert.Equal(HttpStatusCode.OK, jobCreateOrUpdateResponse.StatusCode); // Get a streaming job to check JobGetParameters jobGetParameters = new JobGetParameters(string.Empty); JobGetResponse jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters); Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode); Assert.Equal(serviceLocation, jobGetResponse.Job.Location); Assert.Equal(resourceName, jobGetResponse.Job.Name); // Retrieve default definition of the function string functionName = TestUtilities.GenerateName("functiontest"); string javaScriptFunctionCode = @"function (x, y) { return x + y; }"; var retrieveDefaultDefinitionParameters = new JavaScriptFunctionRetrieveDefaultDefinitionParameters () { BindingRetrievalProperties = new JavaScriptFunctionBindingRetrievalProperties() { Script = javaScriptFunctionCode, UdfType = "Scalar" } }; CloudException cloudException = Assert.Throws <CloudException>( () => client.Functions.RetrieveDefaultDefinition(resourceGroupName, resourceName, functionName, retrieveDefaultDefinitionParameters)); Assert.Equal(HttpStatusCode.InternalServerError, cloudException.Response.StatusCode); Assert.Contains("not supported", cloudException.Error.Message, StringComparison.InvariantCulture); // Add the function Function javaScriptFunction = new Function(functionName) { Properties = new ScalarFunctionProperties() { Properties = new ScalarFunctionConfiguration() { Inputs = new List <FunctionInput>() { new FunctionInput() { DataType = "Any" } }, Output = new FunctionOutput() { DataType = "Any" }, Binding = new JavaScriptFunctionBinding() { Properties = new JavaScriptFunctionBindingProperties() { Script = javaScriptFunctionCode } } } } }; FunctionCreateOrUpdateParameters functionCreateOrUpdateParameters = new FunctionCreateOrUpdateParameters { Function = javaScriptFunction }; FunctionCreateOrUpdateResponse functionCreateOrUpdateResponse = client.Functions.CreateOrUpdate(resourceGroupName, resourceName, functionCreateOrUpdateParameters); Assert.Equal(HttpStatusCode.OK, functionCreateOrUpdateResponse.StatusCode); Assert.Equal(functionName, functionCreateOrUpdateResponse.Function.Name); var scalarFunctionProperties = (ScalarFunctionProperties)functionCreateOrUpdateResponse.Function.Properties; var javaScriptFunctionBinding = (JavaScriptFunctionBinding)scalarFunctionProperties.Properties.Binding; Assert.Equal(javaScriptFunctionCode, javaScriptFunctionBinding.Properties.Script); Assert.NotNull(functionCreateOrUpdateResponse.Function.Properties.Etag); // Get the function FunctionGetResponse functionGetResponse = client.Functions.Get(resourceGroupName, resourceName, functionName); Assert.Equal(HttpStatusCode.OK, functionGetResponse.StatusCode); Assert.Equal(functionName, functionGetResponse.Function.Name); scalarFunctionProperties = (ScalarFunctionProperties)functionGetResponse.Function.Properties; javaScriptFunctionBinding = (JavaScriptFunctionBinding)scalarFunctionProperties.Properties.Binding; Assert.Equal(javaScriptFunctionCode, javaScriptFunctionBinding.Properties.Script); Assert.Equal(functionCreateOrUpdateResponse.Function.Properties.Etag, functionGetResponse.Function.Properties.Etag); // List functions FunctionListResponse functionListResponse = client.Functions.ListFunctionsInJob(resourceGroupName, resourceName); Assert.Equal(HttpStatusCode.OK, functionListResponse.StatusCode); Assert.Equal(1, functionListResponse.Value.Count); // Check that there is 1 function in the job jobGetParameters = new JobGetParameters("functions"); jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters); Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode); Assert.Equal(1, jobGetResponse.Job.Properties.Functions.Count); // Test function connectivity ResourceTestConnectionResponse response = client.Functions.TestConnection(resourceGroupName, resourceName, functionName); Assert.Equal(OperationStatus.Failed, response.Status); Assert.Equal(ResourceTestStatus.TestFailed, response.ResourceTestStatus); Assert.NotNull(response.Error); Assert.Contains("not supported", response.Error.Message, StringComparison.InvariantCulture); // Update the function string newJavaScriptFunctionCode = @"function (x, y) { return x * y; }"; ScalarFunctionProperties scalarFunctionPropertiesForPatch = new ScalarFunctionProperties() { Properties = new ScalarFunctionConfiguration() { Binding = new JavaScriptFunctionBinding() { Properties = new JavaScriptFunctionBindingProperties() { Script = newJavaScriptFunctionCode } } } }; FunctionPatchParameters functionPatchParameters = new FunctionPatchParameters(scalarFunctionPropertiesForPatch); FunctionPatchResponse functionPatchResponse = client.Functions.Patch(resourceGroupName, resourceName, functionName, functionPatchParameters); Assert.Equal(HttpStatusCode.OK, functionPatchResponse.StatusCode); scalarFunctionProperties = (ScalarFunctionProperties)functionPatchResponse.Properties; javaScriptFunctionBinding = (JavaScriptFunctionBinding)scalarFunctionProperties.Properties.Binding; Assert.Equal(newJavaScriptFunctionCode, javaScriptFunctionBinding.Properties.Script); Assert.NotEqual(javaScriptFunctionCode, javaScriptFunctionBinding.Properties.Script); Assert.NotNull(functionPatchResponse.Properties.Etag); Assert.NotEqual(functionCreateOrUpdateResponse.Function.Properties.Etag, functionPatchResponse.Properties.Etag); // Delete the functions AzureOperationResponse deleteFunctionOperationResponse = client.Functions.Delete(resourceGroupName, resourceName, functionName); Assert.Equal(HttpStatusCode.OK, deleteFunctionOperationResponse.StatusCode); // Check that there are 0 functions in the job jobGetParameters = new JobGetParameters("functions"); jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters); Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode); Assert.Equal(0, jobGetResponse.Job.Properties.Functions.Count); } finally { client.StreamingJobs.Delete(resourceGroupName, resourceName); resourceClient.ResourceGroups.Delete(resourceGroupName); } } }