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

using System;
using System.Collections.Generic;
using System.Text;
using Xunit;
using Moq;
using LCU.Shared.Collections.RepoApiLib.Repositories;
using Xunit.Sdk;
using LCU.API.Collections.RepoApi.Services;
using LCU.Shared.Collections.RepoApiLib.Models;
using System.Linq;
using LCU.API.Collections.RepoApi.Exceptions;
using System.Threading.Tasks;
using Castle.Core.Resource;
using System.Runtime.CompilerServices;
using System.IO;

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

            _mockImsAutoFileDataRepo.Setup(repo => repo.ListAllAsync()).ReturnsAsync(new List<ImsAutoFileData>() { new ImsAutoFileData() { } });
            ImsAutoFileDataService imsAutoFileDataService = new ImsAutoFileDataService(_mockImsAutoFileDataRepo.Object, _mockUnitOfWork.Object);

            var res = await imsAutoFileDataService.ListAll();
            Assert.NotNull(res);
            Assert.Single(res);
        }

        [Fact]
        public async void ListAll_Exception()
        {
            var _mockImsAutoFileDataRepo = new Mock<IImsAutoFileDataRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockImsAutoFileDataRepo.Setup(repo => repo.ListAllAsync()).ThrowsAsync(new Exception("oops"));
            ImsAutoFileDataService imsAutoFileDataService = new ImsAutoFileDataService(_mockImsAutoFileDataRepo.Object, _mockUnitOfWork.Object);

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

        [Fact]
        public async void SaveAsync_Ok()
        {
            ImsAutoFileData filedata = new ImsAutoFileData()
            {
                RepoId = 5
            };

            var _mockImsAutoFileDataRepo = new Mock<IImsAutoFileDataRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockImsAutoFileDataRepo.Setup(repo => repo.AddAsync(It.IsAny<ImsAutoFileData>())).Returns(Task.CompletedTask);
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            ImsAutoFileDataService imsAutoFileDataService = new ImsAutoFileDataService(_mockImsAutoFileDataRepo.Object, _mockUnitOfWork.Object);

            var res = await imsAutoFileDataService.SaveAsync(filedata);
            Assert.NotNull(res);
            Assert.Equal(5,res.RepoId);
        }

        [Fact]
        public async void SaveAsync_Exception()
        {
            ImsAutoFileData filedata = new ImsAutoFileData()
            {
                RepoId = 5
            };

            var _mockImsAutoFileDataRepo = new Mock<IImsAutoFileDataRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockImsAutoFileDataRepo.Setup(repo => repo.AddAsync(It.IsAny<ImsAutoFileData>())).ThrowsAsync(new Exception("oops"));
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            ImsAutoFileDataService imsAutoFileDataService = new ImsAutoFileDataService(_mockImsAutoFileDataRepo.Object, _mockUnitOfWork.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await imsAutoFileDataService.SaveAsync(filedata));
        }

        [Fact]
        public async void Get_Exception()
        {

            var _mockImsAutoFileDataRepo = new Mock<IImsAutoFileDataRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

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

            ImsAutoFileDataService imsAutoFileDataService = new ImsAutoFileDataService(_mockImsAutoFileDataRepo.Object, _mockUnitOfWork.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await imsAutoFileDataService.Get("VinNumber", 12345));
        }

        [Fact]
        public async void Get_Null_Exception()
        {
            var _mockImsAutoFileDataRepo = new Mock<IImsAutoFileDataRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockImsAutoFileDataRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<string>(), It.IsAny<int>())).Returns(Task.FromResult<ImsAutoFileData>(null));

            ImsAutoFileDataService imsAutoFileDataService = new ImsAutoFileDataService(_mockImsAutoFileDataRepo.Object, _mockUnitOfWork.Object);

            await Assert.ThrowsAsync<NotFoundException>(async () => await imsAutoFileDataService.Get("VinNumber", 12345));
        }

        [Fact]
        public async void Get_Ok()
        {
            ImsAutoFileData filedata = new ImsAutoFileData()
            {
                RepoId = 5,
                VIN = "VinNumber"
            };
            var _mockImsAutoFileDataRepo = new Mock<IImsAutoFileDataRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockImsAutoFileDataRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<string>(), It.IsAny<int>())).ReturnsAsync(filedata);

            ImsAutoFileDataService imsAutoFileDataService = new ImsAutoFileDataService(_mockImsAutoFileDataRepo.Object, _mockUnitOfWork.Object);

            var res = await imsAutoFileDataService.Get("VinNumber", 12345);
            Assert.NotNull(res);
            Assert.Equal(filedata, res);
        }

        [Fact]
        public async void GetByAuctionAssignmentId_Exception()
        {

            var _mockImsAutoFileDataRepo = new Mock<IImsAutoFileDataRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

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

            ImsAutoFileDataService imsAutoFileDataService = new ImsAutoFileDataService(_mockImsAutoFileDataRepo.Object, _mockUnitOfWork.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await imsAutoFileDataService.GetByAuctionAssignmentId(12345));
        }

        [Fact]
        public async void GetByAuctionAssignmentId_Null_Exception()
        {
            var _mockImsAutoFileDataRepo = new Mock<IImsAutoFileDataRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockImsAutoFileDataRepo.Setup(repo => repo.FindByAuctionAssignmentIdAsync(It.IsAny<int>())).Returns(Task.FromResult<ImsAutoFileData>(null));

            ImsAutoFileDataService imsAutoFileDataService = new ImsAutoFileDataService(_mockImsAutoFileDataRepo.Object, _mockUnitOfWork.Object);

            await Assert.ThrowsAsync<NotFoundException>(async () => await imsAutoFileDataService.GetByAuctionAssignmentId(12345));
        }

        [Fact]
        public async void GetByAuctionAssignmentId_Ok()
        {
            ImsAutoFileData filedata = new ImsAutoFileData()
            {
                RepoId = 12345,
                VIN = "VinNumber"
            };
            var _mockImsAutoFileDataRepo = new Mock<IImsAutoFileDataRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockImsAutoFileDataRepo.Setup(repo => repo.FindByAuctionAssignmentIdAsync(It.IsAny<int>())).ReturnsAsync(filedata);

            ImsAutoFileDataService imsAutoFileDataService = new ImsAutoFileDataService(_mockImsAutoFileDataRepo.Object, _mockUnitOfWork.Object);

            var res = await imsAutoFileDataService.GetByAuctionAssignmentId(12345);
            Assert.NotNull(res);
            Assert.Equal(filedata, res);
        }

        [Fact]
        public async void UpdateAsync_Ok()
        {
            ImsAutoFileData filedata = new ImsAutoFileData()
            {
                RepoId = 12345,
                VIN = "VinNumber"
            };
            var _mockImsAutoFileDataRepo = new Mock<IImsAutoFileDataRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockImsAutoFileDataRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<string>(), It.IsAny<int>())).ReturnsAsync(filedata);
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            _mockImsAutoFileDataRepo.Setup(repo => repo.Update(It.IsAny<ImsAutoFileData>()));

            ImsAutoFileDataService imsAutoFileDataService = new ImsAutoFileDataService(_mockImsAutoFileDataRepo.Object, _mockUnitOfWork.Object);

            var res = await imsAutoFileDataService.UpdateAsync(filedata);
            Assert.NotNull(res);
            Assert.Equal(filedata, res);
        }

        [Fact]
        public async void UpdateAsync_Null_Exception()
        {
            ImsAutoFileData filedata = new ImsAutoFileData()
            {
                RepoId = 12345,
                VIN = "VinNumber"
            };
            var _mockImsAutoFileDataRepo = new Mock<IImsAutoFileDataRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockImsAutoFileDataRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<string>(), It.IsAny<int>())).Returns(Task.FromResult<ImsAutoFileData>(null));
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            _mockImsAutoFileDataRepo.Setup(repo => repo.Update(It.IsAny<ImsAutoFileData>()));

            ImsAutoFileDataService imsAutoFileDataService = new ImsAutoFileDataService(_mockImsAutoFileDataRepo.Object, _mockUnitOfWork.Object);

            await Assert.ThrowsAsync<NotFoundException>(async () => await imsAutoFileDataService.UpdateAsync(filedata));
        }

        [Fact]
        public async void UpdateAsync_Existing_Exception()
        {
            ImsAutoFileData filedata = new ImsAutoFileData()
            {
                RepoId = 12345,
                VIN = "VinNumber"
            };
            var _mockImsAutoFileDataRepo = new Mock<IImsAutoFileDataRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockImsAutoFileDataRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<string>(), It.IsAny<int>())).ThrowsAsync(new Exception("oops"));
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            _mockImsAutoFileDataRepo.Setup(repo => repo.Update(It.IsAny<ImsAutoFileData>()));

            ImsAutoFileDataService imsAutoFileDataService = new ImsAutoFileDataService(_mockImsAutoFileDataRepo.Object, _mockUnitOfWork.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await imsAutoFileDataService.UpdateAsync(filedata));
        }

        [Fact]
        public async void UpdateAsync_Update_Exception()
        {
            ImsAutoFileData filedata = new ImsAutoFileData()
            {
                RepoId = 12345,
                VIN = "VinNumber"
            };
            var _mockImsAutoFileDataRepo = new Mock<IImsAutoFileDataRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockImsAutoFileDataRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<string>(), It.IsAny<int>())).ReturnsAsync(filedata);
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            _mockImsAutoFileDataRepo.Setup(repo => repo.Update(It.IsAny<ImsAutoFileData>())).Throws(new Exception("oops"));

            ImsAutoFileDataService imsAutoFileDataService = new ImsAutoFileDataService(_mockImsAutoFileDataRepo.Object, _mockUnitOfWork.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await imsAutoFileDataService.UpdateAsync(filedata));
        }

        [Fact]
        public async void DeleteAsync_Ok()
        {
            ImsAutoFileData filedata = new ImsAutoFileData()
            {
                RepoId = 12345,
                VIN = "VinNumber"
            };
            var _mockImsAutoFileDataRepo = new Mock<IImsAutoFileDataRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockImsAutoFileDataRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<string>(), It.IsAny<int>())).ReturnsAsync(filedata);
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            _mockImsAutoFileDataRepo.Setup(repo => repo.Remove(It.IsAny<ImsAutoFileData>()));

            ImsAutoFileDataService imsAutoFileDataService = new ImsAutoFileDataService(_mockImsAutoFileDataRepo.Object, _mockUnitOfWork.Object);

            var res = await imsAutoFileDataService.DeleteAsync("vin",5);
            Assert.NotNull(res);
            Assert.Equal(filedata, res);
        }

        [Fact]
        public async void DeleteAsync_Null_Exception()
        {
            ImsAutoFileData filedata = new ImsAutoFileData()
            {
                RepoId = 12345,
                VIN = "VinNumber"
            };
            var _mockImsAutoFileDataRepo = new Mock<IImsAutoFileDataRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockImsAutoFileDataRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<string>(), It.IsAny<int>())).Returns(Task.FromResult<ImsAutoFileData>(null));
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            _mockImsAutoFileDataRepo.Setup(repo => repo.Remove(It.IsAny<ImsAutoFileData>()));

            ImsAutoFileDataService imsAutoFileDataService = new ImsAutoFileDataService(_mockImsAutoFileDataRepo.Object, _mockUnitOfWork.Object);

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

        [Fact]
        public async void DeleteAsync_Existing_Exception()
        {
            ImsAutoFileData filedata = new ImsAutoFileData()
            {
                RepoId = 12345,
                VIN = "VinNumber"
            };
            var _mockImsAutoFileDataRepo = new Mock<IImsAutoFileDataRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockImsAutoFileDataRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<string>(), It.IsAny<int>())).ThrowsAsync(new Exception("oops"));
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            _mockImsAutoFileDataRepo.Setup(repo => repo.Remove(It.IsAny<ImsAutoFileData>()));

            ImsAutoFileDataService imsAutoFileDataService = new ImsAutoFileDataService(_mockImsAutoFileDataRepo.Object, _mockUnitOfWork.Object);

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

        [Fact]
        public async void DeleteAsync_Update_Exception()
        {
            ImsAutoFileData filedata = new ImsAutoFileData()
            {
                RepoId = 12345,
                VIN = "VinNumber"
            };
            var _mockImsAutoFileDataRepo = new Mock<IImsAutoFileDataRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockImsAutoFileDataRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<string>(), It.IsAny<int>())).ReturnsAsync(filedata);
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            _mockImsAutoFileDataRepo.Setup(repo => repo.Remove(It.IsAny<ImsAutoFileData>())).Throws(new Exception("oops"));

            ImsAutoFileDataService imsAutoFileDataService = new ImsAutoFileDataService(_mockImsAutoFileDataRepo.Object, _mockUnitOfWork.Object);

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

    }
}