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);
var deviceTwin = await deviceClient.GetTwinAsync().ConfigureAwait(false);
Assert.AreEqual <String>(deviceTwin.Properties.Reported[propName].ToString(), propValue);
};
await FaultInjection.TestErrorInjectionTemplate(
DevicePrefix,
TestDeviceType.Sasl,
transport,
faultType,
reason,
delayInSec,
FaultInjection.DefaultDurationInSec,
(d, t) => { return(Task.FromResult <bool>(false)); },
testOperation,
() => { return(Task.FromResult <bool>(false)); }).ConfigureAwait(false);
}
private async Task Twin_DeviceDesiredPropertyUpdateRecovery(Client.TransportType transport, string faultType, string reason, int delayInSec)
{
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(Configuration.IoTHub.ConnectionString);
var propName = Guid.NewGuid().ToString();
var props = new TwinCollection();
Func <DeviceClient, TestDevice, Task> testOperation = async(deviceClient, testDevice) =>
{
var propValue = Guid.NewGuid().ToString();
_log.WriteLine($"{nameof(Twin_DeviceDesiredPropertyUpdateRecovery)}: name={propName}, value={propValue}");
Task updateReceivedTask = await SetTwinPropertyUpdateCallbackHandlerAsync(deviceClient, propName, propValue).ConfigureAwait(false);
await Task.WhenAll(
RegistryManagerUpdateDesiredPropertyAsync(testDevice.Id, propName, propValue),
updateReceivedTask).ConfigureAwait(false);
};
await FaultInjection.TestErrorInjectionTemplate(
DevicePrefix,
TestDeviceType.Sasl,
transport,
faultType,
reason,
delayInSec,
FaultInjection.DefaultDurationInSec,
(d, t) => { return(Task.FromResult <bool>(false)); },
testOperation,
() => { return(Task.FromResult <bool>(false)); }).ConfigureAwait(false);
}
internal async Task SendMessageRecovery(
TestDeviceType type,
Client.TransportType transport,
string faultType,
string reason,
int delayInSec,
int durationInSec = FaultInjection.DefaultDurationInSec,
int retryDurationInMilliSec = FaultInjection.RecoveryTimeMilliseconds)
{
EventHubTestListener testListener = null;
Func <DeviceClient, TestDevice, Task> init = async(deviceClient, testDevice) =>
{
testListener = await EventHubTestListener.CreateListener(testDevice.Id).ConfigureAwait(false);
deviceClient.OperationTimeoutInMilliseconds = (uint)retryDurationInMilliSec;
};
Func <DeviceClient, TestDevice, Task> testOperation = async(deviceClient, testDevice) =>
{
string payload, p1Value;
Client.Message testMessage = ComposeD2CTestMessage(out payload, out p1Value);
await deviceClient.SendEventAsync(testMessage).ConfigureAwait(false);
bool isReceived = false;
isReceived = await testListener.WaitForMessage(testDevice.Id, payload, p1Value).ConfigureAwait(false);
Assert.IsTrue(isReceived);
};
Func <Task> cleanupOperation = () =>
{
return(testListener.CloseAsync());
};
await FaultInjection.TestErrorInjectionTemplate(
DevicePrefix,
type,
transport,
faultType,
reason,
delayInSec,
durationInSec,
init,
testOperation,
cleanupOperation).ConfigureAwait(false);
}
private async Task ReceiveMessageRecovery(
TestDeviceType type,
Client.TransportType transport,
string faultType,
string reason,
int delayInSec)
{
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(2)).ConfigureAwait(false);
}
};
Func <DeviceClient, TestDevice, Task> testOperation = async(deviceClient, testDevice) =>
{
string payload, messageId, p1Value;
await serviceClient.SendAsync(
testDevice.Id,
ComposeC2DTestMessage(out payload, out messageId, out p1Value)).ConfigureAwait(false);
await VerifyReceivedC2DMessage(transport, deviceClient, payload, p1Value).ConfigureAwait(false);
};
Func <Task> cleanupOperation = () =>
{
return(serviceClient.CloseAsync());
};
await FaultInjection.TestErrorInjectionTemplate(
DevicePrefix,
type,
transport,
faultType,
reason,
delayInSec,
FaultInjection.DefaultDurationInSec,
init,
testOperation,
cleanupOperation).ConfigureAwait(false);
}
private async Task SendMethodAndRespondRecovery(Client.TransportType transport, string faultType, string reason, int delayInSec)
{
Func <DeviceClient, TestDevice, Task> testOperation = async(deviceClient, testDevice) =>
{
Task methodReceivedTask = await SetDeviceReceiveMethod(deviceClient).ConfigureAwait(false);
await Task.WhenAll(
ServiceSendMethodAndVerifyResponse(testDevice.Id, MethodName, DeviceResponseJson, ServiceRequestJson),
methodReceivedTask).ConfigureAwait(false);
};
await FaultInjection.TestErrorInjectionTemplate(
DevicePrefix,
TestDeviceType.Sasl,
transport,
faultType,
reason,
delayInSec,
FaultInjection.DefaultDelayInSec,
(d, t) => { return(Task.FromResult <bool>(false)); },
testOperation,
() => { return(Task.FromResult <bool>(false)); }).ConfigureAwait(false);
}