public void Test_FunctionOperations_Full_Scalar_AzureMLWebService()
{
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");
var retrieveDefaultDefinitionParameters = new AzureMachineLearningWebServiceFunctionRetrieveDefaultDefinitionParameters
()
{
BindingRetrievalProperties = new AzureMachineLearningWebServiceFunctionBindingRetrievalProperties()
{
ExecuteEndpoint = TestHelper.ExecuteEndpoint,
UdfType = "Scalar"
}
};
FunctionRetrieveDefaultDefinitionResponse retrieveDefaultDefinitionResponse =
client.Functions.RetrieveDefaultDefinition(resourceGroupName, resourceName, functionName,
retrieveDefaultDefinitionParameters);
Assert.Equal(functionName, retrieveDefaultDefinitionResponse.Function.Name);
// Add the function
ScalarFunctionProperties scalarFunctionProperties =
(ScalarFunctionProperties)retrieveDefaultDefinitionResponse.Function.Properties;
AzureMachineLearningWebServiceFunctionBinding azureMachineLearningWebServiceFunctionBinding =
(AzureMachineLearningWebServiceFunctionBinding)scalarFunctionProperties.Properties.Binding;
Assert.Equal(TestHelper.ExecuteEndpoint, azureMachineLearningWebServiceFunctionBinding.Properties.Endpoint);
Assert.Equal(1000, azureMachineLearningWebServiceFunctionBinding.Properties.BatchSize);
Assert.Null(azureMachineLearningWebServiceFunctionBinding.Properties.ApiKey);
azureMachineLearningWebServiceFunctionBinding.Properties.ApiKey = TestHelper.ApiKey;
FunctionCreateOrUpdateParameters functionCreateOrUpdateParameters =
new FunctionCreateOrUpdateParameters {
Function = retrieveDefaultDefinitionResponse.Function
};
FunctionCreateOrUpdateResponse functionCreateOrUpdateResponse = client.Functions.CreateOrUpdate(resourceGroupName, resourceName, functionCreateOrUpdateParameters);
Assert.Equal(HttpStatusCode.OK, functionCreateOrUpdateResponse.StatusCode);
Assert.Equal(functionName, functionCreateOrUpdateResponse.Function.Name);
scalarFunctionProperties =
(ScalarFunctionProperties)functionCreateOrUpdateResponse.Function.Properties;
azureMachineLearningWebServiceFunctionBinding =
(AzureMachineLearningWebServiceFunctionBinding)scalarFunctionProperties.Properties.Binding;
Assert.Equal(TestHelper.ExecuteEndpoint, azureMachineLearningWebServiceFunctionBinding.Properties.Endpoint);
Assert.Equal(1000, azureMachineLearningWebServiceFunctionBinding.Properties.BatchSize);
Assert.Null(azureMachineLearningWebServiceFunctionBinding.Properties.ApiKey);
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;
azureMachineLearningWebServiceFunctionBinding =
(AzureMachineLearningWebServiceFunctionBinding)scalarFunctionProperties.Properties.Binding;
Assert.Equal(TestHelper.ExecuteEndpoint, azureMachineLearningWebServiceFunctionBinding.Properties.Endpoint);
Assert.Equal(1000, azureMachineLearningWebServiceFunctionBinding.Properties.BatchSize);
Assert.Null(azureMachineLearningWebServiceFunctionBinding.Properties.ApiKey);
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.Succeeded, response.Status);
Assert.Equal(ResourceTestStatus.TestSucceeded, response.ResourceTestStatus);
// Update the function
ScalarFunctionProperties scalarFunctionPropertiesForPatch = new ScalarFunctionProperties()
{
Properties = new ScalarFunctionConfiguration()
{
Binding = new AzureMachineLearningWebServiceFunctionBinding()
{
Properties = new AzureMachineLearningWebServiceFunctionBindingProperties()
{
BatchSize = 256
}
}
}
};
FunctionPatchParameters functionPatchParameters = new FunctionPatchParameters(scalarFunctionPropertiesForPatch);
FunctionPatchResponse functionPatchResponse = client.Functions.Patch(resourceGroupName, resourceName, functionName, functionPatchParameters);
Assert.Equal(HttpStatusCode.OK, functionPatchResponse.StatusCode);
scalarFunctionProperties =
(ScalarFunctionProperties)functionPatchResponse.Properties;
azureMachineLearningWebServiceFunctionBinding =
(AzureMachineLearningWebServiceFunctionBinding)scalarFunctionProperties.Properties.Binding;
Assert.Equal(TestHelper.ExecuteEndpoint, azureMachineLearningWebServiceFunctionBinding.Properties.Endpoint);
Assert.Equal(256, azureMachineLearningWebServiceFunctionBinding.Properties.BatchSize);
Assert.Null(azureMachineLearningWebServiceFunctionBinding.Properties.ApiKey);
Assert.NotNull(functionPatchResponse.Properties.Etag);
Assert.NotEqual(functionCreateOrUpdateResponse.Function.Properties.Etag, functionPatchResponse.Properties.Etag);
// Add second function
string functionName2 = TestUtilities.GenerateName("functiontest");
Function function2 = new Function(functionName2)
{
Properties = retrieveDefaultDefinitionResponse.Function.Properties
};
functionCreateOrUpdateParameters.Function = function2;
functionCreateOrUpdateResponse = client.Functions.CreateOrUpdate(resourceGroupName, resourceName, functionCreateOrUpdateParameters);
// List functions
functionListResponse = client.Functions.ListFunctionsInJob(resourceGroupName, resourceName);
Assert.Equal(HttpStatusCode.OK, functionListResponse.StatusCode);
Assert.Equal(2, functionListResponse.Value.Count);
// Check that there are 2 functions in the job
jobGetParameters = new JobGetParameters("functions");
jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(2, jobGetResponse.Job.Properties.Functions.Count);
// Delete the functions
AzureOperationResponse deleteFunctionOperationResponse = client.Functions.Delete(resourceGroupName, resourceName, functionName);
Assert.Equal(HttpStatusCode.OK, deleteFunctionOperationResponse.StatusCode);
deleteFunctionOperationResponse = client.Functions.Delete(resourceGroupName, resourceName, functionName2);
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);
}
}
}
public async Task FunctionOperationsTest_Scalar_AzureMLWebService()
{
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
});
var expectedFunction = new Function()
{
Properties = new ScalarFunctionProperties()
{
Inputs = new List <FunctionInput>()
{
new FunctionInput()
{
DataType = @"nvarchar(max)",
IsConfigurationParameter = null
}
},
Output = new FunctionOutput()
{
DataType = @"nvarchar(max)"
},
Binding = new AzureMachineLearningWebServiceFunctionBinding()
{
Endpoint = TestHelper.ExecuteEndpoint,
ApiKey = null,
Inputs = new AzureMachineLearningWebServiceInputs()
{
Name = "input1",
ColumnNames = new AzureMachineLearningWebServiceInputColumn[]
{
new AzureMachineLearningWebServiceInputColumn()
{
Name = "tweet",
DataType = "string",
MapTo = 0
}
}
},
Outputs = new List <AzureMachineLearningWebServiceOutputColumn>()
{
new AzureMachineLearningWebServiceOutputColumn()
{
Name = "Sentiment",
DataType = "string"
}
},
BatchSize = 1000
}
}
};
// PUT job
streamAnalyticsManagementClient.StreamingJobs.CreateOrReplace(TestHelper.GetDefaultStreamingJob(), resourceGroupName, jobName);
// Retrieve default definition
AzureMachineLearningWebServiceFunctionRetrieveDefaultDefinitionParameters retrieveDefaultDefinitionParameters = new AzureMachineLearningWebServiceFunctionRetrieveDefaultDefinitionParameters()
{
UdfType = UdfType.Scalar,
ExecuteEndpoint = TestHelper.ExecuteEndpoint
};
var function = streamAnalyticsManagementClient.Functions.RetrieveDefaultDefinition(resourceGroupName, jobName, functionName, retrieveDefaultDefinitionParameters);
Assert.Equal(functionName, function.Name);
Assert.Null(function.Id);
Assert.Null(function.Type);
ValidationHelper.ValidateFunctionProperties(expectedFunction.Properties, function.Properties, false);
// PUT function
((AzureMachineLearningWebServiceFunctionBinding)((ScalarFunctionProperties)function.Properties).Binding).ApiKey = TestHelper.ApiKey;
var putResponse = await streamAnalyticsManagementClient.Functions.CreateOrReplaceWithHttpMessagesAsync(function, resourceGroupName, jobName, functionName);
((AzureMachineLearningWebServiceFunctionBinding)((ScalarFunctionProperties)function.Properties).Binding).ApiKey = null; // Null out because secrets are not returned in responses
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("TestSucceeded", testResult.Status);
Assert.Null(testResult.Error);
// PATCH function
var functionPatch = new Function()
{
Properties = new ScalarFunctionProperties()
{
Binding = new AzureMachineLearningWebServiceFunctionBinding()
{
BatchSize = 5000
}
}
};
((AzureMachineLearningWebServiceFunctionBinding)((ScalarFunctionProperties)putResponse.Body.Properties).Binding).BatchSize = ((AzureMachineLearningWebServiceFunctionBinding)((ScalarFunctionProperties)functionPatch.Properties).Binding).BatchSize;
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);
}
}
