public async Task ABP_From_Another_Gateway_Unconfirmed_Message_Should_Load_Device_Cache_And_Disconnect()
{
const string gateway1 = "gateway1";
const string gateway2 = "gateway2";
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1, gatewayID: gateway1))
{
FrmCntUp = 9
};
LoRaDeviceApi.Setup(x => x.SearchByDevAddrAsync(simulatedDevice.DevAddr.Value))
.ReturnsAsync(new SearchDevicesResult(new IoTHubDeviceInfo(simulatedDevice.DevAddr, simulatedDevice.DevEUI, "1234")
{
GatewayId = gateway2
}.AsList()));
using var cache = NewMemoryCache();
using var deviceRegistry = new LoRaDeviceRegistry(ServerConfiguration, cache, LoRaDeviceApi.Object, LoRaDeviceFactory, DeviceCache);
// Send to message processor
using var messageProcessor = new MessageDispatcher(
ServerConfiguration,
deviceRegistry,
FrameCounterUpdateStrategyProvider);
var payload1 = simulatedDevice.CreateUnconfirmedDataUpMessage("1", fcnt: 10);
using var request1 = CreateWaitableRequest(TestUtils.GenerateTestRadioMetadata(), payload1);
messageProcessor.DispatchRequest(request1);
Assert.True(await request1.WaitCompleteAsync());
Assert.True(request1.ProcessingFailed);
Assert.Equal(LoRaDeviceRequestFailedReason.BelongsToAnotherGateway, request1.ProcessingFailedReason);
// Let loading finish
await Task.Delay(50);
// device should be cached
Assert.True(DeviceCache.TryGetByDevEui(simulatedDevice.DevEUI, out var cachedDevice));
var payload2 = simulatedDevice.CreateUnconfirmedDataUpMessage("2", fcnt: 11);
using var request2 = CreateWaitableRequest(TestUtils.GenerateTestRadioMetadata(), payload2);
messageProcessor.DispatchRequest(request2);
Assert.True(await request2.WaitCompleteAsync());
Assert.True(request2.ProcessingFailed);
Assert.Equal(LoRaDeviceRequestFailedReason.BelongsToAnotherGateway, request2.ProcessingFailedReason);
// Expectations
// 1. we never loaded the twins for the device not belonging to us
LoRaDeviceClient.Verify(x => x.GetTwinAsync(It.IsAny <CancellationToken>()), Times.Never);
LoRaDeviceClient.Verify(x => x.EnsureConnected(), Times.Never);
LoRaDeviceApi.VerifyAll();
LoRaDeviceApi.Verify(x => x.SearchByDevAddrAsync(simulatedDevice.DevAddr.Value), Times.Once());
// 2. The device is registered
Assert.Equal(1, DeviceCache.RegistrationCount(simulatedDevice.DevAddr.Value));
}
public async Task When_Device_Is_Assigned_To_Another_Gateway_Cache_Locally_And_Return_Null()
{
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1, gatewayID: "another-gateway"));
var apiService = new Mock <LoRaDeviceAPIServiceBase>(MockBehavior.Strict);
var iotHubDeviceInfo = new IoTHubDeviceInfo(simulatedDevice.LoRaDevice.DevAddr, simulatedDevice.LoRaDevice.DevEui, "pk")
{
GatewayId = "another-gateway",
NwkSKey = simulatedDevice.NwkSKey.Value
};
apiService.Setup(x => x.SearchByDevAddrAsync(It.IsAny <DevAddr>()))
.ReturnsAsync(new SearchDevicesResult(iotHubDeviceInfo.AsList()));
var deviceFactory = new TestLoRaDeviceFactory(LoRaDeviceClient.Object, DeviceCache, ConnectionManager);
using var target = new LoRaDeviceRegistry(ServerConfiguration, this.cache, apiService.Object, deviceFactory, DeviceCache);
// request #1
var payload1 = simulatedDevice.CreateUnconfirmedDataUpMessage("1", fcnt: 11);
using var request1 = WaitableLoRaRequest.Create(payload1);
target.GetLoRaRequestQueue(request1).Queue(request1);
Assert.True(await request1.WaitCompleteAsync());
Assert.True(request1.ProcessingFailed);
Assert.Equal(LoRaDeviceRequestFailedReason.BelongsToAnotherGateway, request1.ProcessingFailedReason);
// request #2
var payload2 = simulatedDevice.CreateUnconfirmedDataUpMessage("2", fcnt: 12);
using var request2 = WaitableLoRaRequest.Create(payload2);
target.GetLoRaRequestQueue(request2).Queue(request2);
Assert.True(await request2.WaitCompleteAsync());
Assert.True(request2.ProcessingFailed);
Assert.Equal(LoRaDeviceRequestFailedReason.BelongsToAnotherGateway, request2.ProcessingFailedReason);
// Device was searched by DevAddr
apiService.VerifyAll();
apiService.Verify(x => x.SearchByDevAddrAsync(It.IsAny <DevAddr>()), Times.Once());
// Device should not be connected
LoRaDeviceClient.VerifyAll();
LoRaDeviceClient.Verify(x => x.GetTwinAsync(CancellationToken.None), Times.Never());
LoRaDeviceClient.Verify(x => x.Disconnect(), Times.Never());
// device is in cache
Assert.True(DeviceCache.TryGetForPayload(request1.Payload, out var loRaDevice));
Assert.False(loRaDevice.IsOurDevice);
}
public async Task When_Device_Is_Assigned_To_Another_Gateway_After_No_Connection_Should_Be_Established()
{
const string gatewayId = "another-gateway";
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1, gatewayID: gatewayId));
var apiService = new Mock <LoRaDeviceAPIServiceBase>(MockBehavior.Strict);
var iotHubDeviceInfo = new IoTHubDeviceInfo(simulatedDevice.LoRaDevice.DevAddr, simulatedDevice.LoRaDevice.DevEui, "pk")
{
NwkSKey = simulatedDevice.NwkSKey.Value, GatewayId = gatewayId
};
apiService.Setup(x => x.SearchByDevAddrAsync(It.IsAny <DevAddr>()))
.ReturnsAsync(new SearchDevicesResult(iotHubDeviceInfo.AsList()));
var deviceFactory = new TestLoRaDeviceFactory(LoRaDeviceClient.Object, DeviceCache, ConnectionManager);
using var target = new LoRaDeviceRegistry(ServerConfiguration, this.cache, apiService.Object, deviceFactory, DeviceCache);
// setup 2 requests - ensure the cache is validated before fetching from the function
var requests = Enumerable.Range(1, 2).Select((n) =>
{
var payload = simulatedDevice.CreateUnconfirmedDataUpMessage(n.ToString(CultureInfo.InvariantCulture), fcnt: (uint)n + 10);
var request = WaitableLoRaRequest.Create(payload);
target.GetLoRaRequestQueue(request).Queue(request);
return(request);
}
).ToList();
foreach (var request in requests)
{
Assert.True(await request.WaitCompleteAsync());
Assert.True(request.ProcessingFailed);
Assert.Equal(LoRaDeviceRequestFailedReason.BelongsToAnotherGateway, request.ProcessingFailedReason);
}
// Device was searched by DevAddr
apiService.VerifyAll();
apiService.Verify(x => x.SearchByDevAddrAsync(It.IsAny <DevAddr>()), Times.Once());
LoRaDeviceClient.Verify(x => x.GetTwinAsync(CancellationToken.None), Times.Never());
// device is in cache
Assert.True(DeviceCache.TryGetForPayload(requests.First().Payload, out var cachedLoRaDevice));
Assert.False(cachedLoRaDevice.IsOurDevice);
}
public async Task Join_Device_Has_Mismatching_AppKey_Should_Return_Null(string deviceGatewayID)
{
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateOTAADevice(1, gatewayID: deviceGatewayID));
var joinRequestPayload = simulatedDevice.CreateJoinRequest();
var devAddr = (DevAddr?)null;
var devEui = simulatedDevice.LoRaDevice.DevEui;
// Device twin will be queried
var twin = new Twin();
twin.Properties.Desired[TwinProperty.DevEUI] = devEui.ToString();
twin.Properties.Desired[TwinProperty.AppEui] = simulatedDevice.LoRaDevice.AppEui?.ToString();
twin.Properties.Desired[TwinProperty.AppKey] = "012345678901234567890123456789FF";
twin.Properties.Desired[TwinProperty.GatewayID] = deviceGatewayID;
twin.Properties.Desired[TwinProperty.SensorDecoder] = simulatedDevice.LoRaDevice.SensorDecoder;
LoRaDeviceClient.Setup(x => x.GetTwinAsync(CancellationToken.None)).ReturnsAsync(twin);
// Lora device api will be search by devices with matching deveui,
LoRaDeviceApi.Setup(x => x.SearchAndLockForJoinAsync(ServerConfiguration.GatewayID, devEui, joinRequestPayload.DevNonce))
.ReturnsAsync(new SearchDevicesResult(new IoTHubDeviceInfo(devAddr, devEui, "aabb").AsList()));
// using factory to create mock of
using var memoryCache = new MemoryCache(new MemoryCacheOptions());
using var deviceRegistry = new LoRaDeviceRegistry(ServerConfiguration, memoryCache, LoRaDeviceApi.Object, LoRaDeviceFactory, DeviceCache);
using var messageProcessor = new MessageDispatcher(
ServerConfiguration,
deviceRegistry,
FrameCounterUpdateStrategyProvider);
// join request should fail
using var joinRequest = CreateWaitableRequest(joinRequestPayload);
messageProcessor.DispatchRequest(joinRequest);
Assert.True(await joinRequest.WaitCompleteAsync());
Assert.True(joinRequest.ProcessingFailed);
Assert.Null(joinRequest.ResponseDownlink);
LoRaDeviceClient.Verify(x => x.UpdateReportedPropertiesAsync(It.IsAny <TwinCollection>(), It.IsAny <CancellationToken>()), Times.Never);
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 ValidateFcnt_Start_Values_And_ResetCounter(
short fcntUp,
uint startFcntUpDesired,
uint startFcntDownDesired,
uint?startFcntUpReported,
uint?startFcntDownReported,
int?fcntResetCounterDesired,
int?fcntResetCounterReported,
uint startUpExpected,
uint startDownExpected,
bool saveExpected)
{
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1, gatewayID: ServerConfiguration.GatewayID));
var devEui = simulatedDevice.LoRaDevice.DevEui;
var devAddr = simulatedDevice.LoRaDevice.DevAddr.Value;
LoRaDeviceClient.Setup(x => x.SendEventAsync(It.IsNotNull <LoRaDeviceTelemetry>(), null)).ReturnsAsync(true);
var initialTwin = SetupTwins((uint)fcntUp, startFcntDownDesired, startFcntUpDesired, startFcntDownDesired, true, false, simulatedDevice, devEui, devAddr);
if (startFcntUpReported.HasValue)
{
initialTwin.Properties.Reported[TwinProperty.FCntUpStart] = startFcntUpReported.Value;
}
if (startFcntDownReported.HasValue)
{
initialTwin.Properties.Reported[TwinProperty.FCntDownStart] = startFcntDownReported.Value;
}
if (fcntResetCounterDesired.HasValue)
{
initialTwin.Properties.Desired[TwinProperty.FCntResetCounter] = fcntResetCounterDesired.Value;
}
if (fcntResetCounterReported.HasValue)
{
initialTwin.Properties.Reported[TwinProperty.FCntResetCounter] = fcntResetCounterReported.Value;
}
LoRaDeviceClient.Setup(x => x.GetTwinAsync(CancellationToken.None)).ReturnsAsync(initialTwin);
uint?fcntUpSavedInTwin = null;
uint?fcntDownSavedInTwin = null;
uint?fcntStartUpSavedInTwin = null;
uint?fcntStartDownSavedInTwin = null;
LoRaDeviceClient.Setup(x => x.UpdateReportedPropertiesAsync(It.IsNotNull <TwinCollection>(), It.IsAny <CancellationToken>()))
.Returns <TwinCollection, CancellationToken>((t, _) =>
{
fcntUpSavedInTwin = (uint)t[TwinProperty.FCntUp];
fcntDownSavedInTwin = (uint)t[TwinProperty.FCntDown];
fcntStartUpSavedInTwin = (uint)t[TwinProperty.FCntUpStart];
fcntStartDownSavedInTwin = (uint)t[TwinProperty.FCntDownStart];
return(Task.FromResult(true));
});
LoRaDeviceClient.Setup(x => x.ReceiveAsync(It.IsAny <TimeSpan>())).ReturnsAsync((Message)null);
LoRaDeviceApi.Setup(x => x.SearchByDevAddrAsync(devAddr)).ReturnsAsync(new SearchDevicesResult(new IoTHubDeviceInfo(devAddr, devEui, "abc").AsList()));
using var memoryCache = new MemoryCache(new MemoryCacheOptions());
using var deviceRegistry = new LoRaDeviceRegistry(ServerConfiguration, memoryCache, LoRaDeviceApi.Object, LoRaDeviceFactory, DeviceCache);
// Send to message processor
using var messageDispatcher = new MessageDispatcher(
ServerConfiguration,
deviceRegistry,
FrameCounterUpdateStrategyProvider);
var payload = simulatedDevice.CreateUnconfirmedDataUpMessage("1234", fcnt: (uint)fcntUp);
using var req = CreateWaitableRequest(TestUtils.GenerateTestRadioMetadata(), payload);
messageDispatcher.DispatchRequest(req);
await req.WaitCompleteAsync();
if (saveExpected)
{
Assert.True(req.ProcessingSucceeded);
LoRaDeviceClient.Verify(x => x.UpdateReportedPropertiesAsync(It.IsNotNull <TwinCollection>(), It.IsAny <CancellationToken>()), Times.Exactly(1));
Assert.Equal(fcntUpSavedInTwin, fcntStartUpSavedInTwin);
Assert.Equal(fcntDownSavedInTwin, fcntStartDownSavedInTwin);
Assert.Equal(startUpExpected, fcntStartUpSavedInTwin.Value);
Assert.Equal(startDownExpected, fcntStartDownSavedInTwin.Value);
}
else
{
LoRaDeviceClient.Verify(x => x.UpdateReportedPropertiesAsync(It.IsNotNull <TwinCollection>(), It.IsAny <CancellationToken>()), Times.Never());
}
}
public async Task When_Updating_PreferredGateway_And_FcntUp_Should_Save_Twin_Once()
{
const uint PayloadFcnt = 10;
const uint InitialDeviceFcntUp = 9;
const uint InitialDeviceFcntDown = 20;
var simulatedDevice = new SimulatedDevice(
TestDeviceInfo.CreateABPDevice(1, deviceClassType: 'c'),
frmCntUp: InitialDeviceFcntUp,
frmCntDown: InitialDeviceFcntDown);
var loraDevice = CreateLoRaDevice(simulatedDevice);
loraDevice.UpdatePreferredGatewayID("another-gateway", acceptChanges: true);
var bundlerResult = new FunctionBundlerResult()
{
PreferredGatewayResult = new PreferredGatewayResult()
{
DevEUI = simulatedDevice.DevEUI,
PreferredGatewayID = ServerGatewayID,
CurrentFcntUp = PayloadFcnt,
RequestFcntUp = PayloadFcnt,
}
};
LoRaDeviceApi
.Setup(x => x.ExecuteFunctionBundlerAsync(simulatedDevice.DevEUI, It.Is((FunctionBundlerRequest r) => PayloadFcnt == r.ClientFCntUp &&
ServerGatewayID == r.GatewayId &&
FunctionBundlerItemType.PreferredGateway == r.FunctionItems)))
.ReturnsAsync(bundlerResult);
TwinCollection actualSavedTwin = null;
LoRaDeviceClient
.Setup(x => x.UpdateReportedPropertiesAsync(It.IsNotNull <TwinCollection>(), It.IsAny <CancellationToken>()))
.Callback <TwinCollection, CancellationToken>((savedTwin, _) => actualSavedTwin = savedTwin)
.ReturnsAsync(true);
LoRaDeviceClient.Setup(x => x.SendEventAsync(It.IsNotNull <LoRaDeviceTelemetry>(), null))
.ReturnsAsync(true);
LoRaDeviceClient.Setup(x => x.ReceiveAsync(It.IsAny <TimeSpan>()))
.ReturnsAsync((Message)null);
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 messageProcessor = new MessageDispatcher(
ServerConfiguration,
deviceRegistry,
FrameCounterUpdateStrategyProvider);
var payload = simulatedDevice.CreateUnconfirmedDataUpMessage("1234", fcnt: PayloadFcnt);
using var request = CreateWaitableRequest(payload);
messageProcessor.DispatchRequest(request);
Assert.True(await request.WaitCompleteAsync());
// Expectations
// 1. Message was sent to IoT Hub
LoRaDeviceClient.VerifyAll();
LoRaDeviceApi.VerifyAll();
// 2. No downstream message for the current device is sent
Assert.Null(request.ResponseDownlink);
Assert.True(request.ProcessingSucceeded);
Assert.Equal(ServerGatewayID, loraDevice.PreferredGatewayID);
Assert.Equal(LoRaRegionType.EU868, loraDevice.LoRaRegion);
Assert.Equal(PayloadFcnt, loraDevice.FCntUp);
LoRaDeviceClient.Verify(x => x.UpdateReportedPropertiesAsync(It.IsNotNull <TwinCollection>(), It.IsAny <CancellationToken>()), Times.Once());
Assert.Equal(ServerGatewayID, actualSavedTwin[TwinProperty.PreferredGatewayID].Value as string);
Assert.Equal(LoRaRegionType.EU868.ToString(), actualSavedTwin[TwinProperty.Region].Value as string);
Assert.Equal(PayloadFcnt, (uint)actualSavedTwin[TwinProperty.FCntUp].Value);
}
public async Task When_First_Join_Fails_Due_To_Slow_Twin_Update_Retry_Second_Attempt_Should_Succeed(string deviceGatewayID)
{
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateOTAADevice(1, gatewayID: deviceGatewayID));
var joinRequestPayload1 = simulatedDevice.CreateJoinRequest();
var joinRequestPayload2 = simulatedDevice.CreateJoinRequest();
var devAddr = (DevAddr?)null;
var devEui = simulatedDevice.LoRaDevice.DevEui;
// Device twin will be queried
var twin = new Twin();
twin.Properties.Desired[TwinProperty.DevEUI] = devEui.ToString();
twin.Properties.Desired[TwinProperty.AppEui] = simulatedDevice.LoRaDevice.AppEui?.ToString();
twin.Properties.Desired[TwinProperty.AppKey] = simulatedDevice.LoRaDevice.AppKey?.ToString();
twin.Properties.Desired[TwinProperty.GatewayID] = deviceGatewayID;
twin.Properties.Desired[TwinProperty.SensorDecoder] = simulatedDevice.LoRaDevice.SensorDecoder;
LoRaDeviceClient.Setup(x => x.GetTwinAsync(CancellationToken.None))
.ReturnsAsync(twin);
// Device twin will be updated
AppSessionKey? afterJoin2AppSKey = null;
NetworkSessionKey?afterJoin2NwkSKey = null;
DevAddr? afterJoin2DevAddr = null;
var mockSequence = new MockSequence();
LoRaDeviceClient.InSequence(mockSequence)
.Setup(x => x.UpdateReportedPropertiesAsync(It.IsNotNull <TwinCollection>(), It.IsAny <CancellationToken>()))
.Returns <TwinCollection, CancellationToken>(async(_, token) =>
{
try
{
await Task.Delay(TimeSpan.FromSeconds(20), token);
Assert.True(false, "Token timeout expected");
}
catch (OperationCanceledException) { }
return(false);
});
LoRaDeviceClient.InSequence(mockSequence)
.Setup(x => x.UpdateReportedPropertiesAsync(It.IsNotNull <TwinCollection>(), It.IsAny <CancellationToken>()))
.Returns <TwinCollection, CancellationToken>((updatedTwin, token) =>
{
afterJoin2AppSKey = updatedTwin.SafeRead <AppSessionKey>(TwinProperty.AppSKey);
afterJoin2NwkSKey = updatedTwin.SafeRead <NetworkSessionKey>(TwinProperty.NwkSKey);
afterJoin2DevAddr = updatedTwin.SafeRead <DevAddr>(TwinProperty.DevAddr);
return(Task.FromResult(true));
});
// Lora device api will be search by devices with matching deveui,
LoRaDeviceApi.Setup(x => x.SearchAndLockForJoinAsync(ServerConfiguration.GatewayID, devEui, joinRequestPayload1.DevNonce))
.ReturnsAsync(new SearchDevicesResult(new IoTHubDeviceInfo(devAddr, devEui, "aabb").AsList()));
LoRaDeviceApi.Setup(x => x.SearchAndLockForJoinAsync(ServerConfiguration.GatewayID, devEui, joinRequestPayload2.DevNonce))
.ReturnsAsync(new SearchDevicesResult(new IoTHubDeviceInfo(devAddr, devEui, "aabb").AsList()));
using var cache = NewMemoryCache();
using var deviceRegistry = new LoRaDeviceRegistry(ServerConfiguration, cache, LoRaDeviceApi.Object, LoRaDeviceFactory, DeviceCache);
using var messageProcessor = new MessageDispatcher(
ServerConfiguration,
deviceRegistry,
FrameCounterUpdateStrategyProvider);
using var joinRequest1 = CreateWaitableRequest(joinRequestPayload1, useRealTimer: true);
messageProcessor.DispatchRequest(joinRequest1);
await Task.Delay(TimeSpan.FromSeconds(7));
using var joinRequest2 = CreateWaitableRequest(joinRequestPayload2, useRealTimer: true);
messageProcessor.DispatchRequest(joinRequest2);
await Task.WhenAll(joinRequest1.WaitCompleteAsync(), joinRequest2.WaitCompleteAsync());
Assert.True(joinRequest1.ProcessingFailed);
Assert.Null(joinRequest1.ResponseDownlink);
Assert.Equal(LoRaDeviceRequestFailedReason.IoTHubProblem, joinRequest1.ProcessingFailedReason);
Assert.True(joinRequest2.ProcessingSucceeded);
Assert.NotNull(joinRequest2.ResponseDownlink);
Assert.Single(DownstreamMessageSender.DownlinkMessages);
Assert.True(DeviceCache.TryGetByDevEui(devEui, out var loRaDevice));
Assert.True(loRaDevice.IsOurDevice);
Assert.Equal(afterJoin2DevAddr, loRaDevice.DevAddr);
Assert.Equal(afterJoin2NwkSKey, loRaDevice.NwkSKey);
Assert.Equal(afterJoin2AppSKey, loRaDevice.AppSKey);
// get twin should happen only once
LoRaDeviceClient.Verify(x => x.GetTwinAsync(CancellationToken.None), Times.Once());
LoRaDeviceClient.VerifyAll();
LoRaDeviceApi.VerifyAll();
}
public async Task When_Join_Fails_Due_To_Timeout_Second_Try_Should_Reuse_Cached_Device_Twin(string deviceGatewayID)
{
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateOTAADevice(1, gatewayID: deviceGatewayID));
var joinRequestPayload1 = simulatedDevice.CreateJoinRequest();
var devAddr = (DevAddr?)null;
var devEui = simulatedDevice.LoRaDevice.DevEui;
// Device twin will be queried twice, 1st time will take 7 seconds, 2nd time 0.1 second
var twin = new Twin();
twin.Properties.Desired[TwinProperty.DevEUI] = devEui.ToString();
twin.Properties.Desired[TwinProperty.AppEui] = simulatedDevice.LoRaDevice.AppEui?.ToString();
twin.Properties.Desired[TwinProperty.AppKey] = simulatedDevice.LoRaDevice.AppKey?.ToString();
if (deviceGatewayID != null)
{
twin.Properties.Desired[TwinProperty.GatewayID] = deviceGatewayID;
}
twin.Properties.Desired[TwinProperty.SensorDecoder] = simulatedDevice.LoRaDevice.SensorDecoder;
LoRaDeviceClient.Setup(x => x.GetTwinAsync(CancellationToken.None))
.ReturnsAsync(twin);
// Device twin will be updated
AppSessionKey? afterJoinAppSKey = null;
NetworkSessionKey?afterJoinNwkSKey = null;
string afterJoinDevAddr = null;
LoRaDeviceClient.Setup(x => x.UpdateReportedPropertiesAsync(It.IsNotNull <TwinCollection>(), It.IsAny <CancellationToken>()))
.Callback <TwinCollection, CancellationToken>((updatedTwin, _) =>
{
afterJoinAppSKey = AppSessionKey.Parse(updatedTwin[TwinProperty.AppSKey].Value);
afterJoinNwkSKey = NetworkSessionKey.Parse(updatedTwin[TwinProperty.NwkSKey].Value);
afterJoinDevAddr = updatedTwin[TwinProperty.DevAddr];
})
.ReturnsAsync(true);
// Lora device api will be search by devices with matching deveui,
LoRaDeviceApi.Setup(x => x.SearchAndLockForJoinAsync(ServerConfiguration.GatewayID, devEui, joinRequestPayload1.DevNonce))
.ReturnsAsync(new SearchDevicesResult(new IoTHubDeviceInfo(devAddr, devEui, "aabb").AsList()));
using var memoryCache = new MemoryCache(new MemoryCacheOptions());
using var deviceRegistry = new LoRaDeviceRegistry(ServerConfiguration, memoryCache, LoRaDeviceApi.Object, LoRaDeviceFactory, DeviceCache);
using var messageProcessor = new MessageDispatcher(
ServerConfiguration,
deviceRegistry,
FrameCounterUpdateStrategyProvider);
// 1st join request
// Should fail
using var joinRequest1 = CreateWaitableRequest(joinRequestPayload1, constantElapsedTime: TimeSpan.FromSeconds(7));
messageProcessor.DispatchRequest(joinRequest1);
Assert.True(await joinRequest1.WaitCompleteAsync());
Assert.True(joinRequest1.ProcessingFailed);
Assert.Null(joinRequest1.ResponseDownlink);
Assert.Equal(LoRaDeviceRequestFailedReason.ReceiveWindowMissed, joinRequest1.ProcessingFailedReason);
// 2nd attempt
var joinRequestPayload2 = simulatedDevice.CreateJoinRequest();
// setup response to this device search
LoRaDeviceApi.Setup(x => x.SearchAndLockForJoinAsync(ServerConfiguration.GatewayID, devEui, joinRequestPayload2.DevNonce))
.ReturnsAsync(new SearchDevicesResult(new IoTHubDeviceInfo(devAddr, devEui, "aabb").AsList()));
using var joinRequest2 = CreateWaitableRequest(joinRequestPayload2);
messageProcessor.DispatchRequest(joinRequest2);
Assert.True(await joinRequest2.WaitCompleteAsync());
Assert.True(joinRequest2.ProcessingSucceeded);
Assert.NotNull(joinRequest2.ResponseDownlink);
Assert.Single(DownstreamMessageSender.DownlinkMessages);
var joinRequestDownlinkMessage = DownstreamMessageSender.DownlinkMessages[0];
var joinAccept = new LoRaPayloadJoinAccept(joinRequestDownlinkMessage.Data, simulatedDevice.LoRaDevice.AppKey.Value);
Assert.Equal(joinAccept.DevAddr.ToString(), afterJoinDevAddr);
Assert.True(DeviceCache.TryGetByDevEui(devEui, out var loRaDevice));
Assert.Equal(simulatedDevice.AppKey, loRaDevice.AppKey);
Assert.Equal(simulatedDevice.AppEui, loRaDevice.AppEui);
Assert.Equal(afterJoinAppSKey, loRaDevice.AppSKey);
Assert.Equal(afterJoinNwkSKey, loRaDevice.NwkSKey);
Assert.Equal(joinAccept.DevAddr, loRaDevice.DevAddr);
if (deviceGatewayID == null)
{
Assert.Null(loRaDevice.GatewayID);
}
else
{
Assert.Equal(deviceGatewayID, loRaDevice.GatewayID);
}
// fcnt is restarted
Assert.Equal(0U, loRaDevice.FCntUp);
Assert.Equal(0U, loRaDevice.FCntDown);
Assert.False(loRaDevice.HasFrameCountChanges);
// searching the device should happen twice
LoRaDeviceApi.Verify(x => x.SearchAndLockForJoinAsync(ServerGatewayID, devEui, It.IsAny <DevNonce>()), Times.Exactly(2));
// getting the device twin should happens once
LoRaDeviceClient.Verify(x => x.GetTwinAsync(CancellationToken.None), Times.Once());
LoRaDeviceClient.VerifyAll();
LoRaDeviceApi.VerifyAll();
}
private async Task Join_With_Subsequent_Unconfirmed_And_Confirmed_Messages(string deviceGatewayID, uint initialFcntUp, uint initialFcntDown, uint startingPayloadFcnt, int netId, Region region)
{
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateOTAADevice(1, gatewayID: deviceGatewayID));
var joinRequestPayload = simulatedDevice.CreateJoinRequest();
var devAddr = (DevAddr?)null;
var devEui = simulatedDevice.LoRaDevice.DevEui;
ServerConfiguration.NetId = new NetId(netId);
// Device twin will be queried
var twin = new Twin();
twin.Properties.Desired[TwinProperty.DevEUI] = devEui.ToString();
twin.Properties.Desired[TwinProperty.AppEui] = simulatedDevice.LoRaDevice.AppEui?.ToString();
twin.Properties.Desired[TwinProperty.AppKey] = simulatedDevice.LoRaDevice.AppKey?.ToString();
if (deviceGatewayID != null)
{
twin.Properties.Desired[TwinProperty.GatewayID] = deviceGatewayID;
}
twin.Properties.Desired[TwinProperty.SensorDecoder] = simulatedDevice.LoRaDevice.SensorDecoder;
twin.Properties.Reported[TwinProperty.FCntUp] = initialFcntUp;
twin.Properties.Reported[TwinProperty.FCntDown] = initialFcntDown;
LoRaDeviceClient.Setup(x => x.GetTwinAsync(CancellationToken.None)).ReturnsAsync(twin);
// Device twin will be updated
AppSessionKey? afterJoinAppSKey = null;
NetworkSessionKey?afterJoinNwkSKey = null;
string afterJoinDevAddr = null;
uint afterJoinFcntDown = 0;
uint afterJoinFcntUp = 0;
TwinCollection actualSavedTwin = null;
LoRaDeviceClient.Setup(x => x.UpdateReportedPropertiesAsync(It.IsNotNull <TwinCollection>(), It.IsAny <CancellationToken>()))
.Callback <TwinCollection, CancellationToken>((updatedTwin, _) =>
{
if (updatedTwin.Contains(TwinProperty.AppSKey))
{
afterJoinAppSKey = AppSessionKey.Parse(updatedTwin[TwinProperty.AppSKey].Value);
}
if (updatedTwin.Contains(TwinProperty.NwkSKey))
{
afterJoinNwkSKey = NetworkSessionKey.Parse(updatedTwin[TwinProperty.NwkSKey].Value);
}
if (updatedTwin.Contains(TwinProperty.DevAddr))
{
afterJoinDevAddr = updatedTwin[TwinProperty.DevAddr];
}
afterJoinFcntDown = updatedTwin[TwinProperty.FCntDown];
afterJoinFcntUp = updatedTwin[TwinProperty.FCntUp];
actualSavedTwin = updatedTwin;
})
.ReturnsAsync(true);
// message will be sent
var sentTelemetry = new List <LoRaDeviceTelemetry>();
LoRaDeviceClient.Setup(x => x.SendEventAsync(It.IsNotNull <LoRaDeviceTelemetry>(), null))
.Callback <LoRaDeviceTelemetry, Dictionary <string, string> >((t, _) => sentTelemetry.Add(t))
.ReturnsAsync(true);
// C2D message will be checked
LoRaDeviceClient.Setup(x => x.ReceiveAsync(It.IsNotNull <TimeSpan>()))
.ReturnsAsync((Message)null);
// Lora device api will be search by devices with matching deveui,
LoRaDeviceApi.Setup(x => x.SearchAndLockForJoinAsync(ServerConfiguration.GatewayID, devEui, joinRequestPayload.DevNonce))
.ReturnsAsync(new SearchDevicesResult(new IoTHubDeviceInfo(devAddr, devEui, "aabb").AsList()));
// multi gateway will request a next frame count down from the lora device api, prepare it
if (string.IsNullOrEmpty(deviceGatewayID))
{
LoRaDeviceApi.Setup(x => x.NextFCntDownAsync(devEui, 0, startingPayloadFcnt + 1, ServerConfiguration.GatewayID))
.ReturnsAsync((ushort)1);
LoRaDeviceApi
.Setup(x => x.ExecuteFunctionBundlerAsync(devEui, It.IsAny <FunctionBundlerRequest>()))
.ReturnsAsync(() => new FunctionBundlerResult
{
AdrResult = new LoRaTools.ADR.LoRaADRResult
{
CanConfirmToDevice = false,
FCntDown = 1,
NbRepetition = 1,
TxPower = 0
},
NextFCntDown = 1
});
}
// using factory to create mock of
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);
// Create a join request and join with the device.
using var joinRequest =
CreateWaitableRequest(joinRequestPayload, constantElapsedTime: TimeSpan.FromMilliseconds(300), region: region);
messageProcessor.DispatchRequest(joinRequest);
Assert.True(await joinRequest.WaitCompleteAsync());
Assert.True(joinRequest.ProcessingSucceeded, $"Failed due to '{joinRequest.ProcessingFailedReason}'.");
Assert.NotNull(joinRequest.ResponseDownlink);
Assert.Single(DownstreamMessageSender.DownlinkMessages);
var downlinkJoinAcceptMessage = DownstreamMessageSender.DownlinkMessages[0];
var joinAccept = new LoRaPayloadJoinAccept(downlinkJoinAcceptMessage.Data, simulatedDevice.LoRaDevice.AppKey.Value);
Assert.Equal(joinAccept.DevAddr.ToString(), afterJoinDevAddr);
// check that the device is in cache
Assert.True(DeviceCache.TryGetByDevEui(devEui, out var loRaDevice));
Assert.Equal(afterJoinAppSKey, loRaDevice.AppSKey);
Assert.Equal(afterJoinNwkSKey, loRaDevice.NwkSKey);
Assert.Equal(afterJoinDevAddr, loRaDevice.DevAddr.ToString());
var netIdBytes = BitConverter.GetBytes(netId);
Assert.Equal(netIdBytes[0] & 0b01111111, DevAddr.Parse(afterJoinDevAddr).NetworkId);
if (deviceGatewayID == null)
{
Assert.Null(loRaDevice.GatewayID);
}
else
{
Assert.Equal(deviceGatewayID, loRaDevice.GatewayID);
}
// Assert that after a join the fcnt is restarted
Assert.Equal(0U, afterJoinFcntDown);
Assert.Equal(0U, afterJoinFcntUp);
Assert.Equal(0U, loRaDevice.FCntUp);
Assert.Equal(0U, loRaDevice.FCntDown);
Assert.False(loRaDevice.HasFrameCountChanges);
simulatedDevice.LoRaDevice.AppSKey = afterJoinAppSKey;
simulatedDevice.LoRaDevice.NwkSKey = afterJoinNwkSKey;
simulatedDevice.LoRaDevice.DevAddr = DevAddr.Parse(afterJoinDevAddr);
// sends unconfirmed message with a given starting frame counter
var unconfirmedMessagePayload = simulatedDevice.CreateUnconfirmedDataUpMessage("100", fcnt: startingPayloadFcnt);
var radioMetadata = TestUtils.GenerateTestRadioMetadata();
using var unconfirmedRequest =
CreateWaitableRequest(radioMetadata, unconfirmedMessagePayload,
constantElapsedTime: TimeSpan.FromMilliseconds(300));
messageProcessor.DispatchRequest(unconfirmedRequest);
Assert.True(await unconfirmedRequest.WaitCompleteAsync());
Assert.Null(unconfirmedRequest.ResponseDownlink);
Assert.True(unconfirmedRequest.ProcessingSucceeded);
// fcnt up was updated
Assert.Equal(startingPayloadFcnt, loRaDevice.FCntUp);
Assert.Equal(0U, loRaDevice.FCntDown);
// If the starting payload was not 0, it is expected that it updates the framecounter char
// The device will perform the frame counter update and at this point in time it will have the same frame counter as the desired
// Therefore savechangesasync will set the hasframcounter change to false
// if (startingPayloadFcnt != 0)
// {
// // Frame change flag will be set, only saving every 10 messages
// Assert.True(loRaDevice.HasFrameCountChanges);
// }
Assert.Single(sentTelemetry);
// sends confirmed message
var confirmedMessagePayload = simulatedDevice.CreateConfirmedDataUpMessage("200", fcnt: startingPayloadFcnt + 1);
using var confirmedRequest = CreateWaitableRequest(confirmedMessagePayload, constantElapsedTime: TimeSpan.FromMilliseconds(300), region: region);
messageProcessor.DispatchRequest(confirmedRequest);
Assert.True(await confirmedRequest.WaitCompleteAsync());
Assert.True(confirmedRequest.ProcessingSucceeded);
Assert.NotNull(confirmedRequest.ResponseDownlink);
Assert.Equal(2, DownstreamMessageSender.DownlinkMessages.Count);
Assert.Equal(2, sentTelemetry.Count);
var downstreamMessage = DownstreamMessageSender.DownlinkMessages[1];
// validates txpk according to region
DeviceJoinInfo deviceJoinInfo = null;
if (region is RegionCN470RP2 cnRegion && cnRegion.TryGetJoinChannelIndex(confirmedRequest.RadioMetadata.Frequency, out var channelIndex))
{
deviceJoinInfo = new DeviceJoinInfo(channelIndex);
}
Assert.True(region.TryGetDownstreamChannelFrequency(confirmedRequest.RadioMetadata.Frequency, confirmedRequest.RadioMetadata.DataRate, deviceJoinInfo, downstreamFrequency: out var frequency));
Assert.Equal(frequency, downstreamMessage.Rx1?.Frequency);
var rx2Freq = region.GetDownstreamRX2Freq(null, deviceJoinInfo, NullLogger.Instance);
Assert.Equal(rx2Freq, downstreamMessage.Rx2.Frequency);
var rx2DataRate = region.GetDownstreamRX2DataRate(null, null, deviceJoinInfo, NullLogger.Instance);
Assert.Equal(rx2DataRate, downstreamMessage.Rx2.DataRate);
// fcnt up was updated
Assert.Equal(startingPayloadFcnt + 1, loRaDevice.FCntUp);
Assert.Equal(1U, loRaDevice.FCntDown);
// Frame change flag will be set, only saving every 10 messages
Assert.True(loRaDevice.HasFrameCountChanges);
// C2D message will be checked twice (for AS923 only once, since we use the first C2D message to send the dwell time MAC command)
var numberOfC2DMessageChecks = region is RegionAS923 ? 1 : 2;
LoRaDeviceClient.Verify(x => x.ReceiveAsync(It.IsNotNull <TimeSpan>()), Times.Exactly(numberOfC2DMessageChecks));
// has telemetry with both fcnt
Assert.Single(sentTelemetry, (t) => t.Fcnt == startingPayloadFcnt);
Assert.Single(sentTelemetry, (t) => t.Fcnt == (startingPayloadFcnt + 1));
// should not save class C device properties
Assert.False(actualSavedTwin.Contains(TwinProperty.Region));
Assert.False(actualSavedTwin.Contains(TwinProperty.PreferredGatewayID));
LoRaDeviceClient.VerifyAll();
}
public async Task When_Multiple_Joins_Are_Received_Should_Get_Twins_Once(string deviceGatewayID)
{
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateOTAADevice(1, gatewayID: deviceGatewayID));
var devAddr = (DevAddr?)null;
var devEui = simulatedDevice.LoRaDevice.DevEui;
// Device twin will be queried
var twin = new Twin();
twin.Properties.Desired[TwinProperty.DevEUI] = devEui.ToString();
twin.Properties.Desired[TwinProperty.AppEui] = simulatedDevice.LoRaDevice.AppEui?.ToString();
twin.Properties.Desired[TwinProperty.AppKey] = simulatedDevice.LoRaDevice.AppKey?.ToString();
twin.Properties.Desired[TwinProperty.GatewayID] = deviceGatewayID;
twin.Properties.Desired[TwinProperty.SensorDecoder] = simulatedDevice.LoRaDevice.SensorDecoder;
LoRaDeviceClient.Setup(x => x.GetTwinAsync(CancellationToken.None))
.ReturnsAsync(twin);
// Device twin will be updated
LoRaDeviceClient.Setup(x => x.UpdateReportedPropertiesAsync(It.IsNotNull <TwinCollection>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(true);
// Lora device api will be search by devices with matching deveui
LoRaDeviceApi.Setup(x => x.SearchAndLockForJoinAsync(ServerConfiguration.GatewayID, devEui, It.IsAny <DevNonce>()))
.ReturnsAsync(new SearchDevicesResult(new IoTHubDeviceInfo(devAddr, devEui, "aabb").AsList()));
// using factory to create mock of
using var memoryCache = new MemoryCache(new MemoryCacheOptions());
using var deviceRegistry = new LoRaDeviceRegistry(ServerConfiguration, memoryCache, LoRaDeviceApi.Object, LoRaDeviceFactory, DeviceCache);
using var messageProcessor = new MessageDispatcher(
ServerConfiguration,
deviceRegistry,
FrameCounterUpdateStrategyProvider);
// 1st join request
using var joinRequest1 =
CreateWaitableRequest(simulatedDevice.CreateJoinRequest());
messageProcessor.DispatchRequest(joinRequest1);
await Task.Delay(100);
// 2nd join request
using var joinRequest2 =
CreateWaitableRequest(simulatedDevice.CreateJoinRequest());
messageProcessor.DispatchRequest(joinRequest2);
await Task.WhenAll(joinRequest1.WaitCompleteAsync(), joinRequest2.WaitCompleteAsync());
Assert.Equal(2, DownstreamMessageSender.DownlinkMessages.Count);
Assert.NotNull(joinRequest1.ResponseDownlink);
Assert.NotNull(joinRequest2.ResponseDownlink);
// get twin only once called
LoRaDeviceClient.Verify(x => x.GetTwinAsync(CancellationToken.None), Times.Once());
// get device for join called x2
LoRaDeviceApi.Verify(x => x.SearchAndLockForJoinAsync(ServerGatewayID, devEui, It.IsAny <DevNonce>()), Times.Exactly(2));
LoRaDeviceClient.VerifyAll();
LoRaDeviceApi.VerifyAll();
}
public async Task When_Getting_C2D_Message_Fails_To_Resolve_Fcnt_Down_Should_Abandon_Message_And_Return_Null()
{
const uint initialFcntDown = 5;
const uint initialFcntUp = 21;
const uint payloadFcnt = 23;
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1, gatewayID: null))
{
FrmCntUp = initialFcntUp,
FrmCntDown = initialFcntDown
};
var devEui = simulatedDevice.LoRaDevice.DevEui;
// message will be sent
LoRaDeviceClient.Setup(x => x.SendEventAsync(It.IsNotNull <LoRaDeviceTelemetry>(), null))
.ReturnsAsync(true);
var c2dMessage = new ReceivedLoRaCloudToDeviceMessage()
{
Fport = FramePorts.App1
};
using var cloudToDeviceMessage = c2dMessage.CreateMessage();
// C2D message will be retrieved
LoRaDeviceClient.Setup(x => x.ReceiveAsync(It.IsAny <TimeSpan>()))
.ReturnsAsync(cloudToDeviceMessage);
// C2D message will not be abandoned
// getting the fcnt down will return 0!
LoRaDeviceApi.Setup(x => x.NextFCntDownAsync(devEui, initialFcntDown, payloadFcnt, ServerConfiguration.GatewayID))
.ReturnsAsync((ushort)0);
var cachedDevice = CreateLoRaDevice(simulatedDevice);
using var cache = EmptyMemoryCache();
using var loraDeviceCache = CreateDeviceCache(cachedDevice);
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("hello", fcnt: payloadFcnt);
using var unconfirmedRequest = CreateWaitableRequest(unconfirmedMessagePayload);
messageDispatcher.DispatchRequest(unconfirmedRequest);
Assert.True(await unconfirmedRequest.WaitCompleteAsync());
Assert.Null(unconfirmedRequest.ResponseDownlink);
Assert.True(loraDeviceCache.TryGetForPayload(unconfirmedRequest.Payload, out var loRaDevice));
// fcnt down did not change
Assert.Equal(initialFcntDown, loRaDevice.FCntDown);
// fcnt up changed
Assert.Equal(unconfirmedMessagePayload.Fcnt, loRaDevice.FCntUp);
LoRaDeviceClient.Verify(x => x.ReceiveAsync(It.IsAny <TimeSpan>()), Times.Once());
LoRaDeviceClient.Verify(x => x.AbandonAsync(It.IsAny <Message>()), Times.Once());
LoRaDeviceClient.VerifyAll();
LoRaDeviceApi.VerifyAll();
}
public async Task When_Resent_Message_Using_Custom_Decoder_Returns_Complex_Object_Should_Send_Decoded_Value()
{
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1, gatewayID: ServerGatewayID));
var loRaDevice = CreateLoRaDevice(simulatedDevice);
loRaDevice.SensorDecoder = "http://customdecoder/test1";
// 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);
_ = LoRaDeviceClient.Setup(x => x.UpdateReportedPropertiesAsync(It.IsAny <TwinCollection>(), It.IsAny <CancellationToken>())).ReturnsAsync(true);
// C2D message will be checked
// LoRaDeviceClient.Setup(x => x.ReceiveAsync(It.IsNotNull<TimeSpan>()))
// .ReturnsAsync((Message)null);
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);
var decodedObject = new { temp = 10, humidity = 22.1, text = "abc", cloudToDeviceMessage = new { test = 1 } };
using var httpMessageHandler = new HttpMessageHandlerMock();
_ = httpMessageHandler.SetupHandler((r) =>
{
return(new HttpResponseMessage(System.Net.HttpStatusCode.OK)
{
Content = new StringContent(JsonConvert.SerializeObject(decodedObject), Encoding.UTF8, "application/json"),
});
});
using var httpClient = new HttpClient(httpMessageHandler);
PayloadDecoder.SetDecoder(new LoRaPayloadDecoder(httpClient));
// sends confirmed message
var confirmedMessagePayload = simulatedDevice.CreateConfirmedDataUpMessage("1", fcnt: 10);
using var request = CreateWaitableRequest(confirmedMessagePayload);
messageDispatcher.DispatchRequest(request);
Assert.True(await request.WaitCompleteAsync());
Assert.NotNull(request.ResponseDownlink);
Assert.NotNull(loRaDeviceTelemetry);
var rawPayload = Convert.ToBase64String(Encoding.UTF8.GetBytes("1"));
Assert.Equal(rawPayload, loRaDeviceTelemetry.Rawdata);
// 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\":{{\"temp\":10,\"humidity\":22.1,\"text\":\"abc\"}},\"port\":1,\"fcnt\":10,\"edgets\":{loRaDeviceTelemetry.Edgets},\"rawdata\":\"{rawPayload}\",\"eui\":\"0000000000000001\",\"gatewayid\":\"test-gateway\",\"stationeui\":\"0000000000000000\"}}";
Assert.Equal(expectedTelemetryJson, actualJsonTelemetry);
// send a second confirmed message with same fcnt to simulate
using var request2 = CreateWaitableRequest(confirmedMessagePayload);
messageDispatcher.DispatchRequest(request2);
Assert.True(await request2.WaitCompleteAsync());
Assert.NotNull(request2.ResponseDownlink);
Assert.NotNull(loRaDeviceTelemetry);
var rawPayload2 = Convert.ToBase64String(Encoding.UTF8.GetBytes("1"));
Assert.Equal(rawPayload2, loRaDeviceTelemetry.Rawdata);
LoRaDeviceClient.Verify(x => x.SendEventAsync(It.IsNotNull <LoRaDeviceTelemetry>(), null), Times.Exactly(2));
LoRaDeviceApi.VerifyAll();
LoRaDeviceClient.VerifyAll();
}
public async Task Multi_OTAA_Unconfirmed_Message_Should_Send_Data_To_IotHub_Update_FcntUp_And_Return_Null()
{
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1));
// 1 messages will be sent
LoRaDeviceClient.Setup(x => x.SendEventAsync(It.IsNotNull <LoRaDeviceTelemetry>(), null))
.ReturnsAsync(true);
SecondLoRaDeviceClient.Setup(x => x.SendEventAsync(It.IsNotNull <LoRaDeviceTelemetry>(), null))
.ReturnsAsync(true);
LoRaDeviceApi.Setup(x => x.ABPFcntCacheResetAsync(It.IsNotNull <DevEui>(), It.IsAny <uint>(), It.IsNotNull <string>()))
.ReturnsAsync(true);
SecondLoRaDeviceApi.Setup(x => x.ABPFcntCacheResetAsync(It.IsNotNull <DevEui>(), It.IsAny <uint>(), It.IsNotNull <string>()))
.ReturnsAsync(true);
// cloud to device messages will be checked twice
LoRaDeviceClient.SetupSequence(x => x.ReceiveAsync(It.IsNotNull <TimeSpan>()))
.ReturnsAsync((Message)null)
.ReturnsAsync((Message)null);
SecondLoRaDeviceClient.SetupSequence(x => x.ReceiveAsync(It.IsNotNull <TimeSpan>()))
.ReturnsAsync((Message)null)
.ReturnsAsync((Message)null);
using var loRaDevice1 = CreateLoRaDevice(simulatedDevice);
using var connectionManager2 = new SingleDeviceConnectionManager(SecondLoRaDeviceClient.Object);
using var loRaDevice2 = TestUtils.CreateFromSimulatedDevice(simulatedDevice, connectionManager2, SecondRequestHandlerImplementation);
using var cache1 = EmptyMemoryCache();
using var loraDeviceCache = CreateDeviceCache(loRaDevice1);
using var loRaDeviceRegistry1 = new LoRaDeviceRegistry(ServerConfiguration, cache1, LoRaDeviceApi.Object, LoRaDeviceFactory, loraDeviceCache);
using var cache2 = EmptyMemoryCache();
using var loraDeviceCache2 = CreateDeviceCache(loRaDevice2);
using var loRaDeviceRegistry2 = new LoRaDeviceRegistry(ServerConfiguration, cache2, SecondLoRaDeviceApi.Object, SecondLoRaDeviceFactory, loraDeviceCache2);
// Send to message processor
using var messageProcessor1 = new MessageDispatcher(
ServerConfiguration,
loRaDeviceRegistry1,
FrameCounterUpdateStrategyProvider);
using var messageProcessor2 = new MessageDispatcher(
SecondServerConfiguration,
loRaDeviceRegistry2,
SecondFrameCounterUpdateStrategyProvider);
// Starts with fcnt up zero
Assert.Equal(0U, loRaDevice1.FCntUp);
Assert.Equal(0U, loRaDevice2.FCntUp);
var payload = simulatedDevice.CreateUnconfirmedDataUpMessage("1234", fcnt: 1);
// Create Rxpk
using var request1 = CreateWaitableRequest(payload, DownstreamMessageSender);
using var request2 = CreateWaitableRequest(payload, SecondDownstreamMessageSender);
messageProcessor1.DispatchRequest(request1);
messageProcessor2.DispatchRequest(request2);
await Task.WhenAll(request1.WaitCompleteAsync(), request2.WaitCompleteAsync());
// Expectations
// 1. Message was sent to IoT Hub
LoRaDeviceClient.VerifyAll();
SecondLoRaDeviceClient.VerifyAll();
LoRaDeviceApi.VerifyAll();
SecondLoRaDeviceApi.VerifyAll();
LoRaDeviceClient.Verify(x => x.SendEventAsync(It.IsNotNull <LoRaDeviceTelemetry>(), null), Times.Once());
SecondLoRaDeviceClient.Verify(x => x.SendEventAsync(It.IsNotNull <LoRaDeviceTelemetry>(), null), Times.Once());
// 2. Return is null (there is nothing to send downstream)
Assert.Null(request1.ResponseDownlink);
Assert.Null(request2.ResponseDownlink);
// 3. Frame counter up was updated to 1
Assert.Equal(1U, loRaDevice1.FCntUp);
Assert.Equal(1U, loRaDevice2.FCntUp);
// the following setup is required after VerifyAll() is called
LoRaDeviceClient.Setup(ldc => ldc.Dispose());
SecondLoRaDeviceClient.Setup(ldc => ldc.Dispose());
}
public async Task After_Disconnecting_Should_Reconnect()
{
var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1))
{
FrmCntUp = 10
};
var isDisconnected = false;
// 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(isDisconnected ? throw new InvalidOperationException("Test setup requires that it may not be disconnected.") : true);
// C2D message will be checked
LoRaDeviceClient.Setup(x => x.ReceiveAsync(It.IsNotNull <TimeSpan>()))
.ReturnsAsync(isDisconnected ? throw new InvalidOperationException("Test setup requires that it may not be disconnected.") : (Message)null);
// will check client connection
LoRaDeviceClient.Setup(x => x.EnsureConnected())
.Callback(() => isDisconnected = false)
.Returns(true);
// will disconnected client
using var disconnectedEvent = new SemaphoreSlim(0, 1);
LoRaDeviceClient.Setup(x => x.Disconnect())
.Callback(() =>
{
disconnectedEvent.Release();
isDisconnected = true;
})
.Returns(true);
var cachedDevice = CreateLoRaDevice(simulatedDevice);
cachedDevice.KeepAliveTimeout = 3;
using var cache = EmptyMemoryCache();
using var loraDeviceCache = CreateDeviceCache(cachedDevice);
using var deviceRegistry = new LoRaDeviceRegistry(ServerConfiguration, cache, LoRaDeviceApi.Object, LoRaDeviceFactory, loraDeviceCache);
using var messageDispatcher = new MessageDispatcher(
ServerConfiguration,
deviceRegistry,
FrameCounterUpdateStrategyProvider);
// sends unconfirmed message #1
using var request1 = CreateWaitableRequest(simulatedDevice.CreateUnconfirmedDataUpMessage("1"));
messageDispatcher.DispatchRequest(request1);
Assert.True(await request1.WaitCompleteAsync());
Assert.True(request1.ProcessingSucceeded);
await EnsureDisconnectedAsync(disconnectedEvent);
// sends unconfirmed message #2
using var request2 = CreateWaitableRequest(simulatedDevice.CreateUnconfirmedDataUpMessage("2"));
messageDispatcher.DispatchRequest(request2);
Assert.True(await request2.WaitCompleteAsync());
Assert.True(request2.ProcessingSucceeded);
await EnsureDisconnectedAsync(disconnectedEvent);
LoRaDeviceClient.Verify(x => x.Disconnect(), Times.Exactly(2));
LoRaDeviceClient.Verify(x => x.EnsureConnected(), Times.Exactly(2));
LoRaDeviceClient.VerifyAll();
LoRaDeviceApi.VerifyAll();
}
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>()));
}
}
