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

using LCU.Api.Internal.CoreApiWrapper.Configuration;
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.Transaction;
using Microsoft.AspNetCore.Mvc;
using Moq;
using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace LCU.Api.Internal.CoreApiWrapperTest.Controllers
{
    public class TransactionControllerTest
    {
        private TransactionController _transactionController;
        private Mock<ITransactionService> _mockTransactionService;
        private CoreApiWrapperConfig _coreApiWrapperConfig;

        [SetUp]
        public void SetUp()
        {
            _mockTransactionService = new Mock<ITransactionService>();
            _coreApiWrapperConfig = new CoreApiWrapperConfig
            {
                FeatureFlags = new FeatureFlags
                {
                    DisableCoreDBWrite = false
                }
            };
            _transactionController = new TransactionController(_mockTransactionService.Object, _coreApiWrapperConfig);
        }

        [Test]
        public async Task PostMonetaryTransactions_OK()
        {
            _mockTransactionService.Setup(x => x.AddMonetaryTransactionsAsync(It.IsAny<List<GroupedMonetaryTransactionRequest>>())).ReturnsAsync(
                                                new List<MonetaryTransactionResponse>() { });

            var groupRequest = new GroupedMonetaryTransactionRequest()
            {
                MonetaryTransactionRequests = new List<MonetaryTransactionRequest>() {
                new MonetaryTransactionRequest()
                {
                        AccountNumber = 19617805142,
                        TransactionAmount = -1.27,
                        ApprovalPersonNumber = 5225,
                        RequestNumber = "1",
                        OverrideCashBoxNumber = 800,
                        TransactionTypeCode = "DRIR",
                        Description = "",
                        BalanceTypes = new List<BalanceType1> {
                            new BalanceType1() {
                                BalanceCategoryCode = "UPFR",
                                BalanceTypeCode = "DLR",
                                BalanceTypeAmount = -1.27
                            }
                        },
                        Funds = new List<Fund> {
                            new Fund() {
                                ClearingCategoryCode = "IMED",
                                FundAmount = -1.27,
                                FundTypeCode = "EL",
                                FundTypeDetailCode = "INTR",
                                NumberOfItems = 1
                            }
                        }
                    }
                }
            };

            var response = new MonetaryTransactionResponse()
            {
                WasSuccessful = false
            };

            var listResponse = new List<MonetaryTransactionResponse> { response };
            var listGroupRequest = new List<GroupedMonetaryTransactionRequest> { groupRequest };

            var result = await _transactionController.PostMonetaryTransactions(listGroupRequest);

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

        [Test]
        public async Task GetTransactionHistory_OK()
        {
            _mockTransactionService.Setup(x => x.GetTransactionHistory(123334234324, 
                                                                       Convert.ToDateTime("12/25/2020"), 
                                                                       Convert.ToDateTime("2/2/2021"),
                                                                       null)).ReturnsAsync(
                new List<TransactionHistory>
                {
                  new TransactionHistory()
                  {
                      AccountNumber = 123334234324,
                      ActivityDateTime = Convert.ToDateTime("1/1/2021")
                  },
                  new TransactionHistory()
                  {
                      AccountNumber = 123334234324,
                      ActivityDateTime = Convert.ToDateTime("1/2/2021")
                  }
                }).Verifiable();

            var results = await _transactionController.GetTransactionHistory(123334234324, Convert.ToDateTime("12/25/2020"), Convert.ToDateTime("2/2/2021"));

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

            var result = okResult.Value as IEnumerable<TransactionHistory>;
            Assert.NotNull(result);
            Assert.AreEqual(2, result.Count());
            _mockTransactionService.Verify();
        }

        [Test]
        public async Task GetTransactionHistory_Null_NotFoundException()
        {
            _mockTransactionService.Setup(x => x.GetTransactionHistory(It.IsAny<long>(), It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string[]>())).ReturnsAsync((IEnumerable<TransactionHistory>)null);

            var results = await _transactionController.GetTransactionHistory(1234555, Convert.ToDateTime("12/25/2020"), Convert.ToDateTime("2/2/2021"));

            Assert.NotNull(results);
            var notFoundRes = results as NotFoundResult;
            Assert.NotNull(notFoundRes);
            Assert.AreEqual(404, notFoundRes.StatusCode);
        }
        
        [Test]
        public async Task GetTransactionHistory_EmptyList_NoContentException()
        {
            _mockTransactionService.Setup(x => x.GetTransactionHistory(It.IsAny<long>(), It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string[]>())).ReturnsAsync(new List<TransactionHistory>());

            var results = await _transactionController.GetTransactionHistory(1234555, Convert.ToDateTime("12/25/2020"), Convert.ToDateTime("2/2/2021"));

            Assert.NotNull(results);
            var noContentResult = results as NoContentResult;
            Assert.NotNull(noContentResult);
            Assert.AreEqual(204, noContentResult.StatusCode);
        }
        
        [Test]
        public async Task GetTransactionHistory_Exception()
        {
            _mockTransactionService.Setup(x => x.GetTransactionHistory(It.IsAny<long>(), It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string[]>()))
               .Throws(new Exception("Oops"));

            var results = await _transactionController.GetTransactionHistory(1234555, Convert.ToDateTime("12/25/2020"), Convert.ToDateTime("2/2/2021"));

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

        [Test]
        public async Task GetTransactionsByDateSpan_OK()
        {
            _mockTransactionService.Setup(x => x.GetTransactionsByDateSpan(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string[]>())).ReturnsAsync(new List<TransactionAlertInfo>() { new TransactionAlertInfo() });

            var results = await _transactionController.GetTransactionsByDateSpan(DateTime.UtcNow.AddMinutes(-1), DateTime.UtcNow, new string[1]);

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

            var result = okResult.Value as IEnumerable<TransactionAlertInfo>;
            Assert.NotNull(result);
            Assert.AreEqual(1, result.Count());
        }

        [Test]
        public async Task GetTransactionsByDateSpan_Exception_DateOrder()
        {
            var results = await _transactionController.GetTransactionsByDateSpan(DateTime.UtcNow, DateTime.UtcNow.AddMinutes(-1));

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

        [Test]
        public async Task GetTransactionsByDateSpan_Exception_DateMinimum()
        {
            var results = await _transactionController.GetTransactionsByDateSpan(DateTime.MinValue, DateTime.UtcNow);

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