private async Task Twin_ServiceSetsDesiredPropertyAndDeviceReceivesEvent(Client.TransportType transport, Func <DeviceClient, string, string, Task <Task> > setTwinPropertyUpdateCallbackAsync)
{
var propName = Guid.NewGuid().ToString();
var propValue = Guid.NewGuid().ToString();
_log.WriteLine($"{nameof(Twin_ServiceSetsDesiredPropertyAndDeviceReceivesEvent)}: name={propName}, value={propValue}");
TestDevice testDevice = await TestDevice.GetTestDeviceAsync(DevicePrefix).ConfigureAwait(false);
using (DeviceClient deviceClient = DeviceClient.CreateFromConnectionString(testDevice.ConnectionString, transport))
{
Task updateReceivedTask = await setTwinPropertyUpdateCallbackAsync(deviceClient, propName, propValue).ConfigureAwait(false);
await Task.WhenAll(
RegistryManagerUpdateDesiredPropertyAsync(testDevice.Id, propName, propValue),
updateReceivedTask).ConfigureAwait(false);
await deviceClient.CloseAsync().ConfigureAwait(false);
}
}
private async Task Twin_DeviceSetsReportedPropertyAndGetsItBack(Client.TransportType transport)
{
var propName = Guid.NewGuid().ToString();
var propValue = Guid.NewGuid().ToString();
TestDevice testDevice = await TestDevice.GetTestDeviceAsync(DevicePrefix).ConfigureAwait(false);
using (DeviceClient deviceClient = DeviceClient.CreateFromConnectionString(testDevice.ConnectionString, transport))
{
TwinCollection props = new TwinCollection();
props[propName] = propValue;
await deviceClient.UpdateReportedPropertiesAsync(props).ConfigureAwait(false);
Twin deviceTwin = await deviceClient.GetTwinAsync().ConfigureAwait(false);
Assert.AreEqual <String>(deviceTwin.Properties.Reported[propName].ToString(), propValue);
await deviceClient.CloseAsync().ConfigureAwait(false);
}
}
private async Task SendMethodAndRespond(Client.TransportType transport)
{
Tuple <string, string> deviceInfo = TestUtil.CreateDevice(DevicePrefix, hostName, registryManager);
var assertResult = new TaskCompletionSource <Tuple <bool, bool> >();
var deviceClient = DeviceClient.CreateFromConnectionString(deviceInfo.Item2, transport);
await deviceClient.SetMethodHandlerAsync(MethodName,
(request, context) =>
{
assertResult.TrySetResult(new Tuple <bool, bool>(request.Name.Equals(MethodName), request.DataAsJson.Equals(ServiceRequestJson)));
return(Task.FromResult(new MethodResponse(Encoding.UTF8.GetBytes(DeviceResponseJson), 200)));
},
null).ConfigureAwait(false);
await ServiceSendMethodAndVerifyResponse(deviceInfo.Item1, MethodName, DeviceResponseJson, ServiceRequestJson, assertResult).ConfigureAwait(false);
await deviceClient.CloseAsync().ConfigureAwait(false);
await TestUtil.RemoveDeviceAsync(deviceInfo.Item1, registryManager).ConfigureAwait(false);
}
private async Task TestSecurityMessage(Client.TransportType transport)
{
TestDevice testDevice = await TestDevice.GetTestDeviceAsync(_devicePrefix).ConfigureAwait(false);
EventHubTestListener testListener = await EventHubTestListener.CreateListener(testDevice.Id).ConfigureAwait(false);
using (DeviceClient deviceClient = testDevice.CreateDeviceClient(transport))
{
try
{
await SendSingleSecurityMessage(deviceClient, testDevice.Id, testListener, _logAnalyticsClient).ConfigureAwait(false);
}
finally
{
await deviceClient.CloseAsync().ConfigureAwait(false);
await testListener.CloseAsync().ConfigureAwait(false);
}
}
}
private async Task TestSecurityMessageModule(Client.TransportType transport)
{
TestModule testModule = await TestModule.GetTestModuleAsync(_devicePrefix, _modulePrefix).ConfigureAwait(false);
EventHubTestListener testListener = await EventHubTestListener.CreateListener(testModule.Id).ConfigureAwait(false);
using (ModuleClient moduleClient = ModuleClient.CreateFromConnectionString(testModule.ConnectionString, transport))
{
try
{
await SendSingleSecurityMessageModule(moduleClient, testModule.DeviceId, testListener, _logAnalyticsClient).ConfigureAwait(false);
}
finally
{
await moduleClient.CloseAsync().ConfigureAwait(false);
await testListener.CloseAsync().ConfigureAwait(false);
}
}
}
private async Task _Twin_DeviceSetsReportedPropertyAndGetsItBack(Client.TransportType transport)
{
var propName = Guid.NewGuid().ToString();
var propValue = Guid.NewGuid().ToString();
Tuple <string, string> deviceInfo = TestUtil.CreateDevice(DevicePrefix, hostName, registryManager);
var deviceClient = DeviceClient.CreateFromConnectionString(deviceInfo.Item2, transport);
TwinCollection props = new TwinCollection();
props[propName] = propValue;
await deviceClient.UpdateReportedPropertiesAsync(props);
var deviceTwin = await deviceClient.GetTwinAsync();
Assert.AreEqual <String>(deviceTwin.Properties.Reported[propName].ToString(), propValue);
await deviceClient.CloseAsync();
TestUtil.RemoveDevice(deviceInfo.Item1, registryManager);
}
private async Task ReceiveMessageWithTimeout(TestDeviceType type, Client.TransportType transport, double time)
{
TestDevice testDevice = await TestDevice.GetTestDeviceAsync(DevicePrefix, type).ConfigureAwait(false);
using (DeviceClient deviceClient = testDevice.CreateDeviceClient(transport))
{
await deviceClient.OpenAsync().ConfigureAwait(false);
if (transport == Client.TransportType.Mqtt_Tcp_Only ||
transport == Client.TransportType.Mqtt_WebSocket_Only)
{
// Dummy ReceiveAsync to ensure mqtt subscription registration before SendAsync() is called on service client.
await deviceClient.ReceiveAsync(TimeSpan.FromSeconds(10)).ConfigureAwait(false);
}
await ReceiveMessageTimeoutCheck(deviceClient, time).ConfigureAwait(false);
await deviceClient.CloseAsync().ConfigureAwait(false);
}
}
private async Task SendMessagePoolOverAmqp(
TestDeviceType type,
Client.TransportType transport,
int poolSize,
int devicesCount,
ConnectionStringAuthScope authScope = ConnectionStringAuthScope.Device)
{
Func <DeviceClient, TestDevice, Task> testOperation = async(deviceClient, testDevice) =>
{
_log.WriteLine($"{nameof(MessageSendE2EPoolAmqpTests)}: Preparing to send message for device {testDevice.Id}");
await deviceClient.OpenAsync().ConfigureAwait(false);
(Client.Message testMessage, string messageId, string payload, string p1Value) = MessageSendE2ETests.ComposeD2CTestMessage();
_log.WriteLine($"{nameof(MessageSendE2EPoolAmqpTests)}.{testDevice.Id}: messageId='{messageId}' payload='{payload}' p1Value='{p1Value}'");
await deviceClient.SendEventAsync(testMessage).ConfigureAwait(false);
bool isReceived = EventHubTestListener.VerifyIfMessageIsReceived(testDevice.Id, payload, p1Value);
Assert.IsTrue(isReceived, "Message is not received.");
};
Func <IList <DeviceClient>, Task> cleanupOperation = (deviceClients) =>
{
foreach (DeviceClient deviceClient in deviceClients)
{
deviceClient.Dispose();
}
return(Task.FromResult(0));
};
await PoolingOverAmqp.TestPoolAmqpAsync(
DevicePrefix,
transport,
poolSize,
devicesCount,
(d, t) => { return(Task.FromResult(false)); },
testOperation,
cleanupOperation,
authScope,
true).ConfigureAwait(false);
}
private async Task UploadFile(Client.TransportType transport, string filename, bool x509auth = false)
{
TestDevice testDevice = await TestDevice.GetTestDeviceAsync(
DevicePrefix,
x509auth ? TestDeviceType.X509 : TestDeviceType.Sasl).ConfigureAwait(false);
DeviceClient deviceClient;
if (x509auth)
{
X509Certificate2 cert = Configuration.IoTHub.GetCertificateWithPrivateKey();
var auth = new DeviceAuthenticationWithX509Certificate(testDevice.Id, cert);
deviceClient = DeviceClient.Create(testDevice.IoTHubHostName, auth, transport);
}
else
{
deviceClient = DeviceClient.CreateFromConnectionString(testDevice.ConnectionString, transport);
}
using(deviceClient)
using (ServiceClient serviceClient = ServiceClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString))
{
FileNotificationReceiver<FileNotification> notificationReceiver = serviceClient.GetFileNotificationReceiver();
using (FileStream fileStreamSource = new FileStream(filename, FileMode.Open, FileAccess.Read))
{
await deviceClient.UploadToBlobAsync(filename, fileStreamSource).ConfigureAwait(false);
}
FileNotification fileNotification = await VerifyFileNotification(notificationReceiver, testDevice.Id).ConfigureAwait(false);
Assert.IsNotNull(fileNotification, "FileNotification is not received.");
Assert.AreEqual(testDevice.Id + "/" + filename, fileNotification.BlobName, "Uploaded file name mismatch in notifications");
Assert.AreEqual(new FileInfo(filename).Length, fileNotification.BlobSizeInBytes, "Uploaded file size mismatch in notifications");
Assert.IsFalse(string.IsNullOrEmpty(fileNotification.BlobUri), "File notification blob uri is null or empty");
await deviceClient.CloseAsync().ConfigureAwait(false);
await serviceClient.CloseAsync().ConfigureAwait(false);
}
}
internal async Task SendSingleMessageX509(Client.TransportType transport)
{
Tuple<string, string> deviceInfo = TestUtil.CreateDeviceWithX509(DevicePrefix, hostName, registryManager);
EventHubClient eventHubClient;
EventHubReceiver eventHubReceiver = await CreateEventHubReceiver(deviceInfo.Item1);
X509Certificate2 cert = Configuration.IoTHub.GetCertificateWithPrivateKey();
var auth = new DeviceAuthenticationWithX509Certificate(deviceInfo.Item1, cert);
var deviceClient = DeviceClient.Create(deviceInfo.Item2, auth, transport);
try
{
await deviceClient.OpenAsync();
string payload;
string p1Value;
Client.Message testMessage = ComposeD2CTestMessage(out payload, out p1Value);
await deviceClient.SendEventAsync(testMessage);
bool isReceived = false;
Stopwatch sw = new Stopwatch();
sw.Start();
while (!isReceived && sw.Elapsed.Minutes < 1)
{
var events = await eventHubReceiver.ReceiveAsync(int.MaxValue, TimeSpan.FromSeconds(5));
isReceived = VerifyTestMessage(events, deviceInfo.Item1, payload, p1Value);
}
sw.Stop();
Assert.IsTrue(isReceived, "Message is not received.");
}
finally
{
await deviceClient.CloseAsync();
await eventHubReceiver.CloseAsync();
await TestUtil.RemoveDeviceAsync(deviceInfo.Item1, registryManager);
}
}
private async Task ReceiveMessageRecovery(Client.TransportType transport, string faultType, string reason,
int delayInSec)
{
TestDevice testDevice = await TestDevice.GetTestDeviceAsync(DevicePrefix).ConfigureAwait(false);
ServiceClient serviceClient = ServiceClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString);
var deviceClient = DeviceClient.CreateFromConnectionString(testDevice.ConnectionString, transport);
try
{
await deviceClient.OpenAsync().ConfigureAwait(false);
if (transport == Client.TransportType.Mqtt_Tcp_Only ||
transport == Client.TransportType.Mqtt_WebSocket_Only)
{
// Dummy ReceiveAsync to ensure mqtt subscription registration before SendAsync() is called on service client.
await deviceClient.ReceiveAsync(TimeSpan.FromSeconds(2)).ConfigureAwait(false);
}
string payload, messageId, p1Value;
await serviceClient.OpenAsync().ConfigureAwait(false);
await serviceClient.SendAsync(
testDevice.Id,
ComposeC2DTestMessage(out payload, out messageId, out p1Value)).ConfigureAwait(false);
await VerifyReceivedC2DMessage(transport, deviceClient, payload, p1Value).ConfigureAwait(false);
// send error command
await deviceClient.SendEventAsync(
FaultInjection.ComposeErrorInjectionProperties(faultType, reason, delayInSec)).ConfigureAwait(false);
await Task.Delay(FaultInjection.WaitForDisconnectMilliseconds).ConfigureAwait(false);
await serviceClient.SendAsync(
testDevice.Id,
ComposeC2DTestMessage(out payload, out messageId, out p1Value)).ConfigureAwait(false);
await VerifyReceivedC2DMessage(transport, deviceClient, payload, p1Value).ConfigureAwait(false);
}
finally
{
await deviceClient.CloseAsync().ConfigureAwait(false);
await serviceClient.CloseAsync().ConfigureAwait(false);
}
}
internal async Task SendSingleMessageX509(Client.TransportType transport)
{
TestDevice testDevice = await TestDevice.GetTestDeviceAsync(DevicePrefix, TestDeviceType.X509).ConfigureAwait(false);
EventHubReceiver eventHubReceiver = await CreateEventHubReceiver(testDevice.Id).ConfigureAwait(false);
X509Certificate2 cert = Configuration.IoTHub.GetCertificateWithPrivateKey();
var auth = new DeviceAuthenticationWithX509Certificate(testDevice.Id, cert);
var deviceClient = DeviceClient.Create(testDevice.IoTHubHostName, auth, transport);
try
{
await deviceClient.OpenAsync().ConfigureAwait(false);
string payload;
string p1Value;
Client.Message testMessage = ComposeD2CTestMessage(out payload, out p1Value);
await deviceClient.SendEventAsync(testMessage).ConfigureAwait(false);
bool isReceived = false;
Stopwatch sw = new Stopwatch();
sw.Start();
while (!isReceived && sw.Elapsed.Minutes < 1)
{
var events = await eventHubReceiver.ReceiveAsync(int.MaxValue, TimeSpan.FromSeconds(5)).ConfigureAwait(false);
isReceived = VerifyTestMessage(events, testDevice.Id, payload, p1Value);
}
sw.Stop();
Assert.IsTrue(isReceived, "Message is not received.");
}
finally
{
await deviceClient.CloseAsync().ConfigureAwait(false);
await eventHubReceiver.CloseAsync().ConfigureAwait(false);
}
}
private async Task _Twin_DeviceSetsReportedPropertyAndServiceReceivesIt(Client.TransportType transport)
{
var propName = Guid.NewGuid().ToString();
var propValue = Guid.NewGuid().ToString();
var deviceClient = DeviceClient.CreateFromConnectionString(deviceConnectionString, transport);
var patch = new TwinCollection();
patch[propName] = propValue;
await deviceClient.UpdateReportedPropertiesAsync(patch);
await deviceClient.CloseAsync();
var registryManager = RegistryManager.CreateFromConnectionString(hubConnectionString);
var serviceTwin = await registryManager.GetTwinAsync(deviceName);
Assert.AreEqual <string>(serviceTwin.Properties.Reported[propName].ToString(), propValue);
TestContext.WriteLine("verified " + serviceTwin.Properties.Reported[propName].ToString() + "=" + propValue);
await registryManager.CloseAsync();
}
private async Task Twin_DeviceSetsReportedPropertyAndServiceReceivesIt(Client.TransportType transport)
{
var propName = Guid.NewGuid().ToString();
var propValue = Guid.NewGuid().ToString();
Tuple <string, string> deviceInfo = TestUtil.CreateDevice(DevicePrefix, hostName, registryManager);
var deviceClient = DeviceClient.CreateFromConnectionString(deviceInfo.Item2, transport);
var patch = new TwinCollection();
patch[propName] = propValue;
await deviceClient.UpdateReportedPropertiesAsync(patch).ConfigureAwait(false);
await deviceClient.CloseAsync().ConfigureAwait(false);
var serviceTwin = await registryManager.GetTwinAsync(deviceInfo.Item1).ConfigureAwait(false);
Assert.AreEqual <string>(serviceTwin.Properties.Reported[propName].ToString(), propValue);
TestContext.WriteLine("verified " + serviceTwin.Properties.Reported[propName].ToString() + "=" + propValue);
await TestUtil.RemoveDeviceAsync(deviceInfo.Item1, registryManager).ConfigureAwait(false);
}
private async Task Twin_DeviceReportedPropertiesRecovery(
Client.TransportType transport,
string faultType,
string reason,
int delayInSec)
{
var propName = Guid.NewGuid().ToString();
var props = new TwinCollection();
Func <DeviceClient, TestDevice, Task> testOperation = async(deviceClient, testDevice) =>
{
var propValue = Guid.NewGuid().ToString();
props[propName] = propValue;
await deviceClient.UpdateReportedPropertiesAsync(props).ConfigureAwait(false);
Twin deviceTwin = await deviceClient.GetTwinAsync().ConfigureAwait(false);
Assert.IsNotNull(deviceTwin, $"{nameof(deviceTwin)} is null");
Assert.IsNotNull(deviceTwin.Properties, $"{nameof(deviceTwin)}.Properties is null");
Assert.IsNotNull(deviceTwin.Properties.Reported, $"{nameof(deviceTwin)}.Properties.Reported is null");
Assert.IsNotNull(deviceTwin.Properties.Reported[propName], $"{nameof(deviceTwin)}.Properties.Reported[{nameof(propName)}] is null");
Assert.AreEqual <string>(deviceTwin.Properties.Reported[propName].ToString(), propValue);
};
await FaultInjection
.TestErrorInjectionAsync(
s_devicePrefix,
TestDeviceType.Sasl,
transport,
faultType,
reason,
delayInSec,
FaultInjection.DefaultDurationInSec,
(d, t) => { return(Task.FromResult <bool>(false)); },
testOperation,
() => { return(Task.FromResult <bool>(false)); },
Logger)
.ConfigureAwait(false);
}
private async Task SendMethodAndRespondPoolOverAmqp(
Client.TransportType transport,
int poolSize,
int devicesCount,
Func <DeviceClient, string, MsTestLogger, Task <Task> > setDeviceReceiveMethod,
ConnectionStringAuthScope authScope = ConnectionStringAuthScope.Device)
{
Func <DeviceClient, TestDevice, Task> initOperation = async(deviceClient, testDevice) =>
{
Logger.Trace($"{nameof(MethodE2EPoolAmqpTests)}: Setting method for device {testDevice.Id}");
Task methodReceivedTask = await setDeviceReceiveMethod(deviceClient, MethodName, Logger).ConfigureAwait(false);
};
Func <DeviceClient, TestDevice, Task> testOperation = async(deviceClient, testDevice) =>
{
Logger.Trace($"{nameof(MethodE2EPoolAmqpTests)}: Preparing to receive method for device {testDevice.Id}");
await MethodE2ETests
.ServiceSendMethodAndVerifyResponseAsync(
testDevice.Id,
MethodName,
MethodE2ETests.DeviceResponseJson,
MethodE2ETests.ServiceRequestJson,
Logger)
.ConfigureAwait(false);
};
await PoolingOverAmqp
.TestPoolAmqpAsync(
_devicePrefix,
transport,
poolSize,
devicesCount,
initOperation,
testOperation,
null,
authScope,
true,
Logger)
.ConfigureAwait(false);
}
private async Task SendMethodAndRespondPoolOverAmqp(
Client.TransportType transport,
int poolSize,
int devicesCount,
Func <DeviceClient, string, Task <Task> > setDeviceReceiveMethod,
ConnectionStringAuthScope authScope = ConnectionStringAuthScope.Device)
{
Func <DeviceClient, TestDevice, Task> initOperation = async(deviceClient, testDevice) =>
{
_log.WriteLine($"{nameof(MethodE2EPoolAmqpTests)}: Setting method for device {testDevice.Id}");
Task methodReceivedTask = await setDeviceReceiveMethod(deviceClient, MethodName).ConfigureAwait(false);
};
Func <DeviceClient, TestDevice, Task> testOperation = async(deviceClient, testDevice) =>
{
_log.WriteLine($"{nameof(MethodE2EPoolAmqpTests)}: Preparing to receive method for device {testDevice.Id}");
await MethodE2ETests.ServiceSendMethodAndVerifyResponse(
testDevice.Id, MethodName, MethodE2ETests.DeviceResponseJson, MethodE2ETests.ServiceRequestJson).ConfigureAwait(false);
};
Func <IList <DeviceClient>, Task> cleanupOperation = async(deviceClients) =>
{
foreach (DeviceClient deviceClient in deviceClients)
{
deviceClient.Dispose();
}
await Task.FromResult <bool>(false).ConfigureAwait(false);
};
await PoolingOverAmqp.TestPoolAmqpAsync(
DevicePrefix,
transport,
poolSize,
devicesCount,
initOperation,
testOperation,
cleanupOperation,
authScope,
true).ConfigureAwait(false);
}
private async Task ReceiveMessageRecovery(Client.TransportType transport, string faultType, string reason, int delayInSec)
{
await sequentialTestSemaphore.WaitAsync();
Tuple <string, string> deviceInfo = TestUtil.CreateDevice(DevicePrefix, hostName, registryManager);
ServiceClient serviceClient = ServiceClient.CreateFromConnectionString(hubConnectionString);
var deviceClient = DeviceClient.CreateFromConnectionString(deviceInfo.Item2, transport);
await deviceClient.OpenAsync();
if (transport == Client.TransportType.Mqtt_Tcp_Only || transport == Client.TransportType.Mqtt_WebSocket_Only)
{
// Dummy ReceiveAsync to ensure mqtt subscription registration before SendAsync() is called on service client.
await deviceClient.ReceiveAsync(TimeSpan.FromSeconds(2));
}
string payload, messageId, p1Value;
await serviceClient.OpenAsync();
await serviceClient.SendAsync(deviceInfo.Item1, ComposeC2DTestMessage(out payload, out messageId, out p1Value));
await VerifyReceivedC2DMessage(transport, deviceClient, payload, p1Value);
// send error command
await deviceClient.SendEventAsync(TestUtil.ComposeErrorInjectionProperties(faultType, reason, delayInSec));
await Task.Delay(1000);
await serviceClient.SendAsync(deviceInfo.Item1, ComposeC2DTestMessage(out payload, out messageId, out p1Value));
await VerifyReceivedC2DMessage(transport, deviceClient, payload, p1Value);
await deviceClient.CloseAsync();
await serviceClient.CloseAsync();
TestUtil.RemoveDevice(deviceInfo.Item1, registryManager);
sequentialTestSemaphore.Release(1);
}
private async Task Twin_ServiceSetsDesiredPropertyAndDeviceReceivesEvent(Client.TransportType transport)
{
var tcs = new TaskCompletionSource<bool>();
var propName = Guid.NewGuid().ToString();
var propValue = Guid.NewGuid().ToString();
TestDevice testDevice = await TestDevice.GetTestDeviceAsync(DevicePrefix).ConfigureAwait(false);
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(Configuration.IoTHub.ConnectionString);
var deviceClient = DeviceClient.CreateFromConnectionString(testDevice.ConnectionString, transport);
await deviceClient.OpenAsync().ConfigureAwait(false);
await deviceClient.SetDesiredPropertyUpdateCallbackAsync((patch, context) =>
{
return Task.Run(() =>
{
try
{
Assert.AreEqual(patch[propName].ToString(), propValue);
}
catch (Exception e)
{
tcs.SetException(e);
}
finally
{
tcs.SetResult(true);
}
});
}, null).ConfigureAwait(false);
var twinPatch = new Twin();
twinPatch.Properties.Desired[propName] = propValue;
await registryManager.UpdateTwinAsync(testDevice.Id, twinPatch, "*").ConfigureAwait(false);
await tcs.Task.ConfigureAwait(false);
await deviceClient.CloseAsync().ConfigureAwait(false);
await registryManager.CloseAsync().ConfigureAwait(false);
}
private async Task SendSingleMessage(Client.TransportType transport)
{
Tuple <string, string> deviceInfo = TestUtil.CreateDevice(DevicePrefix, hostName, registryManager);
EventHubClient eventHubClient;
EventHubReceiver eventHubReceiver = CreateEventHubReceiver(deviceInfo.Item1, out eventHubClient);
var deviceClient = DeviceClient.CreateFromConnectionString(deviceInfo.Item2, transport);
try
{
await deviceClient.OpenAsync();
string payload;
string p1Value;
Client.Message testMessage = ComposeD2CTestMessage(out payload, out p1Value);
await deviceClient.SendEventAsync(testMessage);
bool isReceived = false;
Stopwatch sw = new Stopwatch();
sw.Start();
while (!isReceived && sw.Elapsed.Minutes < 1)
{
var events = await eventHubReceiver.ReceiveAsync(int.MaxValue, TimeSpan.FromSeconds(5));
isReceived = VerifyTestMessage(events, deviceInfo.Item1, payload, p1Value);
}
sw.Stop();
Assert.IsTrue(isReceived, "Message is not received.");
}
finally
{
await deviceClient.CloseAsync();
await eventHubReceiver.CloseAsync();
await eventHubClient.CloseAsync();
TestUtil.RemoveDevice(deviceInfo.Item1, registryManager);
}
}
private async Task Twin_ServiceSetsDesiredPropertyAndDeviceReceivesEvent(Client.TransportType transport)
{
var tcs = new TaskCompletionSource <bool>();
var propName = Guid.NewGuid().ToString();
var propValue = Guid.NewGuid().ToString();
Tuple <string, string> deviceInfo = TestUtil.CreateDevice(DevicePrefix, hostName, registryManager);
var deviceClient = DeviceClient.CreateFromConnectionString(deviceInfo.Item2, transport);
await deviceClient.OpenAsync().ConfigureAwait(false);
await deviceClient.SetDesiredPropertyUpdateCallbackAsync((patch, context) =>
{
return(Task.Run(() =>
{
try
{
Assert.AreEqual(patch[propName].ToString(), propValue);
}
catch (Exception e)
{
tcs.SetException(e);
}
finally
{
tcs.SetResult(true);
}
}));
}, null).ConfigureAwait(false);
var twinPatch = new Twin();
twinPatch.Properties.Desired[propName] = propValue;
await registryManager.UpdateTwinAsync(deviceInfo.Item1, twinPatch, "*").ConfigureAwait(false);
await tcs.Task.ConfigureAwait(false);
await deviceClient.CloseAsync().ConfigureAwait(false);
await TestUtil.RemoveDeviceAsync(deviceInfo.Item1, registryManager).ConfigureAwait(false);
}
private async Task Twin_ClientHandlesRejectionInvalidPropertyName(Client.TransportType transport)
{
var propName1 = "$" + Guid.NewGuid().ToString();
var propName2 = Guid.NewGuid().ToString();
TestDevice testDevice = await TestDevice.GetTestDeviceAsync(DevicePrefix).ConfigureAwait(false);
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(Configuration.IoTHub.ConnectionString);
using (var deviceClient = DeviceClient.CreateFromConnectionString(testDevice.ConnectionString, transport))
{
var exceptionThrown = false;
try
{
await deviceClient.UpdateReportedPropertiesAsync(new TwinCollection
{
[propName1] = 123,
[propName2] = "abcd"
}).ConfigureAwait(false);
}
catch (Exception)
{
exceptionThrown = true;
}
if (!exceptionThrown)
{
throw new AssertFailedException("Exception was expected, but not thrown.");
}
var serviceTwin = await registryManager.GetTwinAsync(testDevice.Id).ConfigureAwait(false);
Assert.IsFalse(serviceTwin.Properties.Reported.Contains(propName1));
await deviceClient.CloseAsync().ConfigureAwait(false);
}
await registryManager.CloseAsync().ConfigureAwait(false);
}
async Task uploadFile(Client.TransportType transport, string filename)
{
Tuple <string, string> deviceInfo = TestUtil.CreateDevice("E2E_FileUpload_CSharp_", hostName, registryManager);
var deviceClient = DeviceClient.CreateFromConnectionString(deviceInfo.Item2, transport);
using (FileStream fileStreamSource = new FileStream(filename, FileMode.Open, FileAccess.Read))
{
await deviceClient.UploadToBlobAsync(filename, fileStreamSource);
}
ServiceClient serviceClient = ServiceClient.CreateFromConnectionString(hubConnectionString);
FileNotificationReceiver <FileNotification> fileNotificationReceiver = serviceClient.GetFileNotificationReceiver();
FileNotification fileNotification;
while (true)
{
// Receive the file notification from queue
fileNotification = await fileNotificationReceiver.ReceiveAsync(TimeSpan.FromSeconds(20));
Assert.IsNotNull(fileNotification);
await fileNotificationReceiver.CompleteAsync(fileNotification);
if (deviceInfo.Item1 == fileNotification.DeviceId)
{
break;
}
}
Assert.AreEqual(deviceInfo.Item1 + "/" + filename, fileNotification.BlobName, "Uploaded file name mismatch in notifications");
Assert.AreEqual(new FileInfo(filename).Length, fileNotification.BlobSizeInBytes, "Uploaded file size mismatch in notifications");
Assert.IsFalse(string.IsNullOrEmpty(fileNotification.BlobUri), "File notification blob uri is null or empty");
await deviceClient.CloseAsync();
await serviceClient.CloseAsync();
TestUtil.RemoveDevice(deviceInfo.Item1, registryManager);
}
private async Task X509InvalidDeviceIdOpenAsyncTest(Client.TransportType transportType)
{
var deviceClient = CreateDeviceClientWithInvalidId(transportType);
using (deviceClient)
{
try
{
await deviceClient.OpenAsync().ConfigureAwait(false);
Assert.Fail("Should throw UnauthorizedException but didn't.");
}
catch (UnauthorizedException)
{
// It should always throw UnauthorizedException
}
// Check TCP connection to verify there is no connection leak
// netstat -na | find "[Your Hub IP]" | find "ESTABLISHED"
await Task.Delay(TimeSpan.FromSeconds(10)).ConfigureAwait(false);
}
}
internal async Task SendMessageRecoveryAsync(
TestDeviceType type,
Client.TransportType transport,
string faultType,
string reason,
int delayInSec,
int durationInSec = FaultInjection.DefaultDurationInSec,
int retryDurationInMilliSec = FaultInjection.RecoveryTimeMilliseconds)
{
Func <DeviceClient, TestDevice, Task> init = (deviceClient, testDevice) =>
{
deviceClient.OperationTimeoutInMilliseconds = (uint)retryDurationInMilliSec;
return(Task.FromResult(0));
};
Func <DeviceClient, TestDevice, Task> testOperation = async(deviceClient, testDevice) =>
{
(Client.Message testMessage, string messageId, string payload, string p1Value) = MessageSendE2ETests.ComposeD2cTestMessage();
await deviceClient.SendEventAsync(testMessage).ConfigureAwait(false);
bool isReceived = false;
isReceived = EventHubTestListener.VerifyIfMessageIsReceived(testDevice.Id, payload, p1Value);
Assert.IsTrue(isReceived);
};
await FaultInjection
.TestErrorInjectionAsync(
_devicePrefix,
type,
transport,
faultType,
reason,
delayInSec,
durationInSec,
init,
testOperation,
() => { return(Task.FromResult(false)); })
.ConfigureAwait(false);
}
internal async Task SendMessageRecoveryAsync(
TestDeviceType type,
Client.TransportType transport,
string faultType,
string reason,
TimeSpan delayInSec,
TimeSpan durationInSec = default,
TimeSpan retryDurationInMilliSec = default,
string proxyAddress = null)
{
TimeSpan operationTimeoutInMilliSecs = retryDurationInMilliSec == TimeSpan.Zero ? FaultInjection.RecoveryTime : retryDurationInMilliSec;
Func <DeviceClient, TestDevice, Task> init = (deviceClient, testDevice) =>
{
deviceClient.OperationTimeoutInMilliseconds = (uint)retryDurationInMilliSec.TotalMilliseconds;
return(Task.FromResult(0));
};
Func <DeviceClient, TestDevice, Task> testOperation = async(deviceClient, testDevice) =>
{
(Client.Message testMessage, string payload, string p1Value) = MessageSendE2ETests.ComposeD2cTestMessage(Logger);
await deviceClient.SendEventAsync(testMessage).ConfigureAwait(false);
};
await FaultInjection
.TestErrorInjectionAsync(
_devicePrefix,
type,
transport,
proxyAddress,
faultType,
reason,
delayInSec,
durationInSec == TimeSpan.Zero?FaultInjection.DefaultFaultDuration : durationInSec,
init,
testOperation,
() => { return(Task.FromResult(false)); },
Logger)
.ConfigureAwait(false);
}
private async Task _Twin_ServiceSetsDesiredPropertyAndDeviceReceivesEvent(Client.TransportType transport)
{
var tcs = new TaskCompletionSource <bool>();
var propName = Guid.NewGuid().ToString();
var propValue = Guid.NewGuid().ToString();
var deviceClient = DeviceClient.CreateFromConnectionString(deviceConnectionString, transport);
await deviceClient.OpenAsync();
await deviceClient.SetDesiredPropertyUpdateCallback((patch, context) =>
{
return(Task.Run(() =>
{
try
{
Assert.AreEqual(patch[propName].ToString(), propValue);
}
catch (Exception e)
{
tcs.SetException(e);
}
finally
{
tcs.SetResult(true);
}
}));
}, null);
var registryManager = RegistryManager.CreateFromConnectionString(hubConnectionString);
var twinPatch = new Twin();
twinPatch.Properties.Desired[propName] = propValue;
await registryManager.UpdateTwinAsync(deviceName, twinPatch, "*");
await registryManager.CloseAsync();
await tcs.Task;
await deviceClient.CloseAsync();
}
private async Task ReceiveMessageInOperationTimeout(TestDeviceType type, Client.TransportType transport)
{
TestDevice testDevice = await TestDevice.GetTestDeviceAsync(DevicePrefix, type).ConfigureAwait(false);
using (DeviceClient deviceClient = testDevice.CreateDeviceClient(transport))
{
_log.WriteLine($"{nameof(ReceiveMessageInOperationTimeout)} - calling OpenAsync() for transport={transport}");
await deviceClient.OpenAsync().ConfigureAwait(false);
if (transport == Client.TransportType.Mqtt_Tcp_Only ||
transport == Client.TransportType.Mqtt_WebSocket_Only)
{
// Dummy ReceiveAsync to ensure mqtt subscription registration before SendAsync() is called on service client.
await deviceClient.ReceiveAsync(TIMESPAN_FIVE_SECONDS).ConfigureAwait(false);
}
try
{
deviceClient.OperationTimeoutInMilliseconds = Convert.ToUInt32(TIMESPAN_ONE_MINUTE.TotalMilliseconds);
_log.WriteLine($"{nameof(ReceiveMessageInOperationTimeout)} - setting device client default operation timeout={deviceClient.OperationTimeoutInMilliseconds} ms");
if (transport == Client.TransportType.Amqp || transport == Client.TransportType.Amqp_Tcp_Only || transport == Client.TransportType.Amqp_WebSocket_Only)
{
// For AMQP because of static 1 min interval check the cancellation token, in worst case it will block upto extra 1 min to return
await ReceiveMessageWithoutTimeoutCheck(deviceClient, TIMESPAN_ONE_MINUTE).ConfigureAwait(false);
}
else
{
await ReceiveMessageWithoutTimeoutCheck(deviceClient, TIMESPAN_FIVE_SECONDS).ConfigureAwait(false);
}
}
finally
{
_log.WriteLine($"{nameof(ReceiveMessageInOperationTimeout)} - calling CloseAsync() for transport={transport}");
deviceClient.OperationTimeoutInMilliseconds = DeviceClient.DefaultOperationTimeoutInMilliseconds;
await deviceClient.CloseAsync().ConfigureAwait(false);
}
}
}
public static async Task VerifyReceivedC2DMessageAsync(Client.TransportType transport, DeviceClient dc, string deviceId, string payload, string p1Value)
{
var wait = true;
Stopwatch sw = new Stopwatch();
sw.Start();
while (wait)
{
Client.Message receivedMessage = null;
_log.WriteLine($"Receiving messages for device {deviceId}.");
receivedMessage = await dc.ReceiveAsync(TimeSpan.FromSeconds(1)).ConfigureAwait(false);
if (receivedMessage != null)
{
string messageData = Encoding.ASCII.GetString(receivedMessage.GetBytes());
_log.WriteLine($"{nameof(VerifyReceivedC2DMessageAsync)}: Received message: for {deviceId}: {messageData}");
Assert.AreEqual(payload, messageData, $"The payload did not match for device {deviceId}");
Assert.AreEqual(1, receivedMessage.Properties.Count, $"The count of received properties did not match for device {deviceId}");
var prop = receivedMessage.Properties.Single();
Assert.AreEqual("property1", prop.Key, $"The key \"property1\" did not match for device {deviceId}");
Assert.AreEqual(p1Value, prop.Value, $"The value of \"property1\" did not match for device {deviceId}");
await dc.CompleteAsync(receivedMessage).ConfigureAwait(false);
break;
}
if (sw.Elapsed.TotalMilliseconds > FaultInjection.RecoveryTimeMilliseconds)
{
throw new TimeoutException("Test is running longer than expected.");
}
}
sw.Stop();
}
private async Task X509InvalidDeviceIdOpenAsyncTest(Client.TransportType transportType)
{
string deviceName = $"DEVICE_NOT_EXIST_{Guid.NewGuid()}";
using var auth = new DeviceAuthenticationWithX509Certificate(deviceName, s_selfSignedCertificateWithPrivateKey);
using var deviceClient = DeviceClient.Create(_hostName, auth, transportType);
try
{
await deviceClient.OpenAsync().ConfigureAwait(false);
Assert.Fail("Should throw UnauthorizedException but didn't.");
}
catch (UnauthorizedException)
{
// It should always throw UnauthorizedException
}
// Check TCP connection to verify there is no connection leak
// netstat -na | find "[Your Hub IP]" | find "ESTABLISHED"
await Task.Delay(TimeSpan.FromSeconds(10)).ConfigureAwait(false);
}
