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