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

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

namespace LCU.API.Collections.RepoApiTests.Services
{
    public class CollateralServiceTests
    {
        [Fact]
        public async void ListAll_Ok()
        {
            var _mockCollateralRepo = new Mock<ICollateralRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

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

            CollateralService collateralService = new CollateralService(_mockCollateralRepo.Object, _mockUnitOfWork.Object);

            var res = await collateralService.ListAll();
            Assert.NotNull(res);
            Assert.Equal(2, res.Count());
        }

        [Fact]
        public async System.Threading.Tasks.Task ListAll_Exception()
        {
            var _mockCollateralRepo = new Mock<ICollateralRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

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

            CollateralService collateralService = new CollateralService(_mockCollateralRepo.Object, _mockUnitOfWork.Object);

            await Assert.ThrowsAsync<ServerErrorException>(() => collateralService.ListAll());
        }

        [Fact]
        public async void SaveAsync_Ok()
        {
            Collateral collateral = new Collateral()
            {
                Make = "Sienar Fleet Systems",
                Model = "TIE/ln space superiority starfighter",
                BodyStyle = "Starfighter",
                CollateralId = 12345
            };

            var _mockCollateralRepo = new Mock<ICollateralRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockCollateralRepo.Setup(repo => repo.AddAsync(It.IsAny<Collateral>())).ReturnsAsync(collateral);
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);

            CollateralService collateralService = new CollateralService(_mockCollateralRepo.Object, _mockUnitOfWork.Object);

            var res = await collateralService.SaveAsync(collateral);

            Assert.Equal(collateral, res);
        }

        [Fact]
        public async void SaveAsync_Exception()
        {
            Collateral collateral = new Collateral()
            {
                Make = "Sienar Fleet Systems",
                Model = "TIE/ln space superiority starfighter",
                BodyStyle = "Starfighter",
                CollateralId = 12345
            };

            var _mockCollateralRepo = new Mock<ICollateralRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockCollateralRepo.Setup(repo => repo.AddAsync(It.Is<Collateral>(param => param == collateral))).ThrowsAsync(new Exception("oops"));

            CollateralService collateralService = new CollateralService(_mockCollateralRepo.Object, _mockUnitOfWork.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await collateralService.SaveAsync(collateral));
        }

        [Fact]
        public async void Get_Exception()
        {
            Collateral collateral = new Collateral()
            {
                Make = "Sienar Fleet Systems",
                Model = "TIE/ln space superiority starfighter",
                BodyStyle = "Starfighter",
                CollateralId = 12345
            };

            var _mockCollateralRepo = new Mock<ICollateralRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockCollateralRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).ThrowsAsync(new Exception("oops"));

            CollateralService collateralService = new CollateralService(_mockCollateralRepo.Object, _mockUnitOfWork.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await collateralService.Get(12345));
        }

        [Fact]
        public async void Get_Null_Exception()
        {
            Collateral collateral = new Collateral()
            {
                Make = "Sienar Fleet Systems",
                Model = "TIE/ln space superiority starfighter",
                BodyStyle = "Starfighter",
                CollateralId = 12345
            };

            var _mockCollateralRepo = new Mock<ICollateralRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockCollateralRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).Returns(Task.FromResult<Collateral>(null));

            CollateralService collateralService = new CollateralService(_mockCollateralRepo.Object, _mockUnitOfWork.Object);

            await Assert.ThrowsAsync<NotFoundException>(async () => await collateralService.Get(12345));
        }

        [Fact]
        public async void Get_Ok()
        {
            Collateral collateral = new Collateral()
            {
                Make = "Sienar Fleet Systems",
                Model = "TIE/ln space superiority starfighter",
                BodyStyle = "Starfighter",
                CollateralId = 12345
            };

            var _mockCollateralRepo = new Mock<ICollateralRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockCollateralRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(collateral);

            CollateralService collateralService = new CollateralService(_mockCollateralRepo.Object, _mockUnitOfWork.Object);

            var res = await collateralService.Get(12345);
            Assert.Equal(collateral, res);
        }

        [Fact]
        public async void UpdateAsync_Ok()
        {
            Collateral collateral = new Collateral()
            {
                Make = "Sienar Fleet Systems",
                Model = "TIE/ln space superiority starfighter",
                BodyStyle = "Starfighter",
                CollateralId = 12345,
                Vin = "r2d2c3p0",
                Year = 10,
                Description = "starfighter of choice for the Galactic Empire",
                VehicleType = 5,
                Inoperable = false,
                CollateralTypeId = 1,
                RetitledInLandmarkName = DateTime.Now
            };

            var _mockCollateralRepo = new Mock<ICollateralRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockCollateralRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(collateral);
            _mockCollateralRepo.Setup(repo => repo.Update(It.Is<Collateral>(param => param.Vin == "r2d2c3p0")));
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);

            CollateralService collateralService = new CollateralService(_mockCollateralRepo.Object, _mockUnitOfWork.Object);

            var res = await collateralService.UpdateAsync(collateral);
            Assert.Equal(collateral, res);
        }

        [Fact]
        public async void UpdateAsync_Existing_Null()
        {
            Collateral collateral = new Collateral()
            {
                Make = "Sienar Fleet Systems",
                Model = "TIE/ln space superiority starfighter",
                BodyStyle = "Starfighter",
                CollateralId = 12345,
                Vin = "r2d2c3p0",
                Year = 10,
                Description = "starfighter of choice for the Galactic Empire",
                VehicleType = 5,
                Inoperable = false,
                CollateralTypeId = 1,
                RetitledInLandmarkName = DateTime.Now
            };

            var _mockCollateralRepo = new Mock<ICollateralRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockCollateralRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).Returns(Task.FromResult<Collateral>(null));
            _mockCollateralRepo.Setup(repo => repo.Update(It.Is<Collateral>(param => param.Vin == "r2d2c3p0")));
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);

            CollateralService collateralService = new CollateralService(_mockCollateralRepo.Object, _mockUnitOfWork.Object);

            await Assert.ThrowsAsync<NotFoundException>(async () => await collateralService.UpdateAsync(collateral));
        }
        
        [Fact]
        public async void UpdateAsync_Existing_Exception()
        {
            Collateral collateral = new Collateral()
            {
                Make = "Sienar Fleet Systems",
                Model = "TIE/ln space superiority starfighter",
                BodyStyle = "Starfighter",
                CollateralId = 12345,
                Vin = "r2d2c3p0",
                Year = 10,
                Description = "starfighter of choice for the Galactic Empire",
                VehicleType = 5,
                Inoperable = false,
                CollateralTypeId = 1,
                RetitledInLandmarkName = DateTime.Now
            };

            var _mockCollateralRepo = new Mock<ICollateralRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockCollateralRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).ThrowsAsync(new Exception("oops"));
            _mockCollateralRepo.Setup(repo => repo.Update(It.Is<Collateral>(param => param.Vin == "r2d2c3p0")));
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);

            CollateralService collateralService = new CollateralService(_mockCollateralRepo.Object, _mockUnitOfWork.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await collateralService.UpdateAsync(collateral));
        }

        [Fact]
        public async void UpdateAsync_Update_Exception()
        {
            Collateral collateral = new Collateral()
            {
                Make = "Sienar Fleet Systems",
                Model = "TIE/ln space superiority starfighter",
                BodyStyle = "Starfighter",
                CollateralId = 12345,
                Vin = "r2d2c3p0",
                Year = 10,
                Description = "starfighter of choice for the Galactic Empire",
                VehicleType = 5,
                Inoperable = false,
                CollateralTypeId = 1,
                RetitledInLandmarkName = DateTime.Now
            };

            var _mockCollateralRepo = new Mock<ICollateralRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockCollateralRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(collateral);
            _mockCollateralRepo.Setup(repo => repo.Update(It.Is<Collateral>(param => param.Vin == "r2d2c3p0"))).Throws(new Exception("oops"));
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);

            CollateralService collateralService = new CollateralService(_mockCollateralRepo.Object, _mockUnitOfWork.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await collateralService.UpdateAsync(collateral));
        }

    }
}