public async Task TransformationOperationsTest()
{
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
string resourceGroupName = TestUtilities.GenerateName("sjrg");
string jobName = TestUtilities.GenerateName("sj");
string transformationName = TestUtilities.GenerateName("transformation");
var resourceManagementClient = this.GetResourceManagementClient(context);
var streamAnalyticsManagementClient = this.GetStreamAnalyticsManagementClient(context);
string expectedTransformationType = TestHelper.GetFullRestOnlyResourceType(TestHelper.TransformationResourceType);
string expectedTransformationResourceId = TestHelper.GetRestOnlyResourceId(streamAnalyticsManagementClient.SubscriptionId, resourceGroupName, jobName, TestHelper.TransformationResourceType, transformationName);
resourceManagementClient.ResourceGroups.CreateOrUpdate(resourceGroupName, new ResourceGroup {
Location = TestHelper.DefaultLocation
});
Transformation transformation = new Transformation()
{
Query = "Select Id, Name from inputtest",
StreamingUnits = 6
};
// PUT job
streamAnalyticsManagementClient.StreamingJobs.CreateOrReplace(TestHelper.GetDefaultStreamingJob(), resourceGroupName, jobName);
// PUT transformation
var putResponse = await streamAnalyticsManagementClient.Transformations.CreateOrReplaceWithHttpMessagesAsync(transformation, resourceGroupName, jobName, transformationName);
ValidationHelper.ValidateTransformation(transformation, putResponse.Body, false);
Assert.Equal(expectedTransformationResourceId, putResponse.Body.Id);
Assert.Equal(transformationName, putResponse.Body.Name);
Assert.Equal(expectedTransformationType, putResponse.Body.Type);
// Verify GET request returns expected transformation
var getResponse = await streamAnalyticsManagementClient.Transformations.GetWithHttpMessagesAsync(resourceGroupName, jobName, transformationName);
ValidationHelper.ValidateTransformation(putResponse.Body, getResponse.Body, true);
// ETag should be the same
Assert.Equal(putResponse.Headers.ETag, getResponse.Headers.ETag);
// PATCH transformation
var transformationPatch = new Transformation()
{
Query = "New query"
};
putResponse.Body.Query = transformationPatch.Query;
var patchResponse = await streamAnalyticsManagementClient.Transformations.UpdateWithHttpMessagesAsync(transformationPatch, resourceGroupName, jobName, transformationName);
ValidationHelper.ValidateTransformation(putResponse.Body, patchResponse.Body, true);
// ETag should be different after a PATCH operation
Assert.NotEqual(putResponse.Headers.ETag, patchResponse.Headers.ETag);
// Run another GET transformation to verify that it returns the newly updated properties as well
getResponse = await streamAnalyticsManagementClient.Transformations.GetWithHttpMessagesAsync(resourceGroupName, jobName, transformationName);
ValidationHelper.ValidateTransformation(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);
}
}
public async Task StreamingJobOperationsTest_FullJob()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
string resourceGroupName = TestUtilities.GenerateName("sjrg");
string jobName = TestUtilities.GenerateName("sj");
string inputName = "inputtest";
string transformationName = "transformationtest";
string outputName = "outputtest";
var resourceManagementClient = this.GetResourceManagementClient(context);
var streamAnalyticsManagementClient = this.GetStreamAnalyticsManagementClient(context);
string expectedJobResourceId = TestHelper.GetJobResourceId(streamAnalyticsManagementClient.SubscriptionId, resourceGroupName, jobName);
string expectedInputResourceId = TestHelper.GetRestOnlyResourceId(streamAnalyticsManagementClient.SubscriptionId, resourceGroupName, jobName, TestHelper.InputsResourceType, inputName);
string expectedTransformationResourceId = TestHelper.GetRestOnlyResourceId(streamAnalyticsManagementClient.SubscriptionId, resourceGroupName, jobName, TestHelper.TransformationResourceType, transformationName);
string expectedOutputResourceId = TestHelper.GetRestOnlyResourceId(streamAnalyticsManagementClient.SubscriptionId, resourceGroupName, jobName, TestHelper.OutputsResourceType, outputName);
resourceManagementClient.ResourceGroups.CreateOrUpdate(resourceGroupName, new ResourceGroup {
Location = TestHelper.DefaultLocation
});
StorageAccount storageAccount = new StorageAccount()
{
AccountName = TestHelper.AccountName,
AccountKey = TestHelper.AccountKey
};
Input input = new Input(id: expectedInputResourceId)
{
Name = inputName,
Properties = new StreamInputProperties()
{
Serialization = new JsonSerialization()
{
Encoding = Encoding.UTF8
},
Datasource = new BlobStreamInputDataSource()
{
StorageAccounts = new[] { storageAccount },
Container = TestHelper.Container,
PathPattern = "",
}
}
};
AzureSqlDatabaseOutputDataSource azureSqlDatabase = new AzureSqlDatabaseOutputDataSource()
{
Server = TestHelper.Server,
Database = TestHelper.Database,
User = TestHelper.User,
Password = TestHelper.Password,
Table = TestHelper.SqlTableName
};
Output output = new Output(id: expectedOutputResourceId)
{
Name = outputName,
Datasource = azureSqlDatabase
};
StreamingJob streamingJob = new StreamingJob()
{
Tags = new Dictionary <string, string>()
{
{ "key1", "value1" },
{ "randomKey", "randomValue" },
{ "key3", "value3" }
},
Location = TestHelper.DefaultLocation,
EventsOutOfOrderPolicy = EventsOutOfOrderPolicy.Drop,
EventsOutOfOrderMaxDelayInSeconds = 0,
EventsLateArrivalMaxDelayInSeconds = 5,
OutputErrorPolicy = OutputErrorPolicy.Drop,
DataLocale = "en-US",
CompatibilityLevel = "1.0",
Sku = new Microsoft.Azure.Management.StreamAnalytics.Models.Sku()
{
Name = SkuName.Standard
},
Inputs = new List <Input>()
{
input
},
Transformation = new Transformation(id: expectedTransformationResourceId)
{
Name = transformationName,
Query = "Select Id, Name from inputtest",
StreamingUnits = 1
},
Outputs = new List <Output>()
{
output
},
Functions = new List <Function>()
};
// PUT job
var putResponse = await streamAnalyticsManagementClient.StreamingJobs.CreateOrReplaceWithHttpMessagesAsync(streamingJob, resourceGroupName, jobName);
// Null out because secrets are not returned in responses
storageAccount.AccountKey = null;
azureSqlDatabase.Password = null;
ValidationHelper.ValidateStreamingJob(streamingJob, putResponse.Body, false);
Assert.Equal(expectedJobResourceId, putResponse.Body.Id);
Assert.Equal(jobName, putResponse.Body.Name);
Assert.Equal(TestHelper.StreamingJobFullResourceType, putResponse.Body.Type);
//Assert.True(putResponse.Body.CreatedDate > DateTime.UtcNow.AddMinutes(-1));
Assert.Equal("Succeeded", putResponse.Body.ProvisioningState);
Assert.Equal("Created", putResponse.Body.JobState);
// Verify GET request returns expected job
var getResponse = await streamAnalyticsManagementClient.StreamingJobs.GetWithHttpMessagesAsync(resourceGroupName, jobName, "inputs,outputs,transformation,functions");
ValidationHelper.ValidateStreamingJob(putResponse.Body, getResponse.Body, true);
// ETag should be the same
Assert.Equal(putResponse.Headers.ETag, getResponse.Headers.ETag);
// PATCH job
var streamingJobPatch = new StreamingJob()
{
EventsOutOfOrderPolicy = EventsOutOfOrderPolicy.Adjust,
OutputErrorPolicy = OutputErrorPolicy.Stop
};
putResponse.Body.EventsOutOfOrderPolicy = streamingJobPatch.EventsOutOfOrderPolicy;
putResponse.Body.OutputErrorPolicy = streamingJobPatch.OutputErrorPolicy;
putResponse.Body.Functions = null;
streamingJob.EventsOutOfOrderPolicy = streamingJobPatch.EventsOutOfOrderPolicy;
streamingJob.OutputErrorPolicy = streamingJobPatch.OutputErrorPolicy;
streamingJob.Inputs = null;
streamingJob.Transformation = null;
streamingJob.Outputs = null;
streamingJob.Functions = null;
var patchResponse = await streamAnalyticsManagementClient.StreamingJobs.UpdateWithHttpMessagesAsync(streamingJobPatch, resourceGroupName, jobName);
ValidationHelper.ValidateStreamingJob(streamingJob, patchResponse.Body, false);
// ETag should be different after a PATCH operation
Assert.NotEqual(putResponse.Headers.ETag, patchResponse.Headers.ETag);
putResponse.Body.Functions = new List <Function>();
// Run another GET job to verify that it returns the newly updated properties as well
getResponse = await streamAnalyticsManagementClient.StreamingJobs.GetWithHttpMessagesAsync(resourceGroupName, jobName, "inputs,outputs,transformation,functions");
ValidationHelper.ValidateStreamingJob(putResponse.Body, getResponse.Body, true);
Assert.NotEqual(putResponse.Headers.ETag, getResponse.Headers.ETag);
Assert.Equal(patchResponse.Headers.ETag, getResponse.Headers.ETag);
// List job and verify that the job shows up in the list
var listByRgResponse = streamAnalyticsManagementClient.StreamingJobs.ListByResourceGroup(resourceGroupName, "inputs,outputs,transformation,functions");
Assert.Single(listByRgResponse);
ValidationHelper.ValidateStreamingJob(putResponse.Body, listByRgResponse.Single(), true);
Assert.Equal(getResponse.Headers.ETag, listByRgResponse.Single().Etag);
var listReponse = streamAnalyticsManagementClient.StreamingJobs.List("inputs, outputs, transformation, functions");
Assert.Single(listReponse);
ValidationHelper.ValidateStreamingJob(putResponse.Body, listReponse.Single(), true);
Assert.Equal(getResponse.Headers.ETag, listReponse.Single().Etag);
// Start job
StartStreamingJobParameters startStreamingJobParameters = new StartStreamingJobParameters()
{
OutputStartMode = OutputStartMode.LastOutputEventTime
};
CloudException cloudException = Assert.Throws <CloudException>(() => streamAnalyticsManagementClient.StreamingJobs.Start(resourceGroupName, jobName, startStreamingJobParameters));
Assert.Equal((HttpStatusCode)422, cloudException.Response.StatusCode);
Assert.Contains("LastOutputEventTime must be available when OutputStartMode is set to LastOutputEventTime. Please make sure at least one output event has been processed.", cloudException.Response.Content);
startStreamingJobParameters.OutputStartMode = OutputStartMode.CustomTime;
startStreamingJobParameters.OutputStartTime = new DateTime(2012, 12, 12, 12, 12, 12, DateTimeKind.Utc);
putResponse.Body.OutputStartMode = startStreamingJobParameters.OutputStartMode;
putResponse.Body.OutputStartTime = startStreamingJobParameters.OutputStartTime;
streamingJob.OutputStartMode = startStreamingJobParameters.OutputStartMode;
streamingJob.OutputStartTime = startStreamingJobParameters.OutputStartTime;
streamAnalyticsManagementClient.StreamingJobs.Start(resourceGroupName, jobName, startStreamingJobParameters);
// Check that job started
var getResponseAfterStart = await streamAnalyticsManagementClient.StreamingJobs.GetWithHttpMessagesAsync(resourceGroupName, jobName);
Assert.Equal("Succeeded", getResponseAfterStart.Body.ProvisioningState);
Assert.True(getResponseAfterStart.Body.JobState == "Running" || getResponseAfterStart.Body.JobState == "Degraded");
Assert.Null(getResponseAfterStart.Body.Inputs);
Assert.Null(getResponseAfterStart.Body.Transformation);
Assert.Null(getResponseAfterStart.Body.Outputs);
Assert.Null(getResponseAfterStart.Body.Functions);
ValidationHelper.ValidateStreamingJob(streamingJob, getResponseAfterStart.Body, false);
Assert.NotEqual(putResponse.Headers.ETag, getResponseAfterStart.Headers.ETag);
Assert.NotEqual(patchResponse.Headers.ETag, getResponseAfterStart.Headers.ETag);
// Check diagnostics
var inputListResponse = streamAnalyticsManagementClient.Inputs.ListByStreamingJob(resourceGroupName, jobName, "*");
Assert.NotNull(inputListResponse);
Assert.Single(inputListResponse);
var inputFromList = inputListResponse.Single();
Assert.NotNull(inputFromList.Properties.Diagnostics);
Assert.Equal(2, inputFromList.Properties.Diagnostics.Conditions.Count());
Assert.NotNull(inputFromList.Properties.Diagnostics.Conditions[0].Since);
DateTime.Parse(inputFromList.Properties.Diagnostics.Conditions[0].Since);
Assert.Equal(@"INP-3", inputFromList.Properties.Diagnostics.Conditions[0].Code);
Assert.Equal(@"Could not deserialize the input event(s) from resource 'https://$testAccountName$.blob.core.windows.net/state/states1.csv' as Json. Some possible reasons: 1) Malformed events 2) Input source configured with incorrect serialization format", inputFromList.Properties.Diagnostics.Conditions[0].Message);
// Stop job
streamAnalyticsManagementClient.StreamingJobs.Stop(resourceGroupName, jobName);
// Check that job stopped
var getResponseAfterStop = await streamAnalyticsManagementClient.StreamingJobs.GetWithHttpMessagesAsync(resourceGroupName, jobName, "inputs,outputs,transformation,functions");
Assert.Equal("Succeeded", getResponseAfterStop.Body.ProvisioningState);
Assert.Equal("Stopped", getResponseAfterStop.Body.JobState);
ValidationHelper.ValidateStreamingJob(putResponse.Body, getResponseAfterStop.Body, false);
Assert.NotEqual(putResponse.Headers.ETag, getResponseAfterStop.Headers.ETag);
Assert.NotEqual(patchResponse.Headers.ETag, getResponseAfterStop.Headers.ETag);
Assert.NotEqual(getResponseAfterStart.Headers.ETag, getResponseAfterStop.Headers.ETag);
// Delete job
streamAnalyticsManagementClient.StreamingJobs.Delete(resourceGroupName, jobName);
// Verify that list operation returns an empty list after deleting the job
listByRgResponse = streamAnalyticsManagementClient.StreamingJobs.ListByResourceGroup(resourceGroupName, "inputs,outputs,transformation,functions");
Assert.Empty(listByRgResponse);
listReponse = streamAnalyticsManagementClient.StreamingJobs.List("inputs, outputs, transformation, functions");
Assert.Empty(listReponse);
}
}
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 AzureMachineLearningStudioFunctionBinding()
{
Endpoint = TestHelper.ExecuteEndpoint,
ApiKey = null,
Inputs = new AzureMachineLearningStudioInputs()
{
Name = "input1",
ColumnNames = new AzureMachineLearningStudioInputColumn[]
{
new AzureMachineLearningStudioInputColumn()
{
Name = "tweet",
DataType = "string",
MapTo = 0
}
}
},
Outputs = new List <AzureMachineLearningStudioOutputColumn>()
{
new AzureMachineLearningStudioOutputColumn()
{
Name = "Sentiment",
DataType = "string"
}
},
BatchSize = 1000
}
}
};
// PUT job
streamAnalyticsManagementClient.StreamingJobs.CreateOrReplace(TestHelper.GetDefaultStreamingJob(), resourceGroupName, jobName);
// Retrieve default definition
AzureMachineLearningStudioFunctionRetrieveDefaultDefinitionParameters retrieveDefaultDefinitionParameters = new AzureMachineLearningStudioFunctionRetrieveDefaultDefinitionParameters()
{
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
((AzureMachineLearningStudioFunctionBinding)((ScalarFunctionProperties)function.Properties).Binding).ApiKey = TestHelper.ApiKey;
var putResponse = await streamAnalyticsManagementClient.Functions.CreateOrReplaceWithHttpMessagesAsync(function, resourceGroupName, jobName, functionName);
((AzureMachineLearningStudioFunctionBinding)((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 AzureMachineLearningStudioFunctionBinding()
{
BatchSize = 5000
}
}
};
((AzureMachineLearningStudioFunctionBinding)((ScalarFunctionProperties)putResponse.Body.Properties).Binding).BatchSize = ((AzureMachineLearningStudioFunctionBinding)((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);
}
}
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 async Task InputOperationsTest_Reference_Blob()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
string resourceGroupName = TestUtilities.GenerateName("sjrg");
string jobName = TestUtilities.GenerateName("sj");
string inputName = TestUtilities.GenerateName("input");
var resourceManagementClient = this.GetResourceManagementClient(context);
var streamAnalyticsManagementClient = this.GetStreamAnalyticsManagementClient(context);
string expectedInputType = TestHelper.GetFullRestOnlyResourceType(TestHelper.InputsResourceType);
string expectedInputResourceId = TestHelper.GetRestOnlyResourceId(streamAnalyticsManagementClient.SubscriptionId, resourceGroupName, jobName, TestHelper.InputsResourceType, inputName);
resourceManagementClient.ResourceGroups.CreateOrUpdate(resourceGroupName, new ResourceGroup {
Location = TestHelper.DefaultLocation
});
StorageAccount storageAccount = new StorageAccount()
{
AccountName = TestHelper.AccountName,
AccountKey = TestHelper.AccountKey
};
Input input = new Input()
{
Properties = new ReferenceInputProperties()
{
Serialization = new CsvSerialization()
{
FieldDelimiter = ",",
Encoding = Encoding.UTF8
},
Datasource = new BlobReferenceInputDataSource()
{
StorageAccounts = new[] { storageAccount },
Container = TestHelper.Container,
PathPattern = "{date}/{time}",
DateFormat = "yyyy/MM/dd",
TimeFormat = "HH"
}
}
};
// PUT job
streamAnalyticsManagementClient.StreamingJobs.CreateOrReplace(TestHelper.GetDefaultStreamingJob(), resourceGroupName, jobName);
// PUT input
var putResponse = await streamAnalyticsManagementClient.Inputs.CreateOrReplaceWithHttpMessagesAsync(input, resourceGroupName, jobName, inputName);
storageAccount.AccountKey = null; // Null out because secrets are not returned in responses
ValidationHelper.ValidateInput(input, putResponse.Body, false);
Assert.Equal(expectedInputResourceId, putResponse.Body.Id);
Assert.Equal(inputName, putResponse.Body.Name);
Assert.Equal(expectedInputType, putResponse.Body.Type);
// Verify GET request returns expected input
var getResponse = await streamAnalyticsManagementClient.Inputs.GetWithHttpMessagesAsync(resourceGroupName, jobName, inputName);
ValidationHelper.ValidateInput(putResponse.Body, getResponse.Body, true);
// ETag should be the same
Assert.Equal(putResponse.Headers.ETag, getResponse.Headers.ETag);
// Test Input
var testResult = streamAnalyticsManagementClient.Inputs.Test(resourceGroupName, jobName, inputName);
Assert.Equal("TestSucceeded", testResult.Status);
Assert.Null(testResult.Error);
// PATCH input
var inputPatch = new Input()
{
Properties = new ReferenceInputProperties()
{
Serialization = new CsvSerialization()
{
FieldDelimiter = "|",
Encoding = Encoding.UTF8
},
Datasource = new BlobReferenceInputDataSource()
{
Container = "differentContainer"
}
}
};
((CsvSerialization)putResponse.Body.Properties.Serialization).FieldDelimiter = ((CsvSerialization)inputPatch.Properties.Serialization).FieldDelimiter;
((BlobReferenceInputDataSource)((ReferenceInputProperties)putResponse.Body.Properties).Datasource).Container = ((BlobReferenceInputDataSource)((ReferenceInputProperties)inputPatch.Properties).Datasource).Container;
var patchResponse = await streamAnalyticsManagementClient.Inputs.UpdateWithHttpMessagesAsync(inputPatch, resourceGroupName, jobName, inputName);
ValidationHelper.ValidateInput(putResponse.Body, patchResponse.Body, true);
// ETag should be different after a PATCH operation
Assert.NotEqual(putResponse.Headers.ETag, patchResponse.Headers.ETag);
// Run another GET input to verify that it returns the newly updated properties as well
getResponse = await streamAnalyticsManagementClient.Inputs.GetWithHttpMessagesAsync(resourceGroupName, jobName, inputName);
ValidationHelper.ValidateInput(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 input and verify that the input shows up in the list
var listResult = streamAnalyticsManagementClient.Inputs.ListByStreamingJob(resourceGroupName, jobName);
Assert.Single(listResult);
ValidationHelper.ValidateInput(putResponse.Body, listResult.Single(), true);
Assert.Equal(getResponse.Headers.ETag, listResult.Single().Properties.Etag);
// Get job with input expanded and verify that the input shows up
var getJobResponse = streamAnalyticsManagementClient.StreamingJobs.Get(resourceGroupName, jobName, "inputs");
Assert.Single(getJobResponse.Inputs);
ValidationHelper.ValidateInput(putResponse.Body, getJobResponse.Inputs.Single(), true);
Assert.Equal(getResponse.Headers.ETag, getJobResponse.Inputs.Single().Properties.Etag);
// Delete input
streamAnalyticsManagementClient.Inputs.Delete(resourceGroupName, jobName, inputName);
// Verify that list operation returns an empty list after deleting the input
listResult = streamAnalyticsManagementClient.Inputs.ListByStreamingJob(resourceGroupName, jobName);
Assert.Empty(listResult);
// Get job with input expanded and verify that there are no inputs after deleting the input
getJobResponse = streamAnalyticsManagementClient.StreamingJobs.Get(resourceGroupName, jobName, "inputs");
Assert.Empty(getJobResponse.Inputs);
}
}
public async Task InputOperationsTest_Stream_IoTHub()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
string resourceGroupName = TestUtilities.GenerateName("sjrg");
string jobName = TestUtilities.GenerateName("sj");
string inputName = TestUtilities.GenerateName("input");
var resourceManagementClient = this.GetResourceManagementClient(context);
var streamAnalyticsManagementClient = this.GetStreamAnalyticsManagementClient(context);
string expectedInputType = TestHelper.GetFullRestOnlyResourceType(TestHelper.InputsResourceType);
string expectedInputResourceId = TestHelper.GetRestOnlyResourceId(streamAnalyticsManagementClient.SubscriptionId, resourceGroupName, jobName, TestHelper.InputsResourceType, inputName);
resourceManagementClient.ResourceGroups.CreateOrUpdate(resourceGroupName, new ResourceGroup {
Location = TestHelper.DefaultLocation
});
IoTHubStreamInputDataSource iotHub = new IoTHubStreamInputDataSource()
{
IotHubNamespace = TestHelper.IoTHubNamespace,
SharedAccessPolicyName = TestHelper.IoTSharedAccessPolicyName,
SharedAccessPolicyKey = TestHelper.IoTHubSharedAccessPolicyKey,
Endpoint = "messages/events",
ConsumerGroupName = "sdkconsumergroup"
};
Input input = new Input()
{
Properties = new StreamInputProperties()
{
Serialization = new AvroSerialization(),
Datasource = iotHub
}
};
// PUT job
streamAnalyticsManagementClient.StreamingJobs.CreateOrReplace(TestHelper.GetDefaultStreamingJob(), resourceGroupName, jobName);
// PUT input
var putResponse = await streamAnalyticsManagementClient.Inputs.CreateOrReplaceWithHttpMessagesAsync(input, resourceGroupName, jobName, inputName);
iotHub.SharedAccessPolicyKey = null; // Null out because secrets are not returned in responses
ValidationHelper.ValidateInput(input, putResponse.Body, false);
Assert.Equal(expectedInputResourceId, putResponse.Body.Id);
Assert.Equal(inputName, putResponse.Body.Name);
Assert.Equal(expectedInputType, putResponse.Body.Type);
// Verify GET request returns expected input
var getResponse = await streamAnalyticsManagementClient.Inputs.GetWithHttpMessagesAsync(resourceGroupName, jobName, inputName);
ValidationHelper.ValidateInput(putResponse.Body, getResponse.Body, true);
// ETag should be the same
Assert.Equal(putResponse.Headers.ETag, getResponse.Headers.ETag);
// Test Input
var testResult = streamAnalyticsManagementClient.Inputs.Test(resourceGroupName, jobName, inputName);
Assert.Equal("TestSucceeded", testResult.Status);
Assert.Null(testResult.Error);
// PATCH input
var inputPatch = new Input()
{
Properties = new StreamInputProperties()
{
Serialization = new CsvSerialization()
{
FieldDelimiter = "|",
Encoding = Encoding.UTF8
},
Datasource = new IoTHubStreamInputDataSource()
{
Endpoint = "messages/operationsMonitoringEvents"
}
}
};
putResponse.Body.Properties.Serialization = inputPatch.Properties.Serialization;
((IoTHubStreamInputDataSource)((StreamInputProperties)putResponse.Body.Properties).Datasource).Endpoint = ((IoTHubStreamInputDataSource)((StreamInputProperties)inputPatch.Properties).Datasource).Endpoint;
var patchResponse = await streamAnalyticsManagementClient.Inputs.UpdateWithHttpMessagesAsync(inputPatch, resourceGroupName, jobName, inputName);
ValidationHelper.ValidateInput(putResponse.Body, patchResponse.Body, true);
// ETag should be different after a PATCH operation
Assert.NotEqual(putResponse.Headers.ETag, patchResponse.Headers.ETag);
// Run another GET input to verify that it returns the newly updated properties as well
getResponse = await streamAnalyticsManagementClient.Inputs.GetWithHttpMessagesAsync(resourceGroupName, jobName, inputName);
ValidationHelper.ValidateInput(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 input and verify that the input shows up in the list
var listResult = streamAnalyticsManagementClient.Inputs.ListByStreamingJob(resourceGroupName, jobName);
Assert.Single(listResult);
ValidationHelper.ValidateInput(putResponse.Body, listResult.Single(), true);
Assert.Equal(getResponse.Headers.ETag, listResult.Single().Properties.Etag);
// Get job with input expanded and verify that the input shows up
var getJobResponse = streamAnalyticsManagementClient.StreamingJobs.Get(resourceGroupName, jobName, "inputs");
Assert.Single(getJobResponse.Inputs);
ValidationHelper.ValidateInput(putResponse.Body, getJobResponse.Inputs.Single(), true);
Assert.Equal(getResponse.Headers.ETag, getJobResponse.Inputs.Single().Properties.Etag);
// Delete input
streamAnalyticsManagementClient.Inputs.Delete(resourceGroupName, jobName, inputName);
// Verify that list operation returns an empty list after deleting the input
listResult = streamAnalyticsManagementClient.Inputs.ListByStreamingJob(resourceGroupName, jobName);
Assert.Empty(listResult);
// Get job with input expanded and verify that there are no inputs after deleting the input
getJobResponse = streamAnalyticsManagementClient.StreamingJobs.Get(resourceGroupName, jobName, "inputs");
Assert.Empty(getJobResponse.Inputs);
}
}
