Inheritance: MonoBehaviour
Exemplo n.º 1
0
        private async Task TestTimeout(TimeSpan? timeout)
        {
            using TestDevice testDevice = await TestDevice.GetTestDeviceAsync(Logger, DevicePrefix).ConfigureAwait(false);
            using var sender = ServiceClient.CreateFromConnectionString(TestConfiguration.IoTHub.ConnectionString);

            var sw = new Stopwatch();
            sw.Start();

            Logger.Trace($"Testing ServiceClient SendAsync() timeout in ticks={timeout?.Ticks}");
            try
            {
                using var testMessage = new Message(Encoding.ASCII.GetBytes("Test Message"));
                await sender.SendAsync(testDevice.Id, testMessage, timeout).ConfigureAwait(false);
            }
            finally
            {
                sw.Stop();
                Logger.Trace($"Testing ServiceClient SendAsync(): exiting test after time={sw.Elapsed}; ticks={sw.ElapsedTicks}");
            }
        }
Exemplo n.º 2
0
        public void Read_GoodPin(TestDevice testDevice)
        {
            Mcp23xxx device = testDevice.Device;

            for (int pin = 0; pin < testDevice.Device.PinCount; pin++)
            {
                bool first    = pin < 8;
                int  register = testDevice.Device.PinCount == 16
                    ? (first ? 0x12 : 0x13)
                    : 0x09;

                // Flip the bit on (set the backing buffer directly to simulate incoming data)
                testDevice.ChipMock.Registers[register] = (byte)(1 << (first ? pin : pin - 8));
                Assert.Equal(PinValue.High, device.Read(pin));

                // Clear the register
                testDevice.ChipMock.Registers[register] = 0x00;
                Assert.Equal(PinValue.Low, device.Read(pin));
            }
        }
Exemplo n.º 3
0
        static void Main(string[] args)
        {
            IProbeFactory _memberFactory = new WindowsProbeFactory();
            //TestDevice device = new TestDevice(PhysicalAddress.Parse("00-E0-4C-68-02-91"), IPAddress.Parse("fe80::1c66:e750:c259:df88"), _memberFactory.CreateNICHelper());
            TestDevice device = new TestDevice(PhysicalAddress.Parse("98-5F-D3-58-7D-28"), IPAddress.Parse("fe80::c71:214f:ef74:b2ce"), _memberFactory.CreateNICHelper());

            for (int i = 0; i < 10; i++)
            {
                int                 transationId = 0x268285 + i;
                DHCPv6Solicit       solicit      = new DHCPv6Solicit(transationId);
                DHCPv6Advertisement advertise    = new DHCPv6Advertisement(transationId);
                DHCPv6Request       request      = new DHCPv6Request(transationId, advertise);
                DHCPv6Reply         confirm      = new DHCPv6Reply(transationId);

                DHCPv6Tester tester = new DHCPv6Tester(solicit, advertise, new DHCPv6Tester(request, confirm, null));
                tester.Start(device);
            }

            Console.ReadLine();
        }
Exemplo n.º 4
0
        public void Write_GoodPin(TestDevice testDevice)
        {
            Mcp23xxx device = testDevice.Device;

            for (int pin = 0; pin < testDevice.Controller.PinCount; pin++)
            {
                bool first = pin < 8;

                testDevice.Controller.OpenPin(pin, PinMode.Output);
                testDevice.Controller.Write(pin, PinValue.High);
                byte expected = (byte)(1 << (first ? pin : pin - 8));

                Assert.Equal(expected,
                             first ? device.ReadByte(Register.OLAT) : ((Mcp23x1x)device).ReadByte(Register.OLAT, Port.PortB));

                testDevice.Controller.Write(pin, PinValue.Low);
                Assert.Equal(0,
                             first ? device.ReadByte(Register.OLAT) : ((Mcp23x1x)device).ReadByte(Register.OLAT, Port.PortB));
            }
        }
Exemplo n.º 5
0
        public async Task MessageIdDefaultNotSet_SendEventDoesNotSetMessageId()
        {
            // arrange
            using TestDevice testDevice = await TestDevice.GetTestDeviceAsync(Logger, DevicePrefix).ConfigureAwait(false);
            using var sender = ServiceClient.CreateFromConnectionString(TestConfiguration.IoTHub.ConnectionString);
            string messageId = Guid.NewGuid().ToString();

            // act
            using var messageWithoutId = new Message();
            using var messageWithId = new Message
            {
                MessageId = messageId,
            };
            await sender.SendAsync(testDevice.Id, messageWithoutId).ConfigureAwait(false);
            await sender.SendAsync(testDevice.Id, messageWithId).ConfigureAwait(false);

            // assert
            messageWithoutId.MessageId.Should().BeNull();
            messageWithId.MessageId.Should().Be(messageId);
        }
Exemplo n.º 6
0
        public void SetsChannelInfo()
        {
            foreach (HekaDAQController daq in HekaDAQController.AvailableControllers())
            {
                const decimal srate = 10000;

                daq.InitHardware();
                Assert.True(daq.HardwareReady);
                Assert.False(daq.HardwareRunning);

                try
                {
                    foreach (IDAQOutputStream s in daq.OutputStreams)
                    {
                        daq.SampleRate = new Measurement(srate, "Hz");
                        TestDevice externalDevice = new TestDevice("OUT-DEVICE", null);

                        s.Device = externalDevice;
                    }

                    daq.ConfigureChannels();

                    foreach (HekaDAQStream s in daq.OutputStreams.Cast <HekaDAQStream>())
                    {
                        ITCMM.ITCChannelInfo actual = daq.ChannelInfo(s.ChannelType, s.ChannelNumber);

                        ITCMM.ITCChannelInfo expected = s.ChannelInfo;

                        Assert.AreEqual(expected.ChannelNumber, actual.ChannelNumber);
                        Assert.AreEqual(expected.ChannelType, actual.ChannelType);
                        Assert.AreEqual(expected.SamplingIntervalFlag, actual.SamplingIntervalFlag);
                        Assert.AreEqual(expected.SamplingRate, actual.SamplingRate);
                        // Gain set by hardware.
                    }
                }
                finally
                {
                    daq.CloseHardware();
                }
            }
        }
Exemplo n.º 7
0
        public async Task RoutesWithConditionsTest2()
        {
            var routes = new List <string>
            {
                @"FROM /messages WHERE as_number(temp) > 50 INTO BrokeredEndpoint(""/modules/mod1/inputs/in1"")",
                @"FROM /messages/* WHERE as_number(temp) < 50 INTO BrokeredEndpoint(""/modules/mod2/inputs/in2"")",
            };

            string edgeDeviceId = "edge";
            var    iotHub       = new IoTHub();

            (IEdgeHub edgeHub, IConnectionManager connectionManager) = await SetupEdgeHub(routes, iotHub, edgeDeviceId);

            TestDevice device1 = await TestDevice.Create("device1", edgeHub, connectionManager);

            TestModule module1 = await TestModule.Create(edgeDeviceId, "mod1", "op1", "in1", edgeHub, connectionManager);

            TestModule module2 = await TestModule.Create(edgeDeviceId, "mod2", "op2", "in2", edgeHub, connectionManager);

            List <IMessage> messages1 = GetMessages();

            messages1.ForEach(d => d.Properties.Add("temp", "100"));
            await device1.SendMessages(messages1);

            await Task.Delay(GetSleepTime());

            Assert.False(iotHub.HasReceivedMessages(messages1));
            Assert.True(module1.HasReceivedMessages(messages1));
            Assert.False(module2.HasReceivedMessages(messages1));

            List <IMessage> messages2 = GetMessages();

            messages2.ForEach(d => d.Properties.Add("temp", "20"));
            await device1.SendMessages(messages2);

            await Task.Delay(GetSleepTime());

            Assert.False(iotHub.HasReceivedMessages(messages2));
            Assert.False(module1.HasReceivedMessages(messages2));
            Assert.True(module2.HasReceivedMessages(messages2));
        }
Exemplo n.º 8
0
        public void Read_GoodPin(TestDevice testDevice)
        {
            Pcx857x device = testDevice.Device;

            for (int pin = 0; pin < testDevice.Controller.PinCount; pin++)
            {
                // Set pin to input
                testDevice.Controller.OpenPin(pin, PinMode.Input);

                bool first    = pin < 8;
                int  register = first ? 0x00 : 0x01;

                // Flip the bit on (set the backing buffer directly to simulate incoming data)
                testDevice.ChipMock.Registers[register] = (byte)(1 << (first ? pin : pin - 8));
                Assert.Equal(PinValue.High, testDevice.Controller.Read(pin));

                // Clear the register
                testDevice.ChipMock.Registers[register] = 0x00;
                Assert.Equal(PinValue.Low, testDevice.Controller.Read(pin));
            }
        }
Exemplo n.º 9
0
        public void Write_GoodPin(TestDevice testDevice)
        {
            Pcx857x device = testDevice.Device;

            for (int pin = 0; pin < testDevice.Controller.PinCount; pin++)
            {
                bool first = pin < 8;

                testDevice.Controller.OpenPin(pin, PinMode.Output);

                testDevice.Controller.Write(pin, PinValue.High);
                byte expected = (byte)(1 << (first ? pin : pin - 8));

                Assert.Equal(expected,
                             first ? device.ReadByte() : (byte)(((Pcx8575)device).ReadUInt16() >> 8));

                testDevice.Controller.Write(pin, PinValue.Low);
                Assert.Equal(0,
                             first ? device.ReadByte() : (byte)(((Pcx8575)device).ReadUInt16() >> 8));
            }
        }
Exemplo n.º 10
0
        public void DisconnectShouldOptionallyCloseAllReferences()
        {
            var handle        = new IntPtr(1);
            var device        = new TestDevice("Test");
            var entryName     = "Test";
            var phoneBook     = @"C:\Test.pbk";
            var entryId       = Guid.NewGuid();
            var options       = new RasConnectionOptions(Ras.RASCF.AllUsers);
            var sessionId     = new Luid(1, 1);
            var correlationId = Guid.NewGuid();

            var rasHangUp = new Mock <IRasHangUp>();

            services.Setup(o => o.GetService(typeof(IRasHangUp))).Returns(rasHangUp.Object);

            var target = new RasConnection(handle, device, entryName, phoneBook, entryId, options, sessionId, correlationId, services.Object);

            target.Disconnect(CancellationToken.None, false);

            rasHangUp.Verify(o => o.HangUpAsync(target, false, CancellationToken.None), Times.Once);
        }
Exemplo n.º 11
0
        public async Task ReportedPropertyUpdatesAsTelemetryTest()
        {
            var routes = new List <string>
            {
                @"FROM /* INTO $upstream",
            };

            string edgeDeviceId = "edge";
            var    iotHub       = new IoTHub();

            (IEdgeHub edgeHub, IConnectionManager connectionManager) = await SetupEdgeHub(routes, iotHub, edgeDeviceId);

            TestDevice device1 = await TestDevice.Create("device1", edgeHub, connectionManager);

            IMessage message = GetReportedPropertiesMessage();
            await device1.UpdateReportedProperties(message);

            await Task.Delay(GetSleepTime());

            Assert.True(iotHub.HasReceivedTwinChangeNotification(edgeDeviceId, edgeHubModuleId));
        }
Exemplo n.º 12
0
        public async Task DisconnectAsyncShouldOptionallyCloseAllReferences()
        {
            var handle        = new IntPtr(1);
            var device        = new TestDevice("Test");
            var entryName     = "Test";
            var phoneBook     = @"C:\Test.pbk";
            var entryId       = Guid.NewGuid();
            var options       = new RasConnectionOptions(Ras.RASCF.AllUsers);
            var sessionId     = new Luid(1, 1);
            var correlationId = Guid.NewGuid();

            var rasGetConnectStatus        = new Mock <IRasGetConnectStatus>();
            var rasGetConnectionStatistics = new Mock <IRasGetConnectionStatistics>();
            var rasHangUp = new Mock <IRasHangUp>();
            var rasClearConnectionStatistics = new Mock <IRasClearConnectionStatistics>();

            var target = new RasConnection(handle, device, entryName, phoneBook, entryId, options, sessionId, correlationId, rasGetConnectStatus.Object, rasGetConnectionStatistics.Object, rasHangUp.Object, rasClearConnectionStatistics.Object);
            await target.DisconnectAsync(CancellationToken.None, false);

            rasHangUp.Verify(o => o.HangUpAsync(target, false, CancellationToken.None), Times.Once);
        }
        public async Task Service_Amqp_TokenCredentialAuth_Success()
        {
            // arrange
            TestDevice testDevice = await TestDevice.GetTestDeviceAsync(Logger, _devicePrefix).ConfigureAwait(false);

            using DeviceClient deviceClient = testDevice.CreateDeviceClient(Client.TransportType.Mqtt);
            await deviceClient.OpenAsync().ConfigureAwait(false);

            using var serviceClient = ServiceClient.Create(
                      Configuration.IoTHub.GetIotHubHostName(),
                      Configuration.IoTHub.GetClientSecretCredential(),
                      TransportType.Amqp);

            // act
            await serviceClient.OpenAsync().ConfigureAwait(false);

            using var message = new Message(Encoding.ASCII.GetBytes("Hello, Cloud!"));
            await serviceClient.SendAsync(testDevice.Id, message);

            // cleanup
            await testDevice.RemoveDeviceAsync().ConfigureAwait(false);
        }
Exemplo n.º 14
0
        public void ClearsTheConnectionStatisticsAsExpected()
        {
            var handle        = new IntPtr(1);
            var device        = new TestDevice("Test");
            var entryName     = "Test";
            var phoneBook     = @"C:\Test.pbk";
            var entryId       = Guid.NewGuid();
            var options       = new RasConnectionOptions(Ras.RASCF.AllUsers);
            var sessionId     = new Luid(1, 1);
            var correlationId = Guid.NewGuid();

            var rasGetConnectStatus        = new Mock <IRasGetConnectStatus>();
            var rasGetConnectionStatistics = new Mock <IRasGetConnectionStatistics>();
            var rasHangUp = new Mock <IRasHangUp>();
            var rasClearConnectionStatistics = new Mock <IRasClearConnectionStatistics>();

            var target = new RasConnection(handle, device, entryName, phoneBook, entryId, options, sessionId, correlationId, rasGetConnectStatus.Object, rasGetConnectionStatistics.Object, rasHangUp.Object, rasClearConnectionStatistics.Object);

            target.ClearStatistics();

            rasClearConnectionStatistics.Verify(o => o.ClearConnectionStatistics(target), Times.Once);
        }
Exemplo n.º 15
0
        public async Task DisconnectAsyncTheConnectionAsExpected()
        {
            var handle        = new IntPtr(1);
            var device        = new TestDevice("Test");
            var entryName     = "Test";
            var phoneBook     = @"C:\Test.pbk";
            var entryId       = Guid.NewGuid();
            var options       = new RasConnectionOptions(Ras.RASCF.AllUsers);
            var sessionId     = new Luid(1, 1);
            var correlationId = Guid.NewGuid();

            var cancellationToken = CancellationToken.None;

            var rasHangUp = new Mock <IRasHangUp>();

            services.Setup(o => o.GetService(typeof(IRasHangUp))).Returns(rasHangUp.Object);

            var target = new RasConnection(handle, device, entryName, phoneBook, entryId, options, sessionId, correlationId, services.Object);
            await target.DisconnectAsync(CancellationToken.None);

            rasHangUp.Verify(o => o.HangUpAsync(target, It.IsAny <bool>(), cancellationToken), Times.Once);
        }
Exemplo n.º 16
0
        public void CacheInvalidatesWhenReset(TestDevice testDevice)
        {
            Mcp23xxx       device     = testDevice.Device;
            GpioController controller = testDevice.Controller;

            // Check the output latches after enabling and setting
            // different bits.
            device.Enable();
            for (int i = 0; i < 4; i++)
            {
                controller.OpenPin(i, PinMode.Output);
            }

            controller.Write(0, PinValue.High);
            Assert.Equal(1, device.ReadByte(Register.OLAT));
            controller.Write(1, PinValue.High);
            Assert.Equal(3, device.ReadByte(Register.OLAT));

            // Flush OLAT
            device.WriteByte(Register.OLAT, 0x00);
            Assert.Equal(0, device.ReadByte(Register.OLAT));

            // Now setting the next bit will pick back up our cached 3
            controller.Write(2, PinValue.High);
            Assert.Equal(7, device.ReadByte(Register.OLAT));

            // Re-enabling will reset the cache
            device.WriteByte(Register.OLAT, 0x00);
            device.Disable();
            device.Enable();
            controller.Write(3, PinValue.High);
            Assert.Equal(8, device.ReadByte(Register.OLAT));

            device.WriteByte(Register.OLAT, 0x02);
            device.Disable();
            device.Enable();
            controller.Write(0, PinValue.High);
            Assert.Equal(3, device.ReadByte(Register.OLAT));
        }
        public async Task Service_Amqp_SasCredentialAuth_Renewed_Success()
        {
            // arrange
            TestDevice testDevice = await TestDevice.GetTestDeviceAsync(Logger, _devicePrefix).ConfigureAwait(false);

            using DeviceClient deviceClient = testDevice.CreateDeviceClient(Client.TransportType.Mqtt);
            await deviceClient.OpenAsync().ConfigureAwait(false);

            string signature     = TestConfiguration.IoTHub.GetIotHubSharedAccessSignature(TimeSpan.FromHours(-1));
            var    sasCredential = new AzureSasCredential(signature);

            using var serviceClient = ServiceClient.Create(
                      TestConfiguration.IoTHub.GetIotHubHostName(),
                      sasCredential,
                      TransportType.Amqp);

            // act
            try
            {
                await serviceClient.OpenAsync().ConfigureAwait(false);

                Assert.Fail("The SAS token is expired so the call should fail with an exception");
            }
            catch (AmqpException ex) when(ex.Error.Description.Contains("401"))
            {
                // Expected to get an unauthorized exception.
            }

            signature = TestConfiguration.IoTHub.GetIotHubSharedAccessSignature(TimeSpan.FromHours(1));
            sasCredential.Update(signature);
            await serviceClient.OpenAsync().ConfigureAwait(false);

            using var message = new Message(Encoding.ASCII.GetBytes("Hello, Cloud!"));
            await serviceClient.SendAsync(testDevice.Id, message);

            // cleanup
            await testDevice.RemoveDeviceAsync().ConfigureAwait(false);
        }
Exemplo n.º 18
0
        public async Task DeviceTwin_Contains_ModelId_X509()
        {
            // Setup

            // Create a device.
            using TestDevice testDevice = await TestDevice.GetTestDeviceAsync(Logger, DevicePrefix, TestDeviceType.X509).ConfigureAwait(false);

            // Send model ID with MQTT connect packet to make the device plug and play.
            var options = new ClientOptions
            {
                ModelId = TestModelId,
            };
            string           hostName        = HostNameHelper.GetHostName(TestConfiguration.IoTHub.ConnectionString);
            X509Certificate2 authCertificate = TestConfiguration.IoTHub.GetCertificateWithPrivateKey();

            using var auth         = new DeviceAuthenticationWithX509Certificate(testDevice.Id, authCertificate);
            using var deviceClient = DeviceClient.Create(hostName, auth, Client.TransportType.Mqtt_Tcp_Only, options);
            await deviceClient.OpenAsync().ConfigureAwait(false);

            // Act

            // Get device twin.
            using var registryManager = RegistryManager.CreateFromConnectionString(TestConfiguration.IoTHub.ConnectionString);
            Twin twin = await registryManager.GetTwinAsync(testDevice.Device.Id).ConfigureAwait(false);

            // Assert
            twin.ModelId.Should().Be(TestModelId, "because the device was created as plug and play");

            // Cleanup
            await registryManager.RemoveDeviceAsync(testDevice.Id).ConfigureAwait(false);

            // X509Certificate needs to be disposed for implementations !NET451 (NET451 doesn't implement X509Certificates as IDisposable).
            if (authCertificate is IDisposable disposableCert)
            {
                disposableCert?.Dispose();
            }
            authCertificate = null;
        }
Exemplo n.º 19
0
        private async Task Twin_DeviceSetsReportedPropertyAndServiceReceivesItAsync(Client.TransportType transport)
        {
            var propName  = Guid.NewGuid().ToString();
            var propValue = Guid.NewGuid().ToString();

            TestDevice testDevice = await TestDevice.GetTestDeviceAsync(Logger, _devicePrefix).ConfigureAwait(false);

            using var registryManager = RegistryManager.CreateFromConnectionString(Configuration.IoTHub.ConnectionString);
            using var deviceClient    = DeviceClient.CreateFromConnectionString(testDevice.ConnectionString, transport);

            var patch = new TwinCollection();

            patch[propName] = propValue;
            await deviceClient.UpdateReportedPropertiesAsync(patch).ConfigureAwait(false);

            await deviceClient.CloseAsync().ConfigureAwait(false);

            Twin serviceTwin = await registryManager.GetTwinAsync(testDevice.Id).ConfigureAwait(false);

            Assert.AreEqual <string>(serviceTwin.Properties.Reported[propName].ToString(), propValue);

            Logger.Trace("verified " + serviceTwin.Properties.Reported[propName].ToString() + "=" + propValue);
        }
Exemplo n.º 20
0
        private async Task Twin_ServiceSetsDesiredPropertyAndDeviceReceivesItOnNextGetAsync(Client.TransportType transport)
        {
            var propName  = Guid.NewGuid().ToString();
            var propValue = Guid.NewGuid().ToString();

            TestDevice testDevice = await TestDevice.GetTestDeviceAsync(Logger, _devicePrefix).ConfigureAwait(false);

            using var registryManager = RegistryManager.CreateFromConnectionString(Configuration.IoTHub.ConnectionString);
            using var deviceClient    = DeviceClient.CreateFromConnectionString(testDevice.ConnectionString, transport);

            var twinPatch = new Twin();

            twinPatch.Properties.Desired[propName] = propValue;
            await registryManager.UpdateTwinAsync(testDevice.Id, twinPatch, "*").ConfigureAwait(false);

            Twin deviceTwin = await deviceClient.GetTwinAsync().ConfigureAwait(false);

            Assert.AreEqual <string>(deviceTwin.Properties.Desired[propName].ToString(), propValue);

            await deviceClient.CloseAsync().ConfigureAwait(false);

            await registryManager.CloseAsync().ConfigureAwait(false);
        }
        public async Task DigitalTwinClient_Http_SasCredentialAuth_Success()
        {
            // arrange
            TestDevice testDevice = await TestDevice.GetTestDeviceAsync(Logger, _devicePrefix).ConfigureAwait(false);

            string thermostatModelId = "dtmi:com:example:TemperatureController;1";

            // Create a device client instance initializing it with the "Thermostat" model.
            var options = new ClientOptions
            {
                ModelId = thermostatModelId,
            };

            using DeviceClient deviceClient = testDevice.CreateDeviceClient(Client.TransportType.Mqtt, options);

            // Call openAsync() to open the device's connection, so that the ModelId is sent over Mqtt CONNECT packet.
            await deviceClient.OpenAsync().ConfigureAwait(false);

            string signature = TestConfiguration.IoTHub.GetIotHubSharedAccessSignature(TimeSpan.FromHours(1));

            using var digitalTwinClient = DigitalTwinClient.Create(
                      TestConfiguration.IoTHub.GetIotHubHostName(),
                      new AzureSasCredential(signature));

            // act
            HttpOperationResponse <ThermostatTwin, DigitalTwinGetHeaders> response = await digitalTwinClient
                                                                                     .GetDigitalTwinAsync <ThermostatTwin>(testDevice.Id)
                                                                                     .ConfigureAwait(false);

            ThermostatTwin twin = response.Body;

            // assert
            twin.Metadata.ModelId.Should().Be(thermostatModelId);

            // cleanup
            await testDevice.RemoveDeviceAsync().ConfigureAwait(false);
        }
Exemplo n.º 22
0
        private async Task ReceiveMessageInOperationTimeoutAsync(TestDeviceType type, Client.TransportType transport)
        {
            TestDevice testDevice = await TestDevice.GetTestDeviceAsync(Logger, s_devicePrefix, type).ConfigureAwait(false);

            using DeviceClient deviceClient = testDevice.CreateDeviceClient(transport);

            Logger.Trace($"{nameof(ReceiveMessageInOperationTimeoutAsync)} - calling OpenAsync() for transport={transport}");
            await deviceClient.OpenAsync().ConfigureAwait(false);

            try
            {
                deviceClient.OperationTimeoutInMilliseconds = Convert.ToUInt32(s_oneMinute.TotalMilliseconds);
                Logger.Trace($"{nameof(ReceiveMessageInOperationTimeoutAsync)} - setting device client default operation timeout={deviceClient.OperationTimeoutInMilliseconds} ms");

                if (transport == Client.TransportType.Amqp ||
                    transport == Client.TransportType.Amqp_Tcp_Only ||
                    transport == Client.TransportType.Amqp_WebSocket_Only)
                {
                    // TODO: this extra minute on the timeout is undesirable by customers, and tests seems to be failing on a slight timing issue.
                    // For now, add an additional 5 second buffer to prevent tests from failing, and meanwhile address issue 1203.

                    // For AMQP because of static 1 min interval check the cancellation token, in worst case it will block upto extra 1 min to return
                    await ReceiveMessageWithoutTimeoutCheckAsync(deviceClient, s_oneMinute + TimeSpan.FromSeconds(5), Logger).ConfigureAwait(false);
                }
                else
                {
                    await ReceiveMessageWithoutTimeoutCheckAsync(deviceClient, s_fiveSeconds, Logger).ConfigureAwait(false);
                }
            }
            finally
            {
                Logger.Trace($"{nameof(ReceiveMessageInOperationTimeoutAsync)} - calling CloseAsync() for transport={transport}");
                deviceClient.OperationTimeoutInMilliseconds = DeviceClient.DefaultOperationTimeoutInMilliseconds;
                await deviceClient.CloseAsync().ConfigureAwait(false);
            }
        }
Exemplo n.º 23
0
        public void DisconnectTheConnectionAsExpected()
        {
            var handle        = new IntPtr(1);
            var device        = new TestDevice("Test");
            var entryName     = "Test";
            var phoneBook     = @"C:\Test.pbk";
            var entryId       = Guid.NewGuid();
            var options       = new RasConnectionOptions(Ras.RASCF.AllUsers);
            var sessionId     = new Luid(1, 1);
            var correlationId = Guid.NewGuid();

            var cancellationToken = CancellationToken.None;

            var rasGetConnectStatus        = new Mock <IRasGetConnectStatus>();
            var rasGetConnectionStatistics = new Mock <IRasGetConnectionStatistics>();
            var rasHangUp = new Mock <IRasHangUp>();
            var rasClearConnectionStatistics = new Mock <IRasClearConnectionStatistics>();

            var target = new RasConnection(handle, device, entryName, phoneBook, entryId, options, sessionId, correlationId, rasGetConnectStatus.Object, rasGetConnectionStatistics.Object, rasHangUp.Object, rasClearConnectionStatistics.Object);

            target.Disconnect(CancellationToken.None);

            rasHangUp.Verify(o => o.HangUpAsync(target, It.IsAny <bool>(), cancellationToken));
        }
        private async void TestModePage_SetTestModeButtonClick(object sender, EventArgs e)
        {
            // TODO: Validate Pin
            // Set app in Test mode here
            App.IsIntegrationTestMode = true;
            App.Container             = Bootstrapper.Run();

            IDatabaseContext database = new DatabaseContext(String.Empty);
            IDevice          device   = new TestDevice();

            App.Container.RegisterInstance(typeof(IDatabaseContext), database, new ContainerControlledLifetimeManager());
            App.Container.RegisterInstance(typeof(IDevice), device, new ContainerControlledLifetimeManager());

            // Read the test data
            var testVoucherData = this.TestModePageViewModel.TestVoucherData;
            var testUserData    = this.TestModePageViewModel.TestUserData;

            UpdateTestVoucherData(testVoucherData);

            //CrossToastPopUp.Current.ShowToastMessage(testUserData.Length.ToString());
            UpdateTestUserData(testUserData);

            await Application.Current.MainPage.Navigation.PopAsync();
        }
Exemplo n.º 25
0
        public async Task TestRoutingTwinChangeNotificationFromDevice()
        {
            var routes = new List <string>
            {
                @"FROM /twinChangeNotifications INTO BrokeredEndpoint(""/modules/mod1/inputs/in1"")"
            };

            string edgeDeviceId = "edge";
            var    iotHub       = new IoTHub();

            (IEdgeHub edgeHub, IConnectionManager connectionManager) = await SetupEdgeHub(routes, iotHub, edgeDeviceId);

            TestDevice device1 = await TestDevice.Create("device1", edgeHub, connectionManager);

            TestModule module1 = await TestModule.Create(edgeDeviceId, "mod1", "op1", "in1", edgeHub, connectionManager);

            IMessage message = GetReportedPropertiesMessage();
            await device1.UpdateReportedProperties(message);

            await Task.Delay(GetSleepTime());

            Assert.True(iotHub.HasReceivedTwinChangeNotification());
            Assert.True(module1.HasReceivedTwinChangeNotification());
        }
Exemplo n.º 26
0
        public async Task RouteToModuleTest()
        {
            var routes = new List <string>
            {
                @"FROM /messages INTO BrokeredEndpoint(""/modules/mod1/inputs/in1"")"
            };

            string edgeDeviceId = "edge";
            var    iotHub       = new IoTHub();

            (IEdgeHub edgeHub, IConnectionManager connectionManager) = await SetupEdgeHub(routes, iotHub, edgeDeviceId);

            TestDevice device1 = await TestDevice.Create("device1", edgeHub, connectionManager);

            TestModule module1 = await TestModule.Create(edgeDeviceId, "mod1", "op1", "in1", edgeHub, connectionManager);

            IList <IMessage> messages = GetMessages();
            await device1.SendMessages(messages);

            await Task.Delay(GetSleepTime());

            Assert.False(iotHub.HasReceivedMessages(messages));
            Assert.True(module1.HasReceivedMessages(messages));
        }
Exemplo n.º 27
0
        public void RetrievesTheStatusAsExpected()
        {
            var handle        = new IntPtr(1);
            var device        = new TestDevice("Test");
            var entryName     = "Test";
            var phoneBook     = @"C:\Test.pbk";
            var entryId       = Guid.NewGuid();
            var options       = new RasConnectionOptions(Ras.RASCF.AllUsers);
            var sessionId     = new Luid(1, 1);
            var correlationId = Guid.NewGuid();

            var status = new Mock <RasConnectionStatus>();
            var rasGetConnectStatus = new Mock <IRasGetConnectStatus>();

            var target = new RasConnection(handle, device, entryName, phoneBook, entryId, options, sessionId, correlationId, services.Object);

            services.Setup(o => o.GetService(typeof(IRasGetConnectStatus))).Returns(rasGetConnectStatus.Object);
            rasGetConnectStatus.Setup(o => o.GetConnectionStatus(target)).Returns(status.Object).Verifiable();

            var result = target.GetStatus();

            Assert.AreEqual(status.Object, result);
            rasGetConnectStatus.Verify();
        }
Exemplo n.º 28
0
        public async Task MessageIdDefaultSetToGuid_SendEventSetMessageIdIfNotSet()
        {
            // arrange
            using TestDevice testDevice = await TestDevice.GetTestDeviceAsync(Logger, DevicePrefix).ConfigureAwait(false);
            var options = new ServiceClientOptions
            {
                SdkAssignsMessageId = Shared.SdkAssignsMessageId.WhenUnset,
            };
            using var sender = ServiceClient.CreateFromConnectionString(TestConfiguration.IoTHub.ConnectionString, options);
            string messageId = Guid.NewGuid().ToString();

            // act
            using var messageWithoutId = new Message();
            using var messageWithId = new Message
            {
                MessageId = messageId,
            };
            await sender.SendAsync(testDevice.Id, messageWithoutId).ConfigureAwait(false);
            await sender.SendAsync(testDevice.Id, messageWithId).ConfigureAwait(false);

            // assert
            messageWithoutId.MessageId.Should().NotBeNullOrEmpty();
            messageWithId.MessageId.Should().Be(messageId);
        }
Exemplo n.º 29
0
        public const int TestSuccessRate = 80; // 4 out of 5 (80%) test runs should pass (even after accounting for network instability issues).

        public static async Task TestPoolAmqpAsync(
            string devicePrefix,
            Client.TransportType transport,
            int poolSize,
            int devicesCount,
            Func <DeviceClient, TestDevice, Task> initOperation,
            Func <DeviceClient, TestDevice, Task> testOperation,
            Func <Task> cleanupOperation,
            ConnectionStringAuthScope authScope,
            bool ignoreConnectionStatus,
            MsTestLogger logger)
        {
            var transportSettings = new ITransportSettings[]
            {
                new AmqpTransportSettings(transport)
                {
                    AmqpConnectionPoolSettings = new AmqpConnectionPoolSettings()
                    {
                        MaxPoolSize = unchecked ((uint)poolSize),
                        Pooling     = true
                    }
                }
            };

            int  totalRuns          = 0;
            int  successfulRuns     = 0;
            int  currentSuccessRate = 0;
            bool reRunTest          = false;

            IList <TestDevice>   testDevices   = new List <TestDevice>();
            IList <DeviceClient> deviceClients = new List <DeviceClient>();
            IList <AmqpConnectionStatusChange> amqpConnectionStatuses = new List <AmqpConnectionStatusChange>();
            IList <Task> operations = new List <Task>();

            do
            {
                totalRuns++;

                // Arrange
                // Initialize the test device client instances
                // Set the device client connection status change handler
                logger.Trace($">>> {nameof(PoolingOverAmqp)} Initializing Device Clients for multiplexing test - Test run {totalRuns}");
                for (int i = 0; i < devicesCount; i++)
                {
                    TestDevice testDevice = await TestDevice.GetTestDeviceAsync(logger, $"{devicePrefix}_{i}_").ConfigureAwait(false);

                    DeviceClient deviceClient = testDevice.CreateDeviceClient(transportSettings, authScope);

                    var amqpConnectionStatusChange = new AmqpConnectionStatusChange(logger);
                    deviceClient.SetConnectionStatusChangesHandler(amqpConnectionStatusChange.ConnectionStatusChangesHandler);

                    testDevices.Add(testDevice);
                    deviceClients.Add(deviceClient);
                    amqpConnectionStatuses.Add(amqpConnectionStatusChange);

                    if (initOperation != null)
                    {
                        operations.Add(initOperation(deviceClient, testDevice));
                    }
                }

                await Task.WhenAll(operations).ConfigureAwait(false);

                operations.Clear();

                try
                {
                    for (int i = 0; i < devicesCount; i++)
                    {
                        operations.Add(testOperation(deviceClients[i], testDevices[i]));
                    }
                    await Task.WhenAll(operations).ConfigureAwait(false);

                    operations.Clear();

                    // Close the device client instances and verify the connection status change checks
                    bool deviceConnectionStatusAsExpected = true;
                    for (int i = 0; i < devicesCount; i++)
                    {
                        await deviceClients[i].CloseAsync().ConfigureAwait(false);

                        if (!ignoreConnectionStatus)
                        {
                            // The connection status change count should be 2: connect (open) and disabled (close)
                            if (amqpConnectionStatuses[i].ConnectionStatusChangesHandlerCount != 2)
                            {
                                deviceConnectionStatusAsExpected = false;
                            }

                            // The connection status should be "Disabled", with connection status change reason "Client_close"
                            Assert.AreEqual(
                                ConnectionStatus.Disabled,
                                amqpConnectionStatuses[i].LastConnectionStatus,
                                $"The actual connection status is = {amqpConnectionStatuses[i].LastConnectionStatus}");
                            Assert.AreEqual(
                                ConnectionStatusChangeReason.Client_Close,
                                amqpConnectionStatuses[i].LastConnectionStatusChangeReason,
                                $"The actual connection status change reason is = {amqpConnectionStatuses[i].LastConnectionStatusChangeReason}");
                        }
                    }
                    if (deviceConnectionStatusAsExpected)
                    {
                        successfulRuns++;
                    }

                    currentSuccessRate = (int)((double)successfulRuns / totalRuns * 100);
                    reRunTest          = currentSuccessRate < TestSuccessRate;
                }
                finally
                {
                    // Close the service-side components and dispose the device client instances.
                    if (cleanupOperation != null)
                    {
                        await cleanupOperation().ConfigureAwait(false);
                    }

                    foreach (DeviceClient deviceClient in deviceClients)
                    {
                        deviceClient.Dispose();
                    }

                    // Clean up the local lists
                    testDevices.Clear();
                    deviceClients.Clear();
                    amqpConnectionStatuses.Clear();
                }
            } while (reRunTest && totalRuns < MaxTestRunCount);

            Assert.IsFalse(reRunTest, $"Device client instances got disconnected in {totalRuns - successfulRuns} runs out of {totalRuns}; current testSuccessRate = {currentSuccessRate}%.");
        }
        // Error injection template method.
        public static async Task TestErrorInjectionAsync(
            string devicePrefix,
            TestDeviceType type,
            Client.TransportType transport,
            string proxyAddress,
            string faultType,
            string reason,
            int delayInSec,
            int durationInSec,
            Func <DeviceClient, TestDevice, Task> initOperation,
            Func <DeviceClient, TestDevice, Task> testOperation,
            Func <Task> cleanupOperation,
            MsTestLogger logger)
        {
            TestDevice testDevice = await TestDevice.GetTestDeviceAsync(logger, devicePrefix, type).ConfigureAwait(false);

            ITransportSettings transportSettings = CreateTransportSettingsFromName(transport, proxyAddress);
            DeviceClient       deviceClient      = testDevice.CreateDeviceClient(new ITransportSettings[] { transportSettings });

            ConnectionStatus?            lastConnectionStatus             = null;
            ConnectionStatusChangeReason?lastConnectionStatusChangeReason = null;
            int connectionStatusChangeCount = 0;

            deviceClient.SetConnectionStatusChangesHandler((status, statusChangeReason) =>
            {
                connectionStatusChangeCount++;
                lastConnectionStatus             = status;
                lastConnectionStatusChangeReason = statusChangeReason;
                logger.Trace($"{nameof(FaultInjection)}.{nameof(ConnectionStatusChangesHandler)}: status={status} statusChangeReason={statusChangeReason} count={connectionStatusChangeCount}");
            });

            var watch = new Stopwatch();

            try
            {
                await deviceClient.OpenAsync().ConfigureAwait(false);

                if (transport != Client.TransportType.Http1)
                {
                    Assert.IsTrue(connectionStatusChangeCount >= 1, $"The expected connection status change should be equal or greater than 1 but was {connectionStatusChangeCount}"); // Normally one connection but in some cases, due to network issues we might have already retried several times to connect.
                    Assert.AreEqual(ConnectionStatus.Connected, lastConnectionStatus, $"The expected connection status should be {ConnectionStatus.Connected} but was {lastConnectionStatus}");
                    Assert.AreEqual(ConnectionStatusChangeReason.Connection_Ok, lastConnectionStatusChangeReason, $"The expected connection status change reason should be {ConnectionStatusChangeReason.Connection_Ok} but was {lastConnectionStatusChangeReason}");
                }

                await initOperation(deviceClient, testDevice).ConfigureAwait(false);

                logger.Trace($">>> {nameof(FaultInjection)} Testing baseline");
                await testOperation(deviceClient, testDevice).ConfigureAwait(false);

                int countBeforeFaultInjection = connectionStatusChangeCount;
                watch.Start();
                logger.Trace($">>> {nameof(FaultInjection)} Testing fault handling");
                await ActivateFaultInjectionAsync(transport, faultType, reason, delayInSec, durationInSec, deviceClient, logger).ConfigureAwait(false);

                logger.Trace($"{nameof(FaultInjection)}: Waiting for fault injection to be active: {delayInSec} seconds.");
                await Task.Delay(TimeSpan.FromSeconds(delayInSec)).ConfigureAwait(false);

                // For disconnect type faults, the device should disconnect and recover.
                if (FaultShouldDisconnect(faultType))
                {
                    logger.Trace($"{nameof(FaultInjection)}: Confirming fault injection has been activated.");
                    // Check that service issued the fault to the faulting device
                    bool isFaulted = false;
                    for (int i = 0; i < LatencyTimeBufferInSec; i++)
                    {
                        if (connectionStatusChangeCount > countBeforeFaultInjection)
                        {
                            isFaulted = true;
                            break;
                        }

                        await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false);
                    }

                    Assert.IsTrue(isFaulted, $"The device {testDevice.Id} did not get faulted with fault type: {faultType}");
                    logger.Trace($"{nameof(FaultInjection)}: Confirmed fault injection has been activated.");

                    // Check the device is back online
                    logger.Trace($"{nameof(FaultInjection)}: Confirming device back online.");
                    for (int i = 0; lastConnectionStatus != ConnectionStatus.Connected && i < durationInSec + LatencyTimeBufferInSec; i++)
                    {
                        await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false);
                    }

                    Assert.AreEqual(ConnectionStatus.Connected, lastConnectionStatus, $"{testDevice.Id} did not reconnect.");
                    logger.Trace($"{nameof(FaultInjection)}: Confirmed device back online.");

                    // Perform the test operation.
                    logger.Trace($">>> {nameof(FaultInjection)}: Performing test operation for device {testDevice.Id}.");
                    await testOperation(deviceClient, testDevice).ConfigureAwait(false);
                }
                else
                {
                    logger.Trace($"{nameof(FaultInjection)}: Performing test operation while fault injection is being activated.");
                    // Perform the test operation for the faulted device multi times.
                    for (int i = 0; i < LatencyTimeBufferInSec; i++)
                    {
                        logger.Trace($">>> {nameof(FaultInjection)}: Performing test operation for device - Run {i}.");
                        await testOperation(deviceClient, testDevice).ConfigureAwait(false);

                        await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false);
                    }
                }

                await deviceClient.CloseAsync().ConfigureAwait(false);

                if (transport != Client.TransportType.Http1)
                {
                    if (FaultInjection.FaultShouldDisconnect(faultType))
                    {
                        // 4 is the minimum notification count: connect, fault, reconnect, disable.
                        // There are cases where the retry must be timed out (i.e. very likely for MQTT where otherwise
                        // we would attempt to send the fault injection forever.)
                        Assert.IsTrue(connectionStatusChangeCount >= 4, $"The expected connection status change count for {testDevice.Id} should be equal or greater than 4 but was {connectionStatusChangeCount}");
                    }
                    else
                    {
                        // 2 is the minimum notification count: connect, disable.
                        // We will monitor the test environment real network stability and switch to >=2 if necessary to
                        // account for real network issues.
                        Assert.IsTrue(connectionStatusChangeCount == 2, $"The expected connection status change count for {testDevice.Id}  should be 2 but was {connectionStatusChangeCount}");
                    }
                    Assert.AreEqual(ConnectionStatus.Disabled, lastConnectionStatus, $"The expected connection status should be {ConnectionStatus.Disabled} but was {lastConnectionStatus}");
                    Assert.AreEqual(ConnectionStatusChangeReason.Client_Close, lastConnectionStatusChangeReason, $"The expected connection status change reason should be {ConnectionStatusChangeReason.Client_Close} but was {lastConnectionStatusChangeReason}");
                }
            }
            finally
            {
                await cleanupOperation().ConfigureAwait(false);

                logger.Trace($"{nameof(FaultInjection)}: Disposing deviceClient {TestLogger.GetHashCode(deviceClient)}");
                deviceClient.Dispose();

                watch.Stop();

                int timeToFinishFaultInjection = durationInSec * 1000 - (int)watch.ElapsedMilliseconds;
                if (timeToFinishFaultInjection > 0)
                {
                    logger.Trace($"{nameof(FaultInjection)}: Waiting {timeToFinishFaultInjection}ms to ensure that FaultInjection duration passed.");
                    await Task.Delay(timeToFinishFaultInjection).ConfigureAwait(false);
                }
            }
        }