monorepo/LCU.API.Collections.RepoApi-old/LCU.API.Collections.RepoApiTests/Services/AuctionHouseServiceTest.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using LCU.API.Collections.RepoApi.Exceptions;
using LCU.API.Collections.RepoApi.Factories;
using LCU.API.Collections.RepoApi.Services;
using LCU.Shared.Collections.RepoApiLib.Models;
using LCU.Shared.Collections.RepoApiLib.Repositories;
using Moq;
using Xunit;

namespace LCU.API.Collections.RepoApiTests.Services
{

        public class AuctionHouseServiceTest
        {
        [Fact]
        public async void ListAll_Ok()
        {
            var mockAuctionHouseRepository = new Mock<IAuctionHouseRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();

            mockAuctionHouseRepository.Setup(repo => repo.ListAllAsync()).ReturnsAsync(new List<AuctionHouse>() { new AuctionHouse(), new AuctionHouse(), new AuctionHouse() });

            AuctionHouseService auctionHouseService = new AuctionHouseService(mockAuctionHouseRepository.Object, mockUnitOfWork.Object);

            var res = await auctionHouseService.ListAllAsync();
            Assert.NotNull(res);
            Assert.Equal(3, res.Count());
        }

        [Fact]
        public async void ListAll_Exception()
        {
            var mockAuctionHouseRepository = new Mock<IAuctionHouseRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();

            mockAuctionHouseRepository.Setup(repo => repo.ListAllAsync()).ThrowsAsync(new Exception("oops"));

            AuctionHouseService auctionHouseService = new AuctionHouseService(mockAuctionHouseRepository.Object, mockUnitOfWork.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await auctionHouseService.ListAllAsync());
        }

        [Fact]
        public async void SaveAsync_OK()
        {
            AuctionHouse AuctionHouse = new AuctionHouse()
            {
                AuctionID = "5"
            };

            var mockAuctionHouseRepository = new Mock<IAuctionHouseRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();

            mockAuctionHouseRepository.Setup(repo => repo.AddAsync(It.Is<AuctionHouse>(param => param.AuctionID == "5"))).Returns(Task.CompletedTask);
            mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);

            AuctionHouseService auctionHouseService = new AuctionHouseService(mockAuctionHouseRepository.Object, mockUnitOfWork.Object);

            var res = await auctionHouseService.SaveAsync(AuctionHouse);
            Assert.NotNull(res);
            Assert.Equal(AuctionHouse, res);
        }

        [Fact]
        public async void SaveAsync_DuplicateResource_Exception()
        {
            AuctionHouse AuctionHouse = new AuctionHouse()
            {
                AuctionID = "5"
            };

            var mockAuctionHouseRepository = new Mock<IAuctionHouseRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();

            mockAuctionHouseRepository.Setup(repo => repo.AddAsync(It.Is<AuctionHouse>(param => param.AuctionID == "5"))).ThrowsAsync(new Exception("Oops"));
            mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);

            AuctionHouseService auctionHouseService = new AuctionHouseService(mockAuctionHouseRepository.Object, mockUnitOfWork.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await auctionHouseService.SaveAsync(AuctionHouse));
        }

        [Fact]
        public async void SaveAsync_Exception()
        {
            AuctionHouse AuctionHouse = new AuctionHouse()
            {
                AuctionID = "5"
            };

            var mockAuctionHouseRepository = new Mock<IAuctionHouseRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();

            mockAuctionHouseRepository.Setup(repo => repo.AddAsync(It.Is<AuctionHouse>(param => param.AuctionID == "5"))).ThrowsAsync(new Exception("oops"));
            mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);

            AuctionHouseService auctionHouseService = new AuctionHouseService(mockAuctionHouseRepository.Object, mockUnitOfWork.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await auctionHouseService.SaveAsync(AuctionHouse));
        }

        [Fact]
        public async void Get_Ok()
        {
            var mockAuctionHouseRepository = new Mock<IAuctionHouseRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            mockAuctionHouseRepository.Setup(repo => repo.FindByIdAsync(It.IsAny<string>())).ReturnsAsync(new AuctionHouse() { AuctionID = "5" });
            mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);

            AuctionHouseService auctionHouseService = new AuctionHouseService(mockAuctionHouseRepository.Object, mockUnitOfWork.Object);

            var res = await auctionHouseService.GetAsync("5");
            Assert.NotNull(res);
            Assert.Equal("5", res.AuctionID);
        }

        [Fact]
        public async void Get_Exception()
        {
            var mockAuctionHouseRepository = new Mock<IAuctionHouseRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            mockAuctionHouseRepository.Setup(repo => repo.FindByIdAsync(It.IsAny<string>())).ThrowsAsync(new Exception("Oops"));
            mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);

            AuctionHouseService auctionHouseService = new AuctionHouseService(mockAuctionHouseRepository.Object, mockUnitOfWork.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await auctionHouseService.GetAsync("5"));
        }

        [Fact]
        public async void Get_Null_Exception()
        {
            var mockAuctionHouseRepository = new Mock<IAuctionHouseRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            mockAuctionHouseRepository.Setup(repo => repo.FindByIdAsync(It.IsAny<string>())).Returns(Task.FromResult<AuctionHouse>(null));
            mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);

            AuctionHouseService auctionHouseService = new AuctionHouseService(mockAuctionHouseRepository.Object, mockUnitOfWork.Object);

            await Assert.ThrowsAsync<NotFoundException>(async () => await auctionHouseService.GetAsync("5"));
        }

        [Fact]
        public async void Update_Null()
        {
            var mockAuctionHouseRepository = new Mock<IAuctionHouseRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();

            mockAuctionHouseRepository.Setup(repo => repo.FindByIdAsync(It.IsAny<string>())).Returns(Task.FromResult<AuctionHouse>(null));

            var auctionHouseService = new AuctionHouseService(mockAuctionHouseRepository.Object, mockUnitOfWork.Object);

            var auctionHouse = new AuctionHouse
            {
                AuctionID = "5"
            };

            await Assert.ThrowsAsync<NotFoundException>(async () => await auctionHouseService.UpdateAsync(auctionHouse));
        }

        [Fact]
        public async void Update_Exception()
        {
            var mockAuctionHouseRepository = new Mock<IAuctionHouseRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();

            mockAuctionHouseRepository.Setup(repo => repo.FindByIdAsync(It.IsAny<string>())).ReturnsAsync(new AuctionHouse());

            var auctionHouseService = new AuctionHouseService(mockAuctionHouseRepository.Object, mockUnitOfWork.Object);

            var auctionHouse = new AuctionHouse
            {
                AuctionID = "5"
            };

            mockAuctionHouseRepository.Setup(repo => repo.Update(It.IsAny<AuctionHouse>())).Throws(new Exception("oops"));

            await Assert.ThrowsAsync<ServerErrorException>(async () => await auctionHouseService.UpdateAsync(auctionHouse));
        }

        [Fact]
        public async void Update_Ok()
        {
            var mockAuctionHouseRepository = new Mock<IAuctionHouseRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();

            mockAuctionHouseRepository.Setup(repo => repo.FindByIdAsync(It.IsAny<string>())).ReturnsAsync(new AuctionHouse() {AuctionID = "6"});

            var auctionHouseService = new AuctionHouseService(mockAuctionHouseRepository.Object, mockUnitOfWork.Object);

            var auctionHouse = new AuctionHouse
            {
                AuctionID = "5",

            };

            var result = await auctionHouseService.UpdateAsync(auctionHouse);

            Assert.NotNull(result);
            Assert.Equal("6", result.AuctionID);
        }

        [Fact]
        public async void Update_Existing_Exception()
        {
            var mockAuctionHouseRepository = new Mock<IAuctionHouseRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();

            mockAuctionHouseRepository.Setup(repo => repo.FindByIdAsync(It.IsAny<string>())).Throws(new Exception("oops"));

            var auctionHouseService = new AuctionHouseService(mockAuctionHouseRepository.Object, mockUnitOfWork.Object);

            var auctionHouse = new AuctionHouse
            {
                AuctionID = "5"
            };

            await Assert.ThrowsAsync<ServerErrorException>(async () => await auctionHouseService.UpdateAsync(auctionHouse));
        }

        [Fact]
        public async void DeleteAsync_Ok()
        {
            var auctionHouse = new AuctionHouse
            {
                AuctionID = "5"
            };

            var mockAuctionHouseRepository = new Mock<IAuctionHouseRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();

            mockAuctionHouseRepository.Setup(repo => repo.FindByIdAsync(It.IsAny<string>())).ReturnsAsync(auctionHouse);
            mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            mockAuctionHouseRepository.Setup(repo => repo.Remove(It.Is<AuctionHouse>(param => param.AuctionID == "5")));

            AuctionHouseService auctionHouseService = new AuctionHouseService(mockAuctionHouseRepository.Object, mockUnitOfWork.Object);

            var res = await auctionHouseService.DeleteAsync("5");
        }

        [Fact]
        public async void DeleteAsync_Null()
        {
            var dummyAlert = new AuctionHouse
            {
                AuctionID = "5"
            };


            var mockAuctionHouseRepository = new Mock<IAuctionHouseRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();

            mockAuctionHouseRepository.Setup(repo => repo.FindByIdAsync(It.IsAny<string>())).Returns(Task.FromResult<AuctionHouse>(null));
            mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            mockAuctionHouseRepository.Setup(repo => repo.Remove(It.Is<AuctionHouse>(param => param.AuctionID == "5")));

            AuctionHouseService auctionHouseService = new AuctionHouseService(mockAuctionHouseRepository.Object, mockUnitOfWork.Object);

            await Assert.ThrowsAsync<NotFoundException>(async () => await auctionHouseService.DeleteAsync("5"));
        }

        [Fact]
        public async void DeleteAsync_Remove_Exception()
        {
        var auctionHouse = new AuctionHouse
        {
            AuctionID = "5"
        };

        var mockAuctionHouseRepository = new Mock<IAuctionHouseRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();

            mockAuctionHouseRepository.Setup(repo => repo.FindByIdAsync(It.IsAny<string>())).ReturnsAsync(auctionHouse);
            mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            mockAuctionHouseRepository.Setup(repo => repo.Remove(It.Is<AuctionHouse>(param => param.AuctionID == "5"))).Throws(new Exception("oops"));

            AuctionHouseService auctionHouseService = new AuctionHouseService(mockAuctionHouseRepository.Object, mockUnitOfWork.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await auctionHouseService.DeleteAsync("5"));
        }

        [Fact]
        public async void DeleteAsync_Existing_Exception()
        {

            var auctionHouse = new AuctionHouse
            {
                AuctionID = "5"
            };

            var mockAuctionHouseRepository = new Mock<IAuctionHouseRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();

            mockAuctionHouseRepository.Setup(repo => repo.FindByIdAsync(It.IsAny<string>())).Throws(new Exception("oops"));
            mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            mockAuctionHouseRepository.Setup(repo => repo.Remove(It.Is<AuctionHouse>(param => param.AuctionID == "5")));

            AuctionHouseService auctionHouseService = new AuctionHouseService(mockAuctionHouseRepository.Object, mockUnitOfWork.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await auctionHouseService.DeleteAsync("5"));
        }

        [Fact]
        public async void ListAll_Ok_2()
        {
            var repository = new Mock<IAuctionHouseRepository>();
            var unitOfWork = new Mock<IUnitOfWork>();

            repository.Setup(repo => repo.ListAllAsync()).ReturnsAsync(new List<AuctionHouse>()
            {
                new AuctionHouse()
                {
                    Name = "Auction House A"
                }
            });

            var service = new AuctionHouseService(repository.Object, unitOfWork.Object);

            var value = await service.ListAllAsync();
            Assert.NotNull(value);

            var enumerator = value.GetEnumerator();
            enumerator.MoveNext();
            Assert.NotNull(enumerator);
            Assert.Equal("Auction House A", enumerator.Current.Name);
        }

        [Fact]
        public async void Get_One_OK()
        {
            var repository = new Mock<IAuctionHouseRepository>();
            var unitOfWork = new Mock<IUnitOfWork>();

            repository.Setup(repo => repo.FindByIdAsync(It.IsAny<string>())).ReturnsAsync(new AuctionHouse()
            {
                Name = "Auction House A"
            });

            var service = new AuctionHouseService(repository.Object, unitOfWork.Object);

            var value = await service.GetAsync("someId");
            Assert.NotNull(value);
            Assert.Equal("Auction House A", value.Name);
        }

        [Fact]
        public async void Get_One_Does_Not_Exist()
        {
            var repository = new Mock<IAuctionHouseRepository>();
            var unitOfWork = new Mock<IUnitOfWork>();

            repository.Setup(repo => repo.FindByIdAsync(It.IsAny<string>())).ReturnsAsync((AuctionHouse) null);

            var service = new AuctionHouseService(repository.Object, unitOfWork.Object);

            try
            {
                var value = await service.GetAsync("someId");
                Assert.True(false, "Exception not thrown for null return.");
            }
            catch (NotFoundException)
            {
            }
        }

        [Fact]
        public async void Delete_Does_Not_Exist()
        {
            var repository = new Mock<IAuctionHouseRepository>();
            var unitOfWork = new Mock<IUnitOfWork>();

            repository.Setup(repo => repo.FindByIdAsync(It.IsAny<string>())).ReturnsAsync((AuctionHouse) null);

            var service = new AuctionHouseService(repository.Object, unitOfWork.Object);

            try
            {
                var value = await service.DeleteAsync("someId");
                Assert.True(false, "Exception not thrown for null return.");
            }
            catch (NotFoundException)
            {
            }
        }
    }
}