WebAPISignalRChat/Backend/Tests/RequestTests.cs

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 Diligent.WebAPI.Host.Mediator.Request.Queries;
using Moq;

namespace Tests
{
    [TestFixture]
    public class RequestTests
    {
        private Mock<IRequestRepository> _requestRepositoryMock;
        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>();
            _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);
        }

        [Test]
        public void AcceptCustomerRequest_RoomIsNull_ThrowNotFoundException()
        {
            _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<NotFoundException>());
        }

        [Test]
        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() 
        {
            var requestDTO = new RequestCreateDTO
            {
                RoomId = "room1",
                RoomName = "room1",
                SenderId = "sender1",
                SenderUsername = "sender1"
            };
            var command = new CreateRequestCommand(requestDTO);
            var handler = new CreateRequestHandler(_mapper, _requestRepositoryMock.Object);

            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));
        }
    }
}