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 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 async Task MessageProcessor_End2End_NoDep_ClassC_CloudToDeviceMessage_SizeLimit_Should_Reject(
bool hasMacInC2D)
{
var simulatedDevice = new SimulatedDevice(
TestDeviceInfo.CreateABPDevice(
1, deviceClassType: 'c', gatewayID: this.serverConfiguration.GatewayID));
var devEUI = simulatedDevice.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(simulatedDevice.CreateABPTwin());
var c2dMessageMacCommand = new DevStatusRequest();
var c2dMessageMacCommandSize = hasMacInC2D ? c2dMessageMacCommand.Length : 0;
var datr = this.loRaRegion.DRtoConfiguration[this.loRaRegion.RX2DefaultReceiveWindows.dr].configuration;
var c2dPayloadSize = this.loRaRegion.GetMaxPayloadSize(datr)
- c2dMessageMacCommandSize
+ 1 // make message too long on purpose
- Constants.LORA_PROTOCOL_OVERHEAD_SIZE;
var c2dMsgPayload = this.GeneratePayload("123457890", (int)c2dPayloadSize);
var c2d = new ReceivedLoRaCloudToDeviceMessage()
{
DevEUI = devEUI,
Payload = c2dMsgPayload,
Fport = 1,
};
if (hasMacInC2D)
{
c2d.MacCommands = new[] { c2dMessageMacCommand };
}
var cloudToDeviceMessage = c2d.CreateMessage();
var target = new DefaultClassCDevicesMessageSender(
this.serverConfiguration,
this.loRaDeviceRegistry,
this.PacketForwarder,
this.frameCounterStrategyProvider);
// Expectations
// Verify that C2D message is sent
Assert.False(await target.SendAsync(c2d));
// Verify that exactly one C2D message was received
Assert.Empty(this.PacketForwarder.DownlinkMessages);
this.deviceApi.VerifyAll();
this.deviceClient.VerifyAll();
}
public async Task Should_Accept(
bool isConfirmed,
bool hasMacInUpstream,
bool hasMacInC2D,
bool isTooLongForUpstreamMacCommandInAnswer,
bool isSendingInRx2,
[CombinatorialValues("SF10BW125", "SF9BW125", "SF8BW125", "SF7BW125")] string datr)
{
const int InitialDeviceFcntUp = 9;
const int InitialDeviceFcntDown = 20;
// This scenario makes no sense
if (hasMacInUpstream && isTooLongForUpstreamMacCommandInAnswer)
{
return;
}
var simulatedDevice = new SimulatedDevice(
TestDeviceInfo.CreateABPDevice(1, gatewayID: ServerConfiguration.GatewayID),
frmCntUp: InitialDeviceFcntUp,
frmCntDown: InitialDeviceFcntDown);
var loraDevice = CreateLoRaDevice(simulatedDevice);
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 = TestUtils.TestRegion;
var c2dMessageMacCommand = new DevStatusRequest();
var c2dMessageMacCommandSize = hasMacInC2D ? c2dMessageMacCommand.Length : 0;
var upstreamMessageMacCommandSize = 0;
DataRateIndex expectedDownlinkDatr;
if (hasMacInUpstream && !isTooLongForUpstreamMacCommandInAnswer)
{
upstreamMessageMacCommandSize = new LinkCheckAnswer(1, 1).Length;
}
expectedDownlinkDatr = isSendingInRx2
? euRegion.GetDefaultRX2ReceiveWindow(default).DataRate
public async Task Should_Accept(
bool isConfirmed,
bool hasMacInUpstream,
bool hasMacInC2D,
bool isTooLongForUpstreamMacCommandInAnswer,
bool isSendingInRx2,
[CombinatorialValues("SF10BW125", "SF9BW125", "SF8BW125", "SF7BW125")] string datr)
{
const int InitialDeviceFcntUp = 9;
const int InitialDeviceFcntDown = 20;
// This scenario makes no sense
if (hasMacInUpstream && isTooLongForUpstreamMacCommandInAnswer)
{
return;
}
var simulatedDevice = new SimulatedDevice(
TestDeviceInfo.CreateABPDevice(1, gatewayID: this.ServerConfiguration.GatewayID),
frmCntUp: InitialDeviceFcntUp,
frmCntDown: InitialDeviceFcntDown);
var loraDevice = this.CreateLoRaDevice(simulatedDevice);
Rxpk rxpk = this.CreateUpstreamRxpk(isConfirmed, hasMacInUpstream, datr, simulatedDevice);
if (!hasMacInUpstream)
{
this.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;
var upstreamMessageMacCommandSize = 0;
string expectedDownlinkDatr;
if (hasMacInUpstream && !isTooLongForUpstreamMacCommandInAnswer)
{
upstreamMessageMacCommandSize = new LinkCheckAnswer(1, 1).Length;
}
if (isSendingInRx2)
{
expectedDownlinkDatr = euRegion.DRtoConfiguration[euRegion.RX2DefaultReceiveWindows.dr].configuration;
}
else
{
expectedDownlinkDatr = datr;
}
var c2dPayloadSize = euRegion.GetMaxPayloadSize(expectedDownlinkDatr)
- c2dMessageMacCommandSize
- upstreamMessageMacCommandSize
- Constants.LORA_PROTOCOL_OVERHEAD_SIZE;
var c2dMessagePayload = TestUtils.GeneratePayload("123457890", (int)c2dPayloadSize);
var c2dMessage = new ReceivedLoRaCloudToDeviceMessage()
{
Payload = c2dMessagePayload,
Fport = 1,
};
if (hasMacInC2D)
{
c2dMessage.MacCommands = new[] { c2dMessageMacCommand };
}
var cloudToDeviceMessage = c2dMessage.CreateMessage();
this.LoRaDeviceClient.SetupSequence(x => x.ReceiveAsync(It.IsAny <TimeSpan>()))
.ReturnsAsync(cloudToDeviceMessage)
.ReturnsAsync((Message)null);
this.LoRaDeviceClient.Setup(x => x.CompleteAsync(cloudToDeviceMessage))
.ReturnsAsync(true);
var deviceRegistry = new LoRaDeviceRegistry(this.ServerConfiguration, this.NewNonEmptyCache(loraDevice), this.LoRaDeviceApi.Object, this.LoRaDeviceFactory);
// Send to message processor
var messageProcessor = new MessageDispatcher(
this.ServerConfiguration,
deviceRegistry,
this.FrameCounterUpdateStrategyProvider);
var startTimeOffset = isSendingInRx2 ? TestUtils.GetStartTimeOffsetForSecondWindow() : TimeSpan.Zero;
var request = this.CreateWaitableRequest(rxpk, startTimeOffset: startTimeOffset);
messageProcessor.DispatchRequest(request);
// Expectations
// 1. Message was sent to IoT Hub
Assert.True(await request.WaitCompleteAsync());
Assert.True(request.ProcessingSucceeded);
// 2. Return is downstream message
Assert.NotNull(request.ResponseDownlink);
Assert.Equal(expectedDownlinkDatr, request.ResponseDownlink.Txpk.Datr);
// Get downlink message
var downlinkMessage = this.PacketForwarder.DownlinkMessages[0];
var payloadDataDown = new LoRaPayloadData(Convert.FromBase64String(downlinkMessage.Txpk.Data));
payloadDataDown.PerformEncryption(loraDevice.AppSKey);
// 3. downlink message payload contains expected message type and DevAddr
Assert.Equal(payloadDataDown.DevAddr.ToArray(), LoRaTools.Utils.ConversionHelper.StringToByteArray(loraDevice.DevAddr));
Assert.Equal(LoRaMessageType.UnconfirmedDataDown, payloadDataDown.LoRaMessageType);
// 4. Expected Mac commands are present
var expectedMacCommandsCount = 0;
if (hasMacInC2D)
{
expectedMacCommandsCount++;
}
if (hasMacInUpstream && !isTooLongForUpstreamMacCommandInAnswer)
{
expectedMacCommandsCount++;
}
if (expectedMacCommandsCount > 0)
{
// Possible problem: Manually casting payloadDataDown.Fopts to array and reversing it
var macCommands = MacCommand.CreateServerMacCommandFromBytes(simulatedDevice.DevEUI, payloadDataDown.Fopts.ToArray().Reverse().ToArray());
Assert.Equal(expectedMacCommandsCount, macCommands.Count);
}
else
{
Assert.Null(payloadDataDown.MacCommands);
}
this.LoRaDeviceClient.VerifyAll();
this.LoRaDeviceApi.VerifyAll();
}
public async Task Should_Reject(
bool isConfirmed,
bool hasMacInUpstream,
bool hasMacInC2D,
[CombinatorialValues("SF10BW125", "SF9BW125", "SF8BW125", "SF7BW125")] string datr)
{
const int InitialDeviceFcntUp = 9;
const int InitialDeviceFcntDown = 20;
var simulatedDevice = new SimulatedDevice(
TestDeviceInfo.CreateABPDevice(1, gatewayID: this.ServerConfiguration.GatewayID),
frmCntUp: InitialDeviceFcntUp,
frmCntDown: InitialDeviceFcntDown);
var loraDevice = this.CreateLoRaDevice(simulatedDevice);
Rxpk rxpk = this.CreateUpstreamRxpk(isConfirmed, hasMacInUpstream, datr, simulatedDevice);
if (!hasMacInUpstream)
{
this.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;
var upstreamMessageMacCommandSize = 0;
string expectedDownlinkDatr;
if (hasMacInUpstream)
{
upstreamMessageMacCommandSize = new LinkCheckAnswer(1, 1).Length;
}
expectedDownlinkDatr = datr;
var c2dPayloadSize = euRegion.GetMaxPayloadSize(expectedDownlinkDatr)
- c2dMessageMacCommandSize
+ 1 // make message too long on purpose
- Constants.LORA_PROTOCOL_OVERHEAD_SIZE;
var c2dMessagePayload = TestUtils.GeneratePayload("123457890", (int)c2dPayloadSize);
var c2dMessage = new ReceivedLoRaCloudToDeviceMessage()
{
Payload = c2dMessagePayload,
Fport = 1,
};
if (hasMacInC2D)
{
c2dMessage.MacCommands = new[] { c2dMessageMacCommand };
}
var cloudToDeviceMessage = c2dMessage.CreateMessage();
this.LoRaDeviceClient.Setup(x => x.ReceiveAsync(It.IsAny <TimeSpan>()))
.ReturnsAsync(cloudToDeviceMessage);
this.LoRaDeviceClient.Setup(x => x.RejectAsync(cloudToDeviceMessage))
.ReturnsAsync(true);
var deviceRegistry = new LoRaDeviceRegistry(this.ServerConfiguration, this.NewNonEmptyCache(loraDevice), 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);
// Expectations
// 1. Message was sent to IoT Hub
Assert.True(await request.WaitCompleteAsync());
Assert.True(request.ProcessingSucceeded);
var shouldHaveADownlink = isConfirmed || hasMacInUpstream;
// 2. Return is downstream message ONLY
// if is confirmed or had Mac commands in upstream message
if (shouldHaveADownlink)
{
Assert.NotNull(request.ResponseDownlink);
Assert.Equal(expectedDownlinkDatr, request.ResponseDownlink.Txpk.Datr);
var downlinkMessage = this.PacketForwarder.DownlinkMessages[0];
var payloadDataDown = new LoRaPayloadData(Convert.FromBase64String(downlinkMessage.Txpk.Data));
payloadDataDown.PerformEncryption(loraDevice.AppSKey);
Assert.Equal(payloadDataDown.DevAddr.ToArray(), LoRaTools.Utils.ConversionHelper.StringToByteArray(loraDevice.DevAddr));
Assert.Equal(LoRaMessageType.UnconfirmedDataDown, payloadDataDown.LoRaMessageType);
if (hasMacInUpstream)
{
Assert.Equal(new LinkCheckAnswer(1, 1).Length, payloadDataDown.Frmpayload.Length);
Assert.Equal(0, payloadDataDown.GetFPort());
}
}
else
{
Assert.Null(request.ResponseDownlink);
}
this.LoRaDeviceClient.VerifyAll();
this.LoRaDeviceApi.VerifyAll();
}
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: this.ServerConfiguration.GatewayID),
frmCntUp: InitialDeviceFcntUp,
frmCntDown: InitialDeviceFcntDown);
var loraDevice = this.CreateLoRaDevice(simulatedDevice);
Rxpk rxpk = this.CreateUpstreamRxpk(isConfirmed, hasMacInUpstream, datr, simulatedDevice);
if (!hasMacInUpstream)
{
this.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;
var upstreamMessageMacCommandSize = 0;
string expectedDownlinkDatr;
if (hasMacInUpstream)
{
upstreamMessageMacCommandSize = new LinkCheckAnswer(1, 1).Length;
}
expectedDownlinkDatr = euRegion.DRtoConfiguration[euRegion.RX2DefaultReceiveWindows.dr].configuration;
var c2dPayloadSize = euRegion.GetMaxPayloadSize(expectedDownlinkDatr)
- c2dMessageMacCommandSize
+ 1 // make message too long on purpose
- Constants.LORA_PROTOCOL_OVERHEAD_SIZE;
var c2dMessagePayload = TestUtils.GeneratePayload("123457890", (int)c2dPayloadSize);
var c2dMessage = new ReceivedLoRaCloudToDeviceMessage()
{
Payload = c2dMessagePayload,
Fport = 1,
};
if (hasMacInC2D)
{
c2dMessage.MacCommands = new[] { c2dMessageMacCommand };
}
var cloudToDeviceMessage = c2dMessage.CreateMessage();
this.LoRaDeviceClient.Setup(x => x.ReceiveAsync(It.IsAny <TimeSpan>()))
.Callback <TimeSpan>((_) =>
{
this.LoRaDeviceClient.Setup(x => x.ReceiveAsync(It.IsAny <TimeSpan>()))
.ReturnsAsync((Message)null);
})
.ReturnsAsync(cloudToDeviceMessage);
this.LoRaDeviceClient.Setup(x => x.AbandonAsync(cloudToDeviceMessage))
.ReturnsAsync(true);
var deviceRegistry = new LoRaDeviceRegistry(this.ServerConfiguration, this.NewNonEmptyCache(loraDevice), this.LoRaDeviceApi.Object, this.LoRaDeviceFactory);
// Send to message processor
var messageProcessor = new MessageDispatcher(
this.ServerConfiguration,
deviceRegistry,
this.FrameCounterUpdateStrategyProvider);
var request = this.CreateWaitableRequest(rxpk, startTimeOffset: TestUtils.GetStartTimeOffsetForSecondWindow(), constantElapsedTime: TimeSpan.FromMilliseconds(1002));
messageProcessor.DispatchRequest(request);
// Expectations
// 1. Message was sent to IoT Hub
Assert.True(await request.WaitCompleteAsync());
Assert.True(request.ProcessingSucceeded);
// 2. Return is downstream message
Assert.NotNull(request.ResponseDownlink);
Assert.Equal(expectedDownlinkDatr, request.ResponseDownlink.Txpk.Datr);
var downlinkMessage = this.PacketForwarder.DownlinkMessages[0];
var payloadDataDown = new LoRaPayloadData(Convert.FromBase64String(downlinkMessage.Txpk.Data));
payloadDataDown.PerformEncryption(loraDevice.AppSKey);
// 3. Fpending flag is set
Assert.Equal((byte)FctrlEnum.FpendingOrClassB, payloadDataDown.Fctrl.Span[0] & (byte)FctrlEnum.FpendingOrClassB);
Assert.Equal(payloadDataDown.DevAddr.ToArray(), LoRaTools.Utils.ConversionHelper.StringToByteArray(loraDevice.DevAddr));
Assert.Equal(LoRaMessageType.UnconfirmedDataDown, payloadDataDown.LoRaMessageType);
// Expected Mac command is present
if (hasMacInUpstream)
{
// Possible problem: manually casting frmPayload to array. No reversal.
var frmPayload = payloadDataDown.Frmpayload.ToArray();
var macCommands = MacCommand.CreateServerMacCommandFromBytes(simulatedDevice.DevEUI, frmPayload);
Assert.Single(macCommands);
Assert.IsType <LinkCheckAnswer>(macCommands.First());
}
else
{
Assert.Null(payloadDataDown.MacCommands);
}
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.SearchByDevEUIAsync(devEUI))
.ReturnsAsync(new SearchDevicesResult(
new IoTHubDeviceInfo(string.Empty, devEUI, "123").AsList()));
var twin = simulatedDevice.CreateABPTwin(reportedProperties: new Dictionary <string, object>
{
{ TwinProperty.Region, LoRaRegionType.EU868.ToString() }
});
this.deviceClient.Setup(x => x.GetTwinAsync())
.ReturnsAsync(twin);
var c2dMessageMacCommand = new DevStatusRequest();
var c2dMessageMacCommandSize = hasMacInC2D ? c2dMessageMacCommand.Length : 0;
var datr = this.loRaRegion.DRtoConfiguration[this.loRaRegion.RX2DefaultReceiveWindows.dr].configuration;
var c2dPayloadSize = this.loRaRegion.GetMaxPayloadSize(datr)
- c2dMessageMacCommandSize
- Constants.LORA_PROTOCOL_OVERHEAD_SIZE;
var c2dMsgPayload = this.GeneratePayload("123457890", (int)c2dPayloadSize);
var c2d = new ReceivedLoRaCloudToDeviceMessage()
{
DevEUI = devEUI,
Payload = c2dMsgPayload,
Fport = 1,
};
if (hasMacInC2D)
{
c2d.MacCommands = new[] { c2dMessageMacCommand };
}
var cloudToDeviceMessage = c2d.CreateMessage();
var target = new DefaultClassCDevicesMessageSender(
this.serverConfiguration,
this.loRaDeviceRegistry,
this.PacketForwarder,
this.frameCounterStrategyProvider);
// Expectations
// Verify that C2D message is sent
Assert.True(await target.SendAsync(c2d));
// Verify that exactly one C2D message was received
Assert.Single(this.PacketForwarder.DownlinkMessages);
// Verify donwlink message is correct
this.EnsureDownlinkIsCorrect(
this.PacketForwarder.DownlinkMessages.First(), simulatedDevice, c2d);
// Get C2D message payload
var downlinkMessage = this.PacketForwarder.DownlinkMessages[0];
var payloadDataDown = new LoRaPayloadData(
Convert.FromBase64String(downlinkMessage.Txpk.Data));
payloadDataDown.PerformEncryption(simulatedDevice.AppSKey);
// Verify that expected Mac commands are present
var expectedMacCommandsCount = 0;
if (hasMacInC2D)
{
expectedMacCommandsCount++;
}
if (expectedMacCommandsCount > 0)
{
var macCommands = MacCommand.CreateServerMacCommandFromBytes(
simulatedDevice.DevEUI, payloadDataDown.Fopts);
Assert.Equal(expectedMacCommandsCount, macCommands.Count);
}
else
{
Assert.Null(payloadDataDown.MacCommands);
}
this.deviceApi.VerifyAll();
this.deviceClient.VerifyAll();
}
public async Task Should_Reject(
bool isConfirmed,
bool hasMacInUpstream,
bool hasMacInC2D,
[CombinatorialValues("SF10BW125", "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(radioMetaData, loraPayload) = CreateUpstreamMessage(isConfirmed, hasMacInUpstream, LoRaDataRate.Parse(datr), simulatedDevice);
if (!hasMacInUpstream)
{
LoRaDeviceClient.Setup(x => x.SendEventAsync(It.IsNotNull <LoRaDeviceTelemetry>(), null))
.ReturnsAsync(true);
}
var region = TestUtils.TestRegion;
var c2dMessageMacCommand = new DevStatusRequest();
var c2dMessageMacCommandSize = hasMacInC2D ? c2dMessageMacCommand.Length : 0;
var expectedDownlinkDatr = region.GetDataRateIndex(LoRaDataRate.Parse(datr));
var c2dPayloadSize = region.GetMaxPayloadSize(expectedDownlinkDatr)
- c2dMessageMacCommandSize
+ 1 // make message too long on purpose
- Constants.LoraProtocolOverheadSize;
var c2dMessagePayload = TestUtils.GeneratePayload("123457890", (int)c2dPayloadSize);
var c2dMessage = new ReceivedLoRaCloudToDeviceMessage()
{
Payload = c2dMessagePayload,
Fport = FramePorts.App1,
};
if (hasMacInC2D)
{
c2dMessage.MacCommands.Add(c2dMessageMacCommand);
}
using var cloudToDeviceMessage = c2dMessage.CreateMessage();
LoRaDeviceClient.Setup(x => x.ReceiveAsync(It.IsAny <TimeSpan>()))
.ReturnsAsync(cloudToDeviceMessage);
LoRaDeviceClient.Setup(x => x.RejectAsync(cloudToDeviceMessage))
.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 messageProcessor = new MessageDispatcher(
ServerConfiguration,
deviceRegistry,
FrameCounterUpdateStrategyProvider);
using var request = CreateWaitableRequest(radioMetaData, loraPayload, constantElapsedTime: TimeSpan.Zero);
messageProcessor.DispatchRequest(request);
// Expectations
// 1. Message was sent to IoT Hub
Assert.True(await request.WaitCompleteAsync());
Assert.True(request.ProcessingSucceeded);
var shouldHaveADownlink = isConfirmed || hasMacInUpstream;
// 2. Return is downstream message ONLY
// if is confirmed or had Mac commands in upstream message
if (shouldHaveADownlink)
{
Assert.NotNull(request.ResponseDownlink);
// TODO CHANGE THIS WHEN MOVING RXPK in #1086
// Assert.Equal(expectedDownlinkDatr, request.ResponseDownlink.Txpk.Datr);
var downlinkMessage = DownstreamMessageSender.DownlinkMessages[0];
var payloadDataDown = new LoRaPayloadData(downlinkMessage.Data);
payloadDataDown.Serialize(loraDevice.AppSKey.Value);
Assert.Equal(payloadDataDown.DevAddr, loraDevice.DevAddr);
Assert.Equal(MacMessageType.UnconfirmedDataDown, payloadDataDown.MessageType);
if (hasMacInUpstream)
{
Assert.Equal(new LinkCheckAnswer(1, 1).Length, payloadDataDown.Frmpayload.Length);
Assert.Equal(FramePort.MacCommand, payloadDataDown.Fport);
}
}
else
{
Assert.Null(request.ResponseDownlink);
}
LoRaDeviceClient.VerifyAll();
LoRaDeviceApi.VerifyAll();
}
