monorepo/LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Controllers/ActivityControllerTest.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.CoreApiWrapperLib.Exceptions;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Activity;
using LCU.Library.Internal.CoreApiWrapperModel.LcuModels.Activity;
using LCU.Library.Internal.CoreApiWrapperModel.LcuModels.Phones;

namespace LCU.Api.Internal.CoreApiWrapperTest.Controllers
{
    public class ActivityControllerTest
    {
        private ActivityController _activityController;
        private Mock<IActivityService> _mockActivityService;

        [SetUp]
        public void SetUp()
        {
            _mockActivityService = new Mock<IActivityService>();
            _activityController = new ActivityController(_mockActivityService.Object);
        }

        [Test]
        public void GetNewCheckingAccountActivities_OK()
        {
            _mockActivityService.Setup(x => x.GetNewCheckingAccountActivities(It.IsAny<string>(), It.IsAny<long?>(), It.IsAny<int>())).ReturnsAsync(
                new List<NewCheckingAccountActivity>()
                {
                    new NewCheckingAccountActivity() { ActivityNbr = 1 },
                    new NewCheckingAccountActivity() { ActivityNbr = 2 },
                    new NewCheckingAccountActivity() { ActivityNbr = 3 }
                });

            var results = _activityController.GetNewCheckingAccountActivities("2020-04-29T11:00:00", null);

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

            results = _activityController.GetNewCheckingAccountActivities(null, 5);

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

            results = _activityController.GetNewCheckingAccountActivities("2020-04-29T11:00:00", 5);

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

        [Test]
        public void GetNewCheckingAccountActivities_FailedToParse()
        {
            _mockActivityService.Setup(x => x.GetNewCheckingAccountActivities(It.IsAny<string>(), It.IsAny<long?>(), It.IsAny<int>()))
                .Throws(new FailedToParseException("Oops"));


            var results = _activityController.GetNewCheckingAccountActivities(">:O", 1);

            Assert.NotNull(results);
            var badRes = results as BadRequestObjectResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(400, badRes.StatusCode);
        }

        [Test]
        public void GetNewCheckingAccountActivities_Exception()
        {
            _mockActivityService.Setup(x => x.GetNewCheckingAccountActivities(It.IsAny<string>(), It.IsAny<long?>(), It.IsAny<int>()))
                .Throws(new Exception("Oops"));


            var results = _activityController.GetNewCheckingAccountActivities("2020-04-29T11:00:00", 4);

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

        [Test]
        public void GetNewAtmCheckCardActivities_OK()
        {
            _mockActivityService.Setup(x => x.GetNewAtmCheckCardActivities(It.IsAny<string>(), It.IsAny<long?>(), It.IsAny<int>())).ReturnsAsync(
                new List<NewAtmCheckCardActivity>()
                {
                    new NewAtmCheckCardActivity() { ActivityNbr = 1 },
                    new NewAtmCheckCardActivity() { ActivityNbr = 2 },
                    new NewAtmCheckCardActivity() { ActivityNbr = 3 }
                });

            var results = _activityController.GetNewAtmCheckCardActivities("2020-04-29T11:00:00", null);

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

            results = _activityController.GetNewAtmCheckCardActivities(null, 5);

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

            results = _activityController.GetNewAtmCheckCardActivities("2020-04-29T11:00:00", 5);

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

        [Test]
        public void GetNewAtmCheckCardActivities_FailedToParse()
        {
            _mockActivityService.Setup(x => x.GetNewAtmCheckCardActivities(It.IsAny<string>(), It.IsAny<long?>(), It.IsAny<int>()))
                .Throws(new FailedToParseException("Oops"));


            var results = _activityController.GetNewAtmCheckCardActivities(">:O", 1);

            Assert.NotNull(results);
            var badRes = results as BadRequestObjectResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(400, badRes.StatusCode);
        }

        [Test]
        public void GetNewAtmCheckCardActivities_Exception()
        {
            _mockActivityService.Setup(x => x.GetNewAtmCheckCardActivities(It.IsAny<string>(), It.IsAny<long?>(), It.IsAny<int>()))
                .Throws(new Exception("Oops"));


            var results = _activityController.GetNewAtmCheckCardActivities("2020-04-29T11:00:00", 4);

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

        [Test]
        public void GetNewActivityManagerReferralActivities_OK()
        {
            _mockActivityService.Setup(x => x.GetNewActivityManagerIncentiveReferrals(It.IsAny<string>(), It.IsAny<long?>())).ReturnsAsync(
                new List<NewActivityManagerIncentiveReferral>()
                {
                    new NewActivityManagerIncentiveReferral() { ActivityId = 1 },
                    new NewActivityManagerIncentiveReferral() { ActivityId = 2 },
                    new NewActivityManagerIncentiveReferral() { ActivityId = 3 }
                });

            var results = _activityController.GetNewActivityManagerReferralActivities("2020-04-29T11:00:00", null);

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

            results = _activityController.GetNewActivityManagerReferralActivities(null, 5);

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

            results = _activityController.GetNewActivityManagerReferralActivities("2020-04-29T11:00:00", 5);

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

        [Test]
        public void GetNewActivityManagerReferralActivities_FailedToParse()
        {
            _mockActivityService.Setup(x => x.GetNewActivityManagerIncentiveReferrals(It.IsAny<string>(), It.IsAny<long?>()))
                .Throws(new FailedToParseException("Oops"));


            var results = _activityController.GetNewActivityManagerReferralActivities(">:O", 1);

            Assert.NotNull(results);
            var badRes = results as BadRequestObjectResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(400, badRes.StatusCode);
        }

        [Test]
        public void GetNewActivityManagerReferralActivities_Exception()
        {
            _mockActivityService.Setup(x => x.GetNewActivityManagerIncentiveReferrals(It.IsAny<string>(), It.IsAny<long?>()))
                .Throws(new Exception("Oops"));


            var results = _activityController.GetNewActivityManagerReferralActivities("2020-04-29T11:00:00", 4);

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

        [Test]
        public void GetNewMortgageAccountActivities_OK()
        {
            _mockActivityService.Setup(x => x.GetNewMortgageSaleActivities(It.IsAny<string>(), It.IsAny<long?>())).ReturnsAsync(
                new List<NewLoanSaleActivity>()
                {
                    new NewLoanSaleActivity() { ActivityNbr = 1 },
                    new NewLoanSaleActivity() { ActivityNbr = 2 },
                    new NewLoanSaleActivity() { ActivityNbr = 3 }
                });

            var results = _activityController.GetNewMortgageAccountActivities("2020-04-29T11:00:00", null);

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

            results = _activityController.GetNewMortgageAccountActivities(null, 5);

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

            results = _activityController.GetNewMortgageAccountActivities("2020-04-29T11:00:00", 5);

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

        [Test]
        public void GetNewMortgageAccountActivities_FailedToParse()
        {
            _mockActivityService.Setup(x => x.GetNewMortgageSaleActivities(It.IsAny<string>(), It.IsAny<long?>()))
                .Throws(new FailedToParseException("Oops"));


            var results = _activityController.GetNewMortgageAccountActivities(">:O", 1);

            Assert.NotNull(results);
            var badRes = results as BadRequestObjectResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(400, badRes.StatusCode);
        }

        [Test]
        public void GetNewMortgageAccountActivities_Exception()
        {
            _mockActivityService.Setup(x => x.GetNewMortgageSaleActivities(It.IsAny<string>(), It.IsAny<long?>()))
                .Throws(new Exception("Oops"));


            var results = _activityController.GetNewMortgageAccountActivities("2020-04-29T11:00:00", 4);

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

        [Test]
        public void GetNewVehicleSaleActivities_OK()
        {
            _mockActivityService.Setup(x => x.GetNewVehicleSaleActivities(It.IsAny<string>(), It.IsAny<long?>())).ReturnsAsync(
                new List<NewLoanSaleActivity>()
                {
                    new NewLoanSaleActivity() { ActivityNbr = 1 },
                    new NewLoanSaleActivity() { ActivityNbr = 2 },
                    new NewLoanSaleActivity() { ActivityNbr = 3 }
                });

            var results = _activityController.GetNewVehicleSaleActivities("2020-04-29T11:00:00", null);

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

            results = _activityController.GetNewVehicleSaleActivities(null, 5);

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

            results = _activityController.GetNewVehicleSaleActivities("2020-04-29T11:00:00", 5);

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

        [Test]
        public void GetNewVehicleSaleActivities_FailedToParse()
        {
            _mockActivityService.Setup(x => x.GetNewVehicleSaleActivities(It.IsAny<string>(), It.IsAny<long?>()))
                .Throws(new FailedToParseException("Oops"));


            var results = _activityController.GetNewVehicleSaleActivities(">:O", 1);

            Assert.NotNull(results);
            var badRes = results as BadRequestObjectResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(400, badRes.StatusCode);
        }

        [Test]
        public void GetNewVehicleSaleActivities_Exception()
        {
            _mockActivityService.Setup(x => x.GetNewVehicleSaleActivities(It.IsAny<string>(), It.IsAny<long?>()))
                .Throws(new Exception("Oops"));


            var results = _activityController.GetNewVehicleSaleActivities("2020-04-29T11:00:00", 4);

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

        [Test]
        public void GetNewDebtProtectedLoanSales_FailedToParse()
        {
            _mockActivityService.Setup(x => x.GetNewDebtProtectedLoanSaleActivities(It.IsAny<string>(), It.IsAny<long?>()))
                .Throws(new FailedToParseException("Oops"));


            var results = _activityController.GetNewDebtProtectedLoanSaleActivities(">:O", 1);

            Assert.NotNull(results);
            var badRes = results as BadRequestObjectResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(400, badRes.StatusCode);
        }

        [Test]
        public void GetNewDebtProtectedLoanSales_Exception()
        {
            _mockActivityService.Setup(x => x.GetNewDebtProtectedLoanSaleActivities(It.IsAny<string>(), It.IsAny<long?>()))
                .Throws(new Exception("Oops"));


            var results = _activityController.GetNewDebtProtectedLoanSaleActivities("2020-04-29T11:00:00", 4);

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

        [Test]
        public void QueryActivityManagerActivity_Exception()
        {
            _mockActivityService.Setup(x => x.QueryActivityManagerActivity(It.IsAny<ActivityQueryRequest>()))
                .Throws(new Exception("Oops"));


            var results = _activityController.QueryActivityManagerActivity(new ActivityQueryRequest());

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

        [Test]
        public void GetNewDebtProtectedLoanSales_OK()
        {
            _mockActivityService.Setup(x => x.QueryActivityManagerActivity(It.IsAny<ActivityQueryRequest>()))
                .ReturnsAsync(new List<NewActivityManagerIncentiveReferral>()
                {
                    new NewActivityManagerIncentiveReferral()
                    {
                        ActivityId = 5
                    },
                    new NewActivityManagerIncentiveReferral()
                    {
                        ActivityId = 4
                    },
                });

            var results = _activityController.QueryActivityManagerActivity(new ActivityQueryRequest());

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

        [Test]
        public void GetNewEStatementDeliverySaleActivities_OK()
        {
            _mockActivityService.Setup(x => x.GetEStatementDeliveryActivity(It.IsAny<string>())).ReturnsAsync(
                new List<EStatementDeliveryMethod>()
                {
                    new EStatementDeliveryMethod() { ActivityNumber = 1 },
                    new EStatementDeliveryMethod() { ActivityNumber = 2 },
                    new EStatementDeliveryMethod() { ActivityNumber = 3 }
                });

            var results = _activityController.GetEStatementDeliveryActivity("2020-04-29T11:00:00");

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

            results = _activityController.GetEStatementDeliveryActivity(null);

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

            results = _activityController.GetEStatementDeliveryActivity("2020-04-29T11:00:00");

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

        [Test]
        public void GetNewEStatementDeliverySaleActivities_FailedToParse()
        {
            _mockActivityService.Setup(x => x.GetEStatementDeliveryActivity(It.IsAny<string>()))
                .Throws(new FailedToParseException("Oops"));


            var results = _activityController.GetEStatementDeliveryActivity(">:O");

            Assert.NotNull(results);
            var badRes = results as BadRequestObjectResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(400, badRes.StatusCode);
        }

        [Test]
        public void GetNewEStatementDeliverySaleActivities_Exception()
        {
            _mockActivityService.Setup(x => x.GetEStatementDeliveryActivity(It.IsAny<string>()))
                .Throws(new Exception("Oops"));


            var results = _activityController.GetEStatementDeliveryActivity("2020-04-29T11:00:00");

            Assert.NotNull(results);
            var badRes = results as StatusCodeResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(500, badRes.StatusCode);
        }
        
        [Test]
        public async Task GetPersonActivityByPhoneNumber_OK()
        {
            var phoneNumber = Guid.NewGuid().ToString();
            var personRecentActivity = new PersonRecentActivity
            {
                HomePhone = phoneNumber
            };
            var response = new PersonRecentActivityResponse
            {
                Success = true,
                PersonRecentActivity = personRecentActivity
            };
        
            _mockActivityService.Setup(x => x.GetPersonActivityByPhoneNumber(phoneNumber))
                .ReturnsAsync(response).Verifiable();

            var result = await _activityController.GetPersonActivityByPhoneNumber(phoneNumber);
            Assert.NotNull(result);
            var status = result as OkObjectResult;
            Assert.NotNull(status);
            Assert.AreEqual(200, status.StatusCode);

            var personRecentActivityResult = status.Value as PersonRecentActivityResponse;
            Assert.NotNull(personRecentActivityResult);
            Assert.AreEqual(phoneNumber, personRecentActivityResult.PersonRecentActivity?.HomePhone);
            _mockActivityService.Verify();
        }

        [Test]
        public async Task GetPersonActivityByPhoneNumber_InternalServerError()
        {
            var phoneNumber = Guid.NewGuid().ToString();
            _mockActivityService.Setup(x => x.GetPersonActivityByPhoneNumber(phoneNumber))
                .Throws(new Exception("Test")).Verifiable();

            var result = await _activityController.GetPersonActivityByPhoneNumber(phoneNumber);
            Assert.NotNull(result);
            var status = result as StatusCodeResult;
            Assert.NotNull(status);
            Assert.AreEqual(500, status.StatusCode);
            _mockActivityService.Verify();
        }
        
        [Test]
        public async Task GetPersonActivityByTaxId_OK()
        {
            var taxId = Guid.NewGuid().ToString();
            var personNumber = DateTime.Now.Millisecond;
            var personRecentActivity = new PersonRecentActivity
            {
                PersonNumber = personNumber
            };
            var response = new PersonRecentActivityResponse
            {
                Success = true,
                PersonRecentActivity = personRecentActivity
            };
        
            _mockActivityService.Setup(x => x.GetPersonActivityByTaxId(taxId))
                .ReturnsAsync(response).Verifiable();

            var result = await _activityController.GetPersonActivityByTaxId(taxId);
            Assert.NotNull(result);
            var status = result as OkObjectResult;
            Assert.NotNull(status);
            Assert.AreEqual(200, status.StatusCode);

            var personRecentActivityResult = status.Value as PersonRecentActivityResponse;
            Assert.NotNull(personRecentActivityResult);
            Assert.AreEqual(personNumber, personRecentActivityResult.PersonRecentActivity?.PersonNumber);
            _mockActivityService.Verify();
        }

        [Test]
        public async Task GetPersonActivityByTaxId_BadRequest()
        {
            var taxId = string.Empty;
        
            var result = await _activityController.GetPersonActivityByTaxId(taxId);
            Assert.NotNull(result);
            var status = result as BadRequestObjectResult;
            Assert.NotNull(status);
            Assert.AreEqual(400, status.StatusCode);
        }
            
        [Test]
        public async Task GetPersonActivityByTaxId_InternalServerError()
        {
            var taxId = Guid.NewGuid().ToString();
            _mockActivityService.Setup(x => x.GetPersonActivityByTaxId(taxId))
                .Throws(new Exception("Test")).Verifiable();

            var result = await _activityController.GetPersonActivityByTaxId(taxId);
            Assert.NotNull(result);
            var status = result as StatusCodeResult;
            Assert.NotNull(status);
            Assert.AreEqual(500, status.StatusCode);
            _mockActivityService.Verify();
        }
    }
}