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

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using Microsoft.AspNetCore.Mvc;
using Moq;
using NUnit.Framework;
using LCU.Api.Internal.CoreApiWrapper.Controllers;
using LCU.Api.Internal.CoreApiWrapper.Services;
using System.Threading.Tasks;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Agreements;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.MemberAgreements;

namespace LCU.Api.Internal.CoreApiWrapperTest.Controllers
{
    public class AgreeControllerTest
    {
        private AgreeController _agreeController;
        private Mock<IAgreeService> _mockAgreeService;

        [SetUp]
        public void SetUp()
        {
            _mockAgreeService = new Mock<IAgreeService>();
            _agreeController = new AgreeController(_mockAgreeService.Object);
        }

        [Test]
        public async Task Get_OK()
        {
            _mockAgreeService.Setup(x => x.GetAgreeUsersByAccountNumbers(It.IsAny<List<string>>())).ReturnsAsync(
                  new List<AgreeUserAccount>()
                  {
                      new AgreeUserAccount()
                      {
                         AccountNumber = 100010,
                         AgreeNumber = 1000,
                         UserId = "101010"
                      },
                      new AgreeUserAccount()
                      {
                         AccountNumber = 200020,
                         AgreeNumber = 2000,
                         UserId = "202020"
                      }
                  });

            var accountNumbers = new List<string>()
            {
                "100010",
                "200020"
            };
            var results = await _agreeController.GetAgreeUsersByAccounts(accountNumbers);

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

        [Test]
        public async Task Get_AccountNumbers_Null_BadRequest()
        {
            var results = await _agreeController.GetAgreeUsersByAccounts(null);

            _mockAgreeService.Verify(x => x.GetAgreeUsersByAccountNumbers(It.IsAny<List<string>>()), Times.Never());

            Assert.NotNull(results);
            var badRequest = results as BadRequestObjectResult;
            Assert.NotNull(badRequest);
            Assert.AreEqual(400, badRequest.StatusCode);
        }
        
        [Test]
        public async Task Get_AccountNumbers_EmptyList_BadRequest()
        {
            var results = await _agreeController.GetAgreeUsersByAccounts(new List<string>());

            _mockAgreeService.Verify(x => x.GetAgreeUsersByAccountNumbers(It.IsAny<List<string>>()), Times.Never());

            Assert.NotNull(results);
            var badRequest = results as BadRequestObjectResult;
            Assert.NotNull(badRequest);
            Assert.AreEqual(400, badRequest.StatusCode);
        }
        
        [Test]
        public async Task Get_Exception()
        {
            _mockAgreeService.Setup(x => x.GetAgreeUsersByAccountNumbers(It.IsAny<List<string>>()))
               .Throws(new Exception("Oops"));

            var accountNumbers = new List<string>()
            {
                "100010",
                "200020"
            };
            var results = await _agreeController.GetAgreeUsersByAccounts(accountNumbers);

            Assert.NotNull(results);
            var badRes = results as StatusCodeResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(500, badRes.StatusCode);
        }
        
        [Test]
        public async Task GetAgreementByUserId_OK()
        {
            _mockAgreeService.Setup(x => x.GetAgreementByUserId("123")).ReturnsAsync(
                new Agreement
                    {
                        AgreementNumber = 111111,
                        PersonNumber = 222222,
                        UserId = "101010"
                    }).Verifiable();

            
            var results = await _agreeController.GetAgreementByUserId("123");

            Assert.NotNull(results);
            var okResult = results as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
            
            var result = okResult.Value as Agreement;
            Assert.NotNull(result);
            Assert.AreEqual(111111, result.AgreementNumber);
            _mockAgreeService.Verify();
        }
        
        [Test]
        public async Task GetAgreementByUserId_NoContent()
        {
            _mockAgreeService.Setup(x => x.GetAgreementByUserId("123")).ReturnsAsync((Agreement)null).Verifiable();
            
            var results = await _agreeController.GetAgreementByUserId("123");

            Assert.NotNull(results);
            var noContentResult = results as NoContentResult;
            Assert.NotNull(noContentResult);
            Assert.AreEqual(204, noContentResult.StatusCode);
        }
        
        [Test]
        public async Task GetAgreementByUserId_empty_BadRequest()
        {
            var results = await _agreeController.GetAgreementByUserId(null);

            _mockAgreeService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never());

            Assert.NotNull(results);
            var badRequest = results as BadRequestObjectResult;
            Assert.NotNull(badRequest);
            Assert.AreEqual(400, badRequest.StatusCode);
            
            var result2 = await _agreeController.GetAgreementByUserId("");

            _mockAgreeService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never());

            Assert.NotNull(result2);
            var badRequest2 = result2 as BadRequestObjectResult;
            Assert.NotNull(badRequest2);
            Assert.AreEqual(400, badRequest2.StatusCode);
        }
        
        [Test]
        public async Task GetAgreementByUserId_Error_StatusServerError()
        {
            _mockAgreeService.Setup(x => x.GetAgreementByUserId("123")).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
            
            var results = await _agreeController.GetAgreementByUserId("123");

            Assert.NotNull(results);
            var badRes = results as StatusCodeResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(500, badRes.StatusCode);
            _mockAgreeService.Verify();
        }
        
        [Test]
        public async Task GetUserIdByPersonNumber_OK()
        {
            var personNumbers = new List<string> { "5436", "44889" };
            _mockAgreeService.Setup(x => x.GetAgreeUsersByPersonNumber(123L)).ReturnsAsync(personNumbers).Verifiable();
            
            var results = await _agreeController.GetAgreeUsersByPersonNumber(123L);

            Assert.NotNull(results);
            var okResult = results as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
            
            var result = okResult.Value as List<string>;
            Assert.NotNull(result);
            Assert.AreEqual("5436", result.FirstOrDefault());
            _mockAgreeService.Verify();
        }
        
        [Test]
        public async Task GetUserIdByPersonNumber_NoContent()
        {
            var personNumbers = new List<string> {};
            _mockAgreeService.Setup(x => x.GetAgreeUsersByPersonNumber(123L)).ReturnsAsync(personNumbers).Verifiable();
            
            var results = await _agreeController.GetAgreeUsersByPersonNumber(123L);

            Assert.NotNull(results);
            var noContentResult = results as NoContentResult;
            Assert.NotNull(noContentResult);
            Assert.AreEqual(204, noContentResult.StatusCode);
        }
        
        [Test]
        public async Task GetUserIdByPersonNumber_empty_BadRequest()
        {
            var results = await _agreeController.GetAgreeUsersByPersonNumber(0);

            _mockAgreeService.Verify(x => x.GetAgreeUsersByPersonNumber(It.IsAny<long>()), Times.Never());

            Assert.NotNull(results);
            var badRequest = results as BadRequestObjectResult;
            Assert.NotNull(badRequest);
            Assert.AreEqual(400, badRequest.StatusCode);
        }
        
        [Test]
        public async Task GetUserIdByPersonNumber_Error_StatusServerError()
        {
            _mockAgreeService.Setup(x => x.GetAgreeUsersByPersonNumber(123)).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
            
            var results = await _agreeController.GetAgreeUsersByPersonNumber(123L);

            Assert.NotNull(results);
            var badRes = results as StatusCodeResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(500, badRes.StatusCode);
            _mockAgreeService.Verify();
        }
        
        [Test]
        public async Task GetUserIdByOrganizationNumber_OK()
        {
            _mockAgreeService.Setup(x => x.GetAgreeUserByOrganizationNumber(123L)).ReturnsAsync("5436").Verifiable();
            
            var results = await _agreeController.GetAgreeUserByOrganizationNumber(123L);

            Assert.NotNull(results);
            var okResult = results as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
            
            var result = okResult.Value as string;
            Assert.NotNull(result);
            Assert.AreEqual("5436", result);
            _mockAgreeService.Verify();
        }
        
        [Test]
        public async Task GetUserIdByOrganizationNumber_NoContent()
        {
            _mockAgreeService.Setup(x => x.GetAgreeUserByOrganizationNumber(123L)).ReturnsAsync((string)null).Verifiable();
            
            var results = await _agreeController.GetAgreeUserByOrganizationNumber(123L);

            Assert.NotNull(results);
            var noContentResult = results as NoContentResult;
            Assert.NotNull(noContentResult);
            Assert.AreEqual(204, noContentResult.StatusCode);
        }
        
        [Test]
        public async Task GetUserIdByOrganizationNumber_empty_BadRequest()
        {
            var results = await _agreeController.GetAgreeUserByOrganizationNumber(0);

            _mockAgreeService.Verify(x => x.GetAgreeUserByOrganizationNumber(It.IsAny<long>()), Times.Never());

            Assert.NotNull(results);
            var badRequest = results as BadRequestObjectResult;
            Assert.NotNull(badRequest);
            Assert.AreEqual(400, badRequest.StatusCode);
        }
        
        [Test]
        public async Task GetUserIdByOrganizationNumber_Error_StatusServerError()
        {
            _mockAgreeService.Setup(x => x.GetAgreeUserByOrganizationNumber(123)).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
            
            var results = await _agreeController.GetAgreeUserByOrganizationNumber(123L);

            Assert.NotNull(results);
            var badRes = results as StatusCodeResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(500, badRes.StatusCode);
            _mockAgreeService.Verify();
        }
        
        [Test]
        public async Task GetAgreementByAgreementId_OK()
        {
            _mockAgreeService.Setup(x => x.GetAgreementByAgreementId(123)).ReturnsAsync(
                new Agreement
                    {
                        AgreementNumber = 111111,
                        PersonNumber = 222222,
                        UserId = "101010"
                    }).Verifiable();

            
            var results = await _agreeController.GetAgreementByAgreementId(123);

            Assert.NotNull(results);
            var okResult = results as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
            
            var result = okResult.Value as Agreement;
            Assert.NotNull(result);
            Assert.AreEqual(111111, result.AgreementNumber);
            _mockAgreeService.Verify();
        }
        
        [Test]
        public async Task GetAgreementByAgreementId_NoContent()
        {
            _mockAgreeService.Setup(x => x.GetAgreementByAgreementId(123)).ReturnsAsync((Agreement)null).Verifiable();
            
            var results = await _agreeController.GetAgreementByAgreementId(123);

            Assert.NotNull(results);
            var noContentResult = results as NoContentResult;
            Assert.NotNull(noContentResult);
            Assert.AreEqual(204, noContentResult.StatusCode);
        }
        
        [Test]
        public async Task GetAgreementByAgreementId_empty_BadRequest()
        {
            var results = await _agreeController.GetAgreementByAgreementId(0);

            _mockAgreeService.Verify(x => x.GetAgreementByAgreementId(It.IsAny<long>()), Times.Never());

            Assert.NotNull(results);
            var badRequest = results as BadRequestObjectResult;
            Assert.NotNull(badRequest);
            Assert.AreEqual(400, badRequest.StatusCode);
        }
        
        [Test]
        public async Task GetAgreementByAgreementId_Error_StatusServerError()
        {
            _mockAgreeService.Setup(x => x.GetAgreementByAgreementId(123)).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
            
            var results = await _agreeController.GetAgreementByAgreementId(123);

            Assert.NotNull(results);
            var badRes = results as StatusCodeResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(500, badRes.StatusCode);
            _mockAgreeService.Verify();
        }
        
        [Test]
        public async Task GetAgreementsByAccountId_OK()
        {
            _mockAgreeService.Setup(x => x.GetAgreementsByAccountId(123)).ReturnsAsync(
                new List<Agreement>
                {
                    new ()
                    {
                        AgreementNumber = 111111,
                        PersonNumber = 222222,
                        UserId = "101010"
                    },
                    new ()
                    {
                        AgreementNumber = 111112,
                        PersonNumber = 222223,
                        UserId = "101011"
                    }
                }).Verifiable();

            
            var results = await _agreeController.GetAgreementsByAccountId(123);

            Assert.NotNull(results);
            var okResult = results as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
            
            var result = okResult.Value as IEnumerable<Agreement>;
            Assert.NotNull(result);
            Assert.AreEqual(2, result.Count());
            _mockAgreeService.Verify();
        }
        
        [Test]
        public async Task GetAgreementsByAccountId_NoContent()
        {
            _mockAgreeService.Setup(x => x.GetAgreementsByAccountId(123)).ReturnsAsync((IEnumerable<Agreement>)null).Verifiable();
            
            var results = await _agreeController.GetAgreementsByAccountId(123);

            Assert.NotNull(results);
            var noContentResult = results as NoContentResult;
            Assert.NotNull(noContentResult);
            Assert.AreEqual(204, noContentResult.StatusCode);
        }
        
        [Test]
        public async Task GetAgreementsByAccountId_empty_BadRequest()
        {
            var results = await _agreeController.GetAgreementsByAccountId(0);

            _mockAgreeService.Verify(x => x.GetAgreementsByAccountId(It.IsAny<long>()), Times.Never());

            Assert.NotNull(results);
            var badRequest = results as BadRequestObjectResult;
            Assert.NotNull(badRequest);
            Assert.AreEqual(400, badRequest.StatusCode);
        }
        
        [Test]
        public async Task GetAgreementsByAccountId_Error_StatusServerError()
        {
            _mockAgreeService.Setup(x => x.GetAgreementsByAccountId(123)).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
            
            var results = await _agreeController.GetAgreementsByAccountId(123);

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

        [Test]
        public async Task GetAgreementAccountByAccountId_OK()
        {
            _mockAgreeService.Setup(x => x.GetAgreementAccountByAccountId(123)).ReturnsAsync(
                new AgreementAccount
                {
                    AccountNumber = 123
                }).Verifiable();

            
            var results = await _agreeController.GetAgreementAccountByAccountId(123);

            Assert.NotNull(results);
            var okResult = results as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
            
            var result = okResult.Value as AgreementAccount;
            Assert.NotNull(result);
            Assert.AreEqual(123, result.AccountNumber);
            _mockAgreeService.Verify();
        }
        
        [Test]
        public async Task GetAgreementAccountByAccountId_NoContent()
        {
            _mockAgreeService.Setup(x => x.GetAgreementAccountByAccountId(123)).ReturnsAsync((AgreementAccount)null).Verifiable();
            
            var results = await _agreeController.GetAgreementAccountByAccountId(123);

            Assert.NotNull(results);
            var noContentResult = results as NoContentResult;
            Assert.NotNull(noContentResult);
            Assert.AreEqual(204, noContentResult.StatusCode);
        }
        
        [Test]
        public async Task GetAgreementAccountByAccountId_empty_BadRequest()
        {
            var results = await _agreeController.GetAgreementAccountByAccountId(0);

            _mockAgreeService.Verify(x => x.GetAgreementAccountByAccountId(It.IsAny<long>()), Times.Never());

            Assert.NotNull(results);
            var badRequest = results as BadRequestObjectResult;
            Assert.NotNull(badRequest);
            Assert.AreEqual(400, badRequest.StatusCode);
        }
        
        [Test]
        public async Task GetAgreementAccountByAccountId_Error_StatusServerError()
        {
            _mockAgreeService.Setup(x => x.GetAgreementAccountByAccountId(123)).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
            
            var results = await _agreeController.GetAgreementAccountByAccountId(123);

            Assert.NotNull(results);
            var badRes = results as StatusCodeResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(500, badRes.StatusCode);
            _mockAgreeService.Verify();
        }
        
        [Test]
        public async Task GetAgreementAccountsByUserId_OK()
        {
            _mockAgreeService.Setup(x => x.GetAgreementAccountsByUserId("123")).ReturnsAsync(
                new List<AgreementAccount>
                {
                    new ()
                    {
                        AccountNumber = 123
                    },
                    new ()
                    {
                        AccountNumber = 124
                    }
                }).Verifiable();

            
            var results = await _agreeController.GetAgreementAccountsByUserId("123");

            Assert.NotNull(results);
            var okResult = results as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
            
            var result = okResult.Value as IEnumerable<AgreementAccount>;
            Assert.NotNull(result);
            Assert.AreEqual(2, result.Count());
            _mockAgreeService.Verify();
        }
        
        [Test]
        public async Task GetAgreementAccountsByUserId_NoContent()
        {
            _mockAgreeService.Setup(x => x.GetAgreementAccountsByUserId("123")).ReturnsAsync((IEnumerable<AgreementAccount>)null).Verifiable();
            
            var results = await _agreeController.GetAgreementAccountsByUserId("123");

            Assert.NotNull(results);
            var noContentResult = results as NoContentResult;
            Assert.NotNull(noContentResult);
            Assert.AreEqual(204, noContentResult.StatusCode);
        }
        
        [Test]
        public async Task GetAgreementAccountsByUserId_empty_BadRequest()
        {
            var results = await _agreeController.GetAgreementAccountsByUserId(null);

            _mockAgreeService.Verify(x => x.GetAgreementAccountsByUserId(It.IsAny<string>()), Times.Never());

            Assert.NotNull(results);
            var badRequest = results as BadRequestObjectResult;
            Assert.NotNull(badRequest);
            Assert.AreEqual(400, badRequest.StatusCode);
            
            var result2 = await _agreeController.GetAgreementAccountsByUserId("");

            _mockAgreeService.Verify(x => x.GetAgreementAccountsByUserId(It.IsAny<string>()), Times.Never());

            Assert.NotNull(result2);
            var badRequest2 = result2 as BadRequestObjectResult;
            Assert.NotNull(badRequest2);
            Assert.AreEqual(400, badRequest2.StatusCode);
        }
        
        [Test]
        public async Task GetAgreementAccountsByUserId_Error_StatusServerError()
        {
            _mockAgreeService.Setup(x => x.GetAgreementAccountsByUserId("123")).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
            
            var results = await _agreeController.GetAgreementAccountsByUserId("123");

            Assert.NotNull(results);
            var badRes = results as StatusCodeResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(500, badRes.StatusCode);
            _mockAgreeService.Verify();
        }
        
        [Test]
        public async Task GetAgreementAccountsByOrganizationId_OK()
        {
            _mockAgreeService.Setup(x => x.GetAgreementAccountsByOrganizationId(123)).ReturnsAsync(
                new List<AgreementAccount>
                {
                    new ()
                    {
                        AccountNumber = 123
                    },
                    new ()
                    {
                        AccountNumber = 124
                    }
                }).Verifiable();

            
            var results = await _agreeController.GetAgreementAccountsByOrganizationId(123);

            Assert.NotNull(results);
            var okResult = results as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
            
            var result = okResult.Value as IEnumerable<AgreementAccount>;
            Assert.NotNull(result);
            Assert.AreEqual(2, result.Count());
            _mockAgreeService.Verify();
        }
        
        [Test]
        public async Task GetAgreementAccountsByOrganizationId_NoContent()
        {
            _mockAgreeService.Setup(x => x.GetAgreementAccountsByOrganizationId(123)).ReturnsAsync((IEnumerable<AgreementAccount>)null).Verifiable();
            
            var results = await _agreeController.GetAgreementAccountsByOrganizationId(123);

            Assert.NotNull(results);
            var noContentResult = results as NoContentResult;
            Assert.NotNull(noContentResult);
            Assert.AreEqual(204, noContentResult.StatusCode);
        }
        
        [Test]
        public async Task GetAgreementAccountsByOrganizationId_empty_BadRequest()
        {
            var results = await _agreeController.GetAgreementAccountsByOrganizationId(0);

            _mockAgreeService.Verify(x => x.GetAgreementAccountsByOrganizationId(It.IsAny<long>()), Times.Never());

            Assert.NotNull(results);
            var badRequest = results as BadRequestObjectResult;
            Assert.NotNull(badRequest);
            Assert.AreEqual(400, badRequest.StatusCode);
        }
        
        [Test]
        public async Task GetAgreementAccountsByOrganizationId_Error_StatusServerError()
        {
            _mockAgreeService.Setup(x => x.GetAgreementAccountsByOrganizationId(123)).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
            
            var results = await _agreeController.GetAgreementAccountsByOrganizationId(123);

            Assert.NotNull(results);
            var badRes = results as StatusCodeResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(500, badRes.StatusCode);
            _mockAgreeService.Verify();
        }
        
        [Test]
        public async Task GetAgreementAccountsAuditFromDateLastMaintained_OK()
        {
            _mockAgreeService.Setup(x => x.AuditAccountDeliveryMethodAndOwnerChangesByDateLastMaintained(It.IsAny<DateTime>())).ReturnsAsync(
                new List<long>
                {
                   123,
                   124
                }).Verifiable();

            
            var results = await _agreeController.GetAgreementAccountsAuditFromDateLastMaintained(DateTime.Now.ToString(CultureInfo.InvariantCulture));

            Assert.NotNull(results);
            var okResult = results as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
            
            var result = okResult.Value as IEnumerable<long>;
            Assert.NotNull(result);
            Assert.AreEqual(2, result.Count());
            _mockAgreeService.Verify();
        }
        
        [Test]
        public async Task GetAgreementAccountsAuditFromDateLastMaintained_BadRequest()
        {
            var results = await _agreeController.GetAgreementAccountsAuditFromDateLastMaintained(null);

            _mockAgreeService.Verify(x => x.AuditAccountDeliveryMethodAndOwnerChangesByDateLastMaintained(It.IsAny<DateTime>()), Times.Never());

            Assert.NotNull(results);
            var badRequest = results as BadRequestObjectResult;
            Assert.NotNull(badRequest);
            Assert.AreEqual(400, badRequest.StatusCode);
            
            var result2 = await _agreeController.GetAgreementAccountsAuditFromDateLastMaintained("");

            _mockAgreeService.Verify(x => x.AuditAccountDeliveryMethodAndOwnerChangesByDateLastMaintained(It.IsAny<DateTime>()), Times.Never());

            Assert.NotNull(result2);
            var badRequest2 = result2 as BadRequestObjectResult;
            Assert.NotNull(badRequest2);
            Assert.AreEqual(400, badRequest2.StatusCode);
            
            var resultParseError = await _agreeController.GetAgreementAccountsAuditFromDateLastMaintained("12");

            _mockAgreeService.Verify(x => x.AuditAccountDeliveryMethodAndOwnerChangesByDateLastMaintained(It.IsAny<DateTime>()), Times.Never());

            Assert.NotNull(resultParseError);
            var badRequestParseError = results as BadRequestObjectResult;
            Assert.NotNull(badRequestParseError);
            Assert.AreEqual(400, badRequest.StatusCode);
        }
        
        [Test]
        public async Task GetAgreementAccountsAuditFromDateLastMaintained_Error_StatusServerError()
        {
            _mockAgreeService.Setup(x => x.AuditAccountDeliveryMethodAndOwnerChangesByDateLastMaintained(It.IsAny<DateTime>())).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
            
            var results = await _agreeController.GetAgreementAccountsAuditFromDateLastMaintained(DateTime.Now.ToString(CultureInfo.InvariantCulture));

            Assert.NotNull(results);
            var badRes = results as StatusCodeResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(500, badRes.StatusCode);
            _mockAgreeService.Verify();
        }
        
        [Test]
        public async Task GetAgreementAuditFromDateLastMaintained_OK()
        {
            _mockAgreeService.Setup(x => x.AuditAgreementChangesByDateLastMaintained(It.IsAny<DateTime>())).ReturnsAsync(
                new List<long>
                {
                   123,
                   124
                }).Verifiable();

            
            var results = await _agreeController.GetAgreementAuditFromDateLastMaintained(DateTime.Now.ToString(CultureInfo.InvariantCulture));

            Assert.NotNull(results);
            var okResult = results as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
            
            var result = okResult.Value as IEnumerable<long>;
            Assert.NotNull(result);
            Assert.AreEqual(2, result.Count());
            _mockAgreeService.Verify();
        }
        
        [Test]
        public async Task GetAgreementAuditFromDateLastMaintained_BadRequest()
        {
            var results = await _agreeController.GetAgreementAuditFromDateLastMaintained(null);

            _mockAgreeService.Verify(x => x.AuditAgreementChangesByDateLastMaintained(It.IsAny<DateTime>()), Times.Never());

            Assert.NotNull(results);
            var badRequest = results as BadRequestObjectResult;
            Assert.NotNull(badRequest);
            Assert.AreEqual(400, badRequest.StatusCode);
            
            var result2 = await _agreeController.GetAgreementAuditFromDateLastMaintained("");

            _mockAgreeService.Verify(x => x.AuditAgreementChangesByDateLastMaintained(It.IsAny<DateTime>()), Times.Never());

            Assert.NotNull(result2);
            var badRequest2 = result2 as BadRequestObjectResult;
            Assert.NotNull(badRequest2);
            Assert.AreEqual(400, badRequest2.StatusCode);
            
            var resultParseError = await _agreeController.GetAgreementAuditFromDateLastMaintained("12");

            _mockAgreeService.Verify(x => x.AuditAgreementChangesByDateLastMaintained(It.IsAny<DateTime>()), Times.Never());

            Assert.NotNull(resultParseError);
            var badRequestParseError = results as BadRequestObjectResult;
            Assert.NotNull(badRequestParseError);
            Assert.AreEqual(400, badRequest.StatusCode);
        }
        
        [Test]
        public async Task GetAgreementAuditFromDateLastMaintained_Error_StatusServerError()
        {
            _mockAgreeService.Setup(x => x.AuditAgreementChangesByDateLastMaintained(It.IsAny<DateTime>())).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
            
            var results = await _agreeController.GetAgreementAuditFromDateLastMaintained(DateTime.Now.ToString(CultureInfo.InvariantCulture));

            Assert.NotNull(results);
            var badRes = results as StatusCodeResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(500, badRes.StatusCode);
            _mockAgreeService.Verify();
        }
        
        [Test]
        public async Task GetOrganizationAuditFromDateLastMaintained_OK()
        {
            _mockAgreeService.Setup(x => x.AuditOrganizationChangesByDateLastMaintained(It.IsAny<DateTime>())).ReturnsAsync(
                new List<long>
                {
                   123,
                   124
                }).Verifiable();

            
            var results = await _agreeController.GetOrganizationAuditFromDateLastMaintained(DateTime.Now.ToString(CultureInfo.InvariantCulture));

            Assert.NotNull(results);
            var okResult = results as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
            
            var result = okResult.Value as IEnumerable<long>;
            Assert.NotNull(result);
            Assert.AreEqual(2, result.Count());
            _mockAgreeService.Verify();
        }
        
        [Test]
        public async Task GetOrganizationAuditFromDateLastMaintained_BadRequest()
        {
            var results = await _agreeController.GetOrganizationAuditFromDateLastMaintained(null);

            _mockAgreeService.Verify(x => x.AuditOrganizationChangesByDateLastMaintained(It.IsAny<DateTime>()), Times.Never());

            Assert.NotNull(results);
            var badRequest = results as BadRequestObjectResult;
            Assert.NotNull(badRequest);
            Assert.AreEqual(400, badRequest.StatusCode);
            
            var result2 = await _agreeController.GetOrganizationAuditFromDateLastMaintained("");

            _mockAgreeService.Verify(x => x.AuditOrganizationChangesByDateLastMaintained(It.IsAny<DateTime>()), Times.Never());

            Assert.NotNull(result2);
            var badRequest2 = result2 as BadRequestObjectResult;
            Assert.NotNull(badRequest2);
            Assert.AreEqual(400, badRequest2.StatusCode);
            
            var resultParseError = await _agreeController.GetOrganizationAuditFromDateLastMaintained("12");

            _mockAgreeService.Verify(x => x.AuditOrganizationChangesByDateLastMaintained(It.IsAny<DateTime>()), Times.Never());

            Assert.NotNull(resultParseError);
            var badRequestParseError = results as BadRequestObjectResult;
            Assert.NotNull(badRequestParseError);
            Assert.AreEqual(400, badRequest.StatusCode);
        }
        
        [Test]
        public async Task GetOrganizationAuditFromDateLastMaintained_Error_StatusServerError()
        {
            _mockAgreeService.Setup(x => x.AuditOrganizationChangesByDateLastMaintained(It.IsAny<DateTime>())).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
            
            var results = await _agreeController.GetOrganizationAuditFromDateLastMaintained(DateTime.Now.ToString(CultureInfo.InvariantCulture));

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