monorepo/LCU.API.Operations.IncentiveAPI/LCU.API.Internal.Operations.IncentiveApi.UnitTests/Services/DnaServiceTests.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using LCU.API.Internal.Operations.IncentiveApi.Services;
using LCU.Library.Internal.IncentiveApiModels.Entities;
using LCU.API.Internal.Operations.IncentiveApi.Models.ExternalActivities;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Accounts;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Activity;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Transaction;
using Moq;
using NUnit.Framework;
using LCU.API.Internal.Operations.IncentiveApi.Services.MicroApiServices;

namespace Application.UnitTests.Services
{
    public class DnaServiceTests
    {
        private IDnaService _dnaService;
        private Mock<ICoreApiWrapperService> _mockCoreApiWrapperService;

        [SetUp]
        public void SetUp()
        {
            _mockCoreApiWrapperService = new Mock<ICoreApiWrapperService>();
            _dnaService = new DnaService(_mockCoreApiWrapperService.Object);
        }

        [Test]
        public async Task GetNewAccountDetailsForActivities_OK()
        {
            _mockCoreApiWrapperService.Setup(x => x.GetUpdatedAccountInformation(It.IsAny<List<long>>())).ReturnsAsync(
                new List<ActivityAccountDetails>()
                {
                    new ActivityAccountDetails()
                    {
                        AccountNumber = 1
                    },
                    new ActivityAccountDetails()
                    {
                        AccountNumber = 2
                    },
                    new ActivityAccountDetails()
                    {
                        AccountNumber = 3
                    }
                });

           var results = await _dnaService.GetNewAccountDetailsForActivities(new List<Activity>()
            {
                new Activity()
                {
                    Id = 1,
                    Detail = new ActivityDetail()
                    {
                        AccountNumber = "1"
                    }
                },
                new Activity()
                {
                    Id = 2,
                    Detail = new ActivityDetail()
                    {
                        AccountNumber = "2"
                    }
                },
                new Activity()
                {
                    Id = 3,
                    Detail = new ActivityDetail()
                    {
                        AccountNumber = "3"
                    }
                }
            });

           Assert.NotNull(results);
           Assert.AreEqual(3, results.Count);

           _mockCoreApiWrapperService.Verify(x =>
               x.GetUpdatedAccountInformation(It.Is<List<long>>(x =>
                   x.Contains(1) && x.Contains(2) && x.Contains(3))));

        }

        [Test]
        public async Task GetNewAccountDetailsForActivities_OnlyKnown_OK()
        {
            _mockCoreApiWrapperService.Setup(x => x.GetUpdatedAccountInformation(It.IsAny<List<long>>())).ReturnsAsync(
                new List<ActivityAccountDetails>()
                {
                    new ActivityAccountDetails()
                    {
                        AccountNumber = 1
                    },
                    new ActivityAccountDetails()
                    {
                        AccountNumber = 3
                    }
                });

            var results = await _dnaService.GetNewAccountDetailsForActivities(new List<Activity>()
            {
                new Activity()
                {
                    Id = 1,
                    Detail = new ActivityDetail()
                    {
                        AccountNumber = "1"
                    }
                },
                //Null Account Number
                new Activity()
                {
                    Id = 2,
                    Detail = new ActivityDetail()
                    {
                    }
                },
                new Activity()
                {
                    Id = 3,
                    Detail = new ActivityDetail()
                    {
                        AccountNumber = "3"
                    }
                }
            });

            Assert.NotNull(results);
            Assert.AreEqual(2, results.Count);

            _mockCoreApiWrapperService.Verify(x =>
                x.GetUpdatedAccountInformation(It.Is<List<long>>(x =>
                    x.Contains(1) && x.Contains(3))));

        }

        [Test]
        public async Task GetNewAccountDetailsForActivities_BadAccountNumber_OK()
        {
            _mockCoreApiWrapperService.Setup(x => x.GetUpdatedAccountInformation(It.IsAny<List<long>>())).ReturnsAsync(
                new List<ActivityAccountDetails>()
                {
                    new ActivityAccountDetails()
                    {
                        AccountNumber = 1
                    },
                    new ActivityAccountDetails()
                    {
                        AccountNumber = 3
                    }
                });

            var results = await _dnaService.GetNewAccountDetailsForActivities(new List<Activity>()
            {
                new Activity()
                {
                    Id = 1,
                    Detail = new ActivityDetail()
                    {
                        AccountNumber = "ADJFALKDSFJA"
                    }
                },
                //Null Account Number
                new Activity()
                {
                    Id = 2,
                    Detail = new ActivityDetail()
                    {
                        AccountNumber = "1"
                    }
                },
                new Activity()
                {
                    Id = 3,
                    Detail = new ActivityDetail()
                    {
                        AccountNumber = "12aDFKADFSF"
                    }
                }
            });

            Assert.NotNull(results);
            Assert.AreEqual(2, results.Count);

            _mockCoreApiWrapperService.Verify(x =>
                x.GetUpdatedAccountInformation(It.Is<List<long>>(x =>
                    x.Contains(1))));

        }

        [Test]
        public async Task QueryActivityManagerForActivities_OK()
        {
            _mockCoreApiWrapperService.Setup(x => x.GetActivityManagerActivities(It.IsAny<ActivityQueryRequest>())).ReturnsAsync(
                new List<NewActivityManagerReferral>()
                {
                    new NewActivityManagerReferral()
                    {
                        ActivityId = 1
                    },
                    new NewActivityManagerReferral()
                    {
                        ActivityId = 2
                    },
                    new NewActivityManagerReferral()
                    {
                        ActivityId = 3
                    }
                });

           var results = await _dnaService.QueryActivityManagerForActivities(new List<string>()
            {
               "1","2","3"
            });

           Assert.NotNull(results);
           Assert.AreEqual(3, results.Count);

           _mockCoreApiWrapperService.Verify(x =>
               x.GetActivityManagerActivities(It.Is<ActivityQueryRequest>(x =>
                   x.ActivityIds.Contains(1) && x.ActivityIds.Contains(2) && x.ActivityIds.Contains(3))));

        }

        [Test]
        public async Task QueryActivityManagerForActivities_Null_OK()
        {
            _mockCoreApiWrapperService.Setup(x => x.GetActivityManagerActivities(It.IsAny<ActivityQueryRequest>())).ReturnsAsync(
                new List<NewActivityManagerReferral>()
                {
                    new NewActivityManagerReferral()
                    {
                        ActivityId = 1
                    },
                    new NewActivityManagerReferral()
                    {
                        ActivityId = 3
                    }
                });

            var results = await _dnaService.QueryActivityManagerForActivities(new List<string>()
            {
                "1",null,"3"
            });

            Assert.NotNull(results);
            Assert.AreEqual(2, results.Count);

            _mockCoreApiWrapperService.Verify(x =>
                x.GetActivityManagerActivities(It.Is<ActivityQueryRequest>(x =>
                    x.ActivityIds.Contains(1) && x.ActivityIds.Contains(3))));
        }

        [Test]
        public async Task GetTransactionHistory_OK()
        {
            var accountNumber = "123456";
            var startDate = DateTime.Now.AddDays(-1);
            var endDate = DateTime.Now;
            var transactionCodes = new List<string> { "XDEP" };

            _mockCoreApiWrapperService.Setup(x => x.GetTransactionHistory(accountNumber, startDate, endDate, transactionCodes)).ReturnsAsync(
                new List<TransactionHistory>()
                {
                    new TransactionHistory()
                    {
                        Id = "1"
                    },
                    new TransactionHistory()
                    {
                        Id = "2"
                    }
                }.AsReadOnly).Verifiable();

            var results = await _dnaService.GetTransactionHistory(accountNumber, startDate, endDate, transactionCodes);

            _mockCoreApiWrapperService.Verify();
            Assert.NotNull(results);
            Assert.AreEqual(2, results.Count);
        }

        [Test]
        public async Task GetTransactionHistory_Null()
        {
            var accountNumber = "123456";
            var startDate = DateTime.Now.AddDays(-1);
            var endDate = DateTime.Now;
            var transactionCodes = new List<string> { "XDEP" };

            _mockCoreApiWrapperService.Setup(x => x.GetTransactionHistory(accountNumber, startDate, endDate, transactionCodes)).ReturnsAsync((IReadOnlyCollection<TransactionHistory>)null).Verifiable();

            var results = await _dnaService.GetTransactionHistory(accountNumber, startDate, endDate, transactionCodes);

            _mockCoreApiWrapperService.Verify();
            Assert.Null(results);
        }
    }
}