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();
}
/// <summary>
/// Prepare the Mac Commands to be sent in the downstream message.
/// </summary>
static ICollection <MacCommand> PrepareMacCommandAnswer(
string devEUI,
IEnumerable <MacCommand> requestedMacCommands,
IEnumerable <MacCommand> serverMacCommands,
Rxpk rxpk,
LoRaADRResult loRaADRResult)
{
var macCommands = new Dictionary <int, MacCommand>();
if (requestedMacCommands != null)
{
foreach (var requestedMacCommand in requestedMacCommands)
{
switch (requestedMacCommand.Cid)
{
case CidEnum.LinkCheckCmd:
{
if (rxpk != null)
{
var linkCheckAnswer = new LinkCheckAnswer(rxpk.GetModulationMargin(), 1);
if (macCommands.TryAdd((int)CidEnum.LinkCheckCmd, linkCheckAnswer))
{
Logger.Log(devEUI, $"answering to a MAC command request {linkCheckAnswer.ToString()}", LogLevel.Information);
}
}
break;
}
}
}
}
if (serverMacCommands != null)
{
foreach (var macCmd in serverMacCommands)
{
if (macCmd != null)
{
try
{
if (!macCommands.TryAdd((int)macCmd.Cid, macCmd))
{
Logger.Log(devEUI, $"could not send the cloud to device MAC command {macCmd.Cid}, as such a property was already present in the message. Please resend the cloud to device message", LogLevel.Error);
}
Logger.Log(devEUI, $"cloud to device MAC command {macCmd.Cid} received {macCmd}", LogLevel.Information);
}
catch (MacCommandException ex)
{
Logger.Log(devEUI, ex.ToString(), LogLevel.Error);
}
}
}
}
// ADR Part.
// Currently only replying on ADR Req
if (loRaADRResult?.CanConfirmToDevice == true)
{
const int placeholderChannel = 25;
LinkADRRequest linkADR = new LinkADRRequest((byte)loRaADRResult.DataRate, (byte)loRaADRResult.TxPower, placeholderChannel, 0, (byte)loRaADRResult.NbRepetition);
macCommands.Add((int)CidEnum.LinkADRCmd, linkADR);
Logger.Log(devEUI, $"performing a rate adaptation: DR {loRaADRResult.DataRate}, transmit power {loRaADRResult.TxPower}, #repetition {loRaADRResult.NbRepetition}", LogLevel.Information);
}
return(macCommands.Values);
}
/// <summary>
/// Prepare the Mac Commands to be sent in the downstream message.
/// </summary>
private static ICollection <MacCommand> PrepareMacCommandAnswer(
IEnumerable <MacCommand> requestedMacCommands,
IEnumerable <MacCommand> serverMacCommands,
LoRaRequest loRaRequest,
LoRaADRResult loRaADRResult,
ILogger logger)
{
var cids = new HashSet <Cid>();
var macCommands = new List <MacCommand>();
if (requestedMacCommands != null)
{
foreach (var requestedMacCommand in requestedMacCommands)
{
switch (requestedMacCommand.Cid)
{
case Cid.LinkCheckCmd:
case Cid.Zero:
case Cid.One:
case Cid.LinkADRCmd:
if (loRaRequest != null)
{
var linkCheckAnswer = new LinkCheckAnswer(checked ((byte)loRaRequest.Region.GetModulationMargin(loRaRequest.RadioMetadata.DataRate, loRaRequest.RadioMetadata.UpInfo.SignalNoiseRatio)), 1);
if (cids.Add(Cid.LinkCheckCmd))
{
macCommands.Add(linkCheckAnswer);
logger.LogInformation($"answering to a MAC command request {linkCheckAnswer}");
}
}
break;
case Cid.DutyCycleCmd:
case Cid.RXParamCmd:
case Cid.DevStatusCmd:
case Cid.NewChannelCmd:
case Cid.RXTimingCmd:
case Cid.TxParamSetupCmd:
default:
break;
}
}
}
if (serverMacCommands != null)
{
foreach (var macCmd in serverMacCommands)
{
if (macCmd != null)
{
try
{
if (cids.Add(macCmd.Cid))
{
macCommands.Add(macCmd);
}
else
{
logger.LogError($"could not send the cloud to device MAC command {macCmd.Cid}, as such a property was already present in the message. Please resend the cloud to device message");
}
logger.LogInformation($"cloud to device MAC command {macCmd.Cid} received {macCmd}");
}
catch (MacCommandException ex) when(ExceptionFilterUtility.True(() => logger.LogError(ex.ToString())))
{
// continue
}
}
}
}
// ADR Part.
// Currently only replying on ADR Req
if (loRaADRResult?.CanConfirmToDevice == true)
{
const int placeholderChannel = 25;
var linkADR = new LinkADRRequest((byte)loRaADRResult.DataRate, (byte)loRaADRResult.TxPower, placeholderChannel, 0, (byte)loRaADRResult.NbRepetition);
macCommands.Add(linkADR);
logger.LogInformation($"performing a rate adaptation: DR {loRaADRResult.DataRate}, transmit power {loRaADRResult.TxPower}, #repetition {loRaADRResult.NbRepetition}");
}
return(macCommands);
}
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();
}
