From 361792bdbe950c331df60e48cfcb83cb3dc1fcf9 Mon Sep 17 00:00:00 2001
From: delager <raphael.delage@cgi.com>
Date: Fri, 26 May 2023 10:13:24 +0200
Subject: [PATCH] #1922 Delete AWS IoT Device

- Delete AWS Device
- TU Delete AWS Device
---
 .../Mappers/AWS/AWSDeviceThingProfile.cs      |   5 +
 .../Services/AWS/IAWSExternalDeviceService.cs |   2 +
 .../Services/AWS/AWSDeviceService.cs          |  11 +-
 .../Services/AWS/AWSExternalDeviceService.cs  |  12 ++
 .../Services/AWSDeviceServiceTests.cs         | 118 ++++++++++++++++++
 .../Services/AWSExternalDeviceServiceTest.cs  |  49 ++++++++
 6 files changed, 194 insertions(+), 3 deletions(-)

diff --git a/src/AzureIoTHub.Portal.Application/Mappers/AWS/AWSDeviceThingProfile.cs b/src/AzureIoTHub.Portal.Application/Mappers/AWS/AWSDeviceThingProfile.cs
index 31fbbbaf0..3f9dddf82 100644
--- a/src/AzureIoTHub.Portal.Application/Mappers/AWS/AWSDeviceThingProfile.cs
+++ b/src/AzureIoTHub.Portal.Application/Mappers/AWS/AWSDeviceThingProfile.cs
@@ -7,6 +7,7 @@ namespace AzureIoTHub.Portal.Application.Mappers.AWS
     using Amazon.IoT.Model;
     using Amazon.IotData.Model;
     using AutoMapper;
+    using AzureIoTHub.Portal.Domain.Entities;
     using Models.v10;
     using Newtonsoft.Json;
 
@@ -25,6 +26,10 @@ public AWSDeviceThingProfile()
                 .ForPath(dest => dest.AttributePayload.Attributes, opts => opts.MapFrom(src => src.Tags))
                 .ReverseMap();
 
+            _ = CreateMap<Device, DeleteThingRequest>()
+                .ForMember(dest => dest.ThingName, opts => opts.MapFrom(src => src.Name))
+                .ReverseMap();
+
             _ = CreateMap<DeviceDetails, UpdateThingShadowRequest>()
                 .ForMember(dest => dest.ThingName, opts => opts.MapFrom(src => src.DeviceName))
                 .ForMember(dest => dest.Payload, opts => opts.MapFrom(src => EmptyPayload()))
diff --git a/src/AzureIoTHub.Portal.Application/Services/AWS/IAWSExternalDeviceService.cs b/src/AzureIoTHub.Portal.Application/Services/AWS/IAWSExternalDeviceService.cs
index c3a7ee7e1..57474977f 100644
--- a/src/AzureIoTHub.Portal.Application/Services/AWS/IAWSExternalDeviceService.cs
+++ b/src/AzureIoTHub.Portal.Application/Services/AWS/IAWSExternalDeviceService.cs
@@ -15,6 +15,8 @@ public interface IAWSExternalDeviceService
 
         Task<UpdateThingResponse> UpdateDevice(UpdateThingRequest device);
 
+        Task<DeleteThingResponse> DeleteDevice(DeleteThingRequest device);
+
         Task<GetThingShadowResponse> GetDeviceShadow(string deviceName);
 
         Task<UpdateThingShadowResponse> UpdateDeviceShadow(UpdateThingShadowRequest shadow);
diff --git a/src/AzureIoTHub.Portal.Infrastructure/Services/AWS/AWSDeviceService.cs b/src/AzureIoTHub.Portal.Infrastructure/Services/AWS/AWSDeviceService.cs
index 40a1f5a00..24261d205 100644
--- a/src/AzureIoTHub.Portal.Infrastructure/Services/AWS/AWSDeviceService.cs
+++ b/src/AzureIoTHub.Portal.Infrastructure/Services/AWS/AWSDeviceService.cs
@@ -3,7 +3,6 @@
 
 namespace AzureIoTHub.Portal.Infrastructure.Services.AWS
 {
-    using System;
     using System.Threading.Tasks;
     using AzureIoTHub.Portal.Application.Services;
     using Models.v10;
@@ -67,9 +66,15 @@ public override async Task<DeviceDetails> UpdateDevice(DeviceDetails device)
             return await UpdateDeviceInDatabase(device);
         }
 
-        public override Task DeleteDevice(string deviceId)
+        public override async Task DeleteDevice(string deviceId)
         {
-            throw new NotImplementedException();
+            //Delete Thing
+            var device = await deviceRepository.GetByIdAsync(deviceId);
+            var deleteThingRequest = this.mapper.Map<DeleteThingRequest>(device);
+            _ = await this.externalDevicesService.DeleteDevice(deleteThingRequest);
+
+            //Delete Thing in DB
+            await DeleteDeviceInDatabase(deviceId);
         }
     }
 }
diff --git a/src/AzureIoTHub.Portal.Infrastructure/Services/AWS/AWSExternalDeviceService.cs b/src/AzureIoTHub.Portal.Infrastructure/Services/AWS/AWSExternalDeviceService.cs
index 6d82ffbae..d13fcae3f 100644
--- a/src/AzureIoTHub.Portal.Infrastructure/Services/AWS/AWSExternalDeviceService.cs
+++ b/src/AzureIoTHub.Portal.Infrastructure/Services/AWS/AWSExternalDeviceService.cs
@@ -65,6 +65,18 @@ public async Task<UpdateThingResponse> UpdateDevice(UpdateThingRequest device)
             return thingResponse;
         }
 
+        public async Task<DeleteThingResponse> DeleteDevice(DeleteThingRequest device)
+        {
+            var deleteResponse = await this.amazonIotClient.DeleteThingAsync(device);
+
+            if (deleteResponse.HttpStatusCode != System.Net.HttpStatusCode.OK)
+            {
+                throw new InternalServerErrorException($"Unable to delete the thing with device name : {device.ThingName} due to an error in the Amazon IoT API : {deleteResponse.HttpStatusCode}");
+            }
+
+            return deleteResponse;
+        }
+
         public async Task<GetThingShadowResponse> GetDeviceShadow(string deviceName)
         {
             var shadowRequest = new GetThingShadowRequest { ThingName = deviceName };
diff --git a/src/AzureIoTHub.Portal.Tests.Unit/Infrastructure/Services/AWSDeviceServiceTests.cs b/src/AzureIoTHub.Portal.Tests.Unit/Infrastructure/Services/AWSDeviceServiceTests.cs
index c0d9ffc76..5704152b1 100644
--- a/src/AzureIoTHub.Portal.Tests.Unit/Infrastructure/Services/AWSDeviceServiceTests.cs
+++ b/src/AzureIoTHub.Portal.Tests.Unit/Infrastructure/Services/AWSDeviceServiceTests.cs
@@ -24,6 +24,7 @@ namespace AzureIoTHub.Portal.Tests.Unit.Infrastructure.Services
     using AzureIoTHub.Portal.Tests.Unit.UnitTests.Bases;
     using EntityFramework.Exceptions.Common;
     using FluentAssertions;
+    using Microsoft.EntityFrameworkCore;
     using Microsoft.Extensions.Configuration;
     using Microsoft.Extensions.DependencyInjection;
     using Moq;
@@ -267,5 +268,122 @@ public async Task UpdateDeviceWhenDbUpdateExceptionIsRaisedCannotInsertNullExcep
             _ = await act.Should().ThrowAsync<CannotInsertNullException>();
             MockRepository.VerifyAll();
         }
+
+        [Test]
+        public async Task DeleteDevice()
+        {
+            // 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.mockAWSExternalDevicesService.Setup(service => service.DeleteDevice(It.IsAny<DeleteThingRequest>()))
+               .ReturnsAsync(new DeleteThingResponse()
+               {
+                   HttpStatusCode = HttpStatusCode.OK
+               });
+
+            _ = this.mockDeviceRepository.Setup(repository => repository.GetByIdAsync(deviceDto.DeviceID, d => d.Tags, d => d.Labels))
+                .ReturnsAsync(device);
+
+            _ = this.mockDeviceRepository.Setup(repository => repository.GetByIdAsync(deviceDto.DeviceID))
+                .ReturnsAsync(device);
+
+            this.mockDeviceTagValueRepository.Setup(repository => repository.Delete(It.IsAny<string>()))
+                .Verifiable();
+
+            this.mockLabelRepository.Setup(repository => repository.Delete(It.IsAny<string>()))
+                .Verifiable();
+
+            this.mockDeviceRepository.Setup(repository => repository.Delete(deviceDto.DeviceID))
+                .Verifiable();
+
+            _ = this.mockUnitOfWork.Setup(work => work.SaveAsync())
+                .Returns(Task.CompletedTask);
+
+            // Act
+            await this.awsDeviceService.DeleteDevice(deviceDto.DeviceID);
+
+            // Assert
+            MockRepository.VerifyAll();
+        }
+
+        [Test]
+        public async Task DeleteDeviceNothingIsDoneIfDeviceNotExist()
+        {
+            // Arrange
+            var deviceDto = new DeviceDetails
+            {
+                DeviceID = Fixture.Create<string>()
+            };
+
+            _ = this.mockAWSExternalDevicesService.Setup(service => service.DeleteDevice(It.IsAny<DeleteThingRequest>()))
+                .ReturnsAsync(new DeleteThingResponse()
+                {
+                    HttpStatusCode = HttpStatusCode.OK
+                });
+
+            _ = this.mockDeviceRepository.Setup(repository => repository.GetByIdAsync(deviceDto.DeviceID, d => d.Tags, d => d.Labels))
+                .ReturnsAsync((Device)null);
+
+            _ = this.mockDeviceRepository.Setup(repository => repository.GetByIdAsync(deviceDto.DeviceID))
+               .ReturnsAsync((Device)null);
+
+            // Act
+            await this.awsDeviceService.DeleteDevice(deviceDto.DeviceID);
+
+            // Assert
+            MockRepository.VerifyAll();
+        }
+
+        [Test]
+        public async Task DeleteDeviceWhenDbUpdateExceptionIsRaisedDbUpdateExceptionIsThrown()
+        {
+            // Arrange
+            var deviceDto = new DeviceDetails
+            {
+                DeviceID = Fixture.Create<string>()
+            };
+
+            var device = new Device
+            {
+                Id = deviceDto.DeviceID,
+                Tags = new List<DeviceTagValue>(),
+                Labels =  new List<Label>(),
+            };
+
+            _ = this.mockAWSExternalDevicesService.Setup(service => service.DeleteDevice(It.IsAny<DeleteThingRequest>()))
+                .ReturnsAsync(new DeleteThingResponse()
+                {
+                    HttpStatusCode = HttpStatusCode.OK
+                });
+
+            _ = this.mockDeviceRepository.Setup(repository => repository.GetByIdAsync(deviceDto.DeviceID, d => d.Tags, d => d.Labels))
+                .ReturnsAsync(device);
+
+            _ = this.mockDeviceRepository.Setup(repository => repository.GetByIdAsync(deviceDto.DeviceID))
+                .ReturnsAsync(device);
+
+            this.mockDeviceRepository.Setup(repository => repository.Delete(deviceDto.DeviceID))
+                .Verifiable();
+
+            _ = this.mockUnitOfWork.Setup(work => work.SaveAsync())
+                .ThrowsAsync(new DbUpdateException());
+
+            // Act
+            var act = () => this.awsDeviceService.DeleteDevice(deviceDto.DeviceID);
+
+            // Assert
+            _ = await act.Should().ThrowAsync<DbUpdateException>();
+            MockRepository.VerifyAll();
+        }
     }
 }
diff --git a/src/AzureIoTHub.Portal.Tests.Unit/Infrastructure/Services/AWSExternalDeviceServiceTest.cs b/src/AzureIoTHub.Portal.Tests.Unit/Infrastructure/Services/AWSExternalDeviceServiceTest.cs
index 2586f6fca..79787ddd7 100644
--- a/src/AzureIoTHub.Portal.Tests.Unit/Infrastructure/Services/AWSExternalDeviceServiceTest.cs
+++ b/src/AzureIoTHub.Portal.Tests.Unit/Infrastructure/Services/AWSExternalDeviceServiceTest.cs
@@ -236,6 +236,55 @@ public Task UpdateDeviceShouldThrowInternalServerErrorIfHttpStatusCodeIsNotOK()
             return Task.CompletedTask;
         }
 
+        [Test]
+        public async Task DeleteDeviceShouldReturnAValue()
+        {
+            // Arrange
+            var deleteThingRequest = new DeleteThingRequest()
+            {
+                ThingName = Fixture.Create<string>(),
+            };
+
+            var expected = new DeleteThingResponse
+            {
+                HttpStatusCode = HttpStatusCode.OK
+            };
+
+            _ = this.mockAmazonIotClient.Setup(iotClient => iotClient.DeleteThingAsync(It.IsAny<DeleteThingRequest>(), It.IsAny<CancellationToken>()))
+                .ReturnsAsync(expected);
+
+            //Act
+            var result = await this.awsExternalDeviceService.DeleteDevice(deleteThingRequest);
+
+            //Assert
+            _ = result.Should().BeEquivalentTo(expected);
+            MockRepository.VerifyAll();
+        }
+
+        [Test]
+        public Task DeleteDeviceShouldThrowInternalServerErrorIfHttpStatusCodeIsNotOK()
+        {
+            // Arrange
+            var deleteThingRequest = new DeleteThingRequest()
+            {
+                ThingName = Fixture.Create<string>(),
+            };
+
+            _ = this.mockAmazonIotClient.Setup(iotClient => iotClient.DeleteThingAsync(It.IsAny<DeleteThingRequest>(), It.IsAny<CancellationToken>()))
+                .ReturnsAsync(new DeleteThingResponse
+                {
+                    HttpStatusCode = HttpStatusCode.BadRequest
+                });
+
+            //Act
+            var result = () => this.awsExternalDeviceService.DeleteDevice(deleteThingRequest);
+
+            //Assert
+            _ = result.Should().ThrowAsync<InternalServerErrorException>();
+            MockRepository.VerifyAll();
+            return Task.CompletedTask;
+        }
+
         [Test]
         public async Task GetDeviceShadowShouldReturnAValue()
         {