private async Task ReceiveMessageRecoveryPoolOverAmqp(
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)
{
// Initialize the service client
ServiceClient serviceClient = ServiceClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString);
Func <DeviceClient, TestDevice, Task> testOperation = async(deviceClient, testDevice) =>
{
(Message msg, string payload, string p1Value) = MessageReceiveE2ETests.ComposeC2dTestMessage(Logger);
Logger.Trace($"{nameof(FaultInjectionPoolAmqpTests)}: Sending message to device {testDevice.Id}: payload='{payload}' p1Value='{p1Value}'");
await serviceClient.SendAsync(testDevice.Id, msg)
.ConfigureAwait(false);
Logger.Trace($"{nameof(FaultInjectionPoolAmqpTests)}: Preparing to receive message for device {testDevice.Id}");
await deviceClient.OpenAsync()
.ConfigureAwait(false);
await MessageReceiveE2ETests.VerifyReceivedC2DMessageAsync(transport, deviceClient, testDevice.Id, msg, payload, Logger)
.ConfigureAwait(false);
};
Func <IList <DeviceClient>, Task> cleanupOperation = async(deviceClients) =>
{
await serviceClient.CloseAsync()
.ConfigureAwait(false);
serviceClient.Dispose();
foreach (DeviceClient deviceClient in deviceClients)
{
deviceClient.Dispose();
}
};
await FaultInjectionPoolingOverAmqp
.TestFaultInjectionPoolAmqpAsync(
MessageReceive_DevicePrefix,
transport,
poolSize,
devicesCount,
faultType,
reason,
delayInSec,
durationInSec,
(d, t) => { return(Task.FromResult(false)); },
testOperation,
cleanupOperation,
authScope,
Logger)
.ConfigureAwait(false);
}
private async Task ReceiveMessageRecoveryPoolOverAmqpAsync(
TestDeviceType type,
Client.TransportType transport,
int poolSize,
int devicesCount,
string faultType,
string reason,
TimeSpan delayInSec = default,
TimeSpan durationInSec = default,
ConnectionStringAuthScope authScope = ConnectionStringAuthScope.Device,
string proxyAddress = null)
{
// Initialize the service client
using var serviceClient = ServiceClient.CreateFromConnectionString(TestConfiguration.IoTHub.ConnectionString);
async Task TestOperationAsync(DeviceClient deviceClient, TestDevice testDevice, TestDeviceCallbackHandler _)
{
(Message msg, string payload, string p1Value) = MessageReceiveE2ETests.ComposeC2dTestMessage(Logger);
Logger.Trace($"{nameof(FaultInjectionPoolAmqpTests)}: Sending message to device {testDevice.Id}: payload='{payload}' p1Value='{p1Value}'");
await serviceClient.SendAsync(testDevice.Id, msg)
.ConfigureAwait(false);
Logger.Trace($"{nameof(FaultInjectionPoolAmqpTests)}: Preparing to receive message for device {testDevice.Id}");
await deviceClient.OpenAsync()
.ConfigureAwait(false);
await MessageReceiveE2ETests.VerifyReceivedC2DMessageAsync(transport, deviceClient, testDevice.Id, msg, payload, Logger)
.ConfigureAwait(false);
}
async Task CleanupOperationAsync(List <DeviceClient> deviceClients, List <TestDeviceCallbackHandler> testDeviceCallbackHandlers)
{
await serviceClient.CloseAsync()
.ConfigureAwait(false);
serviceClient.Dispose();
deviceClients.ForEach(deviceClient => deviceClient.Dispose());
testDeviceCallbackHandlers.ForEach(testDeviceCallbackHandler => testDeviceCallbackHandler.Dispose());
}
await FaultInjectionPoolingOverAmqp
.TestFaultInjectionPoolAmqpAsync(
MessageReceive_DevicePrefix,
transport,
proxyAddress,
poolSize,
devicesCount,
faultType,
reason,
delayInSec == TimeSpan.Zero?FaultInjection.DefaultFaultDelay : delayInSec,
durationInSec == TimeSpan.Zero?FaultInjection.DefaultFaultDuration : durationInSec,
(d, t, h) => { return(Task.FromResult(false)); },
TestOperationAsync,
CleanupOperationAsync,
authScope,
Logger)
.ConfigureAwait(false);
}
private async Task SendMessageRecoveryPoolOverAmqpAsync(
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)
{
Func <DeviceClient, TestDevice, Task> testOperation = async(deviceClient, testDevice) =>
{
_log.WriteLine($"{nameof(FaultInjectionPoolAmqpTests)}: 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(FaultInjectionPoolAmqpTests)}.{testDevice.Id}: 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 for device {testDevice.Id}.");
};
Func <IList <DeviceClient>, Task> cleanupOperation = (deviceClients) =>
{
foreach (DeviceClient deviceClient in deviceClients)
{
deviceClient.Dispose();
}
return(Task.FromResult(0));
};
await FaultInjectionPoolingOverAmqp
.TestFaultInjectionPoolAmqpAsync(
MessageSend_DevicePrefix,
transport,
poolSize,
devicesCount,
faultType,
reason,
delayInSec,
durationInSec,
(d, t) => { return(Task.FromResult(false)); },
testOperation,
cleanupOperation,
authScope)
.ConfigureAwait(false);
}
private async Task SendMessageRecoveryPoolOverAmqpAsync(
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)
{
Func <DeviceClient, TestDevice, Task> testOperation = async(deviceClient, testDevice) =>
{
Logger.Trace($"{nameof(FaultInjectionPoolAmqpTests)}: Preparing to send message for device {testDevice.Id}");
await deviceClient.OpenAsync().ConfigureAwait(false);
(Client.Message testMessage, string payload, string p1Value) = MessageSendE2ETests.ComposeD2cTestMessage(Logger);
Logger.Trace($"{nameof(FaultInjectionPoolAmqpTests)}.{testDevice.Id}: payload='{payload}' p1Value='{p1Value}'");
await deviceClient.SendEventAsync(testMessage).ConfigureAwait(false);
};
Func <IList <DeviceClient>, Task> cleanupOperation = (deviceClients) =>
{
foreach (DeviceClient deviceClient in deviceClients)
{
deviceClient.Dispose();
}
return(Task.FromResult(0));
};
await FaultInjectionPoolingOverAmqp
.TestFaultInjectionPoolAmqpAsync(
MessageSend_DevicePrefix,
transport,
proxyAddress,
poolSize,
devicesCount,
faultType,
reason,
delayInSec,
durationInSec,
(d, t) => { return(Task.FromResult(false)); },
testOperation,
cleanupOperation,
authScope,
Logger)
.ConfigureAwait(false);
}
private async Task SendMessageRecoveryPoolOverAmqpAsync(
TestDeviceType type,
Client.TransportType transport,
int poolSize,
int devicesCount,
string faultType,
string reason,
TimeSpan delayInSec = default,
TimeSpan durationInSec = default,
ConnectionStringAuthScope authScope = ConnectionStringAuthScope.Device,
string proxyAddress = null)
{
async Task TestOperationAsync(DeviceClient deviceClient, TestDevice testDevice, TestDeviceCallbackHandler _)
{
Logger.Trace($"{nameof(FaultInjectionPoolAmqpTests)}: Preparing to send message for device {testDevice.Id}");
await deviceClient.OpenAsync().ConfigureAwait(false);
(Client.Message testMessage, string payload, string p1Value) = MessageSendE2ETests.ComposeD2cTestMessage(Logger);
Logger.Trace($"{nameof(FaultInjectionPoolAmqpTests)}.{testDevice.Id}: payload='{payload}' p1Value='{p1Value}'");
await deviceClient.SendEventAsync(testMessage).ConfigureAwait(false);
}
Task CleanupOperationAsync(List <DeviceClient> deviceClients, List <TestDeviceCallbackHandler> _)
{
deviceClients.ForEach(deviceClient => deviceClient.Dispose());
return(Task.FromResult(0));
}
await FaultInjectionPoolingOverAmqp
.TestFaultInjectionPoolAmqpAsync(
MessageSend_DevicePrefix,
transport,
proxyAddress,
poolSize,
devicesCount,
faultType,
reason,
delayInSec == TimeSpan.Zero?FaultInjection.DefaultFaultDelay : delayInSec,
durationInSec == TimeSpan.Zero?FaultInjection.DefaultFaultDuration : durationInSec,
(d, t, h) => { return(Task.FromResult(false)); },
TestOperationAsync,
CleanupOperationAsync,
authScope,
Logger)
.ConfigureAwait(false);
}
private async Task SendMessageRecoveryPoolOverAmqp(
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)
{
Dictionary <string, EventHubTestListener> eventHubListeners = new Dictionary <string, EventHubTestListener>();
Func <DeviceClient, TestDevice, Task> initOperation = async(deviceClient, testDevice) =>
{
EventHubTestListener testListener = await EventHubTestListener.CreateListener(testDevice.Id).ConfigureAwait(false);
eventHubListeners.Add(testDevice.Id, testListener);
};
Func <DeviceClient, TestDevice, Task> testOperation = async(deviceClient, testDevice) =>
{
_log.WriteLine($"{nameof(FaultInjectionPoolAmqpTests)}: 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(FaultInjectionPoolAmqpTests)}.{testDevice.Id}: payload='{payload}' p1Value='{p1Value}'");
await deviceClient.SendEventAsync(testMessage).ConfigureAwait(false);
EventHubTestListener testListener = eventHubListeners[testDevice.Id];
bool isReceived = await testListener.WaitForMessage(testDevice.Id, payload, p1Value).ConfigureAwait(false);
Assert.IsTrue(isReceived, $"Message is not received for device {testDevice.Id}.");
};
Func <IList <DeviceClient>, Task> cleanupOperation = async(deviceClients) =>
{
foreach (var listener in eventHubListeners)
{
await listener.Value.CloseAsync().ConfigureAwait(false);
}
foreach (DeviceClient deviceClient in deviceClients)
{
deviceClient.Dispose();
}
};
await FaultInjectionPoolingOverAmqp.TestFaultInjectionPoolAmqpAsync(
MessageSend_DevicePrefix,
transport,
poolSize,
devicesCount,
faultType,
reason,
delayInSec,
durationInSec,
initOperation,
testOperation,
cleanupOperation,
authScope).ConfigureAwait(false);
}
private async Task SendMethodAndRespondRecoveryPoolOverAmqpAsync(
TestDeviceType type,
Client.TransportType transport,
int poolSize,
int devicesCount,
Func <DeviceClient, string, Task <Task> > setDeviceReceiveMethod,
string faultType,
string reason,
int delayInSec = FaultInjection.DefaultDelayInSec,
int durationInSec = FaultInjection.DefaultDurationInSec,
ConnectionStringAuthScope authScope = ConnectionStringAuthScope.Device)
{
var testDevicesWithCallbackHandler = new Dictionary <string, TestDeviceCallbackHandler>();
Func <DeviceClient, TestDevice, Task> initOperation = async(deviceClient, testDevice) =>
{
var testDeviceCallbackHandler = new TestDeviceCallbackHandler(deviceClient);
testDevicesWithCallbackHandler.Add(testDevice.Id, testDeviceCallbackHandler);
_log.WriteLine($"{nameof(MethodE2EPoolAmqpTests)}: Setting method callback handler for device {testDevice.Id}");
await testDeviceCallbackHandler
.SetDeviceReceiveMethodAsync(MethodName, MethodE2ETests.DeviceResponseJson, MethodE2ETests.ServiceRequestJson)
.ConfigureAwait(false);
};
Func <DeviceClient, TestDevice, Task> testOperation = async(deviceClient, testDevice) =>
{
TestDeviceCallbackHandler testDeviceCallbackHandler = testDevicesWithCallbackHandler[testDevice.Id];
using var cts = new CancellationTokenSource(FaultInjection.RecoveryTimeMilliseconds);
_log.WriteLine($"{nameof(MethodE2EPoolAmqpTests)}: Preparing to receive method for device {testDevice.Id}");
Task serviceSendTask = MethodE2ETests.ServiceSendMethodAndVerifyResponseAsync(
testDevice.Id,
MethodName,
MethodE2ETests.DeviceResponseJson,
MethodE2ETests.ServiceRequestJson);
Task methodReceivedTask = testDeviceCallbackHandler.WaitForMethodCallbackAsync(cts.Token);
await Task.WhenAll(serviceSendTask, methodReceivedTask).ConfigureAwait(false);
};
Func <IList <DeviceClient>, Task> cleanupOperation = async(deviceClients) =>
{
foreach (DeviceClient deviceClient in deviceClients)
{
deviceClient.Dispose();
}
testDevicesWithCallbackHandler.Clear();
await Task.FromResult <bool>(false).ConfigureAwait(false);
};
await FaultInjectionPoolingOverAmqp
.TestFaultInjectionPoolAmqpAsync(
MethodDevicePrefix,
transport,
poolSize,
devicesCount,
faultType,
reason,
delayInSec,
durationInSec,
initOperation,
testOperation,
cleanupOperation,
authScope)
.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);
}
private async Task SendMethodAndRespondRecoveryPoolOverAmqpAsync(
TestDeviceType type,
Client.TransportType transport,
int poolSize,
int devicesCount,
Func <DeviceClient, string, MsTestLogger, Task <Task> > setDeviceReceiveMethod,
string faultType,
string reason,
TimeSpan delayInSec = default,
TimeSpan durationInSec = default,
ConnectionStringAuthScope authScope = ConnectionStringAuthScope.Device,
string proxyAddress = null)
{
async Task InitOperationAsync(DeviceClient deviceClient, TestDevice testDevice, TestDeviceCallbackHandler testDeviceCallbackHandler)
{
Logger.Trace($"{nameof(MethodE2EPoolAmqpTests)}: Setting method callback handler for device {testDevice.Id}");
await testDeviceCallbackHandler
.SetDeviceReceiveMethodAsync(MethodName, MethodE2ETests.DeviceResponseJson, MethodE2ETests.ServiceRequestJson)
.ConfigureAwait(false);
}
async Task TestOperationAsync(DeviceClient deviceClient, TestDevice testDevice, TestDeviceCallbackHandler testDeviceCallbackHandler)
{
using var cts = new CancellationTokenSource(FaultInjection.RecoveryTime);
Logger.Trace($"{nameof(MethodE2EPoolAmqpTests)}: Preparing to receive method for device {testDevice.Id}");
Task serviceSendTask = MethodE2ETests
.ServiceSendMethodAndVerifyResponseAsync(
testDevice.Id,
MethodName,
MethodE2ETests.DeviceResponseJson,
MethodE2ETests.ServiceRequestJson,
Logger);
Task methodReceivedTask = testDeviceCallbackHandler.WaitForMethodCallbackAsync(cts.Token);
await Task.WhenAll(serviceSendTask, methodReceivedTask).ConfigureAwait(false);
}
async Task CleanupOperationAsync(List <DeviceClient> deviceClients, List <TestDeviceCallbackHandler> testDeviceCallbackHandlers)
{
deviceClients.ForEach(deviceClient => deviceClient.Dispose());
testDeviceCallbackHandlers.ForEach(testDeviceCallbackHandler => testDeviceCallbackHandler.Dispose());
await Task.FromResult <bool>(false).ConfigureAwait(false);
}
await FaultInjectionPoolingOverAmqp
.TestFaultInjectionPoolAmqpAsync(
MethodDevicePrefix,
transport,
proxyAddress,
poolSize,
devicesCount,
faultType,
reason,
delayInSec == TimeSpan.Zero?FaultInjection.DefaultFaultDelay : delayInSec,
durationInSec == TimeSpan.Zero?FaultInjection.DefaultFaultDuration : durationInSec,
InitOperationAsync,
TestOperationAsync,
CleanupOperationAsync,
authScope,
Logger)
.ConfigureAwait(false);
}