Introduce LoRa Concentrator Management

src/AzureIoTHub.Portal.Server.Tests/Controllers/ConcentratorsControllerTests.cs

@@ -0,0 +1,238 @@
+using AzureIoTHub.Portal.Server.Controllers;
+using AzureIoTHub.Portal.Server.Managers;
+using AzureIoTHub.Portal.Server.Mappers;
+using AzureIoTHub.Portal.Server.Services;
+using AzureIoTHub.Portal.Shared.Models.Concentrator;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Azure.Devices;
+using Microsoft.Azure.Devices.Shared;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace AzureIoTHub.Portal.Server.Tests.Controllers
+{
+    [TestFixture]
+    public class ConcentratorsControllerTests
+    {
+        private MockRepository mockRepository;
+
+        private Mock<IRouterConfigManager> mockRouterManager;
+        private Mock<IConcentratorTwinMapper> mockConcentratorTwinMapper;
+        private Mock<IDeviceService> mockDeviceService;
+        private Mock<ILogger<ConcentratorsController>> mockLogger;
+
+        [SetUp]
+        public void SetUp()
+        {
+            this.mockRepository = new MockRepository(MockBehavior.Strict);
+
+            this.mockLogger = this.mockRepository.Create<ILogger<ConcentratorsController>>();
+            this.mockRouterManager = this.mockRepository.Create<IRouterConfigManager>();
+            this.mockConcentratorTwinMapper = this.mockRepository.Create<IConcentratorTwinMapper>();
+            this.mockDeviceService = this.mockRepository.Create<IDeviceService>();
+        }
+
+        private ConcentratorsController CreateController()
+        {
+            return new ConcentratorsController(
+                this.mockLogger.Object,
+                this.mockDeviceService.Object,
+                this.mockRouterManager.Object,
+                this.mockConcentratorTwinMapper.Object);
+        }
+
+        [Test]
+        public async Task GetAllDeviceConcentrator_WithNoArgument_ReturnConcentratorList()
+        {
+            // Arrange
+            var twin = new Twin("aaa");
+            twin.Tags["deviceType"] = "LoRa Concentrator";
+            var concentrator = new Concentrator
+            {
+                DeviceId = twin.DeviceId,
+                DeviceType = "LoRa Concentrator"
+            };
+
+            this.mockDeviceService.Setup(x => x.GetAllDevice())
+                .ReturnsAsync(new[]
+                {
+                    twin
+                });
+
+            this.mockConcentratorTwinMapper.Setup(x => x.CreateDeviceDetails(It.Is<Twin>(c => c.DeviceId == twin.DeviceId)))
+                .Returns(concentrator);
+
+            var concentratorController = this.CreateController();
+
+            // Act
+            var result = await concentratorController.GetAllDeviceConcentrator();
+
+            // Assert
+            Assert.IsNotNull(result);
+            Assert.IsAssignableFrom<OkObjectResult>(result);
+            var okObjectResult = result as ObjectResult;
+
+            Assert.IsNotNull(okObjectResult);
+            Assert.AreEqual(200, okObjectResult.StatusCode);
+            Assert.IsNotNull(okObjectResult.Value);
+            Assert.IsAssignableFrom<List<Concentrator>>(okObjectResult.Value);
+            var deviceList = okObjectResult.Value as List<Concentrator>;
+            Assert.IsNotNull(deviceList);
+            Assert.AreEqual(1, deviceList.Count);
+            var device = deviceList[0];
+            Assert.IsNotNull(device);
+            Assert.AreEqual(twin.DeviceId, device.DeviceId);
+            Assert.AreEqual("LoRa Concentrator", device.DeviceType);
+
+            this.mockRepository.VerifyAll();
+        }
+
+        [Test]
+        public async Task GetDeviceConcentrator_With_Valid_Argument_Should_Return_Concentrator()
+        {
+            // Arrange
+            var twin = new Twin("aaa");
+            twin.Tags["deviceType"] = "LoRa Concentrator";
+            var concentrator = new Concentrator
+            {
+                DeviceId = twin.DeviceId,
+                DeviceType = "LoRa Concentrator"
+            };
+
+            this.mockDeviceService.Setup(x => x.GetDeviceTwin(It.Is<string>(c => c == twin.DeviceId)))
+                .ReturnsAsync(twin);
+
+            this.mockConcentratorTwinMapper.Setup(x => x.CreateDeviceDetails(It.Is<Twin>(c => c.DeviceId == twin.DeviceId)))
+                .Returns(concentrator);
+
+            var concentratorController = this.CreateController();
+
+            // Act
+            var result = await concentratorController.GetDeviceConcentrator(twin.DeviceId);
+
+            // Assert
+            Assert.IsNotNull(result);
+            Assert.IsAssignableFrom<OkObjectResult>(result);
+            var okObjectResult = result as ObjectResult;
+
+            Assert.IsNotNull(okObjectResult);
+            Assert.AreEqual(200, okObjectResult.StatusCode);
+            Assert.IsNotNull(okObjectResult.Value);
+            Assert.IsAssignableFrom<Concentrator>(okObjectResult.Value);
+            var device = okObjectResult.Value as Concentrator;
+            Assert.IsNotNull(device);
+            Assert.AreEqual(twin.DeviceId, device.DeviceId);
+            Assert.AreEqual("LoRa Concentrator", device.DeviceType);
+
+            this.mockRepository.VerifyAll();
+        }
+
+        [Test]
+        public async Task CreateDeviceAsync_With_Valid_Argument_Should_Return_OkResult()
+        {
+            // Arrange
+            var concentratorController = this.CreateController();
+            var concentrator = new Concentrator 
+            {
+                DeviceId = "4512457896451156",
+                LoraRegion = Guid.NewGuid().ToString() ,
+                IsEnabled = true
+            };
+
+            var routerConfig = new RouterConfig();
+            var mockResult = new BulkRegistryOperationResult
+            {
+                IsSuccessful = true
+            };
+
+            var twin = new Twin
+            {
+                DeviceId = concentrator.DeviceId,
+            };
+
+            this.mockDeviceService.Setup(c => c.CreateDeviceWithTwin(
+                It.Is<string>(x => x == twin.DeviceId),
+                It.Is<bool>(x => !x),
+                It.Is<Twin>(x => x.DeviceId == twin.DeviceId),
+                It.Is<DeviceStatus>(x => x == DeviceStatus.Enabled)))
+                .ReturnsAsync(mockResult);
+
+            this.mockRouterManager.Setup(x => x.GetRouterConfig(It.Is<string>(c => c == concentrator.LoraRegion)))
+                .ReturnsAsync(routerConfig);
+
+            this.mockConcentratorTwinMapper.Setup(x => x.UpdateTwin(It.Is<Twin>(c => c.DeviceId == twin.DeviceId), It.Is<Concentrator>(c => c.DeviceId == concentrator.DeviceId)));
+            this.mockLogger.Setup(x => x.Log(It.IsAny<LogLevel>(), It.IsAny<EventId>(), It.IsAny<It.IsAnyType>(), It.IsAny<Exception>(), It.IsAny<Func<It.IsAnyType, Exception, string>>()));
+
+            // Act
+            var result = await concentratorController.CreateDeviceAsync(concentrator);
+
+            // Assert
+            Assert.IsNotNull(result);
+            Assert.IsAssignableFrom<OkObjectResult>(result);
+            var okObjectResult = result as ObjectResult;
+            Assert.IsNotNull(okObjectResult);
+            Assert.AreEqual(200, okObjectResult.StatusCode);
+            Assert.IsNotNull(okObjectResult.Value);
+            Assert.IsAssignableFrom<BulkRegistryOperationResult>(okObjectResult.Value);
+            Assert.AreEqual(mockResult, okObjectResult.Value);
+        }
+
+        [Test]
+        public async Task UpdateDeviceAsync_With_Valid_Argument_Should_Return_OkResult()
+        {
+            // Arrange
+            var concentratorController = this.CreateController();
+            var concentrator = new Concentrator
+            {
+                DeviceId = "4512457896451156",
+                LoraRegion = Guid.NewGuid().ToString(),
+                IsEnabled = true,
+                RouterConfig = new RouterConfig()
+            };
+
+            var twin = new Twin
+            {
+                DeviceId = concentrator.DeviceId,
+            };
+
+            var device = new Device(concentrator.DeviceId);
+
+            this.mockRouterManager.Setup(x => x.GetRouterConfig(It.Is<string>(c => c == concentrator.LoraRegion)))
+                .ReturnsAsync(concentrator.RouterConfig);
+            this.mockConcentratorTwinMapper.Setup(x => x.UpdateTwin(It.Is<Twin>(c => c.DeviceId == twin.DeviceId), It.Is<Concentrator>(c => c.DeviceId == concentrator.DeviceId)));
+
+            this.mockDeviceService.Setup(x => x.GetDevice(It.Is<string>(c => c == concentrator.DeviceId)))
+                .ReturnsAsync(device);
+            this.mockDeviceService.Setup(x => x.UpdateDevice(It.Is<Device>(c => c.Id == concentrator.DeviceId)))
+                .ReturnsAsync(device);
+            this.mockDeviceService.Setup(x => x.GetDeviceTwin(It.Is<string>(c => c == concentrator.DeviceId)))
+                .ReturnsAsync(twin);
+            this.mockDeviceService.Setup(x => x.UpdateDeviceTwin(It.Is<string>(c => c == concentrator.DeviceId), It.Is<Twin>(c => c.DeviceId == concentrator.DeviceId)))
+                .ReturnsAsync(twin);
+
+            // Act
+            var result = await concentratorController.UpdateDeviceAsync(concentrator);
+
+            // Assert
+            Assert.IsNotNull(result);
+            Assert.IsAssignableFrom<OkObjectResult>(result);
+            var okObjectResult = result as ObjectResult;
+            Assert.IsNotNull(okObjectResult);
+            Assert.AreEqual(200, okObjectResult.StatusCode);
+        }
+
+        [Test]
+        public async Task DeleteDeviceAsync()
+        {
+            await Task.CompletedTask;
+            Assert.Inconclusive();
+        }
+    }
+}

src/AzureIoTHub.Portal.Server.Tests/Controllers/DevicesControllerTests.cs

@@ -58,11 +58,14 @@ public async Task GetList_StateUnderTest_ExpectedBehavior()
             // Arrange
             var devicesController = this.CreateDevicesController();
             int count = 100;
+            TwinCollection twinCollection = new TwinCollection();
+            twinCollection["deviceType"] = "test";
 
             this.mockDeviceService.Setup(c => c.GetAllDevice())
                 .ReturnsAsync(Enumerable.Range(0, 100).Select(x => new Twin
                 {
-                    DeviceId = x.ToString()
+                    DeviceId = x.ToString(),
+                    Tags = twinCollection
                 }));
 
             this.mockDeviceTwinMapper.Setup(c => c.CreateDeviceListItem(It.IsAny<Twin>()))

src/AzureIoTHub.Portal.Server.Tests/Managers/RouterConfigManagerTests.cs

@@ -0,0 +1,64 @@
+using AzureIoTHub.Portal.Server.Managers;
+using Moq;
+using Moq.Protected;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace AzureIoTHub.Portal.Server.Tests.Managers
+{
+    [TestFixture]
+    public class RouterConfigManagerTests
+    {
+        private MockRepository mockRepository;
+
+        private HttpClient mockHttpClient;
+        private Mock<HttpMessageHandler> httpMessageHandlerMock;
+
+        [SetUp]
+        public void SetUp()
+        {
+            this.mockRepository = new MockRepository(MockBehavior.Strict);
+
+            this.httpMessageHandlerMock = this.mockRepository.Create<HttpMessageHandler>();
+            this.mockHttpClient = new HttpClient(this.httpMessageHandlerMock.Object)
+            {
+                BaseAddress = new Uri("http://fake.local")
+            };
+        }
+
+        private RouterConfigManager CreateManager()
+        {
+            return new RouterConfigManager(this.mockHttpClient);
+        }
+
+        [Test]
+        public async Task GetRouterConfig_StateUnderTest_ExpectedBehavior()
+        {
+            // Arrange
+            var routerConfig = CreateManager();
+            var loraRegion = Guid.NewGuid().ToString();
+
+            using var deviceResponseMock = new HttpResponseMessage();
+
+            deviceResponseMock.Content = new StringContent("{}", Encoding.UTF8, "application/json");
+
+            this.httpMessageHandlerMock
+                .Protected()
+                .Setup<Task<HttpResponseMessage>>("SendAsync", ItExpr.Is<HttpRequestMessage>(req => req.RequestUri.LocalPath.Equals($"/{loraRegion}.json", StringComparison.OrdinalIgnoreCase)), ItExpr.IsAny<CancellationToken>())
+                .ReturnsAsync((HttpRequestMessage req, CancellationToken token) => deviceResponseMock)
+                .Verifiable();
+
+            // Act
+            var result = await routerConfig.GetRouterConfig(loraRegion);
+
+            // Assert
+            Assert.IsNotNull(result);
+        }
+    }
+}