public async static Task DeleteAllDevicesInHubAsync(IotHubServiceClient hubClient)
{
Console.WriteLine($"\nTrying to clean up all devices\n");
try
{
AsyncPageable <TwinData> asyncPageableResponse = hubClient.Devices.GetTwinsAsync();
List <TwinData> deviceTwins = new List <TwinData>();
await foreach (TwinData twin in asyncPageableResponse)
{
deviceTwins.Add(twin);
}
foreach (TwinData twin in deviceTwins)
{
DeviceIdentity device = await hubClient.Devices.GetIdentityAsync(twin.DeviceId);
await hubClient.Devices.DeleteIdentityAsync(device);
}
SampleLogger.PrintSuccess($"Cleanup succeeded\n");
}
catch (Exception ex)
{
SampleLogger.PrintWarning($"Cleanup failed due to:\n{ex.Message}\n");
}
}
/// <summary>
/// Main entry point to the sample.
/// </summary>
public static async Task Main(string[] args)
{
// Parse and validate parameters
CommandLineOptions options = null;
ParserResult <CommandLineOptions> result = Parser.Default.ParseArguments <CommandLineOptions>(args)
.WithParsed(parsedOptions =>
{
options = parsedOptions;
})
.WithNotParsed(errors =>
{
Environment.Exit(1);
});
// Instantiate the client
IotHubServiceClient hubClient = new IotHubServiceClient(options.IotHubConnectionString);
// Run the samples
var deviceIdentityLifecycleSamples = new DeviceIdentityLifecycleSamples(hubClient);
await deviceIdentityLifecycleSamples.RunSampleAsync();
var moduleIdentityLifecycleSamples = new ModuleIdentityLifecycleSamples(hubClient);
await moduleIdentityLifecycleSamples.RunSampleAsync();
var bulkDeviceIdentityLifecycleSamples = new BulkDeviceIdentityLifecycleSamples(hubClient);
await bulkDeviceIdentityLifecycleSamples.RunSampleAsync();
}
public async Task DevicesClient_BulkCreation_OneAlreadyExists()
{
string testDevicePrefix = $"bulkDevice";
string existingDeviceName = $"{testDevicePrefix}{GetRandom()}";
IotHubServiceClient client = GetClient();
IList <DeviceIdentity> devices = BuildMultipleDevices(testDevicePrefix, BULK_DEVICE_COUNT - 1);
try
{
// We first create a single device.
Response <DeviceIdentity> response = await client.Devices.CreateOrUpdateIdentityAsync(new DeviceIdentity { DeviceId = existingDeviceName }).ConfigureAwait(false);
// Add the existing device to the list of devices to be bulk created.
devices.Add(response.Value);
// Create all devices
Response <BulkRegistryOperationResponse> createResponse = await client.Devices.CreateIdentitiesAsync(devices).ConfigureAwait(false);
// TODO: (azabbasi) Once the issue with the error parsing is resolved, include the error message in the message of the assert statement.
Assert.IsTrue(createResponse.Value.IsSuccessful, "Bulk device creation failed with errors");
}
finally
{
await CleanupAsync(client, devices).ConfigureAwait(false);
}
}
public async Task DevicesClient_BulkCreation_DeviceWithTwin()
{
string testDevicePrefix = $"bulkDeviceWithTwin";
string userPropertyName = "user";
string userPropertyValue = "userA";
IotHubServiceClient client = GetClient();
IDictionary <string, object> desiredProperties = new Dictionary <string, object>
{
{ userPropertyName, userPropertyValue }
};
// We will build multiple devices and all of them with the same desired properties for convenience.
IDictionary <DeviceIdentity, TwinData> devicesAndTwins = BuildDevicesAndTwins(testDevicePrefix, BULK_DEVICE_COUNT, desiredProperties);
try
{
// Create all devices with twins
Response <BulkRegistryOperationResponse> createResponse = await client.Devices.CreateIdentitiesWithTwinAsync(devicesAndTwins).ConfigureAwait(false);
// TODO: (azabbasi) Once the issue with the error parsing is resolved, include the error message in the message of the assert statement.
Assert.IsTrue(createResponse.Value.IsSuccessful, "Bulk device creation ended with errors");
// Verify that the desired properties were set
// For quicker test run, we will only verify the first device on the list.
Response <TwinData> getResponse = await client.Devices.GetTwinAsync(devicesAndTwins.Keys.First().DeviceId).ConfigureAwait(false);
getResponse.Value.Properties.Desired[userPropertyName].Should().Be(userPropertyValue);
}
finally
{
await Cleanup(client, devicesAndTwins.Keys);
}
}
public async Task ModulesClient_BulkCreation_SingleDevice()
{
string testDevicePrefix = $"bulkDevice";
string testModulePrefix = $"bulkModule";
string deviceId = $"{testDevicePrefix}{GetRandom()}";
var deviceIdentity = new DeviceIdentity()
{
DeviceId = deviceId
};
IList <ModuleIdentity> moduleIdentities = BuildMultipleModules(deviceId, testModulePrefix, BULK_MODULE_COUNT);
IotHubServiceClient client = GetClient();
try
{
// Create single device to house these bulk modules
await client.Devices.CreateOrUpdateIdentityAsync(deviceIdentity).ConfigureAwait(false);
// Create modules in bulk on that device
Response <BulkRegistryOperationResponse> createResponse = await client.Modules.CreateIdentitiesAsync(moduleIdentities).ConfigureAwait(false);
Assert.IsTrue(createResponse.Value.IsSuccessful, "Bulk module creation ended with errors");
}
finally
{
await CleanupAsync(client, deviceIdentity).ConfigureAwait(false);
}
}
public async Task ConfigurationsClient_ConfigurationsLifecycle()
{
string testConfigurationId = $"configlifecycle{GetRandom()}";
// Generate a random priority less than 100
int testPriority = int.Parse(GetRandom());
IotHubServiceClient client = GetClient();
TwinConfiguration twinConfiguration = CreateTestConfig(testConfigurationId);
TwinConfiguration createdConfig;
try
{
// Create a twin configuration
Response <TwinConfiguration> createResponse =
await client.Configurations.CreateOrUpdateConfigurationAsync(twinConfiguration).ConfigureAwait(false);
createdConfig = createResponse.Value;
// Get twin configuration
Response <TwinConfiguration> getResponse = await client.Configurations.GetConfigurationAsync(testConfigurationId).ConfigureAwait(false);
getResponse.Value.Etag.Should().BeEquivalentTo(createdConfig.Etag, "ETag value should not have changed.");
// Update a configuration
createdConfig.Priority = testPriority;
Response <TwinConfiguration> updatedConfig = await client.Configurations.CreateOrUpdateConfigurationAsync(createdConfig, IfMatchPrecondition.UnconditionalIfMatch).ConfigureAwait(false);
updatedConfig.Value.Priority.Should().Be(testPriority, "Priority should have been updated.");
}
finally
{
// Delete twin configuration
await CleanupAsync(client, twinConfiguration).ConfigureAwait(false);
}
}
public async Task QueryClient_GetAllModulesTwinsWithTag()
{
string testDeviceId = $"QueryDevice{GetRandom()}";
string testModuleId = $"QueryModule{GetRandom()}";
DeviceIdentity device = null;
IotHubServiceClient client = GetClient();
try
{
// Create a device to house the module
device = (await client.Devices
.CreateOrUpdateIdentityAsync(
new DeviceIdentity
{
DeviceId = testDeviceId
})
.ConfigureAwait(false))
.Value;
// Create a module on the device
Response <ModuleIdentity> createResponse = await client.Modules
.CreateOrUpdateIdentityAsync(
new ModuleIdentity
{
DeviceId = testDeviceId,
ModuleId = testModuleId
})
.ConfigureAwait(false);
int tryCount = 0;
var twinsFound = new List <TwinData>();
// A new device may not return immediately from a query, so give it some time and some retries to appear.
while (tryCount < _maxTryCount && !twinsFound.Any())
{
// Query for module twins with a specific tag.
AsyncPageable <TwinData> queryResponse = client.Query.QueryAsync($"SELECT * FROM devices.modules WHERE moduleId = '{testModuleId}'");
await foreach (TwinData item in queryResponse)
{
twinsFound.Add(item);
}
tryCount++;
// Adding a delay to account for query cache sync.
await Task.Delay(TimeSpan.FromSeconds(5)).ConfigureAwait(false);
}
twinsFound.Count.Should().Be(1);
twinsFound.First().ModuleId.Should().Be(testModuleId);
// Delete the device
// Deleting the device happens in the finally block as cleanup.
}
finally
{
await CleanupAsync(client, device).ConfigureAwait(false);
}
}
public async Task ModulesClient_IdentityLifecycle()
{
string testDeviceId = $"IdentityLifecycleDevice{GetRandom()}";
string testModuleId = $"IdentityLifecycleModule{GetRandom()}";
DeviceIdentity device = null;
ModuleIdentity module = null;
IotHubServiceClient client = GetClient();
try
{
// Create a device to house the module
device = (await client.Devices
.CreateOrUpdateIdentityAsync(
new DeviceIdentity
{
DeviceId = testDeviceId
})
.ConfigureAwait(false))
.Value;
// Create a module on the device
Response <ModuleIdentity> createResponse = await client.Modules.CreateOrUpdateIdentityAsync(
new ModuleIdentity
{
DeviceId = testDeviceId,
ModuleId = testModuleId
}).ConfigureAwait(false);
module = createResponse.Value;
module.DeviceId.Should().Be(testDeviceId);
module.ModuleId.Should().Be(testModuleId);
// Get device
// Get the device and compare ETag values (should remain unchanged);
Response <ModuleIdentity> getResponse = await client.Modules.GetIdentityAsync(testDeviceId, testModuleId).ConfigureAwait(false);
getResponse.Value.Etag.Should().BeEquivalentTo(module.Etag, "ETag value should not have changed.");
module = getResponse.Value;
// Update a module
string managedByValue = "SomeChangedValue";
module.ManagedBy = managedByValue;
// TODO: (azabbasi) We should leave the IfMatchPrecondition to be the default value once we know more about the fix.
Response <ModuleIdentity> updateResponse = await client.Modules.CreateOrUpdateIdentityAsync(module, IfMatchPrecondition.UnconditionalIfMatch).ConfigureAwait(false);
updateResponse.Value.ManagedBy.Should().Be(managedByValue, "Module should have changed its managedBy value");
// Delete the device
// Deleting the device happens in the finally block as cleanup.
}
finally
{
await CleanupAsync(client, device).ConfigureAwait(false);
}
}
public async Task ModulesClient_Query_GetTwins()
{
string testDevicePrefix = $"bulkDevice";
string testModulePrefix = $"bulkModule";
IotHubServiceClient client = GetClient();
string deviceId = $"{testDevicePrefix}{GetRandom()}";
DeviceIdentity deviceIdentity = new DeviceIdentity()
{
DeviceId = deviceId
};
IList <ModuleIdentity> moduleIdentities = BuildMultipleModules(deviceId, testModulePrefix, BULK_MODULE_COUNT);
try
{
// Create the device to house all these modules
await client.Devices.CreateOrUpdateIdentityAsync(deviceIdentity).ConfigureAwait(false);
// Create the modules in bulk so they can be queried later
Response <BulkRegistryOperationResponse> createResponse = await client.Modules.CreateIdentitiesAsync(moduleIdentities).ConfigureAwait(false);
Assert.IsTrue(createResponse.Value.IsSuccessful, "Bulk module creation ended with errors");
// We will retry the operation since it can take some time for the query to match what was recently created.
int matchesFound = 0;
DateTimeOffset startTime = DateTime.UtcNow;
while (DateTime.UtcNow - startTime < _queryMaxWaitTime)
{
matchesFound = 0;
AsyncPageable <TwinData> twins = client.Modules.GetTwinsAsync();
// We will verify we have twins for all recently created devices.
await foreach (TwinData twin in twins)
{
if (moduleIdentities.Any(d => d.DeviceId.Equals(twin.DeviceId, StringComparison.OrdinalIgnoreCase)))
{
matchesFound++;
}
}
if (matchesFound == BULK_MODULE_COUNT)
{
break;
}
await Task.Delay(_queryRetryInterval).ConfigureAwait(false);
}
matchesFound.Should().Be(BULK_MODULE_COUNT, "Timed out waiting for all the bulk created modules to be query-able." +
" Number of matching modules must be equal to the number of recently created modules.");
}
finally
{
await CleanupAsync(client, deviceIdentity).ConfigureAwait(false);
}
}
private async Task CleanupAsync(IotHubServiceClient client, IEnumerable <DeviceIdentity> deviceIdentities)
{
// Delete all devices.
if (deviceIdentities != null)
{
await client.Devices.DeleteIdentitiesAsync(deviceIdentities).ConfigureAwait(false);
}
}
public async Task ModulesClient_UpdateDevice_EtagDoesNotMatch()
{
string testDeviceId = $"UpdateWithETag{GetRandom()}";
string testModuleId = $"UpdateWithETag{GetRandom()}";
DeviceIdentity device = null;
ModuleIdentity module = null;
IotHubServiceClient client = GetClient();
try
{
// Create a device
device = (await client.Devices.CreateOrUpdateIdentityAsync(
new DeviceIdentity
{
DeviceId = testDeviceId
}).ConfigureAwait(false)).Value;
// Create a module on that device
module = (await client.Modules.CreateOrUpdateIdentityAsync(
new ModuleIdentity
{
DeviceId = testDeviceId,
ModuleId = testModuleId
}).ConfigureAwait(false)).Value;
// Update the module to get a new ETag value.
string managedByValue = "SomeChangedValue";
module.ManagedBy = managedByValue;
ModuleIdentity updatedModule = (await client.Modules.CreateOrUpdateIdentityAsync(module).ConfigureAwait(false)).Value;
Assert.AreNotEqual(updatedModule.Etag, module.Etag, "ETag should have been updated.");
// Perform another update using the old device object to verify precondition fails.
string anotherManagedByValue = "SomeOtherChangedValue";
module.ManagedBy = anotherManagedByValue;
try
{
await client.Modules.CreateOrUpdateIdentityAsync(module, IfMatchPrecondition.IfMatch).ConfigureAwait(false);
Assert.Fail($"Update call with outdated ETag should fail with 412 (PreconditionFailed)");
}
// We will catch the exception and verify status is 412 (PreconditionfFailed)
catch (RequestFailedException ex)
{
Assert.AreEqual(412, ex.Status, $"Expected the update to fail with http status code 412 (PreconditionFailed)");
}
// Perform the same update and ignore the ETag value by providing UnconditionalIfMatch precondition
ModuleIdentity forcefullyUpdatedModule = (await client.Modules.CreateOrUpdateIdentityAsync(module, IfMatchPrecondition.UnconditionalIfMatch).ConfigureAwait(false)).Value;
forcefullyUpdatedModule.ManagedBy.Should().Be(anotherManagedByValue);
}
finally
{
await CleanupAsync(client, device).ConfigureAwait(false);
}
}
public async Task StatisticsClient_Service_SuccessfulResponse()
{
IotHubServiceClient client = GetClient();
Response <ServiceStatistics> stat = await client.Statistics.GetServiceStatisticsAsync().ConfigureAwait(false);
Assert.IsNotNull(stat.Value, "Statistics response should not be null");
Assert.IsNotNull(stat.Value.ConnectedDeviceCount, "ConnectedDeviceCount should not be null");
}
public async Task ModulesClient_GetModulesOnDevice()
{
int moduleCount = 5;
string testDeviceId = $"IdentityLifecycleDevice{GetRandom()}";
string[] testModuleIds = new string[moduleCount];
for (int i = 0; i < moduleCount; i++)
{
testModuleIds[i] = $"IdentityLifecycleModule{i}-{GetRandom()}";
}
DeviceIdentity device = null;
IotHubServiceClient client = GetClient();
try
{
// Create a device to house the modules
device = (await client.Devices
.CreateOrUpdateIdentityAsync(
new DeviceIdentity
{
DeviceId = testDeviceId
})
.ConfigureAwait(false))
.Value;
// Create the modules on the device
for (int i = 0; i < moduleCount; i++)
{
Response <ModuleIdentity> createResponse = await client.Modules.CreateOrUpdateIdentityAsync(
new ModuleIdentity
{
DeviceId = testDeviceId,
ModuleId = testModuleIds[i]
}).ConfigureAwait(false);
}
// List the modules on the test device
IReadOnlyList <ModuleIdentity> modulesOnDevice = (await client.Modules.GetIdentitiesAsync(testDeviceId).ConfigureAwait(false)).Value;
IEnumerable <string> moduleIdsOnDevice = modulesOnDevice
.ToList()
.Select(module => module.ModuleId);
Assert.AreEqual(moduleCount, modulesOnDevice.Count);
for (int i = 0; i < moduleCount; i++)
{
Assert.IsTrue(moduleIdsOnDevice.Contains(testModuleIds[i]));
}
}
finally
{
await CleanupAsync(client, device).ConfigureAwait(false);
}
}
public async Task DevicesClient_BulkUpdate()
{
string testDevicePrefix = $"bulkDeviceUpdate";
IotHubServiceClient client = GetClient();
IList <DeviceIdentity> listOfDevicesToUpdate = null;
try
{
// Create two devices
Response <DeviceIdentity> deviceOneCreateResponse = await client.Devices.CreateOrUpdateIdentityAsync(
new DeviceIdentity
{
DeviceId = $"{testDevicePrefix}{GetRandom()}",
Status = DeviceStatus.Enabled,
}).ConfigureAwait(false);
Response <DeviceIdentity> deviceTwoCreateResponse = await client.Devices.CreateOrUpdateIdentityAsync(
new DeviceIdentity
{
DeviceId = $"{testDevicePrefix}{GetRandom()}",
Status = DeviceStatus.Enabled,
}).ConfigureAwait(false);
DeviceIdentity deviceOne = deviceOneCreateResponse.Value;
DeviceIdentity deviceTwo = deviceTwoCreateResponse.Value;
listOfDevicesToUpdate = new List <DeviceIdentity> {
deviceOne, deviceTwo
};
// Update device status to disabled.
deviceOne.Status = DeviceStatus.Disabled;
deviceTwo.Status = DeviceStatus.Disabled;
// Make the API call to disable devices.
Response <BulkRegistryOperationResponse> updateResponse =
await client.Devices.UpdateIdentitiesAsync(listOfDevicesToUpdate, BulkIfMatchPrecondition.Unconditional)
.ConfigureAwait(false);
// TODO: (azabbasi) Once the issue with the error parsing is resolved, include the error message in the message of the assert statement.
Assert.IsTrue(updateResponse.Value.IsSuccessful, "Bulk device update ended with errors");
// Verify the devices status is updated.
deviceOne = (await client.Devices.GetIdentityAsync(deviceOne.DeviceId).ConfigureAwait(false)).Value;
deviceTwo = (await client.Devices.GetIdentityAsync(deviceTwo.DeviceId).ConfigureAwait(false)).Value;
deviceOne.Status.Should().Be(DeviceStatus.Disabled, "Device should have been disabled");
deviceTwo.Status.Should().Be(DeviceStatus.Disabled, "Device should have been disabled");
}
finally
{
await CleanupAsync(client, listOfDevicesToUpdate).ConfigureAwait(false);
}
}
public async Task StatisticsClient_Device_SuccessfulResponse()
{
IotHubServiceClient client = GetClient();
Response <DevicesStatistics> stat = await client.Statistics.GetDevicesStatisticsAsync().ConfigureAwait(false);
Assert.IsNotNull(stat.Value, "Statistics response should not be null");
Assert.IsNotNull(stat.Value.TotalDeviceCount, "TotalDeviceCount should not be null");
Assert.IsNotNull(stat.Value.EnabledDeviceCount, "EnabledDeviceCount should not be null");
Assert.IsNotNull(stat.Value.DisabledDeviceCount, "DisabledDeviceCount should not be null");
}
/// <summary>
/// Main entry point to the sample.
/// </summary>
public static async Task Main(string[] args)
{
// Parse and validate parameters
CommandLineOptions options = null;
ParserResult <CommandLineOptions> result = Parser.Default.ParseArguments <CommandLineOptions>(args)
.WithParsed(parsedOptions =>
{
options = parsedOptions;
})
.WithNotParsed(errors =>
{
Environment.Exit(1);
});
// Instantiate the client
#region Snippet:IotHubServiceClientInitializeWithIotHubSasCredential
// Create an IotHubSasCredential type to use sas tokens to authenticate against your IoT Hub instance.
// The default lifespan of the sas token is 30 minutes, and it is set to be renewed when at 15% or less of its lifespan.
var credential = new IotHubSasCredential(options.IotHubSharedAccessPolicy, options.IotHubSharedAccessKey);
IotHubServiceClient hubClient = new IotHubServiceClient(options.Endpoint, credential);
#endregion Snippet:IotHubServiceClientInitializeWithIotHubSasCredential
// Run the samples
var deviceIdentityLifecycleSamples = new DeviceIdentityLifecycleSamples(hubClient);
await deviceIdentityLifecycleSamples.RunSampleAsync();
var moduleIdentityLifecycleSamples = new ModuleIdentityLifecycleSamples(hubClient);
await moduleIdentityLifecycleSamples.RunSampleAsync();
var bulkDeviceIdentityLifecycleSamples = new BulkDeviceIdentityLifecycleSamples(hubClient);
await bulkDeviceIdentityLifecycleSamples.RunSampleAsync();
var bulkModuledentityLifecycleSamples = new BulkModuleIdentityLifecycleSamples(hubClient);
await bulkModuledentityLifecycleSamples.RunSampleAsync();
var querySamples = new QueryTwinSamples(hubClient);
await querySamples.RunSampleAsync();
// Run samples that require the device sample to be running.
if (options.IsDeviceSampleRunning == true)
{
// This sample requires the device sample to be running so that it can connect to the device.
var methodInvocationSamples = new MethodInvocationSamples(hubClient);
await methodInvocationSamples.RunSampleAsync();
}
}
private async Task CleanupAsync(IotHubServiceClient client, IEnumerable <DeviceIdentity> devices)
{
try
{
if (devices != null && devices.Any())
{
await client.Devices.DeleteIdentitiesAsync(devices, BulkIfMatchPrecondition.Unconditional).ConfigureAwait(false);
}
}
catch (Exception ex)
{
Assert.Fail($"Test clean up failed: {ex.Message}");
}
}
public async Task ModulesClient_DeviceTwinLifecycle()
{
string testDeviceId = $"TwinLifecycleDevice{GetRandom()}";
string testModuleId = $"TwinLifecycleModule{GetRandom()}";
DeviceIdentity device = null;
ModuleIdentity module = null;
IotHubServiceClient client = GetClient();
try
{
// Create a device
device = (await client.Devices.CreateOrUpdateIdentityAsync(
new DeviceIdentity
{
DeviceId = testDeviceId
}).ConfigureAwait(false)).Value;
// Create a module on that device. Note that this implicitly creates the module twin
module = (await client.Modules.CreateOrUpdateIdentityAsync(
new ModuleIdentity
{
DeviceId = testDeviceId,
ModuleId = testModuleId
}).ConfigureAwait(false)).Value;
// Get the module twin
TwinData moduleTwin = (await client.Modules.GetTwinAsync(testDeviceId, testModuleId).ConfigureAwait(false)).Value;
moduleTwin.ModuleId.Should().BeEquivalentTo(testModuleId, "ModuleId on the Twin should match that of the module identity.");
// Update device twin
string propName = "username";
string propValue = "userA";
moduleTwin.Properties.Desired.Add(new KeyValuePair <string, object>(propName, propValue));
// TODO: (azabbasi) We should leave the IfMatchPrecondition to be the default value once we know more about the fix.
Response <TwinData> updateResponse = await client.Modules.UpdateTwinAsync(moduleTwin, IfMatchPrecondition.UnconditionalIfMatch).ConfigureAwait(false);
updateResponse.Value.Properties.Desired.Where(p => p.Key == propName).First().Value.Should().Be(propValue, "Desired property value is incorrect.");
// Delete the module
// Deleting the module happens in the finally block as cleanup.
}
finally
{
await CleanupAsync(client, device).ConfigureAwait(false);
}
}
public async Task DevicesClient_Query_GetTwins()
{
string testDevicePrefix = $"bulkDevice";
IEnumerable <DeviceIdentity> devices = BuildMultipleDevices(testDevicePrefix, BULK_DEVICE_COUNT);
IotHubServiceClient client = GetClient();
try
{
// Create all devices
Response <BulkRegistryOperationResponse> createResponse = await client.Devices.CreateIdentitiesAsync(devices).ConfigureAwait(false);
Assert.IsTrue(createResponse.Value.IsSuccessful, "Bulk device creation ended with errors");
// We will retry the operation since it can take some time for the query to match what was recently created.
int matchesFound = 0;
DateTimeOffset startTime = DateTime.UtcNow;
while (DateTime.UtcNow - startTime < _queryMaxWaitTime)
{
matchesFound = 0;
AsyncPageable <TwinData> twins = client.Devices.GetTwinsAsync();
// We will verify we have twins for all recently created devices.
await foreach (TwinData twin in twins)
{
if (devices.Any(d => d.DeviceId.Equals(twin.DeviceId, StringComparison.OrdinalIgnoreCase)))
{
matchesFound++;
}
}
if (matchesFound == BULK_DEVICE_COUNT)
{
break;
}
await Task.Delay(_queryRetryInterval);
}
matchesFound.Should().Be(BULK_DEVICE_COUNT, "Timed out waiting for all the bulk created devices to be query-able." +
" Number of matching devices must be equal to the number of recently created devices.");
}
finally
{
await Cleanup(client, devices);
}
}
public async Task DevicesClient_UpdateDevice_EtagDoesNotMatch()
{
string testDeviceId = $"UpdateWithETag{GetRandom()}";
DeviceIdentity device = null;
IotHubServiceClient client = GetClient();
try
{
// Create a device
Response <DeviceIdentity> createResponse = await client.Devices.CreateOrUpdateIdentityAsync(
new DeviceIdentity
{
DeviceId = testDeviceId
}).ConfigureAwait(false);
// Store the device object to later update it with invalid ETag
device = createResponse.Value;
// Update the device to get a new ETag value.
device.Status = DeviceStatus.Disabled;
Response <DeviceIdentity> getResponse = await client.Devices.CreateOrUpdateIdentityAsync(device).ConfigureAwait(false);
DeviceIdentity updatedDevice = getResponse.Value;
Assert.AreNotEqual(updatedDevice.Etag, device.Etag, "ETag should have been updated.");
// Perform another update using the old device object to verify precondition fails.
device.Status = DeviceStatus.Enabled;
try
{
Response <DeviceIdentity> updateResponse = await client.Devices.CreateOrUpdateIdentityAsync(device).ConfigureAwait(false);
Assert.Fail($"Update call with outdated ETag should fail with 412 (PreconditionFailed)");
}
// We will catch the exception and verify status is 412 (PreconditionfFailed)
catch (RequestFailedException ex)
{
Assert.AreEqual(412, ex.Status, $"Expected the update to fail with http status code 412 (PreconditionFailed)");
}
// Perform the same update and ignore the ETag value by providing UnconditionalIfMatch precondition
await client.Devices.CreateOrUpdateIdentityAsync(device, IfMatchPrecondition.UnconditionalIfMatch).ConfigureAwait(false);
}
finally
{
await CleanupAsync(client, device).ConfigureAwait(false);
}
}
private async Task CleanupAsync(IotHubServiceClient client, TwinConfiguration config)
{
// cleanup
try
{
if (config != null)
{
await client.Configurations.DeleteConfigurationAsync(config, IfMatchPrecondition.UnconditionalIfMatch).ConfigureAwait(false);
}
}
catch (Exception ex)
{
Assert.Fail($"Test clean up failed: {ex.Message}");
}
}
private async Task CleanupAsync(IotHubServiceClient client, DeviceIdentity device)
{
// cleanup
try
{
if (device != null)
{
await client.Devices.DeleteIdentityAsync(device, IfMatchPrecondition.UnconditionalIfMatch).ConfigureAwait(false);
}
}
catch (Exception ex)
{
Assert.Fail($"Test clean up failed: {ex.Message}");
}
}
private async Task <Response <JobProperties> > WaitForJobCompletionAsync(IotHubServiceClient client, string jobId)
{
Response <JobProperties> response;
// Wait for job to complete.
do
{
response = await client.Jobs.GetImportExportJobAsync(jobId).ConfigureAwait(false);
// We do not need to really wait when running on mocked values(Playback mode).
// This will speed up testing in Playback mode and the PR pipeline.
await Delay(5000);
} while (!IsTerminalStatus(response.Value.Status));
return(response);
}
public async Task ModulesClient_BulkCreation_ModuleWithTwin()
{
string testDevicePrefix = $"bulkDeviceWithTwin";
string testModulePrefix = $"bulkModuleWithTwin";
string userPropertyName = "user";
string userPropertyValue = "userA";
IotHubServiceClient client = GetClient();
string deviceId = $"{testDevicePrefix}{GetRandom()}";
DeviceIdentity deviceIdentity = new DeviceIdentity()
{
DeviceId = deviceId
};
IDictionary <string, object> desiredProperties = new Dictionary <string, object>
{
{ userPropertyName, userPropertyValue }
};
// We will build a single device with multiple modules, and each module will have the same initial twin.
IDictionary <ModuleIdentity, TwinData> modulesAndTwins = BuildModulesAndTwins(deviceId, testModulePrefix, BULK_MODULE_COUNT, desiredProperties);
try
{
// Create device to house the modules
await client.Devices.CreateOrUpdateIdentityAsync(deviceIdentity).ConfigureAwait(false);
// Create the modules with an initial twin in bulk
Response <BulkRegistryOperationResponse> createResponse = await client.Modules.CreateIdentitiesWithTwinAsync(modulesAndTwins).ConfigureAwait(false);
// TODO: (azabbasi) Once the issue with the error parsing is resolved, include the error message in the message of the assert statement.
Assert.IsTrue(createResponse.Value.IsSuccessful, "Bulk module creation ended with errors");
// Verify that the desired properties were set
// For quicker test run, we will only verify the first device on the list.
Response <TwinData> getResponse = await client.Modules.GetTwinAsync(modulesAndTwins.Keys.First().DeviceId, modulesAndTwins.Keys.First().ModuleId).ConfigureAwait(false);
getResponse.Value.Properties.Desired[userPropertyName].Should().Be(userPropertyValue);
}
finally
{
await CleanupAsync(client, deviceIdentity).ConfigureAwait(false);
}
}
public async Task ModulesClient_BulkCreation_OneAlreadyExists()
{
string testDevicePrefix = $"bulkDeviceCreate";
string testModulePrefix = $"bulkModuleCreate";
IotHubServiceClient client = GetClient();
string deviceId = $"{testDevicePrefix}{GetRandom()}";
var deviceIdentity = new DeviceIdentity()
{
DeviceId = deviceId
};
IList <ModuleIdentity> modules = BuildMultipleModules(deviceId, testModulePrefix, BULK_MODULE_COUNT - 1);
try
{
// We first create a single device to house these bulk modules.
await client.Devices.CreateOrUpdateIdentityAsync(deviceIdentity).ConfigureAwait(false);
// Create a single module on that device that will be used to cause a conflict later
await client.Modules.CreateOrUpdateIdentityAsync(
new ModuleIdentity()
{
DeviceId = deviceId,
ModuleId = modules.ElementAt(0).ModuleId //Use the same module id as the first module in the bulk list
}).ConfigureAwait(false);
// Create all devices
Response <BulkRegistryOperationResponse> createResponse = await client.Modules.CreateIdentitiesAsync(modules).ConfigureAwait(false);
// TODO: (azabbasi) Once the issue with the error parsing is resolved, include the error message in the message of the assert statement.
Assert.IsTrue(createResponse.Value.IsSuccessful, "Bulk device creation failed with errors");
createResponse.Value.Errors.Count.Should().Be(1);
// Since there is exactly one error, it is safe to just look at the first one here
var error = createResponse.Value.Errors.First();
error.ModuleId.Should().Be(modules.ElementAt(0).ModuleId, "Error should have been tied to the moduleId that was already created");
}
finally
{
await CleanupAsync(client, deviceIdentity).ConfigureAwait(false);
}
}
private async Task <Response <JobProperties> > WaitForJobCompletionAsync(IotHubServiceClient client, string jobId)
{
Response <JobProperties> response;
// Wait for job to complete.
do
{
response = await client.Jobs.GetImportExportJobAsync(jobId).ConfigureAwait(false);
// We do not need to really wait when running on mocked values(Playback mode).
// This will speed up testing in Playback mode and the PR pipeline.
if (TestSettings.Instance.TestMode != Core.TestFramework.RecordedTestMode.Playback)
{
await Task.Delay(TimeSpan.FromSeconds(5)).ConfigureAwait(false);
}
} while (!IsTerminalStatus(response.Value.Status));
return(response);
}
public async Task Jobs_Export_Import_Lifecycle()
{
// setup
string testDevicePrefix = $"jobDevice";
IEnumerable <DeviceIdentity> deviceIdentities = null;
IotHubServiceClient client = GetClient();
try
{
//Create multiple devices.
deviceIdentities = BuildMultipleDevices(testDevicePrefix, DEVICE_COUNT);
await client.Devices.CreateIdentitiesAsync(deviceIdentities).ConfigureAwait(false);
// Export all devices to blob storage.
Response <JobProperties> response = await client.Jobs
.CreateExportDevicesJobAsync(outputBlobContainerUri : TestEnvironment.StorageSasToken, excludeKeys : false)
.ConfigureAwait(false);
response.GetRawResponse().Status.Should().Be(200);
// Wait for job completion and validate result.
response = await WaitForJobCompletionAsync(client, response.Value.JobId).ConfigureAwait(false);
response.Value.Status.Should().Be(JobPropertiesStatus.Completed);
//Import all devices from storage to create and provision devices on the IoTHub.
response = await client.Jobs
.CreateImportDevicesJobAsync(TestEnvironment.StorageSasToken, TestEnvironment.StorageSasToken)
.ConfigureAwait(false);
response.GetRawResponse().Status.Should().Be(200);
// Wait for job completion and validate result.
response = await WaitForJobCompletionAsync(client, response.Value.JobId).ConfigureAwait(false);
response.Value.Status.Should().Be(JobPropertiesStatus.Completed);
}
finally
{
await CleanupAsync(client, deviceIdentities).ConfigureAwait(false);
}
}
public async Task DevicesClient_IdentityLifecycle()
{
string testDeviceId = $"IdentityLifecycleDevice{GetRandom()}";
DeviceIdentity device = null;
IotHubServiceClient client = GetClient();
try
{
// Create a device
Response <DeviceIdentity> createResponse = await client.Devices.CreateOrUpdateIdentityAsync(
new DeviceIdentity
{
DeviceId = testDeviceId
}).ConfigureAwait(false);
device = createResponse.Value;
// Get device
// Get the device and compare ETag values (should remain unchanged);
Response <DeviceIdentity> getResponse = await client.Devices.GetIdentityAsync(testDeviceId).ConfigureAwait(false);
getResponse.Value.Etag.Should().BeEquivalentTo(device.Etag, "ETag value should not have changed.");
device = getResponse.Value;
// Update a device
device.Status = DeviceStatus.Disabled;
// TODO: (azabbasi) We should leave the IfMatchPrecondition to be the default value once we know more about the fix.
Response <DeviceIdentity> updateResponse = await client.Devices.CreateOrUpdateIdentityAsync(device, IfMatchPrecondition.UnconditionalIfMatch).ConfigureAwait(false);
updateResponse.Value.Status.Should().Be(DeviceStatus.Disabled, "Device should have been disabled");
// Delete the device
// Deleting the device happens in the finally block as cleanup.
}
finally
{
await CleanupAsync(client, device).ConfigureAwait(false);
}
}
public async Task DevicesClient_BulkCreation()
{
string testDevicePrefix = $"bulkDevice";
IEnumerable <DeviceIdentity> devices = BuildMultipleDevices(testDevicePrefix, BULK_DEVICE_COUNT);
IotHubServiceClient client = GetClient();
try
{
// Create all devices
Response <BulkRegistryOperationResponse> createResponse = await client.Devices.CreateIdentitiesAsync(devices).ConfigureAwait(false);
Assert.IsTrue(createResponse.Value.IsSuccessful, "Bulk device creation ended with errors");
}
finally
{
await CleanupAsync(client, devices).ConfigureAwait(false);
}
}
public async Task ModulesClient_BulkCreation_MultipleDevices()
{
string testDevicePrefix = $"bulkDevice";
string testModulePrefix = $"bulkModule";
List <DeviceIdentity> deviceIdentities = new List <DeviceIdentity>();
List <ModuleIdentity> moduleIdentities = new List <ModuleIdentity>();
for (int moduleIndex = 0; moduleIndex < BULK_MODULE_COUNT; moduleIndex++)
{
string deviceId = $"{testDevicePrefix}{GetRandom()}";
deviceIdentities.Add(new DeviceIdentity()
{
DeviceId = deviceId
});
moduleIdentities.Add(new ModuleIdentity()
{
DeviceId = deviceId,
ModuleId = $"{testModulePrefix}{GetRandom()}"
});
}
IotHubServiceClient client = GetClient();
try
{
// Create devices to house these bulk modules
await client.Devices.CreateIdentitiesAsync(deviceIdentities).ConfigureAwait(false);
// Create modules in bulk on those devices
Response <BulkRegistryOperationResponse> createResponse = await client.Modules.CreateIdentitiesAsync(moduleIdentities).ConfigureAwait(false);
Assert.IsTrue(createResponse.Value.IsSuccessful, "Bulk module creation ended with errors");
}
finally
{
await CleanupAsync(client, deviceIdentities).ConfigureAwait(false);
}
}
