private async Task ReceiveMessageWithCallbackRecoveryAsync(
TestDeviceType type,
Client.TransportType transport,
string faultType,
string reason,
TimeSpan delayInSec,
string proxyAddress = null)
{
TestDeviceCallbackHandler testDeviceCallbackHandler = null;
using var serviceClient = ServiceClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString);
async Task InitOperationAsync(DeviceClient deviceClient, TestDevice testDevice)
{
await serviceClient.OpenAsync().ConfigureAwait(false);
testDeviceCallbackHandler = new TestDeviceCallbackHandler(deviceClient, testDevice, Logger);
await testDeviceCallbackHandler.SetMessageReceiveCallbackHandlerAsync().ConfigureAwait(false);
}
async Task TestOperationAsync(DeviceClient deviceClient, TestDevice testDevice)
{
var timeout = TimeSpan.FromSeconds(20);
using var cts = new CancellationTokenSource(timeout);
(Message message, string payload, string p1Value) = MessageReceiveE2ETests.ComposeC2dTestMessage(Logger);
testDeviceCallbackHandler.ExpectedMessageSentByService = message;
await serviceClient.SendAsync(testDevice.Id, message).ConfigureAwait(false);
Client.Message receivedMessage = await deviceClient.ReceiveAsync(timeout).ConfigureAwait(false);
await testDeviceCallbackHandler.WaitForReceiveMessageCallbackAsync(cts.Token).ConfigureAwait(false);
receivedMessage.Should().BeNull();
}
Task CleanupOperationAsync()
{
serviceClient.CloseAsync();
testDeviceCallbackHandler?.Dispose();
return(Task.FromResult(true));
}
await FaultInjection
.TestErrorInjectionAsync(
DevicePrefix,
type,
transport,
proxyAddress,
faultType,
reason,
delayInSec,
FaultInjection.DefaultFaultDuration,
InitOperationAsync,
TestOperationAsync,
CleanupOperationAsync,
Logger)
.ConfigureAwait(false);
}
private async Task ReceiveMessageRecovery(
TestDeviceType type,
Client.TransportType transport,
string faultType,
string reason,
TimeSpan delayInSec,
string proxyAddress = null)
{
using var serviceClient = ServiceClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString);
async Task InitOperationAsync(DeviceClient deviceClient, TestDevice testDevice)
{
await serviceClient.OpenAsync().ConfigureAwait(false);
// For Mqtt - the device needs to have subscribed to the devicebound topic, in order for IoT Hub to deliver messages to the device.
// For this reason we will make a "fake" ReceiveAsync() call, which will result in the device subscribing to the c2d topic.
// Note: We need this "fake" ReceiveAsync() call even though we (SDK default) CONNECT with a CleanSession flag set to 0.
// This is because this test device is newly created, and it has never subscribed to IoT hub c2d topic.
// Hence, IoT hub doesn't know about its CleanSession preference yet.
if (transport == Client.TransportType.Mqtt_Tcp_Only ||
transport == Client.TransportType.Mqtt_WebSocket_Only)
{
await deviceClient.ReceiveAsync(TimeSpan.FromSeconds(5)).ConfigureAwait(false);
}
}
async Task TestOperationAsync(DeviceClient deviceClient, TestDevice testDevice)
{
(Message message, string payload, string p1Value) = MessageReceiveE2ETests.ComposeC2dTestMessage(Logger);
await serviceClient.SendAsync(testDevice.Id, message).ConfigureAwait(false);
await MessageReceiveE2ETests.VerifyReceivedC2DMessageAsync(transport, deviceClient, testDevice.Id, message, payload, Logger).ConfigureAwait(false);
}
Task CleanupOperationAsync()
{
return(serviceClient.CloseAsync());
}
await FaultInjection
.TestErrorInjectionAsync(
DevicePrefix,
type,
transport,
proxyAddress,
faultType,
reason,
delayInSec,
FaultInjection.DefaultFaultDuration,
InitOperationAsync,
TestOperationAsync,
CleanupOperationAsync,
Logger)
.ConfigureAwait(false);
}
private async Task ReceiveMessagePoolOverAmqpAsync(
Client.TransportType transport,
int poolSize,
int devicesCount,
ConnectionStringAuthScope authScope = ConnectionStringAuthScope.Device)
{
var messagesSent = new Dictionary <string, Tuple <Message, string> >();
// Initialize the service client
var serviceClient = ServiceClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString);
async Task InitOperationAsync(DeviceClient deviceClient, TestDevice testDevice, TestDeviceCallbackHandler _)
{
(Message msg, string payload, string p1Value) = MessageReceiveE2ETests.ComposeC2dTestMessage(Logger);
messagesSent.Add(testDevice.Id, Tuple.Create(msg, payload));
await serviceClient.SendAsync(testDevice.Id, msg).ConfigureAwait(false);
}
async Task TestOperationAsync(DeviceClient deviceClient, TestDevice testDevice, TestDeviceCallbackHandler _)
{
Logger.Trace($"{nameof(MessageReceiveE2EPoolAmqpTests)}: Preparing to receive message for device {testDevice.Id}");
await deviceClient.OpenAsync().ConfigureAwait(false);
Tuple <Message, string> msgSent = messagesSent[testDevice.Id];
await MessageReceiveE2ETests.VerifyReceivedC2DMessageAsync(transport, deviceClient, testDevice.Id, msgSent.Item1, msgSent.Item2, Logger).ConfigureAwait(false);
}
async Task CleanupOperationAsync()
{
await serviceClient.CloseAsync().ConfigureAwait(false);
serviceClient.Dispose();
messagesSent.Clear();
}
await PoolingOverAmqp
.TestPoolAmqpAsync(
DevicePrefix,
transport,
poolSize,
devicesCount,
InitOperationAsync,
TestOperationAsync,
CleanupOperationAsync,
authScope,
true,
Logger)
.ConfigureAwait(false);
}
private async Task ReceiveMessageRecovery(
TestDeviceType type,
Client.TransportType transport,
string faultType,
string reason,
int delayInSec,
string proxyAddress = null)
{
using (ServiceClient serviceClient = ServiceClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString))
{
Func <DeviceClient, TestDevice, Task> init = async(deviceClient, testDevice) =>
{
await serviceClient.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(5)).ConfigureAwait(false);
}
};
Func <DeviceClient, TestDevice, Task> testOperation = async(deviceClient, testDevice) =>
{
(Message message, string payload, string p1Value) = MessageReceiveE2ETests.ComposeC2dTestMessage(Logger);
await serviceClient.SendAsync(testDevice.Id, message).ConfigureAwait(false);
await MessageReceiveE2ETests.VerifyReceivedC2DMessageAsync(transport, deviceClient, testDevice.Id, message, payload, Logger).ConfigureAwait(false);
};
Func <Task> cleanupOperation = () =>
{
return(serviceClient.CloseAsync());
};
await FaultInjection.TestErrorInjectionAsync(
DevicePrefix,
type,
transport,
proxyAddress,
faultType,
reason,
delayInSec,
FaultInjection.DefaultDurationInSec,
init,
testOperation,
cleanupOperation,
Logger).ConfigureAwait(false);
}
}
private async Task ReceiveMessageUsingCallbackPoolOverAmqpAsync(
Client.TransportType transport,
int poolSize,
int devicesCount,
ConnectionStringAuthScope authScope = ConnectionStringAuthScope.Device)
{
// Initialize the service client
var serviceClient = ServiceClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString);
async Task InitOperationAsync(DeviceClient deviceClient, TestDevice testDevice, TestDeviceCallbackHandler testDeviceCallbackHandler)
{
(Message msg, string payload, string p1Value) = MessageReceiveE2ETests.ComposeC2dTestMessage(Logger);
await testDeviceCallbackHandler.SetMessageReceiveCallbackHandlerAsync().ConfigureAwait(false);
testDeviceCallbackHandler.ExpectedMessageSentByService = msg;
await serviceClient.SendAsync(testDevice.Id, msg).ConfigureAwait(false);
}
async Task TestOperationAsync(DeviceClient deviceClient, TestDevice testDevice, TestDeviceCallbackHandler testDeviceCallbackHandler)
{
Logger.Trace($"{nameof(MessageReceiveE2EPoolAmqpTests)}: Preparing to receive message for device {testDevice.Id}");
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(20));
await testDeviceCallbackHandler.WaitForReceiveMessageCallbackAsync(cts.Token).ConfigureAwait(false);
}
async Task CleanupOperationAsync()
{
await serviceClient.CloseAsync().ConfigureAwait(false);
serviceClient.Dispose();
}
await PoolingOverAmqp
.TestPoolAmqpAsync(
DevicePrefix,
transport,
poolSize,
devicesCount,
InitOperationAsync,
TestOperationAsync,
CleanupOperationAsync,
authScope,
true,
Logger)
.ConfigureAwait(false);
}
private static async Task CompleteMessageMixOrder(TestDeviceType type, Client.TransportType transport, MsTestLogger logger)
{
using TestDevice testDevice = await TestDevice.GetTestDeviceAsync(logger, s_devicePrefix, type).ConfigureAwait(false);
using (DeviceClient deviceClient = testDevice.CreateDeviceClient(transport))
using (var serviceClient = ServiceClient.CreateFromConnectionString(TestConfiguration.IoTHub.ConnectionString))
{
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);
}
await serviceClient.OpenAsync().ConfigureAwait(false);
var messages = new List <Client.Message>();
for (int i = 0; i < MESSAGE_COUNT; i++)
{
(Message msg, string payload, string p1Value) = MessageReceiveE2ETests.ComposeC2dTestMessage(logger);
await serviceClient.SendAsync(testDevice.Id, msg).ConfigureAwait(false);
Client.Message message = await deviceClient.ReceiveAsync(TIMESPAN_ONE_MINUTE).ConfigureAwait(false);
if (message == null)
{
Assert.Fail("No message received.");
}
messages.Add(message);
}
for (int i = 0; i < MESSAGE_COUNT; i++)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
await deviceClient.CompleteAsync(messages[MESSAGE_COUNT - 1 - i]).ConfigureAwait(false);
stopwatch.Stop();
Assert.IsFalse(stopwatch.ElapsedMilliseconds > deviceClient.OperationTimeoutInMilliseconds, $"CompleteAsync is over {deviceClient.OperationTimeoutInMilliseconds}");
}
await deviceClient.CloseAsync().ConfigureAwait(false);
await serviceClient.CloseAsync().ConfigureAwait(false);
}
}
private async Task ReceiveMessageUsingCallbackAndUnsubscribePoolOverAmqpAsync(
Client.TransportType transport,
int poolSize,
int devicesCount,
ConnectionStringAuthScope authScope = ConnectionStringAuthScope.Device)
{
// Initialize the service client
var serviceClient = ServiceClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString);
async Task InitOperationAsync(DeviceClient deviceClient, TestDevice testDevice, TestDeviceCallbackHandler testDeviceCallbackHandler)
{
await testDeviceCallbackHandler.SetMessageReceiveCallbackHandlerAsync().ConfigureAwait(false);
}
async Task TestOperationAsync(DeviceClient deviceClient, TestDevice testDevice, TestDeviceCallbackHandler testDeviceCallbackHandler)
{
var timeout = TimeSpan.FromSeconds(20);
using var cts = new CancellationTokenSource(timeout);
// Send a message to the device from the service.
(Message firstMessage, string payload, _) = MessageReceiveE2ETests.ComposeC2dTestMessage(Logger);
testDeviceCallbackHandler.ExpectedMessageSentByService = firstMessage;
await serviceClient.SendAsync(testDevice.Id, firstMessage).ConfigureAwait(false);
Logger.Trace($"Sent 1st C2D message from service - to be received on callback: deviceId={testDevice.Id}, messageId={firstMessage.MessageId}");
// The message should be received on the callback, while a call to ReceiveAsync() should return null.
Client.Message receivedMessage = await deviceClient.ReceiveAsync(timeout).ConfigureAwait(false);
await testDeviceCallbackHandler.WaitForReceiveMessageCallbackAsync(cts.Token).ConfigureAwait(false);
receivedMessage.Should().BeNull();
// Now unsubscribe from receiving c2d messages over the callback.
await deviceClient.SetReceiveMessageHandlerAsync(null, deviceClient).ConfigureAwait(false);
// Send a message to the device from the service.
(Message secondMessage, _, _) = MessageReceiveE2ETests.ComposeC2dTestMessage(Logger);
await serviceClient.SendAsync(testDevice.Id, secondMessage).ConfigureAwait(false);
Logger.Trace($"Sent 2nd C2D message from service - to be received on polling ReceiveAsync(): deviceId={testDevice.Id}, messageId={secondMessage.MessageId}");
// This time, the message should not be received on the callback, rather it should be received on a call to ReceiveAsync().
Func <Task> receiveMessageOverCallback = async() =>
{
await testDeviceCallbackHandler.WaitForReceiveMessageCallbackAsync(cts.Token).ConfigureAwait(false);
};
Client.Message message = await deviceClient.ReceiveAsync(timeout).ConfigureAwait(false);
message.MessageId.Should().Be(secondMessage.MessageId);
receiveMessageOverCallback.Should().Throw <OperationCanceledException>();
}
async Task CleanupOperationAsync()
{
await serviceClient.CloseAsync().ConfigureAwait(false);
serviceClient.Dispose();
}
await PoolingOverAmqp
.TestPoolAmqpAsync(
DevicePrefix,
transport,
poolSize,
devicesCount,
InitOperationAsync,
TestOperationAsync,
CleanupOperationAsync,
authScope,
true,
Logger)
.ConfigureAwait(false);
}