public async Task SetDeviceReceiveMethodAsync(string methodName, string deviceResponseJson, string expectedServiceRequestJson) { await _deviceClient.SetMethodHandlerAsync(methodName, (request, context) => { try { s_log.WriteLine($"{nameof(SetDeviceReceiveMethodAsync)}: DeviceClient callback method: {request.Name} {request.ResponseTimeout}."); Assert.AreEqual(methodName, request.Name); Assert.AreEqual(expectedServiceRequestJson, request.DataAsJson); return(Task.FromResult(new MethodResponse(Encoding.UTF8.GetBytes(deviceResponseJson), 200))); } catch (Exception ex) { s_log.WriteLine($"{nameof(SetDeviceReceiveMethodAsync)}: Error during DeviceClient callback method: {ex}."); _methodExceptionDispatch = ExceptionDispatchInfo.Capture(ex); return(Task.FromResult(new MethodResponse(500))); } finally { // Always notify that we got the callback. _methodCallbackSemaphore.Release(); } }, null).ConfigureAwait(false); }
public async Task DeviceClient_TokenConnectionDoubleRelease_Ok() { TestDevice testDevice = await TestDevice.GetTestDeviceAsync(DevicePrefix).ConfigureAwait(false); string deviceConnectionString = testDevice.ConnectionString; var config = new Configuration.IoTHub.DeviceConnectionStringParser(deviceConnectionString); string iotHub = config.IoTHub; string deviceId = config.DeviceID; string key = config.SharedAccessKey; SharedAccessSignatureBuilder builder = new SharedAccessSignatureBuilder() { Key = key, TimeToLive = new TimeSpan(0, 10, 0), Target = $"{iotHub}/devices/{WebUtility.UrlEncode(deviceId)}", }; DeviceAuthenticationWithToken auth = new DeviceAuthenticationWithToken(deviceId, builder.ToSignature()); using (DeviceClient deviceClient = DeviceClient.Create(iotHub, auth, Client.TransportType.Amqp_Tcp_Only)) { _log.WriteLine($"Created {nameof(DeviceClient)} ID={TestLogging.IdOf(deviceClient)}"); Console.WriteLine("DeviceClient OpenAsync."); await deviceClient.OpenAsync().ConfigureAwait(false); Console.WriteLine("DeviceClient SendEventAsync."); await deviceClient.SendEventAsync(new Client.Message(Encoding.UTF8.GetBytes("TestMessage"))).ConfigureAwait(false); Console.WriteLine("DeviceClient CloseAsync."); await deviceClient.CloseAsync().ConfigureAwait(false); // First release } // Second release }
private async Task <Task> SetTwinPropertyUpdateCallbackHandlerAsync(DeviceClient deviceClient, string expectedPropName, string expectedPropValue) { var propertyUpdateReceived = new TaskCompletionSource <bool>(); string userContext = "myContext"; await deviceClient.SetDesiredPropertyUpdateCallbackAsync( (patch, context) => { _log.WriteLine($"{nameof(SetTwinPropertyUpdateCallbackHandlerAsync)}: DesiredProperty: {patch}, {context}"); try { Assert.AreEqual(expectedPropValue, patch[expectedPropName].ToString()); Assert.AreEqual(userContext, context, "Context"); } catch (Exception e) { propertyUpdateReceived.SetException(e); } finally { propertyUpdateReceived.SetResult(true); } return(Task.FromResult <bool>(true)); }, userContext).ConfigureAwait(false); return(propertyUpdateReceived.Task); }
private async Task Twin_DeviceSetsReportedPropertyAndGetsItBackPoolOverAmqp( TestDeviceType type, Client.TransportType transport, int poolSize, int devicesCount, ConnectionStringAuthScope authScope = ConnectionStringAuthScope.Device) { Func <DeviceClient, TestDevice, Task> testOperation = async(deviceClient, testDevice) => { _log.WriteLine($"{nameof(TwinE2EPoolAmqpTests)}: 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 PoolingOverAmqp.TestPoolAmqpAsync( DevicePrefix, transport, poolSize, devicesCount, (d, t) => { return(Task.FromResult(false)); }, testOperation, cleanupOperation, authScope, true).ConfigureAwait(false); }
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 messageId, string payload, string p1Value) = MessageSendE2ETests.ComposeD2cTestMessage(); s_log.WriteLine($"{nameof(MessageSendE2EPoolAmqpTests)}.{testDevice.Id}: messageId='{messageId}' 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."); }; await PoolingOverAmqp .TestPoolAmqpAsync( _devicePrefix, transport, poolSize, devicesCount, null, testOperation, null, authScope, true) .ConfigureAwait(false); }
// verify required message is present in the dictionary public static bool VerifyIfMessageIsReceived(string deviceId, string payload, string p1Value, TimeSpan?maxWaitTime = null) { if (!maxWaitTime.HasValue) { maxWaitTime = MaximumWaitTime; } s_log.WriteLine($"Expected payload: deviceId={deviceId}; payload={payload}; property1={p1Value}"); bool isReceived = false; var sw = new Stopwatch(); sw.Start(); while (!isReceived && sw.Elapsed < maxWaitTime) { events.TryRemove(payload, out EventData eventData); if (eventData == null) { continue; } isReceived = VerifyTestMessage(eventData, deviceId, p1Value); } sw.Stop(); return(isReceived); }
private async Task SendMessagePoolOverAmqp( 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(MessageSendE2EPoolAmqpTests)}: 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(MessageSendE2EPoolAmqpTests)}.{testDevice.Id}: messageId='{messageId}' 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."); }; 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 PoolingOverAmqp.TestPoolAmqpAsync( DevicePrefix, transport, poolSize, devicesCount, initOperation, testOperation, cleanupOperation, authScope).ConfigureAwait(false); }
// Fault timings: // -------------------------------------------------------------------------------------------------------------------------------------------------------------------- // --- device in normal operation --- | FaultRequested | --- <delayInSec> --- | --- Device in fault mode for <durationInSec> --- | --- device in normal operation --- // -------------------------------------------------------------------------------------------------------------------------------------------------------------------- public static async Task ActivateFaultInjection(Client.TransportType transport, string faultType, string reason, int delayInSec, int durationInSec, DeviceClient deviceClient) { s_log.WriteLine($"{nameof(ActivateFaultInjection)}: Requesting fault injection type={faultType} reason={reason}, delay={delayInSec}s, duration={FaultInjection.DefaultDurationInSec}s"); uint oldTimeout = deviceClient.OperationTimeoutInMilliseconds; try { // For MQTT FaultInjection will terminate the connection prior to a PUBACK // which leads to an infinite loop trying to resend the FaultInjection message. if (transport == Client.TransportType.Mqtt || transport == Client.TransportType.Mqtt_Tcp_Only || transport == Client.TransportType.Mqtt_WebSocket_Only) { deviceClient.OperationTimeoutInMilliseconds = (uint)delayInSec * 2000; } await deviceClient.SendEventAsync( FaultInjection.ComposeErrorInjectionProperties( faultType, reason, delayInSec, durationInSec)).ConfigureAwait(false); } catch (TimeoutException ex) { s_log.WriteLine($"{nameof(ActivateFaultInjection)}: {ex}"); } finally { deviceClient.OperationTimeoutInMilliseconds = oldTimeout; s_log.WriteLine($"{nameof(ActivateFaultInjection)}: Fault injection requested."); } }
public static async Task InitAsync() { bool gained = await s_lock.WaitAsync(s_interval).ConfigureAwait(false); if (gained) { try { if (!s_receiving) { s_log.WriteLine("Initializing FileNotificationReceiver..."); ServiceClient serviceClient = ServiceClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString); s_fileNotificationReceiver = serviceClient.GetFileNotificationReceiver(); s_log.WriteLine("Receiving once to connect FileNotificationReceiver..."); await s_fileNotificationReceiver.ReceiveAsync(TimeSpan.FromSeconds(1)).ConfigureAwait(false); s_log.WriteLine("FileNotificationReceiver connected."); _ = StartReceivingLoopAsync().ConfigureAwait(false); s_receiving = true; } } finally { s_lock.Release(); } } }
private Client.Message ComposeD2CTestMessage(out string payload, out string p1Value) { payload = Guid.NewGuid().ToString(); p1Value = Guid.NewGuid().ToString(); _log.WriteLine($"{nameof(ComposeD2CTestMessage)}: payload='{payload}' p1Value='{p1Value}'"); return(new Client.Message(Encoding.UTF8.GetBytes(payload)) { Properties = { ["property1"] = p1Value } }); }
public async Task FaultInjection_NoRecovery() { TestDevice testDevice = await TestDevice.GetTestDeviceAsync(DevicePrefix, TestDeviceType.Sasl).ConfigureAwait(false); using DeviceClient deviceClient = testDevice.CreateDeviceClient(Client.TransportType.Amqp_Tcp_Only); _log.WriteLine($"{nameof(FaultInjection_NoRecovery)}: deviceId={testDevice.Id}"); deviceClient.SetRetryPolicy(new NoRetry()); ConnectionStatus?lastConnectionStatus = null; Dictionary <ConnectionStatus, int> connectionStatusChanges = new Dictionary <ConnectionStatus, int>(); deviceClient.SetConnectionStatusChangesHandler((status, reason) => { connectionStatusChanges.TryGetValue(status, out int count); count++; connectionStatusChanges[status] = count; lastConnectionStatus = status; }); _log.WriteLine($"{nameof(FaultInjection_NoRecovery)}: calling OpenAsync..."); await deviceClient.OpenAsync().ConfigureAwait(false); _log.WriteLine($"{nameof(FaultInjection_NoRecovery)}: injecting fault {FaultInjection.FaultType_Tcp}..."); await FaultInjection .ActivateFaultInjectionAsync( Client.TransportType.Amqp_Tcp_Only, FaultInjection.FaultType_Tcp, FaultInjection.FaultCloseReason_Boom, FaultInjection.DefaultDelayInSec, FaultInjection.DefaultDurationInSec, deviceClient) .ConfigureAwait(false); await Task.Delay(FaultInjection.DefaultDelayInSec).ConfigureAwait(false); _log.WriteLine($"{nameof(FaultInjection_NoRecovery)}: waiting fault injection occurs..."); for (int i = 0; i < FaultInjection.LatencyTimeBufferInSec; i++) { if (connectionStatusChanges.ContainsKey(ConnectionStatus.Disconnected)) { break; } await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false); } Assert.AreEqual(ConnectionStatus.Disconnected, lastConnectionStatus, $"Excepeted device to be {ConnectionStatus.Disconnected} but was {lastConnectionStatus}."); Assert.IsFalse(connectionStatusChanges.ContainsKey(ConnectionStatus.Disconnected_Retrying), $"Shouldn't get {ConnectionStatus.Disconnected_Retrying} status change."); int connected = connectionStatusChanges[ConnectionStatus.Connected]; Assert.AreEqual(1, connected, $"Should get {ConnectionStatus.Connected} once but was {connected}."); int disconnected = connectionStatusChanges[ConnectionStatus.Disconnected]; Assert.AreEqual(1, disconnected, $"Should get {ConnectionStatus.Disconnected} once but was {disconnected}."); }
public static Message ComposeC2DTestMessage(out string payload, out string messageId, out string p1Value) { payload = Guid.NewGuid().ToString(); messageId = Guid.NewGuid().ToString(); p1Value = Guid.NewGuid().ToString(); s_log.WriteLine($"{nameof(ComposeC2DTestMessage)}: payload='{payload}' messageId='{messageId}' p1Value='{p1Value}'"); return(new Message(Encoding.UTF8.GetBytes(payload)) { MessageId = messageId, Properties = { ["property1"] = p1Value } }); }
public static (Message message, string messageId, string payload, string p1Value) ComposeC2DTestMessage() { var payload = Guid.NewGuid().ToString(); var messageId = Guid.NewGuid().ToString(); var p1Value = Guid.NewGuid().ToString(); _log.WriteLine($"{nameof(ComposeC2DTestMessage)}: messageId='{messageId}' payload='{payload}' p1Value='{p1Value}'"); var message = new Message(Encoding.UTF8.GetBytes(payload)) { MessageId = messageId, Properties = { ["property1"] = p1Value } }; return(message, messageId, payload, p1Value); }
private async Task ServiceSendMethodAndVerifyResponse(string deviceName, string methodName, string respJson, string reqJson) { ServiceClient serviceClient = ServiceClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString); _log.WriteLine($"{nameof(ServiceSendMethodAndVerifyResponse)}: Invoke method {methodName}."); CloudToDeviceMethodResult response = await serviceClient.InvokeDeviceMethodAsync( deviceName, new CloudToDeviceMethod(methodName, TimeSpan.FromMinutes(5)).SetPayloadJson(reqJson)).ConfigureAwait(false); _log.WriteLine($"{nameof(ServiceSendMethodAndVerifyResponse)}: Method status: {response.Status}."); Assert.AreEqual(200, response.Status); Assert.AreEqual(respJson, response.GetPayloadAsJson()); await serviceClient.CloseAsync().ConfigureAwait(false); }
public static async Task Twin_DeviceSetsReportedPropertyAndGetsItBack(DeviceClient deviceClient) { var propName = Guid.NewGuid().ToString(); var propValue = Guid.NewGuid().ToString(); _log.WriteLine($"{nameof(Twin_DeviceSetsReportedPropertyAndGetsItBack)}: name={propName}, value={propValue}"); TwinCollection props = new TwinCollection(); props[propName] = propValue; await deviceClient.UpdateReportedPropertiesAsync(props).ConfigureAwait(false); Twin deviceTwin = await deviceClient.GetTwinAsync().ConfigureAwait(false); Assert.AreEqual <String>(deviceTwin.Properties.Reported[propName].ToString(), propValue); }
private async Task ServiceSendMethodAndVerifyResponseAsync(string deviceName, string methodName, string respJson, string reqJson) { var sw = new Stopwatch(); sw.Start(); bool done = false; ExceptionDispatchInfo exceptionDispatchInfo = null; int attempt = 0; while (!done && sw.ElapsedMilliseconds < FaultInjection.RecoveryTimeMilliseconds) { attempt++; try { using ServiceClient serviceClient = ServiceClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString); s_log.WriteLine($"{nameof(ServiceSendMethodAndVerifyResponseAsync)}: Invoke method {methodName}."); CloudToDeviceMethodResult response = await serviceClient .InvokeDeviceMethodAsync( deviceName, new CloudToDeviceMethod(methodName, TimeSpan.FromMinutes(5)).SetPayloadJson(reqJson)) .ConfigureAwait(false); s_log.WriteLine($"{nameof(ServiceSendMethodAndVerifyResponseAsync)}: Method status: {response.Status}."); Assert.AreEqual(200, response.Status, $"The expected respose status should be 200 but was {response.Status}"); string payload = response.GetPayloadAsJson(); Assert.AreEqual(respJson, payload, $"The expected respose payload should be {respJson} but was {payload}"); await serviceClient.CloseAsync().ConfigureAwait(false); done = true; } catch (DeviceNotFoundException ex) { exceptionDispatchInfo = ExceptionDispatchInfo.Capture(ex); s_log.WriteLine($"{nameof(ServiceSendMethodAndVerifyResponseAsync)}: [Tried {attempt} time(s)] ServiceClient exception caught: {ex}."); await Task.Delay(1000).ConfigureAwait(false); } } if (!done && (exceptionDispatchInfo != null)) { exceptionDispatchInfo.Throw(); } }
private async Task Twin_DeviceDesiredPropertyUpdateRecoveryAsync( Client.TransportType transport, string faultType, string reason, int delayInSec) { TestDeviceCallbackHandler testDeviceCallbackHandler = null; var registryManager = RegistryManager.CreateFromConnectionString(Configuration.IoTHub.ConnectionString); using var cts = new CancellationTokenSource(FaultInjection.RecoveryTimeMilliseconds); var propName = Guid.NewGuid().ToString(); var props = new TwinCollection(); // Configure the callback and start accepting twin changes. Func <DeviceClient, TestDevice, Task> initOperation = async(deviceClient, testDevice) => { testDeviceCallbackHandler = new TestDeviceCallbackHandler(deviceClient); await testDeviceCallbackHandler.SetTwinPropertyUpdateCallbackHandlerAsync(propName).ConfigureAwait(false); }; // Change the twin from the service side and verify the device received it. Func <DeviceClient, TestDevice, Task> testOperation = async(deviceClient, testDevice) => { var propValue = Guid.NewGuid().ToString(); testDeviceCallbackHandler.ExpectedTwinPropertyValue = propValue; s_log.WriteLine($"{nameof(Twin_DeviceDesiredPropertyUpdateRecoveryAsync)}: name={propName}, value={propValue}"); Task serviceSendTask = RegistryManagerUpdateDesiredPropertyAsync(testDevice.Id, propName, propValue); Task twinReceivedTask = testDeviceCallbackHandler.WaitForTwinCallbackAsync(cts.Token); var tasks = new List <Task>() { serviceSendTask, twinReceivedTask }; while (tasks.Count > 0) { Task completedTask = await Task.WhenAny(tasks).ConfigureAwait(false); completedTask.GetAwaiter().GetResult(); tasks.Remove(completedTask); } }; await FaultInjection .TestErrorInjectionAsync( s_devicePrefix, TestDeviceType.Sasl, transport, faultType, reason, delayInSec, FaultInjection.DefaultDurationInSec, initOperation, testOperation, () => { return(Task.FromResult(false)); }) .ConfigureAwait(false); }
private async Task ServiceSendMethodAndVerifyResponse(string deviceName, string methodName, string respJson, string reqJson) { var sw = new Stopwatch(); sw.Start(); bool done = false; ExceptionDispatchInfo exceptionDispatchInfo = null; while (!done && sw.ElapsedMilliseconds < FaultInjection.RecoveryTimeMilliseconds) { try { using (ServiceClient serviceClient = ServiceClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString)) { s_log.WriteLine($"{nameof(ServiceSendMethodAndVerifyResponse)}: Invoke method {methodName}."); CloudToDeviceMethodResult response = await serviceClient.InvokeDeviceMethodAsync( deviceName, new CloudToDeviceMethod(methodName, TimeSpan.FromMinutes(5)).SetPayloadJson(reqJson)).ConfigureAwait(false); s_log.WriteLine($"{nameof(ServiceSendMethodAndVerifyResponse)}: Method status: {response.Status}."); // This is a simple hack to ensure that we're still exercising these tests while we address the race conditions causing the following issues: // [Ignore] // TODO: #571 // [Ignore] // TODO: #558 //Assert.AreEqual(200, response.Status); //Assert.AreEqual(respJson, response.GetPayloadAsJson()); await serviceClient.CloseAsync().ConfigureAwait(false); done = true; } } catch (DeviceNotFoundException ex) { exceptionDispatchInfo = ExceptionDispatchInfo.Capture(ex); s_log.WriteLine($"{nameof(ServiceSendMethodAndVerifyResponse)}: ServiceClient exception caught: {ex}."); await Task.Delay(1000).ConfigureAwait(false); } } if (exceptionDispatchInfo != null) { exceptionDispatchInfo.Throw(); } }
public static (Client.Message message, string messageId, string payload, string p1Value) ComposeD2cTestMessage() { string messageId = Guid.NewGuid().ToString(); string payload = Guid.NewGuid().ToString(); string p1Value = Guid.NewGuid().ToString(); _log.WriteLine($"{nameof(ComposeD2cTestMessage)}: messageId='{messageId}' payload='{payload}' p1Value='{p1Value}'"); var message = new Client.Message(Encoding.UTF8.GetBytes(payload)) { MessageId = messageId, }; message.Properties.Add("property1", p1Value); message.Properties.Add("property2", null); return(message, messageId, payload, p1Value); }
private async Task ReceiveMessagePoolOverAmqp( 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(MessageReceiveE2EPoolAmqpTests)}: 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, testDevice.Id, 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 PoolingOverAmqp.TestPoolAmqpAsync( DevicePrefix, transport, poolSize, devicesCount, initOperation, testOperation, cleanupOperation, authScope, true).ConfigureAwait(false); }
public static async Task ServiceSendMethodAndVerifyResponse(string deviceName, string methodName, string respJson, string reqJson) { using (ServiceClient serviceClient = ServiceClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString)) { _log.WriteLine($"{nameof(ServiceSendMethodAndVerifyResponse)}: Invoke method {methodName}."); CloudToDeviceMethodResult response = await serviceClient.InvokeDeviceMethodAsync( deviceName, new CloudToDeviceMethod(methodName, TimeSpan.FromMinutes(5)).SetPayloadJson(reqJson)).ConfigureAwait(false); _log.WriteLine($"{nameof(ServiceSendMethodAndVerifyResponse)}: Method status: {response.Status}."); Assert.AreEqual(200, response.Status, $"The expected respose status should be 200 but was {response.Status}"); string payload = response.GetPayloadAsJson(); Assert.AreEqual(respJson, payload, $"The expected respose payload should be {respJson} but was {payload}"); await serviceClient.CloseAsync().ConfigureAwait(false); } }
private async Task ReceiveAsync() { IEnumerable <EventData> eventDatas = await _receiver.ReceiveAsync(int.MaxValue, TimeSpan.FromSeconds(OperationTimeoutInSeconds)).ConfigureAwait(false); if (eventDatas == null) { s_log.WriteLine($"{nameof(EventHubTestListener)}.{nameof(VerifyTestMessage)}: no events received."); } else { s_log.WriteLine($"{nameof(EventHubTestListener)}.{nameof(VerifyTestMessage)}: {eventDatas.Count()} events received."); foreach (EventData eventData in eventDatas) { string body = GetEventDataBody(eventData); events[body] = eventData; } } }
private async Task TestTimeout(TimeSpan?timeout) { TestDevice testDevice = await TestDevice.GetTestDeviceAsync(DevicePrefix).ConfigureAwait(false); using (ServiceClient sender = ServiceClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString)) { _log.WriteLine($"Testing ServiceClient SendAsync() timeout={timeout}"); await sender.SendAsync(testDevice.Id, new Message(Encoding.ASCII.GetBytes("Dummy Message")), timeout).ConfigureAwait(false); } }
private async Task TestTimeout(TimeSpan?timeout) { TestDevice testDevice = await TestDevice.GetTestDeviceAsync(DevicePrefix).ConfigureAwait(false); using (ServiceClient sender = ServiceClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString)) { Stopwatch sw = new Stopwatch(); sw.Start(); _log.WriteLine($"Testing ServiceClient SendAsync() timeout in ticks={timeout?.Ticks}"); try { await sender.SendAsync(testDevice.Id, new Message(Encoding.ASCII.GetBytes("Dummy Message")), timeout).ConfigureAwait(false); } finally { sw.Stop(); _log.WriteLine($"Testing ServiceClient SendAsync(): exiting test after time={sw.Elapsed}; ticks={sw.ElapsedTicks}"); } } }
private async Task SendMethodAndRespondPoolOverAmqp( Client.TransportType transport, int poolSize, int devicesCount, Func <DeviceClient, string, Task <Task> > setDeviceReceiveMethod, ConnectionStringAuthScope authScope = ConnectionStringAuthScope.Device) { Func <DeviceClient, TestDevice, Task> initOperation = async(deviceClient, testDevice) => { _log.WriteLine($"{nameof(MethodE2EPoolAmqpTests)}: 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(MethodE2EPoolAmqpTests)}: 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 PoolingOverAmqp.TestPoolAmqpAsync( DevicePrefix, transport, poolSize, devicesCount, initOperation, testOperation, cleanupOperation, authScope, true).ConfigureAwait(false); }
public async Task Twin_ClientSetsReportedPropertyWithoutDesiredPropertyCallback(Client.TransportType transportType) { // arrange TestDevice testDevice = await TestDevice.GetTestDeviceAsync(_devicePrefix).ConfigureAwait(false); using var deviceClient = DeviceClient.CreateFromConnectionString(testDevice.ConnectionString, transportType); await Twin_DeviceSetsReportedPropertyAndGetsItBackAsync(deviceClient).ConfigureAwait(false); int connectionStatusChangeCount = 0; ConnectionStatusChangesHandler connectionStatusChangesHandler = (ConnectionStatus status, ConnectionStatusChangeReason reason) => { Interlocked.Increment(ref connectionStatusChangeCount); }; string propName = Guid.NewGuid().ToString(); string propValue = Guid.NewGuid().ToString(); s_log.WriteLine($"{nameof(Twin_ServiceSetsDesiredPropertyAndDeviceReceivesEventAsync)}: name={propName}, value={propValue}"); // act await RegistryManagerUpdateDesiredPropertyAsync(testDevice.Id, propName, propValue).ConfigureAwait(false); await Task.Delay(TimeSpan.FromSeconds(10)).ConfigureAwait(false); // assert Assert.AreEqual(0, connectionStatusChangeCount, "AMQP should not be disconnected."); }
/// <summary> /// Factory method. /// </summary> /// <param name="namePrefix"></param> /// <param name="type"></param> public static async Task <TestDevice> GetTestDeviceAsync(string namePrefix, TestDeviceType type = TestDeviceType.Sasl) { string prefix = namePrefix + type + "_"; try { await s_semaphore.WaitAsync().ConfigureAwait(false); TestDevice ret = await CreateDeviceAsync(type, prefix).ConfigureAwait(false); s_log.WriteLine($"{nameof(GetTestDeviceAsync)}: Using device {ret.Id}."); return(ret); } finally { s_semaphore.Release(); } }
private async Task Twin_DeviceSetsReportedPropertyAndGetsItBackPoolOverAmqp( 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(TwinE2EPoolAmqpTests)}: Setting reported propery and verifying twin for device {testDevice.Id}"); await TwinE2ETests.Twin_DeviceSetsReportedPropertyAndGetsItBackAsync(deviceClient, Guid.NewGuid().ToString()).ConfigureAwait(false); }; await PoolingOverAmqp.TestPoolAmqpAsync( _devicePrefix, transport, poolSize, devicesCount, null, testOperation, null, authScope, true).ConfigureAwait(false); }
private async Task UploadFile(Client.TransportType transport, string filename, bool x509auth = false) { TestDevice testDevice = await TestDevice.GetTestDeviceAsync( DevicePrefix, x509auth?TestDeviceType.X509 : TestDeviceType.Sasl).ConfigureAwait(false); DeviceClient deviceClient; if (x509auth) { X509Certificate2 cert = Configuration.IoTHub.GetCertificateWithPrivateKey(); var auth = new DeviceAuthenticationWithX509Certificate(testDevice.Id, cert); deviceClient = DeviceClient.Create(testDevice.IoTHubHostName, auth, transport); } else { deviceClient = DeviceClient.CreateFromConnectionString(testDevice.ConnectionString, transport); } using (deviceClient) using (ServiceClient serviceClient = ServiceClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString)) { FileNotificationReceiver <FileNotification> notificationReceiver = serviceClient.GetFileNotificationReceiver(); using (FileStream fileStreamSource = new FileStream(filename, FileMode.Open, FileAccess.Read)) { await deviceClient.UploadToBlobAsync(filename, fileStreamSource).ConfigureAwait(false); } FileNotification fileNotification = await VerifyFileNotification(notificationReceiver, testDevice.Id).ConfigureAwait(false); // The following checks allow running these tests multiple times in parallel. // Notifications for one of the test-run instances may be received by the other test-run. Assert.IsNotNull(fileNotification, "FileNotification is not received."); _log.WriteLine($"TestDevice: '{testDevice.Id}', blobName: '{fileNotification.BlobName}', size: {fileNotification.BlobSizeInBytes}"); Assert.IsFalse(string.IsNullOrEmpty(fileNotification.BlobUri), "File notification blob uri is null or empty"); await deviceClient.CloseAsync().ConfigureAwait(false); await serviceClient.CloseAsync().ConfigureAwait(false); } }
/// <summary> /// Factory method. /// IMPORTANT: Not thread safe! /// </summary> /// <param name="namePrefix"></param> /// <param name="type"></param> /// <returns></returns> public static async Task <TestDevice> GetTestDeviceAsync(string namePrefix, TestDeviceType type = TestDeviceType.Sasl) { string prefix = namePrefix + type + "_"; if (!s_deviceCache.TryGetValue(prefix, out TestDevice testDevice)) { string deviceName = prefix + Guid.NewGuid(); s_log.WriteLine($"{nameof(GetTestDeviceAsync)}: Device with prefix {prefix} not found. Removing old devices."); // Delete existing devices named this way and create a new one. RegistryManager rm = RegistryManager.CreateFromConnectionString(Configuration.IoTHub.ConnectionString); s_log.WriteLine($"{nameof(GetTestDeviceAsync)}: Creating device {deviceName} with type {type}."); Client.IAuthenticationMethod auth = null; Device requestDevice = new Device(deviceName); if (type == TestDeviceType.X509) { requestDevice.Authentication = new AuthenticationMechanism() { X509Thumbprint = new X509Thumbprint() { PrimaryThumbprint = Configuration.IoTHub.GetCertificateWithPrivateKey().Thumbprint } }; auth = new DeviceAuthenticationWithX509Certificate(deviceName, Configuration.IoTHub.GetCertificateWithPrivateKey()); } Device device = await rm.AddDeviceAsync(requestDevice).ConfigureAwait(false); s_log.WriteLine($"{nameof(GetTestDeviceAsync)}: Pausing for {DelayAfterDeviceCreationSeconds}s after device was created."); await Task.Delay(DelayAfterDeviceCreationSeconds * 1000).ConfigureAwait(false); s_deviceCache[prefix] = new TestDevice(device, auth); await rm.CloseAsync().ConfigureAwait(false); } TestDevice ret = s_deviceCache[prefix]; s_log.WriteLine($"{nameof(GetTestDeviceAsync)}: Using device {ret.Id}."); return(ret); }