public override void ExecuteCmdlet()
{
if (ResourceGroupName != null && string.IsNullOrWhiteSpace(ResourceGroupName))
{
throw new PSArgumentNullException("ResourceGroupName");
}
if (JobName != null && string.IsNullOrWhiteSpace(JobName))
{
throw new PSArgumentNullException("JobName");
}
if (Name != null && string.IsNullOrWhiteSpace(Name))
{
throw new PSArgumentNullException("Name");
}
try
{
ResourceTestConnectionResponse response = StreamAnalyticsClient.TestPSFunction(ResourceGroupName, JobName, Name);
if (response.StatusCode == HttpStatusCode.OK && response.ResourceTestStatus == ResourceTestStatus.TestSucceeded)
{
WriteObject(true);
}
else if (response.StatusCode == HttpStatusCode.NoContent)
{
WriteWarning(string.Format(CultureInfo.InvariantCulture, Resources.FunctionNotFound, Name, JobName, ResourceGroupName));
}
else
{
string errorId = null;
string errorMessage = null;
string innerErrorMessage = null;
if (response.Error != null)
{
errorId = response.Error.Code;
errorMessage = response.Error.Message;
if (response.Error.Details != null)
{
innerErrorMessage = response.Error.Details.Message;
}
}
Exception ex = new Exception(errorMessage, new Exception(innerErrorMessage));
WriteError(new ErrorRecord(ex, errorId, ErrorCategory.ConnectionError, null));
}
}
catch
{
WriteObject(false);
}
}
public void Test_InputOperations_IoTHub()
{
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);
// Construct the Input
string sharedAccessPolicyName = "owner";
InputProperties inputProperties = new StreamInputProperties()
{
Serialization = new CsvSerialization()
{
Properties = new CsvSerializationProperties()
{
FieldDelimiter = ",",
Encoding = "UTF8"
}
},
DataSource = new IoTHubStreamInputDataSource()
{
Properties = new IoTHubStreamInputDataSourceProperties()
{
IotHubNamespace = TestHelper.IoTHubNamespace,
SharedAccessPolicyName = sharedAccessPolicyName,
SharedAccessPolicyKey = TestHelper.IotHubSharedAccessPolicyKey
}
}
};
string inputName = TestUtilities.GenerateName("inputtest");
Input input1 = new Input(inputName)
{
Properties = inputProperties
};
// Add an input
InputCreateOrUpdateParameters inputCreateOrUpdateParameters = new InputCreateOrUpdateParameters();
inputCreateOrUpdateParameters.Input = input1;
InputCreateOrUpdateResponse inputCreateOrUpdateResponse = client.Inputs.CreateOrUpdate(resourceGroupName, resourceName, inputCreateOrUpdateParameters);
Assert.Equal(HttpStatusCode.OK, inputCreateOrUpdateResponse.StatusCode);
Assert.Equal(inputName, inputCreateOrUpdateResponse.Input.Name);
Assert.Equal("Stream", inputCreateOrUpdateResponse.Input.Properties.Type);
Assert.True(inputCreateOrUpdateResponse.Input.Properties.Serialization is CsvSerialization);
CsvSerialization csvSerializationInResponse1 = (CsvSerialization)inputCreateOrUpdateResponse.Input.Properties.Serialization;
Assert.Equal(",", csvSerializationInResponse1.Properties.FieldDelimiter);
Assert.True(inputCreateOrUpdateResponse.Input.Properties is StreamInputProperties);
StreamInputProperties streamInputPropertiesInResponse = (StreamInputProperties)inputCreateOrUpdateResponse.Input.Properties;
Assert.True(streamInputPropertiesInResponse.DataSource is IoTHubStreamInputDataSource);
IoTHubStreamInputDataSource iotHubInputDataSourceInResponse1 = (IoTHubStreamInputDataSource)streamInputPropertiesInResponse.DataSource;
Assert.Equal(sharedAccessPolicyName, iotHubInputDataSourceInResponse1.Properties.SharedAccessPolicyName);
Assert.NotNull(streamInputPropertiesInResponse.Etag);
// Get the input
InputGetResponse inputGetResponse = client.Inputs.Get(resourceGroupName, resourceName, inputName);
Assert.Equal(HttpStatusCode.OK, inputGetResponse.StatusCode);
Assert.Equal(inputName, inputGetResponse.Input.Name);
Assert.True(inputGetResponse.Input.Properties is StreamInputProperties);
StreamInputProperties streamInputPropertiesInResponse2 = (StreamInputProperties)inputGetResponse.Input.Properties;
Assert.True(streamInputPropertiesInResponse2.DataSource is IoTHubStreamInputDataSource);
IoTHubStreamInputDataSource iotHubInputDataSourceInResponse2 = (IoTHubStreamInputDataSource)streamInputPropertiesInResponse2.DataSource;
Assert.Equal(sharedAccessPolicyName, iotHubInputDataSourceInResponse2.Properties.SharedAccessPolicyName);
Assert.Equal(inputCreateOrUpdateResponse.Input.Properties.Etag, inputGetResponse.Input.Properties.Etag);
// Test input connectivity
ResourceTestConnectionResponse response = client.Inputs.TestConnection(resourceGroupName, resourceName, inputName);
Assert.Equal(OperationStatus.Succeeded, response.Status);
Assert.Equal(ResourceTestStatus.TestSucceeded, response.ResourceTestStatus);
// Update the input
string newSharedPolicyName = TestUtilities.GenerateName("owner");
inputProperties = new StreamInputProperties()
{
Serialization = new CsvSerialization()
{
Properties = new CsvSerializationProperties()
{
FieldDelimiter = "|",
Encoding = "UTF8"
}
},
DataSource = new IoTHubStreamInputDataSource()
{
Properties = new IoTHubStreamInputDataSourceProperties()
{
IotHubNamespace = TestHelper.IoTHubNamespace,
SharedAccessPolicyName = newSharedPolicyName,
SharedAccessPolicyKey = TestHelper.IotHubSharedAccessPolicyKey
}
}
};
inputProperties.Etag = inputCreateOrUpdateResponse.Input.Properties.Etag;
InputPatchParameters inputPatchParameters = new InputPatchParameters(inputProperties);
InputPatchResponse inputPatchResponse = client.Inputs.Patch(resourceGroupName, resourceName, inputName, inputPatchParameters);
Assert.Equal(HttpStatusCode.OK, inputPatchResponse.StatusCode);
Assert.True(inputPatchResponse.Properties.Serialization is CsvSerialization);
CsvSerialization csvSerializationInResponse2 = (CsvSerialization)inputPatchResponse.Properties.Serialization;
Assert.Equal("|", csvSerializationInResponse2.Properties.FieldDelimiter);
Assert.True(inputPatchResponse.Properties is StreamInputProperties);
StreamInputProperties streamInputPropertiesInResponse3 = (StreamInputProperties)inputPatchResponse.Properties;
Assert.True(streamInputPropertiesInResponse3.DataSource is IoTHubStreamInputDataSource);
IoTHubStreamInputDataSource iotHubInputDataSourceInResponse3 = (IoTHubStreamInputDataSource)streamInputPropertiesInResponse3.DataSource;
Assert.Equal(newSharedPolicyName, iotHubInputDataSourceInResponse3.Properties.SharedAccessPolicyName);
Assert.NotNull(inputPatchResponse.Properties.Etag);
Assert.NotEqual(streamInputPropertiesInResponse.Etag, inputPatchResponse.Properties.Etag);
// Delete the input
AzureOperationResponse deleteInputOperationResponse = client.Inputs.Delete(resourceGroupName, resourceName, inputName);
Assert.Equal(HttpStatusCode.OK, deleteInputOperationResponse.StatusCode);
// Check that there are 0 inputs in the job
jobGetParameters = new JobGetParameters("inputs");
jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(0, jobGetResponse.Job.Properties.Inputs.Count);
}
finally
{
client.StreamingJobs.Delete(resourceGroupName, resourceName);
resourceClient.ResourceGroups.Delete(resourceGroupName);
}
}
}
public void Test_InputOperations_ReferenceBlob()
{
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);
// Construct the Input
StorageAccount storageAccount = new StorageAccount();
storageAccount.AccountName = TestHelper.AccountName;
storageAccount.AccountKey = TestHelper.AccountKey;
InputProperties inputProperties = new ReferenceInputProperties()
{
Serialization = new CsvSerialization()
{
Properties = new CsvSerializationProperties()
{
FieldDelimiter = ",",
Encoding = "UTF8"
}
},
DataSource = new BlobReferenceInputDataSource()
{
Properties = new BlobReferenceInputDataSourceProperties()
{
StorageAccounts = new[] { storageAccount },
Container = "state",
PathPattern = "{date}",
DateFormat = "yyyy/MM/dd"
}
}
};
string inputName = TestUtilities.GenerateName("inputtest");
Input input1 = new Input(inputName)
{
Properties = inputProperties
};
// Add an input
InputCreateOrUpdateParameters inputCreateOrUpdateParameters = new InputCreateOrUpdateParameters();
inputCreateOrUpdateParameters.Input = input1;
InputCreateOrUpdateResponse inputCreateOrUpdateResponse = client.Inputs.CreateOrUpdate(resourceGroupName, resourceName, inputCreateOrUpdateParameters);
Assert.Equal(HttpStatusCode.OK, inputCreateOrUpdateResponse.StatusCode);
Assert.Equal(inputName, inputCreateOrUpdateResponse.Input.Name);
Assert.Equal("Reference", inputCreateOrUpdateResponse.Input.Properties.Type);
Assert.True(inputCreateOrUpdateResponse.Input.Properties is ReferenceInputProperties);
ReferenceInputProperties referenceInputPropertiesInResponse1 = (ReferenceInputProperties)inputCreateOrUpdateResponse.Input.Properties;
Assert.True(referenceInputPropertiesInResponse1.DataSource is BlobReferenceInputDataSource);
BlobReferenceInputDataSource blobReferenceInputDataSourceInResponse1 = (BlobReferenceInputDataSource)referenceInputPropertiesInResponse1.DataSource;
Assert.Equal("{date}", blobReferenceInputDataSourceInResponse1.Properties.PathPattern);
Assert.Equal("yyyy/MM/dd", blobReferenceInputDataSourceInResponse1.Properties.DateFormat);
Assert.NotNull(inputCreateOrUpdateResponse.Input.Properties.Etag);
// Get the input
InputGetResponse inputGetResponse = client.Inputs.Get(resourceGroupName, resourceName, inputName);
Assert.Equal(HttpStatusCode.OK, inputGetResponse.StatusCode);
Assert.Equal(inputName, inputGetResponse.Input.Name);
Assert.True(inputGetResponse.Input.Properties is ReferenceInputProperties);
ReferenceInputProperties referenceInputPropertiesInResponse2 = (ReferenceInputProperties)inputGetResponse.Input.Properties;
Assert.True(referenceInputPropertiesInResponse2.DataSource is BlobReferenceInputDataSource);
BlobReferenceInputDataSource blobReferenceInputDataSourceInResponse2 = (BlobReferenceInputDataSource)referenceInputPropertiesInResponse2.DataSource;
Assert.Equal("{date}", blobReferenceInputDataSourceInResponse2.Properties.PathPattern);
Assert.Equal("yyyy/MM/dd", blobReferenceInputDataSourceInResponse2.Properties.DateFormat);
Assert.Equal(inputCreateOrUpdateResponse.Input.Properties.Etag, inputGetResponse.Input.Properties.Etag);
// List inputs
InputListResponse inputListResponse = client.Inputs.ListInputInJob(resourceGroupName, resourceName, new InputListParameters());
Assert.Equal(HttpStatusCode.OK, inputListResponse.StatusCode);
Assert.Equal(1, inputListResponse.Value.Count);
// Test input connectivity
ResourceTestConnectionResponse response = client.Inputs.TestConnection(resourceGroupName, resourceName, inputName);
Assert.Equal(OperationStatus.Succeeded, response.Status);
Assert.Equal(ResourceTestStatus.TestSucceeded, response.ResourceTestStatus);
// Update the input
BlobReferenceInputDataSource blobReferenceInputDataSource = new BlobReferenceInputDataSource()
{
Properties = new BlobReferenceInputDataSourceProperties()
{
StorageAccounts = new[] { storageAccount },
Container = "state",
PathPattern = "test.csv",
DateFormat = "yyyy/MM/dd"
}
};
((ReferenceInputProperties)inputProperties).DataSource = blobReferenceInputDataSource;
inputProperties.Etag = inputCreateOrUpdateResponse.Input.Properties.Etag;
InputPatchParameters inputPatchParameters = new InputPatchParameters(inputProperties);
InputPatchResponse inputPatchResponse = client.Inputs.Patch(resourceGroupName, resourceName, inputName, inputPatchParameters);
Assert.Equal(HttpStatusCode.OK, inputPatchResponse.StatusCode);
Assert.True(inputPatchResponse.Properties is ReferenceInputProperties);
ReferenceInputProperties referenceInputPropertiesInResponse3 = (ReferenceInputProperties)inputPatchResponse.Properties;
Assert.True(referenceInputPropertiesInResponse3.DataSource is BlobReferenceInputDataSource);
BlobReferenceInputDataSource blobReferenceInputDataSourceInResponse3 = (BlobReferenceInputDataSource)referenceInputPropertiesInResponse3.DataSource;
Assert.Equal("test.csv", blobReferenceInputDataSourceInResponse3.Properties.PathPattern);
Assert.Equal("yyyy/MM/dd", blobReferenceInputDataSourceInResponse3.Properties.DateFormat);
Assert.NotNull(inputPatchResponse.Properties.Etag);
Assert.NotEqual(inputCreateOrUpdateResponse.Input.Properties.Etag, inputPatchResponse.Properties.Etag);
// Delete the inputs
AzureOperationResponse deleteInputOperationResponse = client.Inputs.Delete(resourceGroupName, resourceName, inputName);
Assert.Equal(HttpStatusCode.OK, deleteInputOperationResponse.StatusCode);
// Check that there are 0 inputs in the job
jobGetParameters = new JobGetParameters("inputs");
jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(0, jobGetResponse.Job.Properties.Inputs.Count);
}
finally
{
client.StreamingJobs.Delete(resourceGroupName, resourceName);
resourceClient.ResourceGroups.Delete(resourceGroupName);
}
}
}
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);
}
}
}
/// <param name='operationStatusLink'>
/// Required. Location value returned by the Begin operation.
/// </param>
/// <param name='cancellationToken'>
/// Cancellation token.
/// </param>
/// <returns>
/// The test result of the input or output data source.
/// </returns>
public async Task <ResourceTestConnectionResponse> GetTestConnectionStatusAsync(string operationStatusLink, CancellationToken cancellationToken)
{
// Validate
if (operationStatusLink == null)
{
throw new ArgumentNullException("operationStatusLink");
}
// Tracing
bool shouldTrace = TracingAdapter.IsEnabled;
string invocationId = null;
if (shouldTrace)
{
invocationId = TracingAdapter.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("operationStatusLink", operationStatusLink);
TracingAdapter.Enter(invocationId, this, "GetTestConnectionStatusAsync", tracingParameters);
}
// Construct URL
string url = "";
url = url + operationStatusLink;
url = url.Replace(" ", "%20");
// Create HTTP transport objects
HttpRequestMessage httpRequest = null;
try
{
httpRequest = new HttpRequestMessage();
httpRequest.Method = HttpMethod.Get;
httpRequest.RequestUri = new Uri(url);
// Set Headers
httpRequest.Headers.Add("x-ms-client-request-id", Guid.NewGuid().ToString());
// Set Credentials
cancellationToken.ThrowIfCancellationRequested();
await this.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false);
// Send Request
HttpResponseMessage httpResponse = null;
try
{
if (shouldTrace)
{
TracingAdapter.SendRequest(invocationId, httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
httpResponse = await this.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
if (shouldTrace)
{
TracingAdapter.ReceiveResponse(invocationId, httpResponse);
}
HttpStatusCode statusCode = httpResponse.StatusCode;
if (statusCode != HttpStatusCode.OK && statusCode != HttpStatusCode.Accepted && statusCode != HttpStatusCode.NoContent && statusCode != HttpStatusCode.BadRequest)
{
cancellationToken.ThrowIfCancellationRequested();
CloudException ex = CloudException.Create(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false));
if (shouldTrace)
{
TracingAdapter.Error(invocationId, ex);
}
throw ex;
}
// Create Result
ResourceTestConnectionResponse result = null;
// Deserialize Response
if (statusCode == HttpStatusCode.OK || statusCode == HttpStatusCode.Accepted || statusCode == HttpStatusCode.NoContent || statusCode == HttpStatusCode.BadRequest)
{
cancellationToken.ThrowIfCancellationRequested();
string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
result = new ResourceTestConnectionResponse();
JToken responseDoc = null;
if (string.IsNullOrEmpty(responseContent) == false)
{
responseDoc = JToken.Parse(responseContent);
}
if (responseDoc != null && responseDoc.Type != JTokenType.Null)
{
JToken statusValue = responseDoc["status"];
if (statusValue != null && statusValue.Type != JTokenType.Null)
{
string statusInstance = ((string)statusValue);
result.ResourceTestStatus = statusInstance;
}
JToken errorValue = responseDoc["error"];
if (errorValue != null && errorValue.Type != JTokenType.Null)
{
ErrorResponse errorInstance = new ErrorResponse();
result.Error = errorInstance;
JToken codeValue = errorValue["code"];
if (codeValue != null && codeValue.Type != JTokenType.Null)
{
string codeInstance = ((string)codeValue);
errorInstance.Code = codeInstance;
}
JToken messageValue = errorValue["message"];
if (messageValue != null && messageValue.Type != JTokenType.Null)
{
string messageInstance = ((string)messageValue);
errorInstance.Message = messageInstance;
}
JToken detailsValue = errorValue["details"];
if (detailsValue != null && detailsValue.Type != JTokenType.Null)
{
ErrorDetailsResponse detailsInstance = new ErrorDetailsResponse();
errorInstance.Details = detailsInstance;
JToken codeValue2 = detailsValue["code"];
if (codeValue2 != null && codeValue2.Type != JTokenType.Null)
{
string codeInstance2 = ((string)codeValue2);
detailsInstance.Code = codeInstance2;
}
JToken messageValue2 = detailsValue["message"];
if (messageValue2 != null && messageValue2.Type != JTokenType.Null)
{
string messageInstance2 = ((string)messageValue2);
detailsInstance.Message = messageInstance2;
}
}
}
}
}
result.StatusCode = statusCode;
if (httpResponse.Headers.Contains("x-ms-request-id"))
{
result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
}
if (statusCode == HttpStatusCode.BadRequest)
{
result.Status = OperationStatus.Failed;
}
if (statusCode == HttpStatusCode.NotFound)
{
result.Status = OperationStatus.Failed;
}
if (result.ResourceTestStatus == ResourceTestStatus.TestFailed)
{
result.Status = OperationStatus.Failed;
}
if (result.ResourceTestStatus == ResourceTestStatus.TestSucceeded)
{
result.Status = OperationStatus.Succeeded;
}
if (shouldTrace)
{
TracingAdapter.Exit(invocationId, result);
}
return(result);
}
finally
{
if (httpResponse != null)
{
httpResponse.Dispose();
}
}
}
finally
{
if (httpRequest != null)
{
httpRequest.Dispose();
}
}
}
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);
}
}
}
