public async Task Should_Abandon(
bool isConfirmed,
bool hasMacInUpstream,
bool hasMacInC2D,
[CombinatorialValues("SF9BW125", "SF8BW125", "SF7BW125")] string datr)
{
const int InitialDeviceFcntUp = 9;
const int InitialDeviceFcntDown = 20;
var simulatedDevice = new SimulatedDevice(
TestDeviceInfo.CreateABPDevice(1, gatewayID: ServerConfiguration.GatewayID),
frmCntUp: InitialDeviceFcntUp,
frmCntDown: InitialDeviceFcntDown);
var loraDevice = CreateLoRaDevice(simulatedDevice);
var msgPayload = "1234567890";
var confirmedMessagePayload = simulatedDevice.CreateConfirmedDataUpMessage(msgPayload, isHexPayload: true, fport: 0);
var(radioMetaData, loraPayload) = CreateUpstreamMessage(isConfirmed, hasMacInUpstream, LoRaDataRate.Parse(datr), simulatedDevice);
if (!hasMacInUpstream)
{
LoRaDeviceClient.Setup(x => x.SendEventAsync(It.IsNotNull <LoRaDeviceTelemetry>(), null))
.ReturnsAsync(true);
}
var euRegion = RegionManager.EU868;
var c2dMessageMacCommand = new DevStatusRequest();
var c2dMessageMacCommandSize = hasMacInC2D ? c2dMessageMacCommand.Length : 0;
DataRateIndex expectedDownlinkDatr;
expectedDownlinkDatr = euRegion.GetDataRateIndex(euRegion.DRtoConfiguration[euRegion.GetDefaultRX2ReceiveWindow(default).DataRate].DataRate);
public void When_Cache_Clear_Is_Called_Should_Removed_Cached_Devices(string deviceGatewayID)
{
const int deviceCount = 10;
var deviceList = new HashSet<LoRaDevice>();
var apiService = new Mock<LoRaDeviceAPIServiceBase>();
var deviceFactory = new TestLoRaDeviceFactory(this.loRaDeviceClient.Object);
var target = new LoRaDeviceRegistry(this.serverConfiguration, this.cache, apiService.Object, deviceFactory);
var getTwinMockSequence = this.loRaDeviceClient.SetupSequence(x => x.GetTwinAsync());
for (var deviceID = 1; deviceID <= deviceCount; ++deviceID)
{
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice((uint)deviceID, gatewayID: deviceGatewayID));
var dict = target.InternalGetCachedDevicesForDevAddr(simulatedDevice.DevAddr);
var device = TestUtils.CreateFromSimulatedDevice(simulatedDevice, this.loRaDeviceClient.Object);
deviceList.Add(device);
dict.TryAdd(simulatedDevice.DevEUI, device);
}
Assert.Equal(deviceCount, this.cache.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 => target.InternalGetCachedDevicesForDevAddr(x.DevAddr).Count == 1));
target.ResetDeviceCache();
Assert.False(deviceList.Any(x => target.InternalGetCachedDevicesForDevAddr(x.DevAddr).Count > 0), "Should not find devices again");
}
// Ensures that Mac Commands C2D messages working
// Uses Device23_OTAA
private async Task Test_OTAA_Unconfirmed_Send_And_Receive_C2D_Mac_Commands(TestDeviceInfo device)
{
await ArduinoDevice.setDeviceModeAsync(LoRaArduinoSerial._device_mode_t.LWOTAA);
await ArduinoDevice.setIdAsync(device.DevAddr, device.DeviceID, device.AppEui);
await ArduinoDevice.setKeyAsync(device.NwkSKey, device.AppSKey, device.AppKey);
await ArduinoDevice.SetupLora(TestFixtureCi.Configuration);
var joinSucceeded = await ArduinoDevice.setOTAAJoinAsyncWithRetry(LoRaArduinoSerial._otaa_join_cmd_t.JOIN, 20000, 5);
Assert.True(joinSucceeded, "Join failed");
// wait 1 second after joined
await Task.Delay(Constants.DELAY_FOR_SERIAL_AFTER_JOIN);
if (device.IsMultiGw)
{
await TestFixtureCi.WaitForTwinSyncAfterJoinAsync(ArduinoDevice.SerialLogs, device.DevEui);
}
await Test_OTAA_Unconfirmed_Send_And_Receive_C2D_Mac_CommandsImplAsync(device, "test");
await Test_OTAA_Unconfirmed_Send_And_Receive_C2D_Mac_CommandsImplAsync(device, string.Empty);
}
private async Task SendABPMessages(int messages_count, TestDeviceInfo device)
{
await ArduinoDevice.setDeviceModeAsync(LoRaArduinoSerial._device_mode_t.LWABP);
await ArduinoDevice.setIdAsync(device.DevAddr, device.DeviceID, null);
await ArduinoDevice.setKeyAsync(device.NwkSKey, device.AppSKey, null);
await ArduinoDevice.SetupLora(TestFixtureCi.Configuration);
// Sends 10x unconfirmed messages
for (var i = 0; i < messages_count; ++i)
{
var msg = GeneratePayloadMessage();
Log($"{device.DeviceID}: Sending unconfirmed '{msg}' {i + 1}/{messages_count}");
await ArduinoDevice.transferPacketAsync(msg, 10);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
// After transferPacket: Expectation from serial
// +MSG: Done
await AssertUtils.ContainsWithRetriesAsync("+MSG: Done", ArduinoDevice.SerialLogs);
// 0000000000000005: valid frame counter, msg: 1 server: 0
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: valid frame counter, msg:");
// 0000000000000005: decoding with: DecoderValueSensor port: 8
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: decoding with: {device.SensorDecoder} port:");
// 0000000000000005: message '{"value": 51}' sent to hub
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: message '{{\"value\":{msg}}}' sent to hub");
TestFixtureCi.ClearLogs();
}
// Sends 10x confirmed messages
for (var i = 0; i < messages_count; ++i)
{
var msg = GeneratePayloadMessage();
Log($"{device.DeviceID}: Sending confirmed '{msg}' {i + 1}/{messages_count}");
await ArduinoDevice.transferPacketWithConfirmedAsync(msg, 10);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
// After transferPacketWithConfirmed: Expectation from serial
// +CMSG: ACK Received
await AssertUtils.ContainsWithRetriesAsync("+CMSG: ACK Received", ArduinoDevice.SerialLogs);
// 0000000000000005: valid frame counter, msg: 1 server: 0
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: valid frame counter, msg:");
// 0000000000000005: decoding with: DecoderValueSensor port: 8
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: decoding with: {device.SensorDecoder} port:");
// 0000000000000005: message '{"value": 51}' sent to hub
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: message '{{\"value\":{msg}}}' sent to hub");
TestFixtureCi.ClearLogs();
}
}
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));
simulatedDevice.FrmCntDown = initialFcntDown;
simulatedDevice.FrmCntUp = initialFcntUp;
var devEUI = simulatedDevice.LoRaDevice.DeviceID;
var devAddr = simulatedDevice.LoRaDevice.DevAddr;
this.LoRaDeviceApi.Setup(x => x.ExecuteFunctionBundlerAsync(devEUI, It.IsAny <FunctionBundlerRequest>())).ReturnsAsync(() => new FunctionBundlerResult
{
AdrResult = new LoRaTools.ADR.LoRaADRResult {
CanConfirmToDevice = true, FCntDown = 0
},
NextFCntDown = 0
});
this.LoRaDeviceApi.Setup(x => x.ABPFcntCacheResetAsync(devEUI, It.IsAny <uint>(), It.IsNotNull <string>()))
.ReturnsAsync(true);
var memoryCache = new MemoryCache(new MemoryCacheOptions());
var device = this.CreateLoRaDevice(simulatedDevice);
var dicForDevAddr = new DevEUIToLoRaDeviceDictionary();
dicForDevAddr.TryAdd(devEUI, device);
memoryCache.Set(devAddr, dicForDevAddr);
var deviceRegistry = new LoRaDeviceRegistry(this.ServerConfiguration, memoryCache, this.LoRaDeviceApi.Object, this.LoRaDeviceFactory);
// Send to message processor
var messageDispatcher = new MessageDispatcher(
this.ServerConfiguration,
deviceRegistry,
this.FrameCounterUpdateStrategyProvider);
// sends unconfirmed message
var unconfirmedMessagePayload = simulatedDevice.CreateConfirmedDataUpMessage("hello", fcnt: payloadFcnt);
var rxpk = unconfirmedMessagePayload.SerializeUplink(simulatedDevice.AppSKey, simulatedDevice.NwkSKey).Rxpk[0];
var request = this.CreateWaitableRequest(rxpk);
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
var devicesForDevAddr = deviceRegistry.InternalGetCachedDevicesForDevAddr(devAddr);
Assert.Single(devicesForDevAddr);
Assert.True(devicesForDevAddr.TryGetValue(devEUI, 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);
this.LoRaDeviceClient.VerifyAll();
this.LoRaDeviceApi.VerifyAll();
}
public async Task When_Payload_Has_Invalid_Mic_Should_Not_Send_Messages(int searchDevicesDelayMs)
{
// Setup
const string wrongSKey = "00000000000000000000000000EEDDFF";
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1));
var searchResult = new SearchDevicesResult(new IoTHubDeviceInfo(simulatedDevice.DevAddr, simulatedDevice.DevEUI, "1321").AsList());
if (searchDevicesDelayMs > 0)
{
this.LoRaDeviceApi.Setup(x => x.SearchByDevAddrAsync(simulatedDevice.DevAddr))
.ReturnsAsync(searchResult, TimeSpan.FromMilliseconds(searchDevicesDelayMs));
}
else
{
this.LoRaDeviceApi.Setup(x => x.SearchByDevAddrAsync(simulatedDevice.DevAddr))
.ReturnsAsync(searchResult);
}
this.LoRaDeviceClient.Setup(x => x.GetTwinAsync())
.ReturnsAsync(TestUtils.CreateABPTwin(simulatedDevice));
var deviceRegistry = new LoRaDeviceRegistry(this.ServerConfiguration, this.NewMemoryCache(), this.LoRaDeviceApi.Object, this.LoRaDeviceFactory);
// Send to message processor
var messageProcessor = new MessageDispatcher(
this.ServerConfiguration,
deviceRegistry,
this.FrameCounterUpdateStrategyProvider);
// Send request #1
var payload1 = simulatedDevice.CreateUnconfirmedDataUpMessage("1", fcnt: 2);
var request1 = this.CreateWaitableRequest(payload1.SerializeUplink(simulatedDevice.AppSKey, wrongSKey).Rxpk[0]);
messageProcessor.DispatchRequest(request1);
Assert.True(await request1.WaitCompleteAsync());
Assert.Null(request1.ResponseDownlink);
Assert.True(request1.ProcessingFailed);
Assert.Equal(LoRaDeviceRequestFailedReason.NotMatchingDeviceByMicCheck, request1.ProcessingFailedReason);
await Task.Delay(2000);
Assert.Single(deviceRegistry.InternalGetCachedDevicesForDevAddr(simulatedDevice.DevAddr));
// Send request #2
var payload2 = simulatedDevice.CreateUnconfirmedDataUpMessage("2", fcnt: 3);
var request2 = this.CreateWaitableRequest(payload2.SerializeUplink(simulatedDevice.AppSKey, wrongSKey).Rxpk[0]);
messageProcessor.DispatchRequest(request2);
Assert.True(await request2.WaitCompleteAsync());
Assert.Null(request2.ResponseDownlink);
Assert.True(request2.ProcessingFailed);
Assert.Equal(LoRaDeviceRequestFailedReason.NotMatchingDeviceByMicCheck, request2.ProcessingFailedReason);
Assert.Single(deviceRegistry.InternalGetCachedDevicesForDevAddr(simulatedDevice.DevAddr));
this.LoRaDeviceApi.VerifyAll();
this.LoRaDeviceClient.VerifyAll();
this.LoRaDeviceApi.Verify(x => x.SearchByDevAddrAsync(simulatedDevice.DevAddr), Times.Exactly(1));
}
public async Task When_Device_Is_Not_Joined_Should_Fail()
{
var simDevice = new SimulatedDevice(TestDeviceInfo.CreateOTAADevice(1, deviceClassType: 'c', gatewayID: ServerGatewayID));
var devEUI = simDevice.DevEUI;
this.deviceApi.Setup(x => x.SearchByDevEUIAsync(devEUI))
.ReturnsAsync(new SearchDevicesResult(new IoTHubDeviceInfo(string.Empty, devEUI, "123").AsList()));
this.deviceClient.Setup(x => x.GetTwinAsync())
.ReturnsAsync(simDevice.CreateOTAATwin());
var c2dToDeviceMessage = new ReceivedLoRaCloudToDeviceMessage()
{
Payload = "hello",
DevEUI = devEUI,
Fport = 10,
MessageId = Guid.NewGuid().ToString(),
};
var target = new DefaultClassCDevicesMessageSender(
this.serverConfiguration,
this.loRaDeviceRegistry,
this.packetForwarder.Object,
this.frameCounterStrategyProvider);
Assert.False(await target.SendAsync(c2dToDeviceMessage));
this.packetForwarder.VerifyAll();
this.deviceApi.VerifyAll();
this.deviceClient.VerifyAll();
}
public async Task When_Device_Is_Not_Found_In_Api_Should_Return_Null()
{
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateOTAADevice(1, gatewayID: this.ServerConfiguration.GatewayID));
var joinRequest = simulatedDevice.CreateJoinRequest();
// Create Rxpk
var rxpk = joinRequest.SerializeUplink(simulatedDevice.AppKey).Rxpk[0];
var devNonce = ConversionHelper.ByteArrayToString(joinRequest.DevNonce);
var devEUI = simulatedDevice.LoRaDevice.DeviceID;
var appEUI = simulatedDevice.LoRaDevice.AppEUI;
var loRaDeviceRegistryMock = new Mock <ILoRaDeviceRegistry>(MockBehavior.Strict);
loRaDeviceRegistryMock.Setup(x => x.RegisterDeviceInitializer(It.IsNotNull <ILoRaDeviceInitializer>()));
loRaDeviceRegistryMock.Setup(x => x.GetDeviceForJoinRequestAsync(devEUI, appEUI, devNonce))
.ReturnsAsync(() => null);
// Send to message processor
var messageProcessor = new MessageDispatcher(
this.ServerConfiguration,
loRaDeviceRegistryMock.Object,
this.FrameCounterUpdateStrategyProvider);
var request = this.CreateWaitableRequest(rxpk);
messageProcessor.DispatchRequest(request);
Assert.True(await request.WaitCompleteAsync());
Assert.Null(request.ResponseDownlink);
loRaDeviceRegistryMock.VerifyAll();
}
public async Task After_Sending_Class_C_Downstream_Should_Disconnect_Client()
{
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1,
gatewayID: ServerConfiguration.GatewayID,
deviceClassType: 'c'));
var devEui = simulatedDevice.DevEUI;
// will disconnected client
using var disconnectedEvent = new SemaphoreSlim(0, 1);
LoRaDeviceClient.Setup(x => x.Disconnect())
.Callback(() =>
{
disconnectedEvent.Release();
})
.Returns(true);
// will check client connection
LoRaDeviceClient.Setup(x => x.EnsureConnected())
.Returns(true);
// will save twin
LoRaDeviceClient.Setup(x => x.UpdateReportedPropertiesAsync(It.IsNotNull <TwinCollection>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(true);
var c2dToDeviceMessage = new ReceivedLoRaCloudToDeviceMessage()
{
Payload = "hello",
DevEUI = devEui,
Fport = FramePorts.App10,
MessageId = Guid.NewGuid().ToString(),
};
var cachedDevice = CreateLoRaDevice(simulatedDevice);
cachedDevice.KeepAliveTimeout = 3;
cachedDevice.LoRaRegion = LoRaRegionType.EU868;
cachedDevice.InternalAcceptChanges();
cachedDevice.SetFcntDown(cachedDevice.FCntDown + Constants.MaxFcntUnsavedDelta - 1);
cachedDevice.SetLastProcessingStationEui(new StationEui(ulong.MaxValue));
using var cache = EmptyMemoryCache();
using var loraDeviceCache = CreateDeviceCache(cachedDevice);
using var deviceRegistry = new LoRaDeviceRegistry(ServerConfiguration, cache, LoRaDeviceApi.Object, LoRaDeviceFactory, loraDeviceCache);
var target = new DefaultClassCDevicesMessageSender(
ServerConfiguration,
deviceRegistry,
DownstreamMessageSender,
FrameCounterUpdateStrategyProvider,
new TestOutputLogger <DefaultClassCDevicesMessageSender>(testOutputHelper),
TestMeter.Instance);
Assert.True(await target.SendAsync(c2dToDeviceMessage));
Assert.Single(DownstreamMessageSender.DownlinkMessages);
await EnsureDisconnectedAsync(disconnectedEvent);
LoRaDeviceClient.VerifyAll();
LoRaDeviceApi.VerifyAll();
}
public async Task When_Device_Is_Loaded_Should_Disconnect_After_Sending_Data()
{
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1, gatewayID: ServerGatewayID));
// will search for the device by devAddr
this.LoRaDeviceApi.Setup(x => x.SearchByDevAddrAsync(simulatedDevice.DevAddr))
.ReturnsAsync(new SearchDevicesResult(new IoTHubDeviceInfo(simulatedDevice.DevAddr, simulatedDevice.DevEUI, "ada").AsList()));
// will read the device twins
var twin = simulatedDevice.CreateABPTwin(desiredProperties: new Dictionary <string, object>
{
{ TwinProperty.KeepAliveTimeout, 3 }
});
this.LoRaDeviceClient.Setup(x => x.GetTwinAsync())
.ReturnsAsync(twin);
// message will be sent
LoRaDeviceTelemetry loRaDeviceTelemetry = null;
this.LoRaDeviceClient.Setup(x => x.SendEventAsync(It.IsNotNull <LoRaDeviceTelemetry>(), null))
.Callback <LoRaDeviceTelemetry, Dictionary <string, string> >((t, _) => loRaDeviceTelemetry = t)
.ReturnsAsync(true);
// C2D message will be checked
this.LoRaDeviceClient.Setup(x => x.ReceiveAsync(It.IsNotNull <TimeSpan>()))
.ReturnsAsync((Message)null);
// will check client connection
this.LoRaDeviceClient.Setup(x => x.EnsureConnected())
.Returns(true);
// will disconnected client
var disconnectedEvent = new SemaphoreSlim(0, 1);
this.LoRaDeviceClient.Setup(x => x.Disconnect())
.Callback(() => disconnectedEvent.Release())
.Returns(true);
var deviceRegistry = new LoRaDeviceRegistry(this.ServerConfiguration, this.NewMemoryCache(), this.LoRaDeviceApi.Object, this.LoRaDeviceFactory);
var messageDispatcher = new MessageDispatcher(
this.ServerConfiguration,
deviceRegistry,
this.FrameCounterUpdateStrategyProvider);
// sends unconfirmed message
var unconfirmedMessagePayload = simulatedDevice.CreateUnconfirmedDataUpMessage("hello");
var rxpk = unconfirmedMessagePayload.SerializeUplink(simulatedDevice.AppSKey, simulatedDevice.NwkSKey).Rxpk[0];
var request = new WaitableLoRaRequest(rxpk, this.PacketForwarder);
messageDispatcher.DispatchRequest(request);
Assert.True(await request.WaitCompleteAsync());
Assert.True(request.ProcessingSucceeded);
await this.EnsureDisconnectedAsync(disconnectedEvent, (int)TimeSpan.FromSeconds(Constants.MIN_KEEP_ALIVE_TIMEOUT * 2).TotalMilliseconds);
this.LoRaDeviceClient.VerifyAll();
this.LoRaDeviceApi.VerifyAll();
}
public async Task MessageProcessor_End2End_NoDep_ClassC_CloudToDeviceMessage_SizeLimit_Should_Accept(
bool hasMacInC2D)
{
var simulatedDevice = new SimulatedDevice(
TestDeviceInfo.CreateABPDevice(
1, deviceClassType: 'c', gatewayID: this.serverConfiguration.GatewayID));
var devEUI = simulatedDevice.DevEUI;
this.deviceApi.Setup(x => x.GetPrimaryKeyByEuiAsync(devEUI))
.ReturnsAsync("123");
var twin = simulatedDevice.CreateABPTwin(reportedProperties: new Dictionary <string, object>
{
{ TwinProperty.Region, LoRaRegionType.EU868.ToString() },
{ TwinProperty.LastProcessingStationEui, new StationEui(ulong.MaxValue).ToString() }
});
this.deviceClient.Setup(x => x.GetTwinAsync(CancellationToken.None))
.ReturnsAsync(twin);
var c2dMessageMacCommand = new DevStatusRequest();
var c2dMessageMacCommandSize = hasMacInC2D ? c2dMessageMacCommand.Length : 0;
var c2dPayloadSize = this.loRaRegion.GetMaxPayloadSize(this.loRaRegion.GetDefaultRX2ReceiveWindow(default).DataRate)
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 CreateIfRequired_Result_Has_Correct_Bundler_Request()
{
// arrange
const string gatewayId = "foo";
const double rssi = 2.3;
var device = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(0));
using var loRaDevice = TestUtils.CreateFromSimulatedDevice(device, new Mock <ILoRaDeviceClientConnectionManager>().Object);
var payload = device.CreateConfirmedDataUpMessage("foo");
using var request = WaitableLoRaRequest.Create(TestUtils.GenerateTestRadioMetadata(rssi: rssi), payload);
var deviceApiServiceMock = new Mock <LoRaDeviceAPIServiceBase>();
deviceApiServiceMock.Setup(s => s.ExecuteFunctionBundlerAsync(It.IsAny <DevEui>(), It.IsAny <FunctionBundlerRequest>())).ReturnsAsync(new FunctionBundlerResult());
var subject = new FunctionBundlerProvider(deviceApiServiceMock.Object, NullLoggerFactory.Instance, NullLogger <FunctionBundlerProvider> .Instance);
// act
var bundler = subject.CreateIfRequired(gatewayId, payload, loRaDevice, new Mock <IDeduplicationStrategyFactory>().Object, request);
_ = await bundler.Execute();
// assert
deviceApiServiceMock.Verify(s => s.ExecuteFunctionBundlerAsync(loRaDevice.DevEUI,
It.Is <FunctionBundlerRequest>(actual => actual.ClientFCntDown == 0 &&
actual.ClientFCntUp == 1 &&
actual.GatewayId == gatewayId &&
actual.Rssi == rssi)));
}
public async Task When_Device_Is_Not_Joined_Should_Fail()
{
var simDevice = new SimulatedDevice(TestDeviceInfo.CreateOTAADevice(1, deviceClassType: 'c', gatewayID: ServerGatewayID));
var devEUI = simDevice.DevEUI;
this.deviceApi.Setup(x => x.GetPrimaryKeyByEuiAsync(devEUI))
.ReturnsAsync("123");
this.deviceClient.Setup(x => x.GetTwinAsync(CancellationToken.None))
.ReturnsAsync(simDevice.CreateOTAATwin());
var c2dToDeviceMessage = new ReceivedLoRaCloudToDeviceMessage()
{
Payload = "hello",
DevEUI = devEUI,
Fport = TestPort,
MessageId = Guid.NewGuid().ToString(),
};
var target = new DefaultClassCDevicesMessageSender(
this.serverConfiguration,
this.loRaDeviceRegistry,
this.downstreamMessageSender.Object,
this.frameCounterStrategyProvider,
NullLogger <DefaultClassCDevicesMessageSender> .Instance,
TestMeter.Instance);
Assert.False(await target.SendAsync(c2dToDeviceMessage));
this.downstreamMessageSender.VerifyAll();
this.deviceApi.VerifyAll();
this.deviceClient.VerifyAll();
}
public async Task When_Device_Is_Not_Found_In_Api_Should_Return_Null()
{
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateOTAADevice(1, gatewayID: this.ServerConfiguration.GatewayID));
var joinRequest = simulatedDevice.CreateJoinRequest();
// Create Rxpk
var rxpk = joinRequest.SerializeUplink(simulatedDevice.AppKey).Rxpk[0];
var payloadDecoder = new Mock <ILoRaPayloadDecoder>();
var devNonce = ConversionHelper.ByteArrayToString(joinRequest.DevNonce);
var devEUI = simulatedDevice.LoRaDevice.DeviceID;
var appEUI = simulatedDevice.LoRaDevice.AppEUI;
this.LoRaDeviceRegistry.Setup(x => x.GetDeviceForJoinRequestAsync(devEUI, appEUI, devNonce))
.ReturnsAsync(() => null);
// Send to message processor
var messageProcessor = new MessageProcessor(
this.ServerConfiguration,
this.LoRaDeviceRegistry.Object,
this.FrameCounterUpdateStrategyFactory.Object,
payloadDecoder.Object);
var actual = await messageProcessor.ProcessMessageAsync(rxpk);
Assert.Null(actual);
}
public async Task Unknown_Region_Should_Return_Null()
{
// Setup
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1));
var payload = simulatedDevice.CreateUnconfirmedDataUpMessage("1234");
// Create Rxpk
var rxpk = payload.SerializeUplink(simulatedDevice.AppSKey, simulatedDevice.NwkSKey).Rxpk[0];
rxpk.Freq = 0;
var deviceRegistry = new LoRaDeviceRegistry(this.ServerConfiguration, this.NewMemoryCache(), this.LoRaDeviceApi.Object, this.LoRaDeviceFactory);
// Send to message processor
var messageProcessor = new MessageDispatcher(
this.ServerConfiguration,
deviceRegistry,
this.FrameCounterUpdateStrategyProvider);
var request = this.CreateWaitableRequest(rxpk);
messageProcessor.DispatchRequest(request);
Assert.True(await request.WaitCompleteAsync());
// Expectations
// 1. Returns null
Assert.Null(request.ResponseDownlink);
Assert.True(request.ProcessingFailed);
Assert.Equal(LoRaDeviceRequestFailedReason.InvalidRegion, request.ProcessingFailedReason);
}
public async Task When_Device_Api_Throws_Error_Should_Not_Create_Any_Device()
{
const string devAddr = "039090";
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1));
var payload = simulatedDevice.CreateUnconfirmedDataUpMessage("1234");
payload.SerializeUplink(simulatedDevice.AppSKey, simulatedDevice.NwkSKey);
var apiService = new Mock <LoRaDeviceAPIServiceBase>(MockBehavior.Strict);
apiService.Setup(x => x.SearchByDevAddrAsync(It.IsNotNull <string>()))
.Throws(new Exception());
var deviceFactory = new Mock <ILoRaDeviceFactory>(MockBehavior.Strict);
var destinationDictionary = new DevEUIToLoRaDeviceDictionary();
var finished = new SemaphoreSlim(0);
var target = new DeviceLoaderSynchronizer(
devAddr,
apiService.Object,
deviceFactory.Object,
destinationDictionary,
null,
this.serverConfiguration,
(_, l) => { finished.Release(); },
(d) => { destinationDictionary.TryAdd(d.DevEUI, d); });
await finished.WaitAsync();
Assert.Empty(destinationDictionary);
// Device was searched by DevAddr
apiService.VerifyAll();
}
public void When_Disposing_Should_Dispose_All_Managed_Connections(int numberOfDevices)
{
// arrange
using var cache = new MemoryCache(new MemoryCacheOptions());
using var connectionManager = new LoRaDeviceClientConnectionManager(cache, NullLogger <LoRaDeviceClientConnectionManager> .Instance);
var deviceRegistrations =
Enumerable.Range(0, numberOfDevices)
.Select(i => TestUtils.CreateFromSimulatedDevice(new SimulatedDevice(TestDeviceInfo.CreateABPDevice((uint)i)), connectionManager))
.Select(d => (d, new Mock <ILoRaDeviceClient>()))
.ToList();
foreach (var(d, c) in deviceRegistrations)
{
connectionManager.Register(d, c.Object);
}
// act
connectionManager.Dispose();
// assert
foreach (var(_, c) in deviceRegistrations)
{
c.Verify(client => client.Dispose(), Times.Exactly(2));
}
}
public async Task Unknown_Region_Should_Return_Null()
{
// Setup
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1));
var payload = simulatedDevice.CreateUnconfirmedDataUpMessage("1234");
// Create Rxpk
var rxpk = payload.SerializeUplink(simulatedDevice.AppSKey, simulatedDevice.NwkSKey).Rxpk[0];
rxpk.Freq = 0;
var payloadDecoder = new Mock <ILoRaPayloadDecoder>(MockBehavior.Strict);
// Send to message processor
var messageProcessor = new MessageProcessor(
this.ServerConfiguration,
this.LoRaDeviceRegistry.Object,
this.FrameCounterUpdateStrategyFactory.Object,
payloadDecoder.Object);
var actual = await messageProcessor.ProcessMessageAsync(rxpk);
// Expectations
// 1. Returns null
Assert.Null(actual);
}
public async Task When_Regions_Is_Not_Defined_Should_Fail()
{
var simDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1, deviceClassType: 'c', gatewayID: ServerGatewayID));
var devEUI = simDevice.DevEUI;
var c2dToDeviceMessage = new ReceivedLoRaCloudToDeviceMessage()
{
Payload = "hello",
DevEUI = devEUI,
Fport = LoRaFPort.MacCommand,
MessageId = Guid.NewGuid().ToString(),
};
var target = new DefaultClassCDevicesMessageSender(
this.serverConfiguration,
this.loRaDeviceRegistry,
this.packetForwarder.Object,
this.frameCounterStrategyProvider);
Assert.False(await target.SendAsync(c2dToDeviceMessage));
this.packetForwarder.VerifyAll();
this.deviceApi.VerifyAll();
this.deviceClient.VerifyAll();
}
public async Task When_Device_Has_Different_Gateway_Should_Return_Null()
{
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateOTAADevice(1, gatewayID: "another-gateway"));
var joinRequest = simulatedDevice.CreateJoinRequest();
var devEui = simulatedDevice.LoRaDevice.DevEui;
using var loRaDevice = CreateLoRaDevice(simulatedDevice);
loRaDevice.IsOurDevice = false;
loRaDevice.SetFcntDown(10);
loRaDevice.SetFcntUp(20);
var loRaDeviceRegistryMock = new Mock <ILoRaDeviceRegistry>();
loRaDeviceRegistryMock.Setup(x => x.RegisterDeviceInitializer(It.IsNotNull <ILoRaDeviceInitializer>()));
loRaDeviceRegistryMock.Setup(x => x.GetDeviceForJoinRequestAsync(devEui, joinRequest.DevNonce))
.ReturnsAsync(loRaDevice);
// Send to message processor
using var messageProcessor = new MessageDispatcher(
ServerConfiguration,
loRaDeviceRegistryMock.Object,
FrameCounterUpdateStrategyProvider);
using var request = CreateWaitableRequest(TestUtils.GenerateTestRadioMetadata(), joinRequest);
messageProcessor.DispatchRequest(request);
Assert.True(await request.WaitCompleteAsync());
Assert.Null(request.ResponseDownlink);
Assert.False(request.ProcessingSucceeded);
Assert.Equal(LoRaDeviceRequestFailedReason.HandledByAnotherGateway, request.ProcessingFailedReason);
// Device frame counts did not changed
Assert.Equal(10U, loRaDevice.FCntDown);
Assert.Equal(20U, loRaDevice.FCntUp);
}
public void When_Creating_Should_Copy_Values_From_Rxpk_And_Payload(int fcnt, byte fport)
{
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1));
var payload = simulatedDevice.CreateUnconfirmedDataUpMessage("1", fcnt: fcnt, fport: fport);
var rxpk = payload.SerializeUplink(simulatedDevice.AppSKey, simulatedDevice.NwkSKey).Rxpk[0];
var decodedValue = new { value = 1 };
var target = new LoRaDeviceTelemetry(rxpk, payload, decodedValue);
Assert.Equal(rxpk.Chan, target.Chan);
Assert.Equal(rxpk.Codr, target.Codr);
Assert.Equal(rxpk.Data, target.Rawdata);
Assert.Equal(decodedValue, target.Data);
Assert.Equal(rxpk.Datr, target.Datr);
Assert.Equal(rxpk.Freq, target.Freq);
Assert.Equal(rxpk.Lsnr, target.Lsnr);
Assert.Equal(rxpk.Modu, target.Modu);
Assert.Equal(rxpk.Rfch, target.Rfch);
Assert.Equal(rxpk.Rssi, target.Rssi);
Assert.Equal(rxpk.Size, target.Size);
Assert.Equal(rxpk.Stat, target.Stat);
Assert.Equal(rxpk.Time, target.Time);
Assert.Equal(rxpk.Tmms, target.Tmms);
Assert.Equal(rxpk.Tmst, target.Tmst);
Assert.Equal(payload.GetFcnt(), target.Fcnt);
Assert.Equal(payload.GetFPort(), target.Port);
}
public async Task When_Device_Is_Not_Found_In_Api_Should_Return_Null()
{
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateOTAADevice(1, gatewayID: ServerConfiguration.GatewayID));
var joinRequest = simulatedDevice.CreateJoinRequest();
var devEui = simulatedDevice.LoRaDevice.DevEui;
var loRaDeviceRegistryMock = new Mock <ILoRaDeviceRegistry>(MockBehavior.Strict);
loRaDeviceRegistryMock.Setup(x => x.RegisterDeviceInitializer(It.IsNotNull <ILoRaDeviceInitializer>()));
loRaDeviceRegistryMock.Setup(x => x.GetDeviceForJoinRequestAsync(devEui, joinRequest.DevNonce))
.ReturnsAsync(() => null);
// Send to message processor
using var messageProcessor = new MessageDispatcher(
ServerConfiguration,
loRaDeviceRegistryMock.Object,
FrameCounterUpdateStrategyProvider);
using var request = CreateWaitableRequest(TestUtils.GenerateTestRadioMetadata(), joinRequest);
messageProcessor.DispatchRequest(request);
Assert.True(await request.WaitCompleteAsync());
Assert.Null(request.ResponseDownlink);
loRaDeviceRegistryMock.VerifyAll();
loRaDeviceRegistryMock.Setup(dr => dr.Dispose());
LoRaDeviceClient.Setup(ldc => ldc.Dispose());
}
public async Task When_Devices_From_Another_Gateway_Is_Cached_Return_Null()
{
var simulatedDevice1 = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1, gatewayID: "another-gateway"));
var loraDevice1 = TestUtils.CreateFromSimulatedDevice(simulatedDevice1, null);
loraDevice1.IsOurDevice = false;
var existingCache = new DevEUIToLoRaDeviceDictionary();
this.cache.Set<DevEUIToLoRaDeviceDictionary>(simulatedDevice1.LoRaDevice.DevAddr, existingCache);
existingCache.TryAdd(loraDevice1.DevEUI, loraDevice1);
var payload = simulatedDevice1.CreateUnconfirmedDataUpMessage("1234");
payload.SerializeUplink(simulatedDevice1.AppSKey, simulatedDevice1.NwkSKey);
var apiService = new Mock<LoRaDeviceAPIServiceBase>(MockBehavior.Strict);
var target = new LoRaDeviceRegistry(this.serverConfiguration, this.cache, apiService.Object, this.loraDeviceFactoryMock.Object);
var request = new WaitableLoRaRequest(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_Api_Returns_DevAlreadyUsed_Should_Return_Null()
{
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateOTAADevice(1, gatewayID: null));
var joinRequest = simulatedDevice.CreateJoinRequest();
var devEui = simulatedDevice.LoRaDevice.DevEui;
// Lora device api will be search by devices with matching deveui,
LoRaDeviceApi.Setup(x => x.SearchAndLockForJoinAsync(ServerConfiguration.GatewayID, devEui, joinRequest.DevNonce))
.ReturnsAsync(new SearchDevicesResult()
{
IsDevNonceAlreadyUsed = true
});
using var memoryCache = new MemoryCache(new MemoryCacheOptions());
using var deviceRegistry = new LoRaDeviceRegistry(ServerConfiguration, memoryCache, LoRaDeviceApi.Object, LoRaDeviceFactory, DeviceCache);
// Send to message processor
using var messageProcessor = new MessageDispatcher(
ServerConfiguration,
deviceRegistry,
FrameCounterUpdateStrategyProvider);
using var request = CreateWaitableRequest(TestUtils.GenerateTestRadioMetadata(), joinRequest);
messageProcessor.DispatchRequest(request);
Assert.True(await request.WaitCompleteAsync());
Assert.Null(request.ResponseDownlink);
LoRaDeviceApi.VerifyAll();
LoRaDeviceClient.VerifyAll();
}
public async Task When_Loading_Device_By_DevAddr_Should_Be_Able_To_Load_By_DevEUI()
{
var simDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1));
var deviceApi = new Mock<LoRaDeviceAPIServiceBase>(MockBehavior.Strict);
deviceApi.Setup(x => x.SearchByDevAddrAsync(simDevice.DevAddr))
.ReturnsAsync(new SearchDevicesResult(new IoTHubDeviceInfo(simDevice.DevAddr, simDevice.DevEUI, "123").AsList()));
var deviceClient = new Mock<ILoRaDeviceClient>(MockBehavior.Strict);
deviceClient.Setup(x => x.GetTwinAsync())
.ReturnsAsync(simDevice.CreateABPTwin());
var handlerImplementation = new Mock<ILoRaDataRequestHandler>(MockBehavior.Strict);
var deviceFactory = new TestLoRaDeviceFactory(deviceClient.Object, handlerImplementation.Object);
var deviceRegistry = new LoRaDeviceRegistry(
this.serverConfiguration,
this.cache,
deviceApi.Object,
deviceFactory);
var payload = simDevice.CreateUnconfirmedDataUpMessage("1");
payload.SerializeUplink(simDevice.AppSKey, simDevice.NwkSKey);
var request = new WaitableLoRaRequest(payload);
deviceRegistry.GetLoRaRequestQueue(request).Queue(request);
Assert.True(await request.WaitCompleteAsync());
await Task.Delay(50);
Assert.NotNull(await deviceRegistry.GetDeviceByDevEUIAsync(simDevice.DevEUI));
handlerImplementation.VerifyAll();
deviceApi.VerifyAll();
deviceClient.VerifyAll();
deviceClient.Verify(x => x.GetTwinAsync(), Times.Once());
}
public async Task When_No_Decoder_Is_Defined_Sends_Raw_Payload(string deviceGatewayID, string msgPayload, string sensorDecoder)
{
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1, gatewayID: deviceGatewayID));
var loRaDevice = CreateLoRaDevice(simulatedDevice);
loRaDevice.SensorDecoder = sensorDecoder;
// message will be sent
LoRaDeviceTelemetry loRaDeviceTelemetry = null;
LoRaDeviceClient.Setup(x => x.SendEventAsync(It.IsNotNull <LoRaDeviceTelemetry>(), null))
.Callback <LoRaDeviceTelemetry, Dictionary <string, string> >((t, _) => loRaDeviceTelemetry = t)
.ReturnsAsync(true);
// C2D message will be checked
LoRaDeviceClient.Setup(x => x.ReceiveAsync(It.IsNotNull <TimeSpan>()))
.ReturnsAsync((Message)null);
if (string.IsNullOrEmpty(deviceGatewayID))
{
// multi GW will reset
LoRaDeviceApi.Setup(x => x.ABPFcntCacheResetAsync(It.IsNotNull <DevEui>(), It.IsAny <uint>(), It.IsNotNull <string>()))
.ReturnsAsync(true);
}
using var cache = EmptyMemoryCache();
using var loraDeviceCache = CreateDeviceCache(loRaDevice);
using var deviceRegistry = new LoRaDeviceRegistry(ServerConfiguration, cache, LoRaDeviceApi.Object, LoRaDeviceFactory, loraDeviceCache);
// Send to message processor
using var messageDispatcher = new MessageDispatcher(
ServerConfiguration,
deviceRegistry,
FrameCounterUpdateStrategyProvider);
// sends unconfirmed message
var unconfirmedMessagePayload = simulatedDevice.CreateUnconfirmedDataUpMessage(msgPayload, fcnt: 1);
using var request = CreateWaitableRequest(unconfirmedMessagePayload);
messageDispatcher.DispatchRequest(request);
Assert.True(await request.WaitCompleteAsync());
Assert.Null(request.ResponseDownlink);
Assert.NotNull(loRaDeviceTelemetry);
Assert.IsType <UndecodedPayload>(loRaDeviceTelemetry.Data);
var undecodedPayload = (UndecodedPayload)loRaDeviceTelemetry.Data;
var rawPayload = Convert.ToBase64String(Encoding.UTF8.GetBytes(msgPayload));
Assert.Equal(rawPayload, loRaDeviceTelemetry.Rawdata);
Assert.Equal(rawPayload, undecodedPayload.Value);
// Validate json
var actualJsonTelemetry = JsonConvert.SerializeObject(loRaDeviceTelemetry, Formatting.None);
var expectedTelemetryJson = $"{{\"time\":100000,\"tmms\":100000,\"freq\":868.3,\"chan\":2,\"rfch\":1,\"modu\":\"LoRa\",\"datr\":\"SF10BW125\",\"rssi\":2.0,\"lsnr\":0.1,\"data\":{{\"value\":\"{rawPayload}\"}},\"port\":1,\"fcnt\":1,\"edgets\":{loRaDeviceTelemetry.Edgets},\"rawdata\":\"{rawPayload}\",\"eui\":\"0000000000000001\",\"gatewayid\":\"test-gateway\",\"stationeui\":\"0000000000000000\"}}";
Assert.Equal(expectedTelemetryJson, actualJsonTelemetry);
LoRaDeviceClient.VerifyAll();
LoRaDeviceApi.VerifyAll();
}
public ConcentratorDeduplicationJoinRequestsIntegrationTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper)
{
this.simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateOTAADevice(0));
this.deviceMock = new Mock <LoRaDevice>(MockBehavior.Default,
this.simulatedDevice.DevAddr,
this.simulatedDevice.DevEUI,
ConnectionManager)
{
CallBase = true
};
this.deviceMock.Object.AppKey = this.simulatedDevice.AppKey;
this.deviceMock.Object.AppEui = this.simulatedDevice.AppEui;
this.deviceMock.Object.IsOurDevice = true;
this.testOutputLoggerFactory = new TestOutputLoggerFactory(testOutputHelper);
this.cache = new MemoryCache(new MemoryCacheOptions());
var concentratorDeduplication = new ConcentratorDeduplication(this.cache, this.testOutputLoggerFactory.CreateLogger <IConcentratorDeduplication>());
var deviceRegistryMock = new Mock <ILoRaDeviceRegistry>();
_ = deviceRegistryMock.Setup(x => x.GetDeviceForJoinRequestAsync(It.IsAny <DevEui>(), It.IsAny <DevNonce>()))
.ReturnsAsync(this.deviceMock.Object);
var clientMock = new Mock <ILoRaDeviceClient>();
_ = clientMock.Setup(x => x.UpdateReportedPropertiesAsync(It.IsAny <TwinCollection>(), It.IsAny <CancellationToken>())).ReturnsAsync(true);
ConnectionManager.Register(this.deviceMock.Object, clientMock.Object);
this.joinRequestHandler = new JoinRequestMessageHandler(
ServerConfiguration,
concentratorDeduplication,
deviceRegistryMock.Object,
this.testOutputLoggerFactory.CreateLogger <JoinRequestMessageHandler>(),
null);
}
public async Task When_Devices_From_Another_Gateway_Is_Cached_Return_Null()
{
var simulatedDevice1 = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1, gatewayID: "another-gateway"));
var loraDevice1 = TestUtils.CreateFromSimulatedDevice(simulatedDevice1, null);
loraDevice1.IsOurDevice = false;
var existingCache = new DevEUIToLoRaDeviceDictionary();
this.cache.Set <DevEUIToLoRaDeviceDictionary>(simulatedDevice1.LoRaDevice.DevAddr, existingCache);
existingCache.TryAdd(loraDevice1.DevEUI, loraDevice1);
var payload = simulatedDevice1.CreateUnconfirmedDataUpMessage("1234");
payload.SerializeUplink(simulatedDevice1.AppSKey, simulatedDevice1.NwkSKey);
var apiService = new Mock <LoRaDeviceAPIServiceBase>(MockBehavior.Strict);
var target = new LoRaDeviceRegistry(this.serverConfiguration, this.cache, apiService.Object, this.loraDeviceFactoryMock.Object);
var actual = await target.GetDeviceForPayloadAsync(payload);
Assert.Null(actual);
// Device was searched by DevAddr
apiService.VerifyAll();
// Device was created by factory
this.loraDeviceFactoryMock.VerifyAll();
}
