monorepo/LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/DataAccess/ActivityDaoTest.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Threading.Tasks;
using LCU.Library.Internal.CoreApiWrapperLib.CoreDbUtilities;
using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Activity;
using LCU.Library.Internal.CoreApiWrapperModel.LcuModels.Activity;
using LCU.Library.Internal.CoreApiWrapperModel.LcuModels.Phones;
using Moq;
using NUnit.Framework;

namespace LCU.Api.Internal.CoreApiWrapperTest.DataAccess
{
    public class ActivityDaoTest
    {
        private ActivityDao _activityDao;
        private Mock<ICoreDbExecution> _mockCoreDbExecution;

        [SetUp]
        public void SetUp()
        {
            _mockCoreDbExecution = new Mock<ICoreDbExecution>();
            _activityDao = new ActivityDao(_mockCoreDbExecution.Object);
        }

        [Test]
        public async Task GetNewCheckingActivities_OK()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewCheckingAccountActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ReturnsAsync(new List<NewCheckingAccountActivity>()
                {
                    new NewCheckingAccountActivity() { ActivityNbr = 1 },
                    new NewCheckingAccountActivity() { ActivityNbr = 2 },
                    new NewCheckingAccountActivity() { ActivityNbr = 3 }
                }).Verifiable();

            var results = await _activityDao.GetNewCheckingActivities(DateTime.Parse("2020-04-02T11:00:00"), 1, 100);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<NewCheckingAccountActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
                    It.Is<object>(obj =>
                        obj.GetHashCode()
                            .Equals(new { afterActivityNbr = "1", newerThanDateTime = "2020-04-02 11:00:00", limitAmount = "100" }.GetHashCode()))));
        }

        [Test]
        public async Task GetNewCheckingActivities_Exception()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewCheckingAccountActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ThrowsAsync(new Exception("Yikes"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _activityDao.GetNewCheckingActivities(DateTime.Parse("2020-04-02T11:00:00"), 1, 100));

            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<NewCheckingAccountActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
                    It.Is<object>(obj =>
                        obj.GetHashCode().Equals(new { newerThanDateTime = "2020-04-02 11:00:00", afterActivityNbr = "1" }.GetHashCode()))), Times.Never);
        }

        [Test]
        public async Task GetNewCheckingActivitiesNewerThanDate_OK()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewCheckingAccountActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ReturnsAsync(new List<NewCheckingAccountActivity>()
                {
                    new NewCheckingAccountActivity() { ActivityNbr = 1 },
                    new NewCheckingAccountActivity() { ActivityNbr = 2 },
                    new NewCheckingAccountActivity() { ActivityNbr = 3 }
                }).Verifiable();

            var results = await _activityDao.GetNewCheckingActivitiesNewerThanDate(DateTime.Parse("2020-04-02T11:00:00"), 100);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<NewCheckingAccountActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
                    It.Is<object>(obj =>
                        obj.GetHashCode().Equals(new { newerThanDateTime = "2020-04-02 11:00:00", afterActivityNbr = (string)null, limitAmount = "100" }
                            .GetHashCode()))));
        }

        [Test]
        public async Task GetNewCheckingActivitiesNewerThanDate()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewCheckingAccountActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ThrowsAsync(new Exception("Yikes"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _activityDao.GetNewCheckingActivitiesNewerThanDate(DateTime.Parse("2020-04-02T11:00:00"), 100));

            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<NewCheckingAccountActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
                    It.Is<object>(obj =>
                        obj.GetHashCode().Equals(new { newerThanDateTime = "2020-04-02 11:00:00", afterActivityNbr = (string)null, limitAmount = "100" }
                            .GetHashCode()))));
        }

        [Test]
        public async Task GetNewCheckingActivitiesAfterActivityNbr_OK()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewCheckingAccountActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ReturnsAsync(new List<NewCheckingAccountActivity>()
                {
                    new NewCheckingAccountActivity() { ActivityNbr = 1 },
                    new NewCheckingAccountActivity() { ActivityNbr = 2 },
                    new NewCheckingAccountActivity() { ActivityNbr = 3 }
                }).Verifiable();

            var results = await _activityDao.GetNewCheckingActivitiesAfterActivityNbr(1, 100);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<NewCheckingAccountActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
                    It.Is<object>(obj =>
                        obj.GetHashCode().Equals(new { newerThanDateTime = (string)null, afterActivityNbr = "1" }.GetHashCode()))), Times.Never);
        }

        [Test]
        public async Task GetNewCheckingActivitiesAfterActivityNbr_Exception()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewCheckingAccountActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ThrowsAsync(new Exception("Yikes"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _activityDao.GetNewCheckingActivitiesAfterActivityNbr(1, 100));

            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<NewCheckingAccountActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
                    It.Is<object>(obj =>
                        obj.GetHashCode().Equals(new { newerThanDateTime = (string)null, afterActivityNbr = "1" }.GetHashCode()))), Times.Never);
        }

        [Test]
        public async Task GetNewAtmCheckCardActivities_OK()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewAtmCheckCardActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ReturnsAsync(new List<NewAtmCheckCardActivity>()
                {
                    new NewAtmCheckCardActivity() { ActivityNbr = 1 },
                    new NewAtmCheckCardActivity() { ActivityNbr = 2 },
                    new NewAtmCheckCardActivity() { ActivityNbr = 3 }
                }).Verifiable();

            var results = await _activityDao.GetNewAtmCheckCardActivities(DateTime.Parse("2020-04-02T11:00:00"), 1, 100);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<NewAtmCheckCardActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
                    It.Is<object>(obj =>
                        obj.GetHashCode()
                            .Equals(new { afterActivityNbr = "1", newerThanDateTime = "2020-04-02 11:00:00", limitAmount = "100" }.GetHashCode()))));
        }

        [Test]
        public async Task GetNewAtmCheckCardActivities_Exception()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewAtmCheckCardActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ThrowsAsync(new Exception("Yikes"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _activityDao.GetNewAtmCheckCardActivities(DateTime.Parse("2020-04-02T11:00:00"), 1, 100));

            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<NewAtmCheckCardActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
                    It.Is<object>(obj =>
                        obj.GetHashCode().Equals(new { newerThanDateTime = "2020-04-02 11:00:00", afterActivityNbr = "1" }.GetHashCode()))), Times.Never);
        }

        [Test]
        public async Task GetNewAtmCheckCardActivitiesNewerThanDate_OK()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewAtmCheckCardActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ReturnsAsync(new List<NewAtmCheckCardActivity>()
                {
                    new NewAtmCheckCardActivity() { ActivityNbr = 1 },
                    new NewAtmCheckCardActivity() { ActivityNbr = 2 },
                    new NewAtmCheckCardActivity() { ActivityNbr = 3 }
                }).Verifiable();

            var results = await _activityDao.GetNewAtmCheckCardActivitiesNewerThanDate(DateTime.Parse("2020-04-02T11:00:00"), 100);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<NewAtmCheckCardActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
                    It.Is<object>(obj =>
                        obj.GetHashCode().Equals(new { newerThanDateTime = "2020-04-02 11:00:00", afterActivityNbr = (string)null, limitAmount = "100" }
                            .GetHashCode()))));
        }

        [Test]
        public async Task GetNewAtmCheckCardActivitiesNewerThanDate()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewAtmCheckCardActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ThrowsAsync(new Exception("Yikes"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _activityDao.GetNewAtmCheckCardActivitiesNewerThanDate(DateTime.Parse("2020-04-02T11:00:00"), 100));

            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<NewAtmCheckCardActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
                    It.Is<object>(obj =>
                        obj.GetHashCode().Equals(new { newerThanDateTime = "2020-04-02 11:00:00", afterActivityNbr = (string)null, limitAmount = "100" }
                            .GetHashCode()))));
        }

        [Test]
        public async Task GetNewAtmCheckCardActivitiesAfterActivityNbr_OK()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewAtmCheckCardActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ReturnsAsync(new List<NewAtmCheckCardActivity>()
                {
                    new NewAtmCheckCardActivity() { ActivityNbr = 1 },
                    new NewAtmCheckCardActivity() { ActivityNbr = 2 },
                    new NewAtmCheckCardActivity() { ActivityNbr = 3 }
                }).Verifiable();

            var results = await _activityDao.GetNewAtmCheckCardActivitiesAfterActivityNbr(1, 100);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<NewAtmCheckCardActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
                    It.Is<object>(obj =>
                        obj.GetHashCode().Equals(new { newerThanDateTime = (string)null, afterActivityNbr = "1" }.GetHashCode()))), Times.Never);
        }

        [Test]
        public async Task GetNewAtmCheckCardActivitiesAfterActivityNbr_Exception()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewAtmCheckCardActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ThrowsAsync(new Exception("Yikes"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _activityDao.GetNewAtmCheckCardActivitiesAfterActivityNbr(1, 100));

            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<NewAtmCheckCardActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
                    It.Is<object>(obj =>
                        obj.GetHashCode().Equals(new { newerThanDateTime = (string)null, afterActivityNbr = "1" }.GetHashCode()))), Times.Never);
        }

        [Test]
        public async Task GetNewActivityManagerReferrals_OK()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ReturnsAsync(new List<NewActivityManagerIncentiveReferral>()
                {
                    new NewActivityManagerIncentiveReferral() { ActivityId = 1 },
                    new NewActivityManagerIncentiveReferral() { ActivityId = 2 },
                    new NewActivityManagerIncentiveReferral() { ActivityId = 3 }
                }).Verifiable();

            var results = await _activityDao.GetNewActivityManagerReferrals(DateTime.Parse("2020-04-02T11:00:00"), 1);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.Is<string>(str => str.Contains(":newerThanOriginationDate")),
                    It.Is<object>(obj =>
                        obj.GetHashCode().Equals(new { afterActivityId = "1", newerThanOriginationDate = "2020-04-02 11:00:00" }.GetHashCode()))));
        }

        [Test]
        public async Task GetNewActivityManagerReferrals_Exception()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ThrowsAsync(new Exception("Yikes"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _activityDao.GetNewActivityManagerReferrals(DateTime.Parse("2020-04-02T11:00:00"), 1));

            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.Is<string>(str => str.Contains(":newerThanOriginationDate")),
                    It.Is<object>(obj =>
                        obj.GetHashCode().Equals(new { newerThanOriginationDate = "2020-04-02 11:00:00", afterActivityId = "1" }.GetHashCode()))), Times.Never);
        }

        [Test]
        public async Task GetNewActivityManagerReferralsNewerThan_OK()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ReturnsAsync(new List<NewActivityManagerIncentiveReferral>()
                {
                    new NewActivityManagerIncentiveReferral() { ActivityId = 1 },
                    new NewActivityManagerIncentiveReferral() { ActivityId = 2 },
                    new NewActivityManagerIncentiveReferral() { ActivityId = 3 }
                }).Verifiable();

            var results = await _activityDao.GetNewActivityManagerReferralsNewerThan(DateTime.Parse("2020-04-02T11:00:00"));

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.Is<string>(str => str.Contains(":newerThanOriginationDate")),
                    It.Is<object>(obj =>
                        obj.GetHashCode().Equals(new { newerThanOriginationDate = "2020-04-02 11:00:00", afterActivityId = (string)null }.GetHashCode()))));
        }

        [Test]
        public async Task GetNewActivityManagerReferralsNewerThan_Exception()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ThrowsAsync(new Exception("Yikes"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _activityDao.GetNewActivityManagerReferralsNewerThan(DateTime.Parse("2020-04-02T11:00:00")));

            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.Is<string>(str => str.Contains(":newerThanOriginationDate")),
                    It.Is<object>(obj =>
                        obj.GetHashCode().Equals(new { newerThanOriginationDate = "2020-04-02 11:00:00", afterActivityId = (string)null }.GetHashCode()))));
        }

        [Test]
        public async Task GetNewActivityManagerReferralsAfterActivityId_OK()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ReturnsAsync(new List<NewActivityManagerIncentiveReferral>()
                {
                    new NewActivityManagerIncentiveReferral() { ActivityId = 1 },
                    new NewActivityManagerIncentiveReferral() { ActivityId = 2 },
                    new NewActivityManagerIncentiveReferral() { ActivityId = 3 }
                }).Verifiable();

            var results = await _activityDao.GetNewActivityManagerReferralsAfterActivityId(1);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.Is<string>(str => str.Contains(":newerThanOriginationDate")),
                    It.Is<object>(obj =>
                        obj.GetHashCode().Equals(new { newerThanOriginationDate = (string)null, afterActivityId = "1" }.GetHashCode()))), Times.Never);
        }

        [Test]
        public async Task GetNewActivityManagerReferralsAfterActivityId_Exception()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ThrowsAsync(new Exception("Yikes"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _activityDao.GetNewActivityManagerReferralsAfterActivityId(1));

            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.Is<string>(str => str.Contains(":newerThanOriginationDate")),
                    It.Is<object>(obj =>
                        obj.GetHashCode().Equals(new { newerThanOriginationDate = (string)null, afterActivityId = "1" }.GetHashCode()))), Times.Never);
        }

        [Test]
        public async Task GetNewMortgageSaleActivities_OK()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewLoanSaleActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ReturnsAsync(new List<NewLoanSaleActivity>()
                {
                    new NewLoanSaleActivity() { ActivityNbr = 1 },
                    new NewLoanSaleActivity() { ActivityNbr = 2 },
                    new NewLoanSaleActivity() { ActivityNbr = 3 }
                }).Verifiable();

            var results = await _activityDao.GetNewMortgageSaleActivities(DateTime.Parse("2020-04-02T11:00:00"), 1);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<NewLoanSaleActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
                    It.Is<object>(obj =>
                        obj.GetHashCode().Equals(new { afterActivityNbr = "1", newerThanDateTime = "2020-04-02 11:00:00" }.GetHashCode()))));
        }

        [Test]
        public async Task GetNewMortgageSaleActivities_Exception()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewLoanSaleActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ThrowsAsync(new Exception("Yikes"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _activityDao.GetNewMortgageSaleActivities(DateTime.Parse("2020-04-02T11:00:00"), 1));

            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<NewLoanSaleActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
                    It.Is<object>(obj =>
                        obj.GetHashCode().Equals(new { newerThanDateTime = "2020-04-02 11:00:00", afterActivityNbr = "1" }.GetHashCode()))), Times.Never);
        }

        [Test]
        public async Task GetNewVehicleSaleActivities_OK()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewLoanSaleActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ReturnsAsync(new List<NewLoanSaleActivity>()
                {
                    new NewLoanSaleActivity() { ActivityNbr = 1 },
                    new NewLoanSaleActivity() { ActivityNbr = 2 },
                    new NewLoanSaleActivity() { ActivityNbr = 3 }
                }).Verifiable();

            var results = await _activityDao.GetNewVehicleSaleActivities(DateTime.Parse("2020-04-02T11:00:00"), 1);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<NewLoanSaleActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
                    It.Is<object>(obj =>
                        obj.GetHashCode().Equals(new { afterActivityNbr = "1", newerThanDateTime = "2020-04-02 11:00:00" }.GetHashCode()))));
        }

        [Test]
        public async Task GetNewVehicleSaleActivities_Exception()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewLoanSaleActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ThrowsAsync(new Exception("Yikes"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _activityDao.GetNewVehicleSaleActivities(DateTime.Parse("2020-04-02T11:00:00"), 1));

            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<NewLoanSaleActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
                    It.Is<object>(obj =>
                        obj.GetHashCode().Equals(new { newerThanDateTime = "2020-04-02 11:00:00", afterActivityNbr = "1" }.GetHashCode()))), Times.Never);
        }

        [Test]
        public async Task GetNewEDeliverySaleActivities_OK()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<EStatementDeliveryMethod, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ReturnsAsync(new List<EStatementDeliveryMethod>()
                {
                    new EStatementDeliveryMethod() { ActivityNumber = 1 },
                    new EStatementDeliveryMethod() { ActivityNumber = 2 },
                    new EStatementDeliveryMethod() { ActivityNumber = 3 }
                }).Verifiable();

            var results = await _activityDao.GetEStatementDeliveryActivity(DateTime.Parse("2020-04-02T11:00:00"));

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
          
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<EStatementDeliveryMethod, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
                    It.Is<object>(obj =>
                        obj.GetHashCode().Equals(new { newerThanDateTime = "2020-04-02 11:00:00" }.GetHashCode()))));
        }

        [Test]
        public async Task GetNewEDeliverySaleActivities_Exception()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<EStatementDeliveryMethod, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ThrowsAsync(new Exception("Exception thrown"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _activityDao.GetEStatementDeliveryActivity(null));

            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<EStatementDeliveryMethod, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
                    It.Is<object>(obj =>
                        obj.GetHashCode().Equals(new { newerThanDateTime = "2020-04-02 11:00:00" }.GetHashCode()))), Times.Never);
        }

        [Test]
        public async Task GetNewDebtProtectedLoanSaleActivities_OK()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewLoanSaleActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ReturnsAsync(new List<NewLoanSaleActivity>()
                {
                    new NewLoanSaleActivity() { ActivityNbr = 1 },
                    new NewLoanSaleActivity() { ActivityNbr = 2 },
                    new NewLoanSaleActivity() { ActivityNbr = 3 }
                }).Verifiable();

            var results = await _activityDao.GetNewDebtProtectedLoanSaleActivities(DateTime.Parse("2020-04-02T11:00:00"), 1);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<NewLoanSaleActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
                    It.Is<object>(obj =>
                        obj.GetHashCode().Equals(new { afterActivityNbr = "1", newerThanDateTime = "2020-04-02 11:00:00" }.GetHashCode()))));
        }

        [Test]
        public async Task GetNewDebtProtectedLoanSaleActivities_Exception()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewLoanSaleActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ThrowsAsync(new Exception("Yikes"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _activityDao.GetNewDebtProtectedLoanSaleActivities(DateTime.Parse("2020-04-02T11:00:00"), 1));

            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<NewLoanSaleActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
                    It.Is<object>(obj =>
                        obj.GetHashCode().Equals(new { newerThanDateTime = "2020-04-02 11:00:00", afterActivityNbr = "1" }.GetHashCode()))), Times.Never);
        }

        [Test]
        public async Task QueryActivityManagerActivity_OK()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ReturnsAsync(new List<NewActivityManagerIncentiveReferral>()
                {
                    new() { ActivityId = 1 },
                    new() { ActivityId = 2 },
                    new() { ActivityId = 3 }
                }).Verifiable();

            var results = await _activityDao.QueryActivityManagerActivity(new ActivityQueryRequest()
            {
                ActivityIds = new List<long>() { 1, 2, 3 }
            });

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.Is<string>(str => str.Contains(":activityIds")), It.IsAny<object>()));
        }

        [Test]
        public async Task QueryActivityManagerActivity_Exception()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.IsAny<string>(),
                    It.IsAny<object>()))
                .ThrowsAsync(new Exception());

            Assert.ThrowsAsync<Exception>(async () =>
                await _activityDao.QueryActivityManagerActivity(new ActivityQueryRequest()
                {
                    ActivityIds = new List<long>() { 1, 2, 3 }
                }));
        }
        
        [Test]
        public async Task GetPersonActivityByPhoneNumber_OK()
        {
            var phoneNumber = Guid.NewGuid().ToString();
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<PersonRecentActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ReturnsAsync(new List<PersonRecentActivity>()
                {
                    new() { PersonNumber = DateTime.Now.Millisecond, HomePhone = phoneNumber }
                }).Verifiable();

            var result = await _activityDao.GetPersonActivityByPhoneNumber(phoneNumber);

            Assert.NotNull(result);
            Assert.AreEqual(phoneNumber, result.FirstOrDefault()?.HomePhone);
            _mockCoreDbExecution.Verify();
        }

        [Test]
        public void GetPersonActivityByPhoneNumber_Exception()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<PersonRecentActivity, object>(It.IsAny<string>(),
                    It.IsAny<object>()))
                .ThrowsAsync(new Exception());

            Assert.ThrowsAsync<Exception>(async () =>
                await _activityDao.GetPersonActivityByPhoneNumber(It.IsAny<string>()));
        }
        
        [Test]
        public async Task GetPersonActivityByPersonNumber_OK()
        {
            var personNumber = DateTime.Now.Millisecond;
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<PersonRecentActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ReturnsAsync(new List<PersonRecentActivity>
                {
                    new() { PersonNumber = personNumber }
                }).Verifiable();

            var result = await _activityDao.GetPersonActivityByPersonNumber(personNumber.ToString());

            Assert.NotNull(result);
            Assert.AreEqual(personNumber, result.PersonNumber);
            _mockCoreDbExecution.Verify();
        }

        [Test]
        public void GetPersonActivityByPersonNumber_Exception()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<PersonRecentActivity, object>(It.IsAny<string>(),
                    It.IsAny<object>()))
                .ThrowsAsync(new Exception());

            Assert.ThrowsAsync<Exception>(async () =>
                await _activityDao.GetPersonActivityByPersonNumber(It.IsAny<string>()));
        }
    }
}