DamageAssessment_Backend/DamageAssesmentApi/DamageAssesment.Api.Employees.Test/EmployeeServiceTest.cs

using AutoMapper;
using DamageAssesment.Api.Employees.Controllers;
using DamageAssesment.Api.Employees.Db;
using DamageAssesment.Api.Employees.Interfaces;
using DamageAssesment.Api.Employees.Profiles;
using DamageAssesment.Api.Employees.Providers;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Moq;
using Xunit;

namespace DamageAssesment.Api.Employees.Test
{
    public class EmployeeServiceTest
    {
        [Fact(DisplayName = "Get Employees - Ok case")]
        public async Task GetEmployeesAsync_ShouldReturnStatusCode200()
        {
            var mockEmployeeService = new Mock<IEmployeesProvider>();
            var mockResponse = await MockData.getOkResponse();
            mockEmployeeService.Setup(service => service.GetEmployeesAsync()).ReturnsAsync(mockResponse);

            var EmployeeProvider = new EmployeesController(mockEmployeeService.Object);
            var result = (OkObjectResult)await EmployeeProvider.GetEmployeesAsync();

            Assert.Equal(200, result.StatusCode);
        }

        [Fact(DisplayName = "Get Employees - NoContent Case")]
        public async Task GetEmployeesAsync_ShouldReturnStatusCode204()
        {
            var mockEmployeeService = new Mock<IEmployeesProvider>();
            var mockResponse = await MockData.getNoContentResponse();
            mockEmployeeService.Setup(service => service.GetEmployeesAsync()).ReturnsAsync(mockResponse);

            var EmployeeProvider = new EmployeesController(mockEmployeeService.Object);
            var result = (NoContentResult)await EmployeeProvider.GetEmployeesAsync();

            Assert.Equal(204, result.StatusCode);
        }

        [Fact(DisplayName = "Get Employee by Id - Ok case")]
        public async Task GetEmployeeAsync_ShouldReturnStatusCode200()
        {
            var mockEmployeeService = new Mock<IEmployeesProvider>();
            var mockResponse = await MockData.getOkResponse("Emp1");
            mockEmployeeService.Setup(service => service.GetEmployeeByIdAsync("Emp1")).ReturnsAsync(mockResponse);

            var EmployeeProvider = new EmployeesController(mockEmployeeService.Object);
            var result = (OkObjectResult)await EmployeeProvider.GetEmployeeByIdAsync("Emp1");

            Assert.Equal(200, result.StatusCode);
        }

        [Fact(DisplayName = "Get Employee by Id - NotFound case")]
        public async Task GetEmployeeAsync_ShouldReturnStatusCode404()
        {
            var mockEmployeeService = new Mock<IEmployeesProvider>();
            var mockResponse = await MockData.getNotFoundResponse();
            mockEmployeeService.Setup(service => service.GetEmployeeByIdAsync("Emp99")).ReturnsAsync(mockResponse);

            var EmployeeProvider = new EmployeesController(mockEmployeeService.Object);
            var result = (NotFoundResult)await EmployeeProvider.GetEmployeeByIdAsync("Emp99");
            Assert.Equal(404, result.StatusCode);
        }

        [Fact(DisplayName = "Post Employee - Ok case")]
        public async Task PostEmployeeAsync_ShouldReturnStatusCode200()
        {
            var mockEmployeeService = new Mock<IEmployeesProvider>();
            var mockResponse = await MockData.getOkResponse("Emp1");
            var mockInputEmployee = await MockData.getInputEmployeeData();
            mockEmployeeService.Setup(service => service.PostEmployeeAsync(mockInputEmployee)).ReturnsAsync(mockResponse);

            var EmployeeProvider = new EmployeesController(mockEmployeeService.Object);
            var result = (OkObjectResult)await EmployeeProvider.CreateEmployee(mockInputEmployee);

            Assert.Equal(200, result.StatusCode);
        }

        [Fact(DisplayName = "Post Employee - BadRequest case")]
        public async Task PostEmployeeAsync_ShouldReturnStatusCode400()
        {
            var mockEmployeeService = new Mock<IEmployeesProvider>();
            var mockInputEmployee = await MockData.getInputEmployeeData();
            var mockResponse = await MockData.getBadRequestResponse();
            mockEmployeeService.Setup(service => service.PostEmployeeAsync(mockInputEmployee)).ReturnsAsync(mockResponse);

            var EmployeeProvider = new EmployeesController(mockEmployeeService.Object);
            var result = (BadRequestObjectResult)await EmployeeProvider.CreateEmployee(mockInputEmployee);

            Assert.Equal(400, result.StatusCode);
        }

        [Fact(DisplayName = "Put Employee - Ok case")]
        public async Task PutEmployeeAsync_ShouldReturnStatusCode200()
        {
            var mockEmployeeService = new Mock<IEmployeesProvider>();
            var mockResponse = await MockData.getOkResponse("Emp1");
            var mockInputEmployee = await MockData.getInputEmployeeData();
            mockEmployeeService.Setup(service => service.UpdateEmployeeAsync(mockInputEmployee)).ReturnsAsync(mockResponse);

            var EmployeeProvider = new EmployeesController(mockEmployeeService.Object);
            var result = (OkObjectResult)await EmployeeProvider.UpdateEmployee(mockInputEmployee);

            Assert.Equal(200, result.StatusCode);
        }

        [Fact(DisplayName = "Put Employee - NotFound case")]
        public async Task PutEmployeeAsync_ShouldReturnStatusCode404()
        {
            var mockEmployeeService = new Mock<IEmployeesProvider>();
            var mockResponse = await MockData.getNotFoundResponse();
            var mockInputEmployee = await MockData.getInputEmployeeData();
            mockEmployeeService.Setup(service => service.UpdateEmployeeAsync(mockInputEmployee)).ReturnsAsync(mockResponse);

            var EmployeeProvider = new EmployeesController(mockEmployeeService.Object);
            var result = (NotFoundObjectResult)await EmployeeProvider.UpdateEmployee(mockInputEmployee);

            Assert.Equal(404, result.StatusCode);
        }

        [Fact(DisplayName = "Put Employee - BadRequest case")]
        public async Task PutEmployeeAsync_ShouldReturnStatusCode400()
        {
            var mockEmployeeService = new Mock<IEmployeesProvider>();
            var mockResponse = await MockData.getBadRequestResponse();
            var mockInputEmployee = await MockData.getInputEmployeeData();
            mockEmployeeService.Setup(service => service.UpdateEmployeeAsync(mockInputEmployee)).ReturnsAsync(mockResponse);

            var EmployeeProvider = new EmployeesController(mockEmployeeService.Object);
            var result = (BadRequestObjectResult)await EmployeeProvider.UpdateEmployee(mockInputEmployee);

            Assert.Equal(400, result.StatusCode);
        }

        [Fact(DisplayName = "Delete Employee - Ok case")]
        public async Task DeleteEmployeeAsync_ShouldReturnStatusCode200()
        {
            var mockEmployeeService = new Mock<IEmployeesProvider>();
            var mockResponse = await MockData.getOkResponse("Emp1");

            mockEmployeeService.Setup(service => service.DeleteEmployeeAsync("Emp1")).ReturnsAsync(mockResponse);

            var EmployeeProvider = new EmployeesController(mockEmployeeService.Object);
            var result = (OkObjectResult)await EmployeeProvider.DeleteEmployee("Emp1");

            Assert.Equal(200, result.StatusCode);
        }

        [Fact(DisplayName = "Delete Employee - NotFound case")]
        public async Task DeleteEmployeeAsync_ShouldReturnStatusCode404()
        {
            var mockEmployeeService = new Mock<IEmployeesProvider>();
            var mockResponse = await MockData.getNotFoundResponse();
            mockEmployeeService.Setup(service => service.DeleteEmployeeAsync("Emp1")).ReturnsAsync(mockResponse);

            var EmployeeProvider = new EmployeesController(mockEmployeeService.Object);
            var result = (NotFoundResult)await EmployeeProvider.DeleteEmployee("Emp1");

            Assert.Equal(404, result.StatusCode);
        }
    }
}