implemented test for request handler

Backend/Diligent.WebAPI.Business/Interfaces/IRequestRepository.cs

@@ -1,6 +1,7 @@
 using Diligent.WebAPI.Data.Entities;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;

Backend/Diligent.WebAPI.Host/Mediator/Request/Handlers/CreateRequestHandler.cs

@@ -19,12 +19,7 @@ namespace Diligent.WebAPI.Host.Mediator.Request.Handlers
 
         public async Task<Data.Entities.Request> Handle(CreateRequestCommand request, CancellationToken cancellationToken)
         {
-            var req = request.Request;
-
-            if (req == null)
-                throw new BadHttpRequestException("Resource object cannot be null.");
-
-            var createdRequest = _mapper.Map<Data.Entities.Request>(req);
+            var createdRequest = _mapper.Map<Data.Entities.Request>(request.Request);
             await _requestService.CreateAsync(createdRequest);
 
             return createdRequest;

Backend/Diligent.WebAPI.Host/Mediator/Request/Handlers/GetRequestHandler.cs

@@ -17,14 +17,9 @@ namespace Diligent.WebAPI.Host.Mediator.Request.Handlers
         }
         public async Task<Data.Entities.Request> Handle(GetRequestQuery request, CancellationToken cancellationToken)
         {
-            if (request.Id == null)
-            {
-                throw new BadHttpRequestException("Id cannot be null");
-            }
-
             var req = await _requestService.GetByIdAsync(request.Id);
 
-            if (request == null)
+            if (req == null)
             {
                 throw new NotFoundException("Request not found");
             }

Backend/Tests/RequestTests.cs

@@ -1,11 +1,13 @@
 using AutoMapper;
 using Diligent.WebAPI.Business.Interfaces;
 using Diligent.WebAPI.Data.Entities;
+using Diligent.WebAPI.Data.HelperModels;
 using Diligent.WebAPI.Host.DTOs.Request;
+using Diligent.WebAPI.Host.Exceptions;
 using Diligent.WebAPI.Host.Mapper;
 using Diligent.WebAPI.Host.Mediator.Request.Commands;
 using Diligent.WebAPI.Host.Mediator.Request.Handlers;
-using Microsoft.AspNetCore.Http;
+using Diligent.WebAPI.Host.Mediator.Request.Queries;
 using Moq;
 
 namespace Tests
@@ -14,31 +16,116 @@ namespace Tests
     public class RequestTests
     {
         private Mock<IRequestRepository> _requestRepositoryMock;
-        private CreateRequestHandler _handler;
+        private Mock<IRoomRepository> _roomRepositoryMock;
         private IMapper _mapper;
+        private readonly List<Request> _requests = new()
+        {
+             new Request
+                {
+                    Id = "1",
+                    RoomId = "123",
+                    RoomName = "Room1",
+                    SenderId = "123",
+                    SenderUsername = "user1",
+                    CreatedAtUtc = DateTime.UtcNow,
+                },
+             new Request
+                {
+                    Id = "2",
+                    RoomId = "1234",
+                    RoomName = "Room2",
+                    SenderId = "1234",
+                    SenderUsername = "user1",
+                    CreatedAtUtc = DateTime.UtcNow,
+                },
+              new Request
+                {
+                    Id = "3",
+                    RoomId = "123",
+                    RoomName = "Room3",
+                    SenderId = "123",
+                    SenderUsername = "user2",
+                    CreatedAtUtc = DateTime.UtcNow,
+                },
+        };
+        private readonly List<Room> _rooms = new()
+        {
+            new Room
+            {
+                Id = "123",
+                CreatedBy = "123",
+                Customers = new List<CustomerDTO>(),
+                CreatedAtUtc = DateTime.UtcNow,
+                IsOneToOne = true,
+                Messages = new List<Message>(),
+                Name = "room1"
+            },
+            new Room
+            {
+                Id = "1234",
+                CreatedBy = "1234",
+                Customers = new List<CustomerDTO>(),
+                CreatedAtUtc = DateTime.UtcNow,
+                IsOneToOne = true,
+                Messages = new List<Message>(),
+                Name = "room2"
+            },
+
+        };
 
         [SetUp]
         public void Setup()
         {
             _requestRepositoryMock = new Mock<IRequestRepository>();
-            var myProfile = new RequestMappingProfile();
-            var configuration = new MapperConfiguration(cfg => cfg.AddProfile(myProfile));
+            _roomRepositoryMock = new Mock<IRoomRepository>();
+            _requestRepositoryMock.Setup(r => r.RemoveAsync(It.IsAny<string>())).Returns(Task.CompletedTask);
+            _requestRepositoryMock.Setup(x => x.CreateAsync(It.IsAny<Request>())).Returns(Task.CompletedTask);
+            var listOfProfiles = new List<Profile>
+            {
+                new RequestMappingProfile(),
+                new CustomerMappingProfile()
+            };
+            var configuration = new MapperConfiguration(cfg => cfg.AddProfiles(listOfProfiles));
             _mapper = new Mapper(configuration);
-            _handler = new CreateRequestHandler(_mapper, _requestRepositoryMock.Object);
         }
 
         [Test]
-        public async Task CreateRequest_ObjectIsNull_ThrowsBadHttpRequestException()
+        public void AcceptCustomerRequest_RoomIsNull_ThrowNotFoundException()
         {
-            var command = new CreateRequestCommand(null);
+            _roomRepositoryMock.Setup(r => r.GetByIdAsync(It.IsAny<string>())).Returns(Task.FromResult<Room>(null));
+            var command = new AcceptCustomerRequestCommand("1", "1");
+            var handler = new AcceptCustomerRequestHandler(_requestRepositoryMock.Object, _roomRepositoryMock.Object);
 
-            Assert.That(async () => await _handler.Handle(command, new CancellationToken()), Throws.Exception.TypeOf<BadHttpRequestException>());
+            Assert.That(async () => await handler.Handle(command, new CancellationToken()), Throws.Exception.TypeOf<NotFoundException>());
         }
 
         [Test]
-        public async Task CreateRequest_ObjectIsNotNull_ReturnsObject()
+        public void AcceptCustomerRequest_RoomIsNotNullAndRequestIsNull_ThrowNotFoundException() 
+        {
+            _roomRepositoryMock.Setup(r => r.GetByIdAsync(It.IsAny<string>())).Returns(Task.FromResult(_rooms[0]));
+            _requestRepositoryMock.Setup(r => r.FindRequestAsync(It.IsAny<string>(), It.IsAny<string>())).Returns(Task.FromResult<Request>(null));
+            var command = new AcceptCustomerRequestCommand("1", "1");
+            var handler = new AcceptCustomerRequestHandler(_requestRepositoryMock.Object, _roomRepositoryMock.Object);
+
+            Assert.That(async () => await handler.Handle(command, new CancellationToken()), Throws.Exception.TypeOf<NotFoundException>());
+        }
+
+        [Test]
+        public async Task AcceptCustomerRequest_RoomIsNotNullAndRequestInNotNull_ReturnIdOfRequest()
+        {
+            _roomRepositoryMock.Setup(r => r.GetByIdAsync(It.IsAny<string>())).Returns(Task.FromResult(_rooms[0]));
+            _requestRepositoryMock.Setup(r => r.FindRequestAsync(It.IsAny<string>(), It.IsAny<string>())).Returns(Task.FromResult(_requests[0]));
+            var command = new AcceptCustomerRequestCommand("1", "1");
+            var handler = new AcceptCustomerRequestHandler(_requestRepositoryMock.Object, _roomRepositoryMock.Object);
+
+            var result = await handler.Handle(command, new CancellationToken());
+
+            Assert.That(result, Is.EqualTo(_requests[0].Id));
+        }
+
+        [Test]
+        public async Task CreateRequest_WhenCalled_ReturnsObject() 
         {
-            _requestRepositoryMock.Setup(x => x.CreateAsync(It.IsAny<Request>())).Returns(Task.CompletedTask);
             var requestDTO = new RequestCreateDTO
             {
                 RoomId = "room1",
@@ -47,10 +134,167 @@ namespace Tests
                 SenderUsername = "sender1"
             };
             var command = new CreateRequestCommand(requestDTO);
+            var handler = new CreateRequestHandler(_mapper, _requestRepositoryMock.Object);
 
-            var result = await _handler.Handle(command, new CancellationToken());
+            var result = await handler.Handle(command, new CancellationToken());
 
             Assert.That(result, Is.Not.Null);
         }
+
+        [Test]
+        public async Task GetAllRequest_ThereAreNoRequests_ReturnEmptyList() 
+        {
+            _requestRepositoryMock.Setup(x => x.GetAsync()).Returns(Task.FromResult(new List<Request>()));
+
+            var query = new GetAllRequestsQuery();
+            var handler = new GetAllRequestHandler(_requestRepositoryMock.Object);
+            var result = await handler.Handle(query, new CancellationToken());
+
+            Assert.That(result, Is.Empty);
+
+        }
+        [Test]
+        public async Task GetAllRequest_ThereAreRequests_ReturnListOfRequests() 
+        {
+            _requestRepositoryMock.Setup(x => x.GetAsync()).Returns(Task.FromResult(_requests));
+
+            var query = new GetAllRequestsQuery();
+            var handler = new GetAllRequestHandler(_requestRepositoryMock.Object);
+            var result = await handler.Handle(query, new CancellationToken());
+
+            Assert.That(result, Is.EqualTo(_requests));
+        }
+
+        [Test]
+        public void GetRequest_RequestIsNull_ThrowNotFoundException() 
+        {
+            _requestRepositoryMock.Setup(r => r.GetByIdAsync(It.IsAny<string>())).Returns(Task.FromResult<Request>(null));
+            var query = new GetRequestQuery("123");
+            var handler = new GetRequestHandler(_requestRepositoryMock.Object);
+
+            var result = handler.Handle(query, new CancellationToken());
+
+            Assert.That(async () => await handler.Handle(query, new CancellationToken()), Throws.Exception.TypeOf<NotFoundException>());
+        }
+
+        [Test]
+        public async Task GetRequest_RequestIsNotNull_ReturnRequest()
+        {
+            var request = _requests[0];
+            _requestRepositoryMock.Setup(r => r.GetByIdAsync(It.IsAny<string>())).Returns(Task.FromResult(request));
+            var query = new GetRequestQuery("123");
+            var handler = new GetRequestHandler(_requestRepositoryMock.Object);
+
+            var result = await handler.Handle(query, new CancellationToken());
+
+            Assert.That(result, Is.EqualTo(request));
+        }
+
+        [Test]
+        public async Task GetRoomsForWhichRequestExist_ThereAreNoRequests_ReturnEmptyList()
+        {
+            _requestRepositoryMock.Setup(r => r.GetAsync()).Returns(Task.FromResult(new List<Request>()));
+            var query = new GetRoomsForWhichRequestExistQuery();
+            var handler = new GetRoomsForWhichRequestExistHandler(_requestRepositoryMock.Object,_mapper,_roomRepositoryMock.Object);
+
+            var result = await handler.Handle(query, new CancellationToken());
+
+            Assert.That(result, Is.Empty);
+        }
+
+        [Test]
+        public async Task GetRoomsForWhichRequestExist_ThereAreOneRequestForOneRoom_ReturnListWithOneElement()
+        {
+            _requestRepositoryMock.Setup(r => r.GetAsync()).Returns(Task.FromResult(new List<Request> { _requests[0] })); //parameter must be _requests[0]
+            _roomRepositoryMock.Setup(r => r.GetAsync()).Returns(Task.FromResult(new List<Room> { _rooms[0] })); //parameter must be _rooms[0]
+            var query = new GetRoomsForWhichRequestExistQuery();
+            var handler = new GetRoomsForWhichRequestExistHandler(_requestRepositoryMock.Object, _mapper, _roomRepositoryMock.Object);
+
+            var result = await handler.Handle(query, new CancellationToken());
+
+            Assert.That(result, Has.Count.EqualTo(1));
+        }
+
+        [Test]
+        public async Task GetRoomsForWhichRequestExist_ThereAreTwoRequestsForOneRoom_ReturnListWithOneElement()
+        {
+            _requestRepositoryMock.Setup(r => r.GetAsync()).Returns(Task.FromResult(new List<Request> { _requests[0], _requests[2] })); //parameter must be _requests[0] and _requests[2]
+            _roomRepositoryMock.Setup(r => r.GetAsync()).Returns(Task.FromResult(new List<Room> { _rooms[0] })); //parameter must be _rooms[0]
+            var query = new GetRoomsForWhichRequestExistQuery();
+            var handler = new GetRoomsForWhichRequestExistHandler(_requestRepositoryMock.Object, _mapper, _roomRepositoryMock.Object);
+
+            var result = await handler.Handle(query, new CancellationToken());
+
+            Assert.That(result, Has.Count.EqualTo(1));
+        }
+
+        [Test]
+        public async Task GetRoomsForWhichRequestExist_ThereAreTwoRequestsForTwoRooms_ReturnListWithTwoElements()
+        {
+            _requestRepositoryMock.Setup(r => r.GetAsync()).Returns(Task.FromResult(new List<Request> { _requests[0], _requests[1] })); //parameter must be _requests[0] and _requests[1]
+            _roomRepositoryMock.Setup(r => r.GetAsync()).Returns(Task.FromResult(new List<Room> { _rooms[0], _rooms[1] })); //parameter must be _rooms[0] and _rooms[1]
+            var query = new GetRoomsForWhichRequestExistQuery();
+            var handler = new GetRoomsForWhichRequestExistHandler(_requestRepositoryMock.Object, _mapper, _roomRepositoryMock.Object);
+
+            var result = await handler.Handle(query, new CancellationToken());
+
+            Assert.That(result, Has.Count.EqualTo(2));
+        }
+
+        [Test]
+        public async Task GetSendersForSpecificRoom_ThereAreNoRequests_ReturnEmptyList()
+        {
+            _requestRepositoryMock.Setup(x => x.GetAsync()).Returns(Task.FromResult(new List<Request>()));
+            var query = new GetSendersForSpecificRequestRoomQuery("1");
+            var handler = new GetSendersForSpecificRoomHandler(_requestRepositoryMock.Object, _mapper);
+
+            var result = await handler.Handle(query, new CancellationToken());
+
+            Assert.That(result, Is.Empty);
+        }
+
+        [Test]
+        public async Task GetSendersForSpecificRoom_ThereAreRequestsAndOneSender_ReturnListWithOneItem()
+        {
+            _requestRepositoryMock.Setup(x => x.GetAsync()).Returns(Task.FromResult(_requests));
+            var query = new GetSendersForSpecificRequestRoomQuery("1234"); // parameter must be equal 1234
+            var handler = new GetSendersForSpecificRoomHandler(_requestRepositoryMock.Object, _mapper);
+
+            var result = await handler.Handle(query, new CancellationToken());
+
+            Assert.That(result, Has.Count.EqualTo(1));
+        }
+        [Test]
+        public async Task GetSendersForSpecificRoom_ThereAreRequestsAndTwoSenders_ReturnListWithTwoSenders() 
+        {
+            _requestRepositoryMock.Setup(x => x.GetAsync()).Returns(Task.FromResult(_requests));
+            var query = new GetSendersForSpecificRequestRoomQuery("123"); // parameter must be equal 123
+            var handler = new GetSendersForSpecificRoomHandler(_requestRepositoryMock.Object, _mapper);
+
+            var result = await handler.Handle(query, new CancellationToken());
+
+            Assert.That(result, Has.Count.EqualTo(2));
+        }
+        [Test]
+        public void RejectCustomer_ThereAreNoRequest_ThrowNotFoundException()
+        {
+            _requestRepositoryMock.Setup(r => r.FindRequestAsync(It.IsAny<string>(), It.IsAny<string>())).Returns(Task.FromResult<Request>(null));
+            var command = new RejectCustomerRequestCommand("1", "1");
+            var handler = new RejectCustomerRequestHandler(_requestRepositoryMock.Object);
+
+            Assert.That(async () => await handler.Handle(command, new CancellationToken()), Throws.Exception.TypeOf<NotFoundException>());
+        }
+        [Test]
+        public async Task RejectCustomer_ThereAreRequest_ReturnIdOfRequest()
+        {
+            var request = _requests[0];
+            _requestRepositoryMock.Setup(r => r.FindRequestAsync(It.IsAny<string>(), It.IsAny<string>())).Returns(Task.FromResult(request));
+            var command = new RejectCustomerRequestCommand("1", "1");
+            var handler = new RejectCustomerRequestHandler(_requestRepositoryMock.Object);
+
+            var result = await handler.Handle(command, new CancellationToken());
+
+            Assert.That(result, Is.EqualTo(request.Id));
+        }
     }
 }