public async Task When_Device_Api_Throws_Error_Should_Not_Create_Any_Device()
        {
            var devAddr = new DevAddr(0x039090);

            var apiService = new Mock <LoRaDeviceAPIServiceBase>(MockBehavior.Strict);

            apiService.Setup(x => x.SearchByDevAddrAsync(It.IsAny <DevAddr>()))
            .Throws(new InvalidOperationException());

            var deviceFactory = new Mock <ILoRaDeviceFactory>(MockBehavior.Strict);

            using var deviceCache = LoRaDeviceCacheDefault.CreateDefault();
            var target = new DeviceLoaderSynchronizer(
                devAddr,
                apiService.Object,
                deviceFactory.Object,
                new NetworkServerConfiguration(),
                deviceCache,
                null,
                NullLogger <DeviceLoaderSynchronizer> .Instance);

            var ex = await Assert.ThrowsAsync <LoRaProcessingException>(async() => await target.LoadAsync());

            Assert.IsType <InvalidOperationException>(ex.InnerException);

            Assert.Equal(0, deviceCache.CalculateStatistics().Count);

            // Device was searched by DevAddr
            apiService.VerifyAll();
        }
示例#2
0
        public async Task When_Not_In_Cache_It_Is_Loaded()
        {
            using var cache = LoRaDeviceCacheDefault.CreateDefault();
            var factory = new Mock <ILoRaDeviceFactory>();

            using var joinDeviceLoader = new JoinDeviceLoader(DefaultDeviceInfo, factory.Object, cache, NullLogger <JoinDeviceLoader> .Instance);

            await joinDeviceLoader.LoadAsync();

            factory.Verify(x => x.CreateAndRegisterAsync(DefaultDeviceInfo, It.IsAny <CancellationToken>()), Times.Once);
            Assert.True(joinDeviceLoader.CanCache);
        }
示例#3
0
        public async Task When_The_Load_Fails_CanCache_Is_False()
        {
            using var cache = LoRaDeviceCacheDefault.CreateDefault();
            var factory = new Mock <ILoRaDeviceFactory>();

            factory.Setup(x => x.CreateAndRegisterAsync(DefaultDeviceInfo, It.IsAny <CancellationToken>()))
            .ThrowsAsync(new LoRaProcessingException());

            using var joinDeviceLoader = new JoinDeviceLoader(DefaultDeviceInfo, factory.Object, cache, NullLogger <JoinDeviceLoader> .Instance);

            Assert.Null(await joinDeviceLoader.LoadAsync());
            Assert.False(joinDeviceLoader.CanCache);
        }
        public async Task When_Device_Does_Not_Exist_Should_Complete_Requests_As_Failed(int loadDevicesDurationInMs)
        {
            var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1));
            var devAddr         = simulatedDevice.DevAddr.Value;
            var payload1        = simulatedDevice.CreateUnconfirmedDataUpMessage("1");

            var apiService = new Mock <LoRaDeviceAPIServiceBase>();
            var searchMock = apiService.Setup(x => x.SearchByDevAddrAsync(devAddr));

            if (loadDevicesDurationInMs > 0)
            {
                searchMock.ReturnsAsync(new SearchDevicesResult(), TimeSpan.FromMilliseconds(loadDevicesDurationInMs));
            }
            else
            {
                searchMock.ReturnsAsync(new SearchDevicesResult());
            }

            var deviceFactory = new Mock <ILoRaDeviceFactory>(MockBehavior.Strict);

            using var deviceCache = LoRaDeviceCacheDefault.CreateDefault();
            var target = new DeviceLoaderSynchronizer(
                devAddr,
                apiService.Object,
                deviceFactory.Object,
                new NetworkServerConfiguration(),
                deviceCache,
                null,
                NullLogger <DeviceLoaderSynchronizer> .Instance);

            _ = target.LoadAsync();

            using var req1 = WaitableLoRaRequest.Create(payload1);
            target.Queue(req1);

            Assert.True(await req1.WaitCompleteAsync());
            Assert.Equal(LoRaDeviceRequestFailedReason.NotMatchingDeviceByDevAddr, req1.ProcessingFailedReason);

            var payload2 = simulatedDevice.CreateUnconfirmedDataUpMessage("2");

            using var req2 = WaitableLoRaRequest.Create(payload2);
            target.Queue(req2);

            Assert.True(await req2.WaitCompleteAsync());
            Assert.Equal(LoRaDeviceRequestFailedReason.NotMatchingDeviceByDevAddr, req2.ProcessingFailedReason);

            // Device was searched by DevAddr
            apiService.VerifyAll();
        }
        public async Task When_Device_Does_Not_Match_Gateway_Should_Fail_Request()
        {
            var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1, gatewayID: "a_different_one"));
            var payload         = simulatedDevice.CreateUnconfirmedDataUpMessage("1234");

            var apiService       = new Mock <LoRaDeviceAPIServiceBase>();
            var iotHubDeviceInfo = new IoTHubDeviceInfo(simulatedDevice.LoRaDevice.DevAddr, simulatedDevice.LoRaDevice.DevEui, "pk")
            {
                GatewayId = "a_different_one",
                NwkSKey   = simulatedDevice.NwkSKey.Value
            };

            apiService.Setup(x => x.SearchByDevAddrAsync(It.IsAny <DevAddr>()))
            .ReturnsAsync(new SearchDevicesResult(iotHubDeviceInfo.AsList()));

            var loRaDeviceClient = new Mock <ILoRaDeviceClient>(MockBehavior.Loose);

            using var deviceCache = LoRaDeviceCacheDefault.CreateDefault();
            var deviceFactory = new TestLoRaDeviceFactory(loRaDeviceClient.Object, deviceCache, this.connectionManager);
            var target        = new DeviceLoaderSynchronizer(
                simulatedDevice.DevAddr.Value,
                apiService.Object,
                deviceFactory,
                new NetworkServerConfiguration(),
                deviceCache,
                null,
                NullLogger <DeviceLoaderSynchronizer> .Instance);

            _ = target.LoadAsync();

            using var request = WaitableLoRaRequest.Create(payload);
            target.Queue(request);
            Assert.True(await request.WaitCompleteAsync());
            Assert.True(request.ProcessingFailed);
            Assert.Equal(LoRaDeviceRequestFailedReason.BelongsToAnotherGateway, request.ProcessingFailedReason);

            // device should not be initialized, since it belongs to another gateway
            loRaDeviceClient.Verify(x => x.GetTwinAsync(CancellationToken.None), Times.Never());

            // device should not be disconnected (was never connected)
            loRaDeviceClient.Verify(x => x.Disconnect(), Times.Never());

            // Device was searched by DevAddr
            apiService.VerifyAll();

            // Device was created by factory
            loRaDeviceClient.VerifyAll();
        }
        public async Task When_Device_Is_Not_In_Cache_And_Found_In_Api_Does_Not_Match_Mic_Should_Fail_Request(string deviceGatewayID)
        {
            var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1, gatewayID: deviceGatewayID));

            var apiService       = new Mock <LoRaDeviceAPIServiceBase>();
            var iotHubDeviceInfo = new IoTHubDeviceInfo(simulatedDevice.LoRaDevice.DevAddr, simulatedDevice.LoRaDevice.DevEui, "pk");

            apiService.Setup(x => x.SearchByDevAddrAsync(It.IsAny <DevAddr>()))
            .ReturnsAsync(new SearchDevicesResult(iotHubDeviceInfo.AsList()));

            // Will get device twin
            var loRaDeviceClient = new Mock <ILoRaDeviceClient>(MockBehavior.Loose);

            loRaDeviceClient.Setup(x => x.GetTwinAsync(CancellationToken.None))
            .ReturnsAsync(TestUtils.CreateABPTwin(simulatedDevice));

            using var deviceCache = LoRaDeviceCacheDefault.CreateDefault();
            var deviceFactory = new TestLoRaDeviceFactory(loRaDeviceClient.Object, deviceCache, this.connectionManager);
            var target        = new DeviceLoaderSynchronizer(
                simulatedDevice.DevAddr.Value,
                apiService.Object,
                deviceFactory,
                new NetworkServerConfiguration(),
                deviceCache,
                null,
                NullLogger <DeviceLoaderSynchronizer> .Instance);

            _ = target.LoadAsync();

            var payload = simulatedDevice.CreateUnconfirmedDataUpMessage("1234", appSKey: simulatedDevice.AppSKey, nwkSKey: TestKeys.CreateNetworkSessionKey(0xEEAAFF));

            using var request = WaitableLoRaRequest.Create(payload);
            target.Queue(request);
            Assert.True(await request.WaitCompleteAsync());
            Assert.True(request.ProcessingFailed);
            Assert.Equal(LoRaDeviceRequestFailedReason.NotMatchingDeviceByMicCheck, request.ProcessingFailedReason);

            // Device was searched by DevAddr
            apiService.VerifyAll();
            loRaDeviceClient.VerifyAll();
        }
示例#7
0
        public async Task When_One_Load_Is_Pending_Other_Is_Waiting()
        {
            using var cache = LoRaDeviceCacheDefault.CreateDefault();
            var factory = new Mock <ILoRaDeviceFactory>();

            using var device = new LoRaDevice(DefaultDeviceInfo.DevAddr, DefaultDeviceInfo.DevEUI, null);

            factory.Setup(x => x.CreateAndRegisterAsync(DefaultDeviceInfo, It.IsAny <CancellationToken>()))
            .ReturnsAsync(() =>
            {
                cache.Register(device);
                return(device);
            });

            using var joinDeviceLoader = new JoinDeviceLoader(DefaultDeviceInfo, factory.Object, cache, NullLogger <JoinDeviceLoader> .Instance);

            var t1 = joinDeviceLoader.LoadAsync();
            var t2 = joinDeviceLoader.LoadAsync();

            Assert.All(await Task.WhenAll(t1, t2), x => Assert.Equal(device, x));
            factory.Verify(x => x.CreateAndRegisterAsync(DefaultDeviceInfo, It.IsAny <CancellationToken>()), Times.Once);
        }
 private static LoRaDeviceCache CreateDefaultCache()
 => LoRaDeviceCacheDefault.CreateDefault();