DamageAssessment_Backend/DamageAssesmentApi/DamageAssesment.Api.Locations.Test/LocationsServiceTest.cs

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

namespace DamageAssesment.Api.Locations.Test
{
    public class LocationsServiceTest
    {


        //Tests for regions

        [Fact(DisplayName = "Get Regions - Ok case")]
        public async Task GetRegionsAsync_ShouldReturnStatusCode200()
        {
            var mockRegionService = new Mock<IRegionsProvider>();
            var mockResponse = await MockData.getOkResponse();
            mockRegionService.Setup(service => service.GetRegionsAsync()).ReturnsAsync(mockResponse);

            var regionProvider = new RegionsController(mockRegionService.Object);
            var result = (OkObjectResult)await regionProvider.GetRegionsAsync();

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

        [Fact(DisplayName = "Get Regions - NoContent Case")]
        public async Task GetRegionsAsync_ShouldReturnStatusCode204()
        {
            var mockRegionService = new Mock<IRegionsProvider>();
            var mockResponse = await MockData.getNoContentResponse();
            mockRegionService.Setup(service => service.GetRegionsAsync()).ReturnsAsync(mockResponse);

            var regionProvider = new RegionsController(mockRegionService.Object);
            var result = (NoContentResult)await regionProvider.GetRegionsAsync();

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

        [Fact(DisplayName = "Get Region by Id - Ok case")]
        public async Task GetRegionAsync_ShouldReturnStatusCode200()
        {
            var mockRegionService = new Mock<IRegionsProvider>();
            var mockResponse = await MockData.getOkResponse("1");
            mockRegionService.Setup(service => service.GetRegionByIdAsync("1")).ReturnsAsync(mockResponse);

            var regionProvider = new RegionsController(mockRegionService.Object);
            var result = (OkObjectResult)await regionProvider.GetRegionAsync("1");

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

        [Fact(DisplayName = "Get Region by Id - NotFound case")]
        public async Task GetRegionAsync_ShouldReturnStatusCode404()
        {
            var mockRegionService = new Mock<IRegionsProvider>();
            var mockResponse = await MockData.getNotFoundResponse();
            mockRegionService.Setup(service => service.GetRegionByIdAsync("99")).ReturnsAsync(mockResponse);

            var regionProvider = new RegionsController(mockRegionService.Object);
            var result = (NotFoundResult)await regionProvider.GetRegionAsync("99");
            Assert.Equal(404, result.StatusCode);
        }

        [Fact(DisplayName = "Post Region - Ok case")]
        public async Task PostSurveyAsync_ShouldReturnStatusCode200()
        {
            var mockRegionService = new Mock<IRegionsProvider>();
            var mockResponse = await MockData.getOkResponse("1");
            var mockInputRegion = await MockData.getInputRegionData();
            mockRegionService.Setup(service => service.PostRegionAsync(mockInputRegion)).ReturnsAsync(mockResponse);

            var regionProvider = new RegionsController(mockRegionService.Object);
            var result = (OkObjectResult)await regionProvider.PostRegionAsync(mockInputRegion);

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

        [Fact(DisplayName = "Post Region - BadRequest case")]
        public async Task PostSurveyAsync_ShouldReturnStatusCode400()
        {
            var mockRegionService = new Mock<IRegionsProvider>();
            var mockResponse = await MockData.getBadRequestResponse();
            var mockInputRegion = await MockData.getInputRegionData();
            mockRegionService.Setup(service => service.PostRegionAsync(mockInputRegion)).ReturnsAsync(mockResponse);

            var regionProvider = new RegionsController(mockRegionService.Object);
            var result = (BadRequestObjectResult)await regionProvider.PostRegionAsync(mockInputRegion);

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

        [Fact(DisplayName = "Put Region - Ok case")]
        public async Task PutRegionAsync_ShouldReturnStatusCode200()
        {
            var mockRegionService = new Mock<IRegionsProvider>();
            var mockResponse = await MockData.getOkResponse("1");
            var mockInputRegion = await MockData.getInputRegionData();
            mockRegionService.Setup(service => service.PutRegionAsync(mockInputRegion)).ReturnsAsync(mockResponse);

            var regionProvider = new RegionsController(mockRegionService.Object);
            var result = (OkObjectResult)await regionProvider.PutRegionAsync(mockInputRegion);

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

        [Fact(DisplayName = "Put Region - NotFound case")]
        public async Task PutSurveyAsync_ShouldReturnStatusCode404()
        {
            var mockRegionService = new Mock<IRegionsProvider>();
            var mockResponse = await MockData.getNotFoundResponse();
            var mockInputRegion = await MockData.getInputRegionData();
            mockRegionService.Setup(service => service.PutRegionAsync(mockInputRegion)).ReturnsAsync(mockResponse);

            var regionProvider = new RegionsController(mockRegionService.Object);
            var result = (NotFoundObjectResult)await regionProvider.PutRegionAsync(mockInputRegion);

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

        [Fact(DisplayName = "Put Region - BadRequest case")]
        public async Task PutSurveyAsync_ShouldReturnStatusCode400()
        {
            var mockRegionService = new Mock<IRegionsProvider>();
            var mockResponse = await MockData.getBadRequestResponse();
            var mockInputRegion = await MockData.getInputRegionData();
            mockRegionService.Setup(service => service.PutRegionAsync(mockInputRegion)).ReturnsAsync(mockResponse);

            var regionProvider = new RegionsController(mockRegionService.Object);
            var result = (BadRequestObjectResult)await regionProvider.PutRegionAsync(mockInputRegion);

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

        [Fact(DisplayName = "Delete Region - Ok case")]
        public async Task DeleteSurveyAsync_ShouldReturnStatusCode200()
        {
            var mockRegionService = new Mock<IRegionsProvider>();
            var mockResponse = await MockData.getOkResponse("1");

            mockRegionService.Setup(service => service.DeleteRegionAsync("1")).ReturnsAsync(mockResponse);

            var regionProvider = new RegionsController(mockRegionService.Object);
            var result = (OkObjectResult)await regionProvider.DeleteRegionAsync("1");

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

        [Fact(DisplayName = "Delete Region - NotFound case")]
        public async Task DeleteSurveyAsync_ShouldReturnStatusCode404()
        {
            var mockRegionService = new Mock<IRegionsProvider>();
            var mockResponse = await MockData.getNotFoundResponse();

            mockRegionService.Setup(service => service.DeleteRegionAsync("1")).ReturnsAsync(mockResponse);

            var regionProvider = new RegionsController(mockRegionService.Object);
            var result = (NotFoundResult)await regionProvider.DeleteRegionAsync("1");

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