public MessageProcessorTestBase()
{
this.startTime = DateTimeOffset.UtcNow.Ticks;
this.macAddress = Utility.GetMacAddress();
this.ServerConfiguration = new NetworkServerConfiguration
{
GatewayID = ServerGatewayID,
LogToConsole = true,
LogLevel = ((int)LogLevel.Debug).ToString(),
};
Logger.Init(new LoggerConfiguration()
{
LogLevel = LogLevel.Debug,
LogToConsole = true,
});
this.PayloadDecoder = new TestLoRaPayloadDecoder(new LoRaPayloadDecoder());
this.PacketForwarder = new TestPacketForwarder();
this.LoRaDeviceApi = new Mock <LoRaDeviceAPIServiceBase>(MockBehavior.Strict);
this.FrameCounterUpdateStrategyProvider = new LoRaDeviceFrameCounterUpdateStrategyProvider(ServerGatewayID, this.LoRaDeviceApi.Object);
var deduplicationFactory = new DeduplicationStrategyFactory(this.LoRaDeviceApi.Object);
var adrStrategyProvider = new LoRaADRStrategyProvider();
var adrManagerFactory = new LoRAADRManagerFactory(this.LoRaDeviceApi.Object);
var functionBundlerProvider = new FunctionBundlerProvider(this.LoRaDeviceApi.Object);
this.RequestHandlerImplementation = new DefaultLoRaDataRequestHandler(this.ServerConfiguration, this.FrameCounterUpdateStrategyProvider, this.PayloadDecoder, deduplicationFactory, adrStrategyProvider, adrManagerFactory, functionBundlerProvider);
this.LoRaDeviceClient = new Mock <ILoRaDeviceClient>(MockBehavior.Strict);
this.ConnectionManager = new LoRaDeviceClientConnectionManager(new MemoryCache(new MemoryCacheOptions()
{
ExpirationScanFrequency = TimeSpan.FromSeconds(5)
}));
this.LoRaDeviceFactory = new TestLoRaDeviceFactory(this.ServerConfiguration, this.FrameCounterUpdateStrategyProvider, this.LoRaDeviceClient.Object, deduplicationFactory, adrStrategyProvider, adrManagerFactory, functionBundlerProvider, this.ConnectionManager);
}
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 void When_Needed_Should_Reconnect_Client()
{
var deviceClient = new Mock <ILoRaDeviceClient>(MockBehavior.Strict);
var cache = new MemoryCache(new MemoryCacheOptions());
var manager = new LoRaDeviceClientConnectionManager(cache);
var device = new LoRaDevice("00000000", "0123456789", manager);
device.KeepAliveTimeout = 60;
manager.Register(device, deviceClient.Object);
deviceClient.Setup(x => x.EnsureConnected())
.Returns(true);
deviceClient.Setup(x => x.Disconnect())
.Returns(true);
using (var activity1 = device.BeginDeviceClientConnectionActivity())
{
Assert.NotNull(activity1);
}
Assert.True(device.TryDisconnect());
using (var activity2 = device.BeginDeviceClientConnectionActivity())
{
Assert.NotNull(activity2);
Assert.False(device.TryDisconnect());
}
Assert.True(device.TryDisconnect());
deviceClient.Verify(x => x.EnsureConnected(), Times.Exactly(2));
deviceClient.Verify(x => x.Disconnect(), Times.Exactly(2));
}
public void When_Registering_Existing_Connection_Throws()
{
// arrange
using var cache = new MemoryCache(new MemoryCacheOptions());
using var connectionManager = new LoRaDeviceClientConnectionManager(cache, NullLogger <LoRaDeviceClientConnectionManager> .Instance);
using var loraDevice = new LoRaDevice(null, new DevEui(0), null);
connectionManager.Register(loraDevice, new Mock <ILoRaDeviceClient>().Object);
Assert.Throws <InvalidOperationException>(() => connectionManager.Register(loraDevice, new Mock <ILoRaDeviceClient>().Object));
}
public MessageProcessorMultipleGatewayBase(ITestOutputHelper testOutputHelper) : base(testOutputHelper)
{
SecondServerConfiguration = new NetworkServerConfiguration
{
GatewayID = SecondServerGatewayID,
LogToConsole = true,
LogLevel = ((int)LogLevel.Debug).ToString(CultureInfo.InvariantCulture),
};
SecondDownstreamMessageSender = new TestDownstreamMessageSender();
SecondLoRaDeviceApi = new Mock <LoRaDeviceAPIServiceBase>(MockBehavior.Strict);
SecondFrameCounterUpdateStrategyProvider = new LoRaDeviceFrameCounterUpdateStrategyProvider(SecondServerConfiguration, SecondLoRaDeviceApi.Object);
this.cache = new MemoryCache(new MemoryCacheOptions()
{
ExpirationScanFrequency = TimeSpan.FromSeconds(5)
});
this.testOutputLoggerFactory = new TestOutputLoggerFactory(testOutputHelper);
var deduplicationStrategyFactory = new DeduplicationStrategyFactory(this.testOutputLoggerFactory, this.testOutputLoggerFactory.CreateLogger <DeduplicationStrategyFactory>());
var loRaAdrManagerFactory = new LoRAADRManagerFactory(SecondLoRaDeviceApi.Object, this.testOutputLoggerFactory);
var adrStrategyProvider = new LoRaADRStrategyProvider(this.testOutputLoggerFactory);
var functionBundlerProvider = new FunctionBundlerProvider(SecondLoRaDeviceApi.Object, this.testOutputLoggerFactory, this.testOutputLoggerFactory.CreateLogger <FunctionBundlerProvider>());
SecondConcentratorDeduplication = new ConcentratorDeduplication(this.cache, this.testOutputLoggerFactory.CreateLogger <IConcentratorDeduplication>());
SecondRequestHandlerImplementation = new DefaultLoRaDataRequestHandler(SecondServerConfiguration,
SecondFrameCounterUpdateStrategyProvider,
SecondConcentratorDeduplication,
new LoRaPayloadDecoder(this.testOutputLoggerFactory.CreateLogger <LoRaPayloadDecoder>()),
deduplicationStrategyFactory,
adrStrategyProvider,
loRaAdrManagerFactory,
functionBundlerProvider,
this.testOutputLoggerFactory.CreateLogger <DefaultLoRaDataRequestHandler>(),
null);
SecondLoRaDeviceClient = new Mock <ILoRaDeviceClient>(MockBehavior.Strict);
this.cache = new MemoryCache(new MemoryCacheOptions()
{
ExpirationScanFrequency = TimeSpan.FromSeconds(5)
});
var defaultRequestHandler = new DefaultLoRaDataRequestHandler(SecondServerConfiguration,
SecondFrameCounterUpdateStrategyProvider,
SecondConcentratorDeduplication,
new LoRaPayloadDecoder(this.testOutputLoggerFactory.CreateLogger <LoRaPayloadDecoder>()),
deduplicationStrategyFactory,
adrStrategyProvider,
loRaAdrManagerFactory,
functionBundlerProvider,
this.testOutputLoggerFactory.CreateLogger <DefaultLoRaDataRequestHandler>(),
meter: null);
SecondConnectionManager = new LoRaDeviceClientConnectionManager(this.cache, this.testOutputLoggerFactory.CreateLogger <LoRaDeviceClientConnectionManager>());
SecondLoRaDeviceFactory = new TestLoRaDeviceFactory(SecondServerConfiguration, SecondLoRaDeviceClient.Object, SecondConnectionManager, DeviceCache, defaultRequestHandler);
}
public ConcentratorDeduplicationTest()
{
this.cache = new MemoryCache(new MemoryCacheOptions());
this.connectionManager = new LoRaDeviceClientConnectionManager(this.cache, NullLogger <LoRaDeviceClientConnectionManager> .Instance);
this.simulatedABPDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(0));
this.dataPayload = this.simulatedABPDevice.CreateConfirmedDataUpMessage("payload");
this.dataRequest = WaitableLoRaRequest.Create(this.dataPayload);
this.loRaDevice = new LoRaDevice(this.simulatedABPDevice.DevAddr, this.simulatedABPDevice.DevEUI, this.connectionManager);
this.simulatedOTAADevice = new SimulatedDevice(TestDeviceInfo.CreateOTAADevice(0));
this.joinPayload = this.simulatedOTAADevice.CreateJoinRequest(appkey: this.simulatedOTAADevice.AppKey);
this.joinRequest = WaitableLoRaRequest.Create(this.joinPayload);
this.joinRequest.SetPayload(this.joinPayload);
this.concentratorDeduplication = new ConcentratorDeduplication(
this.cache,
NullLogger <IConcentratorDeduplication> .Instance);
}
public void When_Device_Has_No_Connection_Timeout_Should_Disconnect()
{
var deviceClient = new Mock <ILoRaDeviceClient>(MockBehavior.Strict);
var cache = new MemoryCache(new MemoryCacheOptions());
var manager = new LoRaDeviceClientConnectionManager(cache);
var device = new LoRaDevice("00000000", "0123456789", manager);
manager.Register(device, deviceClient.Object);
var activity = device.BeginDeviceClientConnectionActivity();
Assert.NotNull(activity);
deviceClient.Setup(x => x.Disconnect())
.Returns(true);
Assert.True(device.TryDisconnect());
deviceClient.Verify(x => x.Disconnect(), Times.Once());
}
public ClassCCloudToDeviceMessageSizeLimitTests(ITestOutputHelper testOutputHelper)
{
this.serverConfiguration = new NetworkServerConfiguration()
{
GatewayID = ServerGatewayID,
};
this.loRaRegion = RegionManager.EU868;
DownstreamMessageSender = new TestDownstreamMessageSender();
this.deviceApi = new Mock <LoRaDeviceAPIServiceBase>(MockBehavior.Strict);
this.deviceClient = new Mock <ILoRaDeviceClient>(MockBehavior.Loose);
this.testOutputLoggerFactory = new TestOutputLoggerFactory(testOutputHelper);
this.cache = new MemoryCache(new MemoryCacheOptions());
this.connectionManager = new LoRaDeviceClientConnectionManager(this.cache, testOutputLoggerFactory.CreateLogger <LoRaDeviceClientConnectionManager>());
this.loRaDeviceFactory = new TestLoRaDeviceFactory(this.deviceClient.Object, this.deviceCache, this.connectionManager);
this.loRaDeviceRegistry = new LoRaDeviceRegistry(this.serverConfiguration, this.cache, this.deviceApi.Object, this.loRaDeviceFactory, this.deviceCache);
this.frameCounterStrategyProvider = new LoRaDeviceFrameCounterUpdateStrategyProvider(this.serverConfiguration, this.deviceApi.Object);
}
public void When_Device_Has_No_Connection_Timeout_Should_Disconnect()
{
var deviceClient = new Mock <ILoRaDeviceClient>(MockBehavior.Strict);
deviceClient.Setup(dc => dc.Dispose());
using var cache = new MemoryCache(new MemoryCacheOptions());
using var manager = new LoRaDeviceClientConnectionManager(cache, NullLogger <LoRaDeviceClientConnectionManager> .Instance);
using var device = new LoRaDevice(DevAddr.Private0(0), new DevEui(0x0123456789), manager);
manager.Register(device, deviceClient.Object);
var activity = device.BeginDeviceClientConnectionActivity();
Assert.NotNull(activity);
deviceClient.Setup(x => x.Disconnect())
.Returns(true);
Assert.True(device.TryDisconnect());
deviceClient.Verify(x => x.Disconnect(), Times.Once());
}
public void When_Needed_Should_Reconnect_Client()
{
var deviceClient = new Mock <ILoRaDeviceClient>(MockBehavior.Strict);
deviceClient.Setup(dc => dc.Dispose());
using var cache = new MemoryCache(new MemoryCacheOptions());
using var manager = new LoRaDeviceClientConnectionManager(cache, NullLogger <LoRaDeviceClientConnectionManager> .Instance);
using var device = new LoRaDevice(DevAddr.Private0(0), new DevEui(0x0123456789), manager);
device.KeepAliveTimeout = 60;
manager.Register(device, deviceClient.Object);
deviceClient.Setup(x => x.EnsureConnected())
.Returns(true);
deviceClient.Setup(x => x.Disconnect())
.Returns(true);
using (var activity1 = device.BeginDeviceClientConnectionActivity())
{
Assert.NotNull(activity1);
}
Assert.True(device.TryDisconnect());
using (var activity2 = device.BeginDeviceClientConnectionActivity())
{
Assert.NotNull(activity2);
Assert.False(device.TryDisconnect());
}
Assert.True(device.TryDisconnect());
deviceClient.Verify(x => x.EnsureConnected(), Times.Exactly(2));
deviceClient.Verify(x => x.Disconnect(), Times.Exactly(2));
}
public DeviceLoaderSynchronizerTest()
{
this.memoryCache = new MemoryCache(new MemoryCacheOptions());
this.connectionManager = new LoRaDeviceClientConnectionManager(this.memoryCache, NullLogger <LoRaDeviceClientConnectionManager> .Instance);
}
