private async Task ReceiveMessageMuxedOverAmqp(
Client.TransportType transport,
int poolSize,
int devicesCount,
ConnectionStringAuthScope authScope = ConnectionStringAuthScope.Device)
{
Dictionary <string, List <string> > messagesSent = new Dictionary <string, List <string> >();
// Initialize the service client
ServiceClient serviceClient = ServiceClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString);
Func <DeviceClient, TestDevice, Task> initOperation = async(deviceClient, testDevice) =>
{
(Message msg, string messageId, string payload, string p1Value) = MessageReceiveE2ETests.ComposeC2DTestMessage();
messagesSent.Add(testDevice.Id, new List <string> {
payload, p1Value
});
await serviceClient.SendAsync(testDevice.Id, msg).ConfigureAwait(false);
};
Func <DeviceClient, TestDevice, Task> testOperation = async(deviceClient, testDevice) =>
{
_log.WriteLine($"{nameof(MessageReceiveE2EMultiplexingOverAmqpTests)}: Preparing to receive message for device {testDevice.Id}");
await deviceClient.OpenAsync().ConfigureAwait(false);
List <string> msgSent = messagesSent[testDevice.Id];
string payload = msgSent[0];
string p1Value = msgSent[1];
await MessageReceiveE2ETests.VerifyReceivedC2DMessageAsync(transport, deviceClient, payload, p1Value).ConfigureAwait(false);
};
Func <IList <DeviceClient>, Task> cleanupOperation = async(deviceClients) =>
{
await serviceClient.CloseAsync().ConfigureAwait(false);
serviceClient.Dispose();
foreach (DeviceClient deviceClient in deviceClients)
{
deviceClient.Dispose();
}
messagesSent.Clear();
};
await MultiplexingOverAmqp.TestMultiplexingOperationAsync(
DevicePrefix,
transport,
poolSize,
devicesCount,
initOperation,
testOperation,
cleanupOperation
).ConfigureAwait(false);
}
private async Task SendMessageMuxedOverAmqp(
TestDeviceType type,
Client.TransportType transport,
int poolSize,
int devicesCount,
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(MessageSendE2EMultiplexingOverAmqpTests)}: Preparing to send message for device {testDevice.Id}");
await deviceClient.OpenAsync().ConfigureAwait(false);
(Client.Message testMessage, string messageId, string payload, string p1Value) = MessageSendE2ETests.ComposeD2CTestMessage();
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.");
};
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();
}
eventHubListeners.Clear();
};
await MultiplexingOverAmqp.TestMultiplexingOperationAsync(
DevicePrefix,
transport,
poolSize,
devicesCount,
initOperation,
testOperation,
cleanupOperation
).ConfigureAwait(false);
}
private async Task Twin_ServiceSetsDesiredPropertyAndDeviceReceivesEventMuxedOverAmqp(
ConnectionStringAuthScope authScope,
Client.TransportType transport,
int poolSize,
int devicesCount,
Func <DeviceClient, string, string, Task <Task> > setTwinPropertyUpdateCallbackAsync
)
{
Dictionary <string, List <string> > twinPropertyMap = new Dictionary <string, List <string> >();
Func <DeviceClient, TestDevice, Task> initOperation = async(deviceClient, testDevice) =>
{
var propName = Guid.NewGuid().ToString();
var propValue = Guid.NewGuid().ToString();
twinPropertyMap.Add(testDevice.Id, new List <string> {
propName, propValue
});
_log.WriteLine($"{nameof(TwinE2EMultiplexingOverAmqpTests)}: Setting desired propery for device {testDevice.Id}");
_log.WriteLine($"{nameof(Twin_ServiceSetsDesiredPropertyAndDeviceReceivesEventMuxedOverAmqp)}: name={propName}, value={propValue}");
Task updateReceivedTask = await setTwinPropertyUpdateCallbackAsync(deviceClient, propName, propValue).ConfigureAwait(false);
};
Func <DeviceClient, TestDevice, Task> testOperation = async(deviceClient, testDevice) =>
{
_log.WriteLine($"{nameof(TwinE2EMultiplexingOverAmqpTests)}: Verifying desired property is set for device {testDevice.Id}");
List <string> twinProperties = twinPropertyMap[testDevice.Id];
var propName = twinProperties[0];
var propValue = twinProperties[1];
await TwinE2ETests.RegistryManagerUpdateDesiredPropertyAsync(testDevice.Id, propName, propValue).ConfigureAwait(false);
};
Func <IList <DeviceClient>, Task> cleanupOperation = async(deviceClients) =>
{
foreach (DeviceClient deviceClient in deviceClients)
{
deviceClient.Dispose();
}
twinPropertyMap.Clear();
await Task.FromResult <bool>(false).ConfigureAwait(false);
};
await MultiplexingOverAmqp.TestMultiplexingOperationAsync(
DevicePrefix,
transport,
poolSize,
devicesCount,
initOperation,
testOperation,
cleanupOperation
).ConfigureAwait(false);
}
private async Task SendMethodAndRespondMuxedOverAmqp(
ConnectionStringAuthScope authScope,
Client.TransportType transport,
int poolSize,
int devicesCount,
Func <DeviceClient, string, Task <Task> > setDeviceReceiveMethod
)
{
Func <DeviceClient, TestDevice, Task> initOperation = async(deviceClient, testDevice) =>
{
_log.WriteLine($"{nameof(MethodE2EMultiplexingOverAmqpTests)}: Setting method for device {testDevice.Id}");
Task methodReceivedTask = await setDeviceReceiveMethod(deviceClient, MethodName).ConfigureAwait(false);
};
Func <DeviceClient, TestDevice, Task> testOperation = async(deviceClient, testDevice) =>
{
_log.WriteLine($"{nameof(MethodE2EMultiplexingOverAmqpTests)}: Preparing to receive method for device {testDevice.Id}");
await MethodE2ETests.ServiceSendMethodAndVerifyResponse(
testDevice.Id, MethodName, MethodE2ETests.DeviceResponseJson, MethodE2ETests.ServiceRequestJson).ConfigureAwait(false);
};
Func <IList <DeviceClient>, Task> cleanupOperation = async(deviceClients) =>
{
foreach (DeviceClient deviceClient in deviceClients)
{
deviceClient.Dispose();
}
await Task.FromResult <bool>(false).ConfigureAwait(false);
};
await MultiplexingOverAmqp.TestMultiplexingOperationAsync(
DevicePrefix,
transport,
poolSize,
devicesCount,
initOperation,
testOperation,
cleanupOperation
).ConfigureAwait(false);
}
private async Task Twin_DeviceSetsReportedPropertyAndGetsItBackMuxedOverAmqp(
ConnectionStringAuthScope authScope,
Client.TransportType transport,
int poolSize,
int devicesCount)
{
Func <DeviceClient, TestDevice, Task> initOperation = async(deviceClient, testDevice) =>
{
await Task.FromResult <bool>(false).ConfigureAwait(false);
};
Func <DeviceClient, TestDevice, Task> testOperation = async(deviceClient, testDevice) =>
{
_log.WriteLine($"{nameof(TwinE2EMultiplexingOverAmqpTests)}: Setting reported propery and verifying twin for device {testDevice.Id}");
await TwinE2ETests.Twin_DeviceSetsReportedPropertyAndGetsItBack(deviceClient).ConfigureAwait(false);
};
Func <IList <DeviceClient>, Task> cleanupOperation = async(deviceClients) =>
{
foreach (DeviceClient deviceClient in deviceClients)
{
deviceClient.Dispose();
}
await Task.FromResult <bool>(false).ConfigureAwait(false);
};
await MultiplexingOverAmqp.TestMultiplexingOperationAsync(
DevicePrefix,
transport,
poolSize,
devicesCount,
initOperation,
testOperation,
cleanupOperation
).ConfigureAwait(false);
}
private async Task DeviceCombinedClientOperations(
Client.TransportType transport,
int poolSize,
int devicesCount,
ConnectionStringAuthScope authScope)
{
// Initialize service client for service-side operations
ServiceClient serviceClient = ServiceClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString);
// Message payload for C2D operation
Dictionary <string, List <string> > messagesSent = new Dictionary <string, List <string> >();
// Twin properties
Dictionary <string, List <string> > twinPropertyMap = new Dictionary <string, List <string> >();
Func <DeviceClient, TestDevice, Task> initOperation = async(deviceClient, testDevice) =>
{
IList <Task> initOperations = new List <Task>();
// Send C2D Message
_log.WriteLine($"{nameof(CombinedClientOperationsMultiplexingOverAmqpTests)}: Send C2D for device={testDevice.Id}");
(Message msg, string messageId, string payload, string p1Value) = MessageReceiveE2ETests.ComposeC2DTestMessage();
messagesSent.Add(testDevice.Id, new List <string> {
payload, p1Value
});
var sendC2DMessage = serviceClient.SendAsync(testDevice.Id, msg);
initOperations.Add(sendC2DMessage);
// Set method handler
_log.WriteLine($"{nameof(CombinedClientOperationsMultiplexingOverAmqpTests)}: Set direct method {MethodName} for device={testDevice.Id}");
var methodReceivedTask = MethodE2ETests.SetDeviceReceiveMethod(deviceClient, MethodName);
initOperations.Add(methodReceivedTask);
// Set the twin desired properties callback
_log.WriteLine($"{nameof(CombinedClientOperationsMultiplexingOverAmqpTests)}: Set desired property callback for device={testDevice.Id}");
var propName = Guid.NewGuid().ToString();
var propValue = Guid.NewGuid().ToString();
twinPropertyMap.Add(testDevice.Id, new List <string> {
propName, propValue
});
var updateReceivedTask = TwinE2ETests.SetTwinPropertyUpdateCallbackHandlerAsync(deviceClient, propName, propValue);
initOperations.Add(updateReceivedTask);
await Task.WhenAll(initOperations).ConfigureAwait(false);
};
Func <DeviceClient, TestDevice, Task> testOperation = async(deviceClient, testDevice) =>
{
IList <Task> clientOperations = new List <Task>();
await deviceClient.OpenAsync().ConfigureAwait(false);
// D2C Operation
_log.WriteLine($"{nameof(CombinedClientOperationsMultiplexingOverAmqpTests)}: Operation 1: Send D2C for device={testDevice.Id}");
var sendD2CMessage = MessageSendE2ETests.SendSingleMessageAndVerifyAsync(deviceClient, testDevice.Id);
clientOperations.Add(sendD2CMessage);
// C2D Operation
_log.WriteLine($"{nameof(CombinedClientOperationsMultiplexingOverAmqpTests)}: Operation 2: Receive C2D for device={testDevice.Id}");
List <string> msgSent = messagesSent[testDevice.Id];
var payload = msgSent[0];
var p1Value = msgSent[1];
var verifyDeviceClientReceivesMessage = MessageReceiveE2ETests.VerifyReceivedC2DMessageAsync(transport, deviceClient, payload, p1Value);
clientOperations.Add(verifyDeviceClientReceivesMessage);
// Invoke direct methods
_log.WriteLine($"{nameof(CombinedClientOperationsMultiplexingOverAmqpTests)}: Operation 3: Direct methods test for device={testDevice.Id}");
var serviceInvokeMethod = MethodE2ETests.ServiceSendMethodAndVerifyResponse(testDevice.Id, MethodName, MethodE2ETests.DeviceResponseJson, MethodE2ETests.ServiceRequestJson);
clientOperations.Add(serviceInvokeMethod);
// Set reported twin properties
_log.WriteLine($"{nameof(CombinedClientOperationsMultiplexingOverAmqpTests)}: Operation 4: Set reported property for device={testDevice.Id}");
var setReportedProperties = TwinE2ETests.Twin_DeviceSetsReportedPropertyAndGetsItBack(deviceClient);
clientOperations.Add(setReportedProperties);
// Receive set desired twin properties
_log.WriteLine($"{nameof(CombinedClientOperationsMultiplexingOverAmqpTests)}: Operation 5: Receive desired property for device={testDevice.Id}");
List <string> twinProperties = twinPropertyMap[testDevice.Id];
var propName = twinProperties[0];
var propValue = twinProperties[1];
var updateDesiredProperties = TwinE2ETests.RegistryManagerUpdateDesiredPropertyAsync(testDevice.Id, propName, propValue);
clientOperations.Add(updateDesiredProperties);
await Task.WhenAll(clientOperations).ConfigureAwait(false);
_log.WriteLine($"{nameof(CombinedClientOperationsMultiplexingOverAmqpTests)}: All operations completed for device={testDevice.Id}");
};
Func <IList <DeviceClient>, Task> cleanupOperation = async(deviceClients) =>
{
await serviceClient.CloseAsync().ConfigureAwait(false);
serviceClient.Dispose();
foreach (DeviceClient deviceClient in deviceClients)
{
deviceClient.Dispose();
}
messagesSent.Clear();
twinPropertyMap.Clear();
};
await MultiplexingOverAmqp.TestMultiplexingOperationAsync(
DevicePrefix,
transport,
poolSize,
devicesCount,
initOperation,
testOperation,
cleanupOperation).ConfigureAwait(false);
}
