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 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);
}
private async Task ReceiveMessageUsingCallbackAndUnsubscribeAsync(TestDeviceType type, Client.TransportType transport)
{
TestDevice testDevice = await TestDevice.GetTestDeviceAsync(Logger, s_devicePrefix, type).ConfigureAwait(false);
using DeviceClient deviceClient = testDevice.CreateDeviceClient(transport);
using var testDeviceCallbackHandler = new TestDeviceCallbackHandler(deviceClient, testDevice, Logger);
using var serviceClient = ServiceClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString);
// For Mqtt - we will need to subscribe to the Mqtt receive telemetry topic
// before the device can begin receiving c2d messages.
if (transport == Client.TransportType.Mqtt_Tcp_Only ||
transport == Client.TransportType.Mqtt_WebSocket_Only)
{
Client.Message leftoverMessage = await deviceClient.ReceiveAsync(s_fiveSeconds).ConfigureAwait(false);
Logger.Trace($"Leftover message on Mqtt was: {leftoverMessage} with Id={leftoverMessage?.MessageId}");
}
// First receive message using the polling ReceiveAsync() API.
(Message firstMessage, _, _) = ComposeC2dTestMessage(Logger);
await serviceClient.SendAsync(testDevice.Id, firstMessage).ConfigureAwait(false);
Logger.Trace($"Sent C2D message from service, messageId={firstMessage.MessageId} - to be received on polling ReceiveAsync");
using Client.Message receivedFirstMessage = await deviceClient.ReceiveAsync(s_tenSeconds).ConfigureAwait(false);
receivedFirstMessage.MessageId.Should().Be(firstMessage.MessageId);
await deviceClient.CompleteAsync(receivedFirstMessage).ConfigureAwait(false);
// Now, set a callback on the device client to receive C2D messages.
await testDeviceCallbackHandler.SetMessageReceiveCallbackHandlerAsync().ConfigureAwait(false);
// Now, send a message to the device from the service.
(Message secondMessage, _, _) = ComposeC2dTestMessage(Logger);
testDeviceCallbackHandler.ExpectedMessageSentByService = secondMessage;
await serviceClient.SendAsync(testDevice.Id, secondMessage).ConfigureAwait(false);
Logger.Trace($"Sent C2D message from service, messageId={secondMessage.MessageId} - to be received on callback");
// The message should be received on the callback, while a call to ReceiveAsync() should return null.
using var cts = new CancellationTokenSource(s_tenSeconds);
using Client.Message receivedSecondMessage = await deviceClient.ReceiveAsync(s_tenSeconds).ConfigureAwait(false);
await testDeviceCallbackHandler.WaitForReceiveMessageCallbackAsync(cts.Token).ConfigureAwait(false);
receivedSecondMessage.Should().BeNull();
// Now unsubscribe from receiving c2d messages over the callback.
await deviceClient.SetReceiveMessageHandlerAsync(null, deviceClient).ConfigureAwait(false);
// For Mqtt - since we have explicitly unsubscribed, we will need to resubscribe again
// before the device can begin receiving c2d messages.
if (transport == Client.TransportType.Mqtt_Tcp_Only ||
transport == Client.TransportType.Mqtt_WebSocket_Only)
{
Client.Message leftoverMessage = await deviceClient.ReceiveAsync(s_fiveSeconds).ConfigureAwait(false);
Logger.Trace($"Leftover message on Mqtt was: {leftoverMessage} with Id={leftoverMessage?.MessageId}");
}
// Send a message to the device from the service.
(Message thirdMessage, _, _) = ComposeC2dTestMessage(Logger);
await serviceClient.SendAsync(testDevice.Id, thirdMessage).ConfigureAwait(false);
Logger.Trace($"Sent C2D message from service, messageId={thirdMessage.MessageId} - to be received on polling ReceiveAsync");
// 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);
};
using Client.Message receivedThirdMessage = await deviceClient.ReceiveAsync(s_tenSeconds).ConfigureAwait(false);
receivedThirdMessage.MessageId.Should().Be(thirdMessage.MessageId);
receiveMessageOverCallback.Should().Throw <OperationCanceledException>();
await deviceClient.CompleteAsync(receivedThirdMessage).ConfigureAwait(false);
firstMessage.Dispose();
secondMessage.Dispose();
thirdMessage.Dispose();
await deviceClient.CloseAsync().ConfigureAwait(false);
await serviceClient.CloseAsync().ConfigureAwait(false);
}
private async Task ReceiveMessageUsingCallbackRecoveryPoolOverAmqpAsync(
TestDeviceType type,
Client.TransportType transport,
int poolSize,
int devicesCount,
string faultType,
string reason,
int delayInSec = FaultInjection.DefaultDelayInSec,
int durationInSec = FaultInjection.DefaultDurationInSec,
ConnectionStringAuthScope authScope = ConnectionStringAuthScope.Device,
string proxyAddress = null)
{
// 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);
(Message msg, string payload, string p1Value) = MessageReceiveE2ETests.ComposeC2dTestMessage(Logger);
testDeviceCallbackHandler.ExpectedMessageSentByService = msg;
await serviceClient.SendAsync(testDevice.Id, msg).ConfigureAwait(false);
Logger.Trace($"{nameof(FaultInjectionPoolAmqpTests)}: Sent message to device {testDevice.Id}: payload='{payload}' p1Value='{p1Value}'");
Client.Message receivedMessage = await deviceClient.ReceiveAsync(timeout).ConfigureAwait(false);
await testDeviceCallbackHandler.WaitForReceiveMessageCallbackAsync(cts.Token).ConfigureAwait(false);
receivedMessage.Should().BeNull();
}
async Task CleanupOperationAsync(IList <DeviceClient> deviceClients)
{
await serviceClient.CloseAsync().ConfigureAwait(false);
serviceClient.Dispose();
foreach (DeviceClient deviceClient in deviceClients)
{
deviceClient.Dispose();
}
}
await FaultInjectionPoolingOverAmqp
.TestFaultInjectionPoolAmqpAsync(
MessageReceive_DevicePrefix,
transport,
proxyAddress,
poolSize,
devicesCount,
faultType,
reason,
delayInSec,
durationInSec,
InitOperationAsync,
TestOperationAsync,
CleanupOperationAsync,
authScope,
Logger)
.ConfigureAwait(false);
}