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) =>
{
s_log.WriteLine($"{nameof(MessageSendE2EPoolAmqpTests)}: Preparing to send message for device {testDevice.Id}");
await deviceClient.OpenAsync().ConfigureAwait(false);
(Client.Message testMessage, string payload, string p1Value) = MessageSendE2ETests.ComposeD2cTestMessage();
s_log.WriteLine($"{nameof(MessageSendE2EPoolAmqpTests)}.{testDevice.Id}: messageId='{testMessage.MessageId}' payload='{payload}' p1Value='{p1Value}'");
await deviceClient.SendEventAsync(testMessage).ConfigureAwait(false);
bool isReceived = EventHubTestListener.VerifyIfMessageIsReceived(testDevice.Id, testMessage, payload, p1Value);
Assert.IsTrue(isReceived, "Message is not received.");
};
await PoolingOverAmqp
.TestPoolAmqpAsync(
_devicePrefix,
transport,
poolSize,
devicesCount,
null,
testOperation,
null,
authScope,
true)
.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,
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 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, testMessage, 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,
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);
}
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 payload, string p1Value) = MessageSendE2ETests.ComposeD2cTestMessage();
await deviceClient.SendEventAsync(testMessage).ConfigureAwait(false);
bool isReceived = false;
isReceived = EventHubTestListener.VerifyIfMessageIsReceived(testDevice.Id, testMessage, payload, p1Value);
Assert.IsTrue(isReceived);
};
await FaultInjection
.TestErrorInjectionAsync(
_devicePrefix,
type,
transport,
faultType,
reason,
delayInSec,
durationInSec,
init,
testOperation,
() => { return(Task.FromResult(false)); })
.ConfigureAwait(false);
}