From edd72cc52090d795f2d136c75451abc2dc7f9201 Mon Sep 17 00:00:00 2001
From: delager <raphael.delage@cgi.com>
Date: Fri, 9 Jun 2023 10:08:13 +0200
Subject: [PATCH] #2110 Add missing TU

---
 .../Services/AWSDevicePropertyServiceTests.cs |  57 +++++
 .../Services/AWSDeviceServiceTests.cs         | 218 +++++++++++++++++-
 .../Services/ExternalDeviceServiceTests.cs    |  70 ++++++
 3 files changed, 342 insertions(+), 3 deletions(-)

diff --git a/src/IoTHub.Portal.Tests.Unit/Infrastructure/Services/AWSDevicePropertyServiceTests.cs b/src/IoTHub.Portal.Tests.Unit/Infrastructure/Services/AWSDevicePropertyServiceTests.cs
index 91a11531b..ee5aac341 100644
--- a/src/IoTHub.Portal.Tests.Unit/Infrastructure/Services/AWSDevicePropertyServiceTests.cs
+++ b/src/IoTHub.Portal.Tests.Unit/Infrastructure/Services/AWSDevicePropertyServiceTests.cs
@@ -90,6 +90,33 @@ public async Task WhenDeviceIdNotExistGetPropertiesShouldThrowResourceNotFoundEx
             MockRepository.VerifyAll();
         }
 
+        [Test]
+        public async Task GetPropertiesShouldThrowInternalServerErrorExceptionWhenHttpStatusCodeIsNotOKForGetThingShadow()
+        {
+            // Arrange
+            var device = new Device()
+            {
+                Id = "aaa",
+                DeviceModelId = "bbb"
+            };
+
+            _ = this.mockDeviceRepository.Setup(c => c.GetByIdAsync("aaa"))
+                .ReturnsAsync(device);
+
+            _ = this.mockAmazonIotDataClient.Setup(iotDataClient => iotDataClient.GetThingShadowAsync(It.IsAny<GetThingShadowRequest>(), It.IsAny<CancellationToken>()))
+                .ReturnsAsync(new GetThingShadowResponse
+                {
+                    HttpStatusCode = HttpStatusCode.BadRequest
+                });
+
+            // Act
+            var act = () => this.awsDevicePropertyService.GetProperties(device.Id);
+
+            // Assert
+            _ = await act.Should().ThrowAsync<InternalServerErrorException>();
+            MockRepository.VerifyAll();
+        }
+
         [Test]
         public async Task GetPropertiesShouldThrowInternalServerErrorExceptionWhenIssueOccursOnGettingProperties()
         {
@@ -227,5 +254,35 @@ public async Task SetPropertiesShouldThrowInternalServerErrorExceptionWhenIssueO
             _ = await act.Should().ThrowAsync<InternalServerErrorException>();
             MockRepository.VerifyAll();
         }
+
+        [Test]
+        public async Task SetPropertiesShouldThrowInternalServerErrorExceptionWhenHttpStatusIsNotOKForUpdateThingShadow()
+        {
+            // Arrange
+            var device = new Device()
+            {
+                Id = "aaa",
+                DeviceModelId = "bbb"
+            };
+
+            _ = this.mockDeviceRepository.Setup(c => c.GetByIdAsync(device.Id))
+                .ReturnsAsync(device);
+
+            _ = this.mockDeviceModelPropertiesService.Setup(c => c.GetModelProperties(device.DeviceModelId))
+                    .ReturnsAsync(Enumerable.Empty<DeviceModelProperty>());
+
+            _ = this.mockAmazonIotDataClient.Setup(iotDataClient => iotDataClient.UpdateThingShadowAsync(It.IsAny<UpdateThingShadowRequest>(), It.IsAny<CancellationToken>()))
+                .ReturnsAsync(new UpdateThingShadowResponse
+                {
+                    HttpStatusCode = HttpStatusCode.BadRequest
+                });
+
+            // Act
+            var act = () => this.awsDevicePropertyService.SetProperties(device.Id, null);
+
+            // Assert
+            _ = await act.Should().ThrowAsync<InternalServerErrorException>();
+            MockRepository.VerifyAll();
+        }
     }
 }
diff --git a/src/IoTHub.Portal.Tests.Unit/Infrastructure/Services/AWSDeviceServiceTests.cs b/src/IoTHub.Portal.Tests.Unit/Infrastructure/Services/AWSDeviceServiceTests.cs
index 7ace262fa..f6282b98d 100644
--- a/src/IoTHub.Portal.Tests.Unit/Infrastructure/Services/AWSDeviceServiceTests.cs
+++ b/src/IoTHub.Portal.Tests.Unit/Infrastructure/Services/AWSDeviceServiceTests.cs
@@ -31,6 +31,7 @@ namespace IoTHub.Portal.Tests.Unit.Infrastructure.Services
     using Device = Portal.Domain.Entities.Device;
     using ResourceNotFoundException = Portal.Domain.Exceptions.ResourceNotFoundException;
     using System.Threading;
+    using IoTHub.Portal.Domain.Exceptions;
 
     [TestFixture]
     public class AWSDeviceServiceTests : BackendUnitTest
@@ -120,6 +121,59 @@ public async Task CreateADeviceShouldReturnAValue()
             MockRepository.VerifyAll();
         }
 
+        [Test]
+        public async Task CreateDeviceShouldThrowInternalServerErrorIfHttpStatusCodeIsNotOKForCreateThing()
+        {
+            // Arrange
+            var deviceDto = new DeviceDetails()
+            {
+                DeviceID = Fixture.Create<string>()
+            };
+
+            _ = this.mockAmazonIotClient.Setup(service => service.CreateThingAsync(It.IsAny<CreateThingRequest>(), It.IsAny<CancellationToken>()))
+                .ReturnsAsync(new CreateThingResponse()
+                {
+                    HttpStatusCode = HttpStatusCode.BadRequest
+                });
+
+            //Act
+            var result = () => this.awsDeviceService.CreateDevice(deviceDto);
+
+            //Assert
+            _ = await result.Should().ThrowAsync<InternalServerErrorException>();
+            MockRepository.VerifyAll();
+        }
+
+        [Test]
+        public async Task CreateDeviceShouldThrowInternalServerErrorIfHttpStatusCodeIsNotOKForUpdateThingShadow()
+        {
+            // Arrange
+            var deviceDto = new DeviceDetails()
+            {
+                DeviceID = Fixture.Create<string>()
+            };
+
+            _ = this.mockAmazonIotClient.Setup(service => service.CreateThingAsync(It.IsAny<CreateThingRequest>(), It.IsAny<CancellationToken>()))
+                .ReturnsAsync(new CreateThingResponse()
+                {
+                    ThingId = deviceDto.DeviceID,
+                    HttpStatusCode = HttpStatusCode.OK
+                });
+
+            _ = this.mockAmazonIotDataClient.Setup(service => service.UpdateThingShadowAsync(It.IsAny<UpdateThingShadowRequest>(), It.IsAny<CancellationToken>()))
+                .ReturnsAsync(new UpdateThingShadowResponse()
+                {
+                    HttpStatusCode = HttpStatusCode.BadRequest
+                });
+
+            //Act
+            var result = () => this.awsDeviceService.CreateDevice(deviceDto);
+
+            //Assert
+            _ = await result.Should().ThrowAsync<InternalServerErrorException>();
+            MockRepository.VerifyAll();
+        }
+
         [Test]
         public async Task CreateDeviceDuplicateExceptionIsThrown()
         {
@@ -205,6 +259,30 @@ public async Task UpdateDeviceShouldReturnValue()
             MockRepository.VerifyAll();
         }
 
+        [Test]
+        public async Task UpdateDeviceShouldThrowInternalServerErrorIfHttpStatusCodeIsNotOKForUpdateThing()
+        {
+            // Arrange
+            var deviceDto = new DeviceDetails
+            {
+                DeviceID = Fixture.Create<string>(),
+                DeviceName = Fixture.Create<string>(),
+            };
+
+            _ = this.mockAmazonIotClient.Setup(service => service.UpdateThingAsync(It.IsAny<UpdateThingRequest>(), It.IsAny<CancellationToken>()))
+                .ReturnsAsync(new UpdateThingResponse()
+                {
+                    HttpStatusCode = HttpStatusCode.BadRequest
+                });
+
+            // Act
+            var result = () => this.awsDeviceService.UpdateDevice(deviceDto);
+
+            // Assert
+            _ = await result.Should().ThrowAsync<InternalServerErrorException>();
+            MockRepository.VerifyAll();
+        }
+
         [Test]
         public async Task UpdateDeviceThatNotExistThrowResourceNotFoundException()
         {
@@ -287,6 +365,16 @@ public async Task DeleteDevice()
 
             _ = this.mockAmazonIotClient.Setup(service => service.ListThingPrincipalsAsync(It.IsAny<ListThingPrincipalsRequest>(), It.IsAny<CancellationToken>()))
             .ReturnsAsync(new ListThingPrincipalsResponse()
+            {
+                Principals = new List<string>()
+                {
+                    Fixture.Create<string>()
+                },
+                HttpStatusCode = HttpStatusCode.OK
+            });
+
+            _ = this.mockAmazonIotClient.Setup(service => service.DetachThingPrincipalAsync(It.IsAny<DetachThingPrincipalRequest>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new DetachThingPrincipalResponse()
             {
                 HttpStatusCode = HttpStatusCode.OK
             });
@@ -323,7 +411,7 @@ public async Task DeleteDevice()
         }
 
         [Test]
-        public Task DeleteDeviceResourceNotFoundExceptionIfDeviceNotExist()
+        public async Task DeleteDeviceResourceNotFoundExceptionIfDeviceNotExist()
         {
             // Arrange
             var deviceDto = new DeviceDetails
@@ -338,9 +426,133 @@ public Task DeleteDeviceResourceNotFoundExceptionIfDeviceNotExist()
             var response = () => this.awsDeviceService.DeleteDevice(deviceDto.DeviceID);
 
             // Assert
-            _ = response.Should().ThrowAsync<ResourceNotFoundException>();
+            _ = await response.Should().ThrowAsync<ResourceNotFoundException>();
+            MockRepository.VerifyAll();
+        }
+
+        [Test]
+        public async Task DeleteDeviceShouldThrowInternalServerErrorIfHttpStatusCodeIsNotOKForListThingPrincipals()
+        {
+            // Arrange
+            var deviceDto = new DeviceDetails
+            {
+                DeviceID = Fixture.Create<string>()
+            };
+
+            var device = new Device
+            {
+                Id = deviceDto.DeviceID,
+                Tags = Fixture.CreateMany<DeviceTagValue>(5).ToList(),
+                Labels = Fixture.CreateMany<Label>(5).ToList()
+            };
+
+            _ = this.mockDeviceRepository.Setup(repository => repository.GetByIdAsync(deviceDto.DeviceID))
+                .ReturnsAsync(device);
+
+            _ = this.mockAmazonIotClient.Setup(service => service.ListThingPrincipalsAsync(It.IsAny<ListThingPrincipalsRequest>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new ListThingPrincipalsResponse()
+            {
+                HttpStatusCode = HttpStatusCode.BadRequest
+            });
+
+            // Act
+            var result = () => this.awsDeviceService.DeleteDevice(deviceDto.DeviceID);
+
+            // Assert
+            _ = await result.Should().ThrowAsync<InternalServerErrorException>();
+            MockRepository.VerifyAll();
+        }
+
+        [Test]
+        public async Task DeleteDeviceShouldThrowInternalServerErrorIfHttpStatusCodeIsNotOKForDetachThingPrincipal()
+        {
+            // Arrange
+            var deviceDto = new DeviceDetails
+            {
+                DeviceID = Fixture.Create<string>()
+            };
+
+            var device = new Device
+            {
+                Id = deviceDto.DeviceID,
+                Tags = Fixture.CreateMany<DeviceTagValue>(5).ToList(),
+                Labels = Fixture.CreateMany<Label>(5).ToList()
+            };
+
+            _ = this.mockDeviceRepository.Setup(repository => repository.GetByIdAsync(deviceDto.DeviceID))
+                .ReturnsAsync(device);
+
+            _ = this.mockAmazonIotClient.Setup(service => service.ListThingPrincipalsAsync(It.IsAny<ListThingPrincipalsRequest>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new ListThingPrincipalsResponse()
+            {
+                Principals = new List<string>()
+                {
+                    Fixture.Create<string>()
+                },
+                HttpStatusCode = HttpStatusCode.OK
+            }); ;
+
+            _ = this.mockAmazonIotClient.Setup(service => service.DetachThingPrincipalAsync(It.IsAny<DetachThingPrincipalRequest>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new DetachThingPrincipalResponse()
+            {
+                HttpStatusCode = HttpStatusCode.BadRequest
+            });
+
+            // Act
+            var result = () => this.awsDeviceService.DeleteDevice(deviceDto.DeviceID);
+
+            // Assert
+            _ = await result.Should().ThrowAsync<InternalServerErrorException>();
+            MockRepository.VerifyAll();
+        }
+
+        [Test]
+        public async Task DeleteDeviceShouldThrowInternalServerErrorIfHttpStatusCodeIsNotOKForDeleteThing()
+        {
+            // Arrange
+            var deviceDto = new DeviceDetails
+            {
+                DeviceID = Fixture.Create<string>()
+            };
+
+            var device = new Device
+            {
+                Id = deviceDto.DeviceID,
+                Tags = Fixture.CreateMany<DeviceTagValue>(5).ToList(),
+                Labels = Fixture.CreateMany<Label>(5).ToList()
+            };
+
+            _ = this.mockDeviceRepository.Setup(repository => repository.GetByIdAsync(deviceDto.DeviceID))
+                .ReturnsAsync(device);
+
+            _ = this.mockAmazonIotClient.Setup(service => service.ListThingPrincipalsAsync(It.IsAny<ListThingPrincipalsRequest>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new ListThingPrincipalsResponse()
+            {
+                Principals = new List<string>()
+                {
+                    Fixture.Create<string>()
+                },
+                HttpStatusCode = HttpStatusCode.OK
+            }); ;
+
+            _ = this.mockAmazonIotClient.Setup(service => service.DetachThingPrincipalAsync(It.IsAny<DetachThingPrincipalRequest>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new DetachThingPrincipalResponse()
+            {
+                HttpStatusCode = HttpStatusCode.OK
+            });
+
+            _ = this.mockAmazonIotClient.Setup(service => service.DeleteThingAsync(It.IsAny<DeleteThingRequest>(), It.IsAny<CancellationToken>()))
+               .ReturnsAsync(new DeleteThingResponse()
+               {
+                   HttpStatusCode = HttpStatusCode.BadRequest
+               });
+
+            // Act
+            var result = () => this.awsDeviceService.DeleteDevice(deviceDto.DeviceID);
+
+            // Assert
+            _ = await result.Should().ThrowAsync<InternalServerErrorException>();
             MockRepository.VerifyAll();
-            return Task.CompletedTask;
         }
 
         [Test]
diff --git a/src/IoTHub.Portal.Tests.Unit/Server/Services/ExternalDeviceServiceTests.cs b/src/IoTHub.Portal.Tests.Unit/Server/Services/ExternalDeviceServiceTests.cs
index ea8aeeb7c..41cccd2d9 100644
--- a/src/IoTHub.Portal.Tests.Unit/Server/Services/ExternalDeviceServiceTests.cs
+++ b/src/IoTHub.Portal.Tests.Unit/Server/Services/ExternalDeviceServiceTests.cs
@@ -2132,5 +2132,75 @@ public async Task DeleteDeviceModel_AnyExternalDeviceModelDto_NotImplementedExce
             _ = await act.Should().ThrowAsync<NotImplementedException>();
             this.mockRepository.VerifyAll();
         }
+
+        [Test]
+        public async Task CreateEnrollementScriptShouldThrowNotImplementedException()
+        {
+            // Arrange
+            var template = Fixture.Create<string>();
+            var edgeDevice = new Portal.Domain.Entities.EdgeDevice();
+            var service = CreateService();
+
+            // Act
+            var act = () => service.CreateEnrollementScript(template, edgeDevice);
+
+            // Assert
+            _ = await act.Should().ThrowAsync<NotImplementedException>();
+        }
+
+        [Test]
+        public async Task CreateEdgeDeviceShouldThrowNotImplementedException()
+        {
+            // Arrange
+            var deviceId = Fixture.Create<string>();
+            var service = CreateService();
+
+            // Act
+            var act = () => service.CreateEdgeDevice(deviceId);
+
+            // Assert
+            _ = await act.Should().ThrowAsync<NotImplementedException>();
+        }
+
+        [Test]
+        public async Task RemoveDeviceCredentialsShouldThrowNotImplementedException()
+        {
+            // Arrange
+            var edgeDevice = new IoTEdgeDevice();
+            var service = CreateService();
+
+            // Act
+            var act = () => service.RemoveDeviceCredentials(edgeDevice);
+
+            // Assert
+            _ = await act.Should().ThrowAsync<NotImplementedException>();
+        }
+
+        [Test]
+        public async Task IsEdgeDeviceModelShouldThrowNotImplementedException()
+        {
+            // Arrange
+            var externalDeviceModelDto = new ExternalDeviceModelDto();
+            var service = CreateService();
+
+            // Act
+            var act = () => service.IsEdgeDeviceModel(externalDeviceModelDto);
+
+            // Assert
+            _ = await act.Should().ThrowAsync<NotImplementedException>();
+        }
+
+        [Test]
+        public async Task GetAllThingShouldThrowNotImplementedException()
+        {
+            // Arrange
+            var service = CreateService();
+
+            // Act
+            var act = () => service.GetAllThing();
+
+            // Assert
+            _ = await act.Should().ThrowAsync<NotImplementedException>();
+        }
     }
 }