monorepo/LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Controllers/PersonControllerTest.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Moq;
using NUnit.Framework;
using LCU.Api.Internal.CoreApiWrapper.Controllers;
using LCU.Api.Internal.CoreApiWrapper.Services;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Persons;
using LCU.Library.Internal.Exceptions;
using Microsoft.AspNetCore.Http;

namespace LCU.Api.Internal.CoreApiWrapperTest.Controllers
{
    public class PersonControllerTest
    {
        private PersonController _personController;
        private Mock<IPersonService> _mockPersonService;

        [SetUp]
        public void SetUp()
        {
            _mockPersonService = new Mock<IPersonService>();
            _personController = new PersonController(_mockPersonService.Object);
        }

        [Test]
        public async Task GetPersonByPersonNumber_OK()
        {
            const long personNumber = 123334234324;
            var testPersonResult = new Person
            {
                FirstName = "Tester"
            };
            var testPersonsResult = new List<Person> { testPersonResult };

            _mockPersonService.Setup(x => x.GetPersonByPersonNumber(personNumber)).ReturnsAsync(testPersonsResult).Verifiable();

            var results = await _personController.GetPersonByPersonNumber(personNumber);

            Assert.NotNull(results);
            var okResult = results as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);

            var result = okResult.Value as List<Person>;
            Assert.NotNull(result);
            Assert.AreEqual(1, result.Count);
            Assert.AreEqual(testPersonResult.FirstName, result.FirstOrDefault()?.FirstName);
            _mockPersonService.Verify();
        }

        [Test]
        public async Task GetPersonByPersonNumber_ServiceException_ServerErrorReturned()
        {
            const long personNumber = 123334234324;
            _mockPersonService.Setup(x => x.GetPersonByPersonNumber(personNumber)).ThrowsAsync(new ServiceException("Exception thrown from unit test")).Verifiable();

            var results = await _personController.GetPersonByPersonNumber(personNumber);

            Assert.NotNull(results);
            var badRes = results as StatusCodeResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(500, badRes.StatusCode);
        }

        [Test]
        public async Task GetPersonByPersonNumber_Exception_ServerErrorReturned()
        {
            const long personNumber = 123334234324;
            _mockPersonService.Setup(x => x.GetPersonByPersonNumber(personNumber)).ThrowsAsync(new Exception("Thrown from unit test")).Verifiable();

            var results = await _personController.GetPersonByPersonNumber(personNumber);

            Assert.NotNull(results);
            var badRes = results as StatusCodeResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(500, badRes.StatusCode);
        }

        [Test]
        public async Task GetMemberByMemberAgreeNbr_OK()
        {
            const long memberNumber = 123334234324;
            var testPersonResult = new Person
            {
                FirstName = "Tester"
            };

            _mockPersonService.Setup(x => x.GetMemberByMemberAgreeNbr(memberNumber)).ReturnsAsync(testPersonResult).Verifiable();

            var results = await _personController.GetPersonByMemberAgreementNumber(memberNumber);

            Assert.NotNull(results);
            var okResult = results as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);

            var result = okResult.Value as Person;
            Assert.NotNull(result);
            Assert.AreEqual(testPersonResult.FirstName, result?.FirstName);
            _mockPersonService.Verify();
        }

        [Test]
        public async Task GetMemberByMemberAgreeNbr_ServiceException_ServerErrorReturned()
        {
            const long memberNumber = 123334234324;
            _mockPersonService.Setup(x => x.GetMemberByMemberAgreeNbr(memberNumber)).ThrowsAsync(new ServiceException("Thrown from unit test")).Verifiable();

            var results = await _personController.GetPersonByMemberAgreementNumber(memberNumber);

            Assert.NotNull(results);
            var badRes = results as StatusCodeResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(500, badRes.StatusCode);
        }

        [Test]
        public async Task GetMemberByMemberAgreeNbr_Exception_ServerErrorReturned()
        {
            const long memberNumber = 123334234324;
            _mockPersonService.Setup(x => x.GetMemberByMemberAgreeNbr(memberNumber)).ThrowsAsync(new Exception("Thrown from unit test")).Verifiable();

            var results = await _personController.GetPersonByMemberAgreementNumber(memberNumber);

            Assert.NotNull(results);
            var badRes = results as StatusCodeResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(500, badRes.StatusCode);
        }

        [Test]
        public async Task GetPersonNameLike_RequestModelInvalid_Returns400()
        {
            var modelErrorKey = Guid.NewGuid().ToString();
            var modelErrorMessage = Guid.NewGuid().ToString();
            _personController.ModelState.AddModelError(modelErrorKey, modelErrorMessage);

            var response = await _personController.GetPersonNameLike(new PersonNameRequest());

            Assert.IsInstanceOf<BadRequestObjectResult>(response);
            Assert.AreEqual(StatusCodes.Status400BadRequest, ((BadRequestObjectResult)response).StatusCode);
        }

        [Test]
        public async Task GetPersonNameLike_ServiceThrowsServiceException_Returns500()
        {
            var request = new PersonNameRequest();
            var limit = DateTime.Now.Millisecond;
            _mockPersonService
                .Setup(s => s.GetPersonsByNameLike(request, limit))
                .ThrowsAsync(new ServiceException(string.Empty));

            var response = await _personController.GetPersonNameLike(request, limit);

            Assert.IsInstanceOf<StatusCodeResult>(response);
            Assert.AreEqual(StatusCodes.Status500InternalServerError, ((StatusCodeResult)response).StatusCode);
        }

        [Test]
        public async Task GetPersonNameLike_ServiceThrowsException_Returns500()
        {
            var request = new PersonNameRequest();
            var limit = DateTime.Now.Millisecond;
            _mockPersonService
                .Setup(s => s.GetPersonsByNameLike(request, limit))
                .ThrowsAsync(new Exception());

            var response = await _personController.GetPersonNameLike(request, limit);

            Assert.IsInstanceOf<StatusCodeResult>(response);
            Assert.AreEqual(StatusCodes.Status500InternalServerError, ((StatusCodeResult)response).StatusCode);
        }

        [Test]
        public async Task GetPersonNameLike_ServiceReturnsPeople_Returns200AndPeople()
        {
            var request = new PersonNameRequest();
            var limit = DateTime.Now.Millisecond;
            var people = Enumerable.Repeat<Func<Person>>(() => new Person(), limit).Select(f => f()).ToArray();
            _mockPersonService
                .Setup(s => s.GetPersonsByNameLike(request, limit))
                .ReturnsAsync(people);

            var response = await _personController.GetPersonNameLike(request, limit);

            Assert.IsInstanceOf<OkObjectResult>(response);
            Assert.AreEqual(StatusCodes.Status200OK, ((OkObjectResult)response).StatusCode);
            Assert.AreEqual(people, ((OkObjectResult)response).Value);
        }

        [Test]
        public async Task CountPersonNameLike_RequestModelInvalid_Returns400()
        {
            var modelErrorKey = Guid.NewGuid().ToString();
            var modelErrorMessage = Guid.NewGuid().ToString();
            _personController.ModelState.AddModelError(modelErrorKey, modelErrorMessage);

            var response = await _personController.CountPersonNameLike(new PersonNameRequest());

            Assert.IsInstanceOf<BadRequestObjectResult>(response);
            Assert.AreEqual(StatusCodes.Status400BadRequest, ((BadRequestObjectResult)response).StatusCode);
        }

        [Test]
        public async Task CountPersonNameLike_ServiceThrowsServiceException_Returns500()
        {
            var request = new PersonNameRequest();
            var limit = DateTime.Now.Millisecond;
            _mockPersonService
                .Setup(s => s.CountPersonsByNameLike(request))
                .ThrowsAsync(new ServiceException(string.Empty));

            var response = await _personController.CountPersonNameLike(request);

            Assert.IsInstanceOf<StatusCodeResult>(response);
            Assert.AreEqual(StatusCodes.Status500InternalServerError, ((StatusCodeResult)response).StatusCode);
        }

        [Test]
        public async Task CountPersonNameLike_ServiceThrowsException_Returns500()
        {
            var request = new PersonNameRequest();
            var limit = DateTime.Now.Millisecond;
            _mockPersonService
                .Setup(s => s.CountPersonsByNameLike(request))
                .ThrowsAsync(new Exception());

            var response = await _personController.CountPersonNameLike(request);

            Assert.IsInstanceOf<StatusCodeResult>(response);
            Assert.AreEqual(StatusCodes.Status500InternalServerError, ((StatusCodeResult)response).StatusCode);
        }

        [Test]
        public async Task CountPersonNameLike_ServiceReturnsPeople_Returns200AndCount()
        {
            var request = new PersonNameRequest();
            var count = DateTime.Now.Ticks;
            _mockPersonService
                .Setup(s => s.CountPersonsByNameLike(request))
                .ReturnsAsync(count);

            var response = await _personController.CountPersonNameLike(request);

            Assert.IsInstanceOf<OkObjectResult>(response);
            Assert.AreEqual(StatusCodes.Status200OK, ((OkObjectResult)response).StatusCode);
            Assert.AreEqual(count, ((OkObjectResult)response).Value);
        }
    }
}