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); } }