public async Task GetDeviceForJoinRequestAsync_When_Join_Handled_By_Other_Cache_Is_Updated(bool joinedDevice)
{
var devNonce = new DevNonce(1);
var apiService = new Mock <LoRaDeviceAPIServiceBase>();
var otaaDevice = TestDeviceInfo.CreateOTAADevice(1);
if (joinedDevice)
{
otaaDevice.AppSKey = new AppSessionKey();
}
var simulatedDevice = new SimulatedDevice(otaaDevice);
apiService.Setup(x => x.SearchAndLockForJoinAsync(ServerConfiguration.GatewayID, simulatedDevice.DevEUI, devNonce))
.ReturnsAsync(new SearchDevicesResult()
{
IsDevNonceAlreadyUsed = true
});
DeviceCache.Register(CreateLoRaDevice(simulatedDevice));
using var target = new LoRaDeviceRegistry(ServerConfiguration, this.cache, apiService.Object, this.loraDeviceFactoryMock.Object, DeviceCache);
Assert.Null(await target.GetDeviceForJoinRequestAsync(simulatedDevice.DevEUI, devNonce));
Assert.Equal(joinedDevice, !DeviceCache.TryGetByDevEui(simulatedDevice.DevEUI, out _));
}
public async Task When_Devices_From_Another_Gateway_Is_Cached_Return_Null()
{
var simulatedDevice1 = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1, gatewayID: "another-gateway"));
using var loraDevice1 = TestUtils.CreateFromSimulatedDevice(simulatedDevice1, ConnectionManager);
loraDevice1.IsOurDevice = false;
DeviceCache.Register(loraDevice1);
var payload = simulatedDevice1.CreateUnconfirmedDataUpMessage("1234");
var apiService = new Mock <LoRaDeviceAPIServiceBase>(MockBehavior.Strict);
using var target = new LoRaDeviceRegistry(ServerConfiguration, this.cache, apiService.Object, this.loraDeviceFactoryMock.Object, DeviceCache);
using var request = WaitableLoRaRequest.Create(payload);
var queue = target.GetLoRaRequestQueue(request);
queue.Queue(request);
Assert.IsType <ExternalGatewayLoRaRequestQueue>(queue);
Assert.True(await request.WaitCompleteAsync());
Assert.True(request.ProcessingFailed);
Assert.Equal(LoRaDeviceRequestFailedReason.BelongsToAnotherGateway, request.ProcessingFailedReason);
// Device was searched by DevAddr
apiService.VerifyAll();
// Device was created by factory
this.loraDeviceFactoryMock.VerifyAll();
}
public async Task When_Fcnt_Down_Fails_Should_Stop_And_Not_Update_Device_Twin(uint initialFcntDown, uint initialFcntUp, uint payloadFcnt)
{
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1, gatewayID: null))
{
FrmCntDown = initialFcntDown,
FrmCntUp = initialFcntUp
};
var devEui = simulatedDevice.LoRaDevice.DevEui;
var devAddr = simulatedDevice.LoRaDevice.DevAddr;
LoRaDeviceApi
.Setup(x => x.ExecuteFunctionBundlerAsync(devEui, It.IsAny <FunctionBundlerRequest>()))
.ReturnsAsync(() =>
new FunctionBundlerResult
{
AdrResult = new LoRaTools.ADR.LoRaADRResult {
CanConfirmToDevice = true, FCntDown = 0
},
NextFCntDown = 0
});
LoRaDeviceApi.Setup(x => x.ABPFcntCacheResetAsync(devEui, It.IsAny <uint>(), It.IsNotNull <string>()))
.ReturnsAsync(true);
using var memoryCache = new MemoryCache(new MemoryCacheOptions());
var device = CreateLoRaDevice(simulatedDevice);
DeviceCache.Register(device);
using var deviceRegistry = new LoRaDeviceRegistry(ServerConfiguration, memoryCache, LoRaDeviceApi.Object, LoRaDeviceFactory, DeviceCache);
// Send to message processor
using var messageDispatcher = new MessageDispatcher(
ServerConfiguration,
deviceRegistry,
FrameCounterUpdateStrategyProvider);
// sends unconfirmed message
var unconfirmedMessagePayload = simulatedDevice.CreateConfirmedDataUpMessage("hello", fcnt: payloadFcnt);
using var request = CreateWaitableRequest(unconfirmedMessagePayload);
messageDispatcher.DispatchRequest(request);
Assert.True(await request.WaitCompleteAsync());
Assert.Null(request.ResponseDownlink);
// verify that the device in device registry has correct properties and frame counters
Assert.True(DeviceCache.TryGetForPayload(request.Payload, out var loRaDevice));
Assert.Equal(devAddr, loRaDevice.DevAddr);
Assert.Equal(devEui, loRaDevice.DevEUI);
Assert.True(loRaDevice.IsABP);
Assert.Equal(initialFcntUp, loRaDevice.FCntUp);
Assert.Equal(initialFcntDown, loRaDevice.FCntDown);
Assert.False(loRaDevice.HasFrameCountChanges);
LoRaDeviceClient.VerifyAll();
LoRaDeviceApi.VerifyAll();
}
public async Task When_Device_With_Downlink_Disabled_Received_Unconfirmed_Data_Should_Not_Check_For_C2D(string deviceGatewayID)
{
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1, gatewayID: deviceGatewayID));
// message will be sent
LoRaDeviceClient.Setup(x => x.SendEventAsync(It.IsNotNull <LoRaDeviceTelemetry>(), null))
.ReturnsAsync(true);
if (string.IsNullOrEmpty(deviceGatewayID))
{
LoRaDeviceApi.Setup(x => x.ABPFcntCacheResetAsync(It.IsNotNull <DevEui>(), It.IsAny <uint>(), It.IsNotNull <string>()))
.ReturnsAsync(true);
}
using var memoryCache = new MemoryCache(new MemoryCacheOptions());
var cachedDevice = CreateLoRaDevice(simulatedDevice);
cachedDevice.DownlinkEnabled = false;
DeviceCache.Register(cachedDevice);
using var deviceRegistry = new LoRaDeviceRegistry(ServerConfiguration, memoryCache, LoRaDeviceApi.Object, LoRaDeviceFactory, DeviceCache);
// Send to message processor
using var messageProcessor = new MessageDispatcher(
ServerConfiguration,
deviceRegistry,
FrameCounterUpdateStrategyProvider);
// sends unconfirmed message
var unconfirmedMessagePayload = simulatedDevice.CreateUnconfirmedDataUpMessage("1234");
using var request = CreateWaitableRequest(unconfirmedMessagePayload);
messageProcessor.DispatchRequest(request);
Assert.True(await request.WaitCompleteAsync());
Assert.Null(request.ResponseDownlink);
Assert.True(request.ProcessingSucceeded);
LoRaDeviceClient.Verify(x => x.ReceiveAsync(It.IsAny <TimeSpan>()), Times.Never());
LoRaDeviceClient.VerifyAll();
LoRaDeviceApi.VerifyAll();
}
public async Task When_Multiple_Devices_With_Same_DevAddr_Are_Cached_Should_Find_Matching_By_Mic(string deviceGatewayID)
{
var connectionManager = new Mock <ILoRaDeviceClientConnectionManager>();
var simulatedDevice1 = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1, gatewayID: deviceGatewayID));
using var loraDevice1 = TestUtils.CreateFromSimulatedDevice(simulatedDevice1, connectionManager.Object);
var simulatedDevice2 = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1, gatewayID: ServerConfiguration.GatewayID));
simulatedDevice2.LoRaDevice.DeviceID = new DevEui(2).ToString();
simulatedDevice2.LoRaDevice.NwkSKey = TestKeys.CreateNetworkSessionKey(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF);
using var loraDevice2 = TestUtils.CreateFromSimulatedDevice(simulatedDevice2, connectionManager.Object);
DeviceCache.Register(loraDevice1);
DeviceCache.Register(loraDevice2);
var payload = simulatedDevice1.CreateUnconfirmedDataUpMessage("1234");
var apiService = new Mock <LoRaDeviceAPIServiceBase>();
using var request = WaitableLoRaRequest.Create(payload);
var requestHandler = new Mock <ILoRaDataRequestHandler>(MockBehavior.Strict);
requestHandler.Setup(x => x.ProcessRequestAsync(request, loraDevice1))
.ReturnsAsync(new LoRaDeviceRequestProcessResult(loraDevice1, request));
loraDevice1.SetRequestHandler(requestHandler.Object);
using var target = new LoRaDeviceRegistry(ServerConfiguration, this.cache, apiService.Object, this.loraDeviceFactoryMock.Object, DeviceCache);
target.GetLoRaRequestQueue(request).Queue(request);
Assert.True(await request.WaitCompleteAsync());
Assert.True(request.ProcessingSucceeded);
// Device was searched by DevAddr
apiService.VerifyAll();
// Device was created by factory
this.loraDeviceFactoryMock.VerifyAll();
requestHandler.VerifyAll();
}
public void When_Cache_Clear_Is_Called_Should_Removed_Cached_Devices(string deviceGatewayID)
{
LoRaDeviceClient.Setup(ldc => ldc.Dispose());
const int deviceCount = 10;
var deviceList = new HashSet <LoRaDevice>();
var apiService = new Mock <LoRaDeviceAPIServiceBase>();
var deviceFactory = new TestLoRaDeviceFactory(LoRaDeviceClient.Object, DeviceCache);
using var target = new LoRaDeviceRegistry(ServerConfiguration, this.cache, apiService.Object, deviceFactory, DeviceCache);
using var connectionManager = new SingleDeviceConnectionManager(LoRaDeviceClient.Object);
for (var deviceID = 1; deviceID <= deviceCount; ++deviceID)
{
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice((uint)deviceID, gatewayID: deviceGatewayID));
#pragma warning disable CA2000 // Dispose objects before losing scope - transfer ownership
var device = TestUtils.CreateFromSimulatedDevice(simulatedDevice, connectionManager);
#pragma warning restore CA2000 // Dispose objects before losing scope
DeviceCache.Register(device);
deviceList.Add(device);
}
Assert.Equal(deviceCount, DeviceCache.CalculateStatistics().Count);
// Device was searched by DevAddr
apiService.VerifyAll();
// Device was created by factory
this.loraDeviceFactoryMock.VerifyAll();
// ensure all devices are in cache
Assert.Equal(deviceCount, deviceList.Count(x => DeviceCache.TryGetByDevEui(x.DevEUI, out _)));
target.ResetDeviceCache();
Assert.False(deviceList.Any(x => DeviceCache.TryGetByDevEui(x.DevEUI, out _)), "Should not find devices again");
}
public async Task When_Device_With_Downlink_Disabled_Received_Confirmed_Data_Should_Not_Check_For_C2D(string deviceGatewayID)
{
const int payloadFcnt = 10;
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1, gatewayID: deviceGatewayID));
var devEUI = simulatedDevice.LoRaDevice.DevEui;
// message will be sent
LoRaDeviceClient.Setup(x => x.SendEventAsync(It.IsNotNull <LoRaDeviceTelemetry>(), null))
.ReturnsAsync(true);
this.LoRaDeviceClient.Setup(x => x.UpdateReportedPropertiesAsync(It.IsAny <TwinCollection>(), It.IsAny <CancellationToken>())).ReturnsAsync(true);
// multi gateway will ask for next fcnt down
var isMultigateway = string.IsNullOrEmpty(deviceGatewayID);
if (isMultigateway)
{
LoRaDeviceApi.Setup(x => x.NextFCntDownAsync(devEUI, simulatedDevice.FrmCntDown, payloadFcnt, ServerConfiguration.GatewayID))
.ReturnsAsync((ushort)(simulatedDevice.FrmCntDown + 1));
// if we run with ADR, we will combine the call with the bundler
LoRaDeviceApi
.Setup(x => x.ExecuteFunctionBundlerAsync(devEUI, It.IsAny <FunctionBundlerRequest>()))
.ReturnsAsync(() =>
new FunctionBundlerResult
{
AdrResult = new LoRaTools.ADR.LoRaADRResult
{
// Todo check
CanConfirmToDevice = false,
FCntDown = simulatedDevice.FrmCntDown + 1,
NbRepetition = 1,
TxPower = 0
},
NextFCntDown = simulatedDevice.FrmCntDown + 1
});
}
using var memoryCache = new MemoryCache(new MemoryCacheOptions());
var cachedDevice = CreateLoRaDevice(simulatedDevice);
cachedDevice.DownlinkEnabled = false;
DeviceCache.Register(cachedDevice);
using var deviceRegistry = new LoRaDeviceRegistry(ServerConfiguration, memoryCache, LoRaDeviceApi.Object, LoRaDeviceFactory, DeviceCache);
// Send to message processor
using var messageProcessor = new MessageDispatcher(
ServerConfiguration,
deviceRegistry,
FrameCounterUpdateStrategyProvider);
// sends confirmed message
var payload = simulatedDevice.CreateConfirmedDataUpMessage("1234", fcnt: payloadFcnt);
using var request = CreateWaitableRequest(payload);
messageProcessor.DispatchRequest(request);
Assert.True(await request.WaitCompleteAsync());
Assert.NotNull(request.ResponseDownlink);
Assert.True(request.ProcessingSucceeded);
Assert.Single(DownstreamMessageSender.DownlinkMessages);
LoRaDeviceClient.Verify(x => x.ReceiveAsync(It.IsAny <TimeSpan>()), Times.Never());
LoRaDeviceClient.VerifyAll();
if (isMultigateway && ((LoRaPayloadData)request.Payload).IsDataRateNetworkControlled)
{
LoRaDeviceApi.Verify(x => x.ExecuteFunctionBundlerAsync(devEUI, It.IsAny <FunctionBundlerRequest>()));
}
}
public async Task When_Queueing_To_Multiple_Devices_With_Same_DevAddr_Should_Queue_To_Device_Matching_Mic(string deviceGatewayID)
{
var simulatedDevice1 = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1, gatewayID: deviceGatewayID));
var payload = simulatedDevice1.CreateUnconfirmedDataUpMessage("1234");
var loRaDeviceClient1 = new Mock <ILoRaDeviceClient>(MockBehavior.Loose);
loRaDeviceClient1.Setup(x => x.GetTwinAsync(CancellationToken.None))
.ReturnsAsync(simulatedDevice1.CreateABPTwin());
using var connectionManager1 = new SingleDeviceConnectionManager(loRaDeviceClient1.Object);
using var loraDevice1 = TestUtils.CreateFromSimulatedDevice(simulatedDevice1, connectionManager1);
var devAddr = loraDevice1.DevAddr.Value;
var reqHandler1 = new Mock <ILoRaDataRequestHandler>(MockBehavior.Strict);
reqHandler1.Setup(x => x.ProcessRequestAsync(It.IsNotNull <LoRaRequest>(), loraDevice1))
.ReturnsAsync(new LoRaDeviceRequestProcessResult(loraDevice1, null));
loraDevice1.SetRequestHandler(reqHandler1.Object);
var simulatedDevice2 = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1, gatewayID: deviceGatewayID));
simulatedDevice2.LoRaDevice.DeviceID = new DevEui(2).ToString();
simulatedDevice2.LoRaDevice.NwkSKey = TestKeys.CreateNetworkSessionKey(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF);
var loRaDeviceClient2 = new Mock <ILoRaDeviceClient>(MockBehavior.Loose);
loRaDeviceClient2.Setup(x => x.GetTwinAsync(CancellationToken.None))
.ReturnsAsync(simulatedDevice2.CreateABPTwin());
using var connectionManager2 = new SingleDeviceConnectionManager(loRaDeviceClient2.Object);
using var loraDevice2 = TestUtils.CreateFromSimulatedDevice(simulatedDevice2, connectionManager2);
// Api service: search devices async
var iotHubDeviceInfo1 = new IoTHubDeviceInfo(devAddr, loraDevice1.DevEUI, string.Empty);
var iotHubDeviceInfo2 = new IoTHubDeviceInfo(devAddr, loraDevice2.DevEUI, string.Empty);
var apiService = new Mock <LoRaDeviceAPIServiceBase>();
apiService.Setup(x => x.SearchByDevAddrAsync(devAddr))
.ReturnsAsync(new SearchDevicesResult(new IoTHubDeviceInfo[]
{
iotHubDeviceInfo2,
iotHubDeviceInfo1,
}));
// Device factory: create 2 devices
this.loraDeviceFactoryMock.Setup(x => x.CreateAndRegisterAsync(iotHubDeviceInfo1, It.IsAny <CancellationToken>())).ReturnsAsync(() => {
DeviceCache.Register(loraDevice1);
return(loraDevice1);
});
this.loraDeviceFactoryMock.Setup(x => x.CreateAndRegisterAsync(iotHubDeviceInfo2, It.IsAny <CancellationToken>())).ReturnsAsync(() => {
DeviceCache.Register(loraDevice2);
return(loraDevice2);
});
using var target = new LoRaDeviceRegistry(ServerConfiguration, this.cache, apiService.Object, this.loraDeviceFactoryMock.Object, DeviceCache);
using var request = WaitableLoRaRequest.Create(payload);
target.GetLoRaRequestQueue(request).Queue(request);
Assert.True(await request.WaitCompleteAsync());
Assert.True(request.ProcessingSucceeded);
// Device was searched by DevAddr
apiService.VerifyAll();
// Device was created by factory
this.loraDeviceFactoryMock.VerifyAll();
// Both devices are in cache
Assert.Equal(2, DeviceCache.RegistrationCount(devAddr)); // 2 devices with same devAddr exist in cache
// find device 1
Assert.True(DeviceCache.TryGetForPayload(request.Payload, out var actualCachedLoRaDevice1));
Assert.Same(loraDevice1, actualCachedLoRaDevice1);
Assert.True(loraDevice1.IsOurDevice);
// find device 2
Assert.True(DeviceCache.TryGetByDevEui(loraDevice2.DevEUI, out var actualCachedLoRaDevice2));
Assert.Same(loraDevice2, actualCachedLoRaDevice2);
Assert.True(loraDevice2.IsOurDevice);
reqHandler1.VerifyAll();
}