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

using System;
using LCU.API.Internal.Operations.IncentiveApi.Services;
using LCU.Library.Internal.IncentiveApiModels.Entities;
using Moq;
using NUnit.Framework;
using System.Collections.Generic;
using System.Threading.Tasks;
using LCU.API.Internal.Operations.IncentiveApiLib.Repositories;
using LCU.Library.Internal.IncentiveApiModels.Enums;
using LCU.API.Internal.Operations.IncentiveApi.Exceptions;

namespace Application.UnitTests.Services
{
    public class DeadActivityServiceTest
    {
        private IDeadActivityService _service;
        private Mock<IDeadActivityRepository> _mockDeadActivityRepository;
        private Mock<IUnitOfWork> _mockUnitOfWork;

        [SetUp]
        public void Setup()
        {
            _mockDeadActivityRepository = new Mock<IDeadActivityRepository>();
            _mockUnitOfWork = new Mock<IUnitOfWork>();
            _service = new DeadActivityService(_mockDeadActivityRepository.Object, _mockUnitOfWork.Object);
        }

        [Test]
        public async Task SaveDeadActivity_Ok()
        {
            var deadActivity = new DeadActivity("12345", SystemType.IncentiveLog, DeadActivityReason.Other,
                "Sad Incentive Manager Noises");

            _mockDeadActivityRepository.Setup(x => x.SaveDeadActivityRange(It.IsAny<List<DeadActivity>>()))
                .ReturnsAsync(new List<DeadActivity>() { deadActivity });
            _mockDeadActivityRepository.Setup(x => x.GetDeadActivitiesBySourceIds(It.IsAny<List<string>>()))
                .ReturnsAsync(new List<DeadActivity>() {});


            var result = await _service.SaveDeadActivity(deadActivity);

            Assert.NotNull(result);
            Assert.AreEqual(deadActivity, result);
        }

        [Test]
        public async Task SaveDeadActivity_DidntSave_Ok()
        {
            var deadActivity = new DeadActivity("12345", SystemType.IncentiveLog, DeadActivityReason.Other,
                "Sad Incentive Manager Noises");

            _mockDeadActivityRepository.Setup(x => x.SaveDeadActivityRange(It.IsAny<List<DeadActivity>>()))
                .ReturnsAsync(new List<DeadActivity>() {});
            _mockDeadActivityRepository.Setup(x => x.GetDeadActivitiesBySourceIds(It.IsAny<List<string>>()))
                .ReturnsAsync(new List<DeadActivity>() {});


            var result = await _service.SaveDeadActivity(deadActivity);

            Assert.Null(result);
        }

        [Test]
        public async Task SaveDeadActivity_FilteredOut_Ok()
        {
            var deadActivity = new DeadActivity("12345", SystemType.IncentiveLog, DeadActivityReason.Other,
                "Sad Incentive Manager Noises");

            _mockDeadActivityRepository.Setup(x => x.SaveDeadActivityRange(It.IsAny<List<DeadActivity>>()))
                .ReturnsAsync(new List<DeadActivity>() {deadActivity});
            _mockDeadActivityRepository.Setup(x => x.GetDeadActivitiesBySourceIds(It.IsAny<List<string>>()))
                .ReturnsAsync(new List<DeadActivity>() {deadActivity});


            var result = await _service.SaveDeadActivity(deadActivity);

            Assert.Null(result);
        }

        [Test]
        public async Task SaveDeadActivityRange_OK()
        {
            var deadActivities = new List<DeadActivity>()
            {
                new DeadActivity("1", SystemType.Action, DeadActivityReason.Other, "Oh"),
                new DeadActivity("2", SystemType.Action, DeadActivityReason.Other, "No"),
                new DeadActivity("3", SystemType.Action, DeadActivityReason.Other, "Dead"),
                new DeadActivity("4", SystemType.Action, DeadActivityReason.Other, "Activity")
            };

            _mockDeadActivityRepository.Setup(x => x.SaveDeadActivityRange(It.IsAny<List<DeadActivity>>()))
                .ReturnsAsync(deadActivities);
            _mockDeadActivityRepository.Setup(x => x.GetDeadActivitiesBySourceIds(It.IsAny<List<string>>()))
                .ReturnsAsync(new List<DeadActivity>() {});

            var result = await _service.SaveDeadActivityRange(deadActivities);

            _mockDeadActivityRepository.Verify(x => x.SaveDeadActivityRange(It.Is<List<DeadActivity>>(x => x.Count == 4)));
            Assert.NotNull(result);
            Assert.AreEqual(4, result.Count);
        }

        [Test]
        public async Task SaveDeadActivityRange_FilteredOut_OK()
        {
            var deadActivities = new List<DeadActivity>()
            {
                new DeadActivity("1", SystemType.Action, DeadActivityReason.Other, "Oh"),
                new DeadActivity("2", SystemType.Action, DeadActivityReason.Other, "No"),
                new DeadActivity("3", SystemType.Action, DeadActivityReason.Other, "Dead"),
                new DeadActivity("4", SystemType.Action, DeadActivityReason.Other, "Activity")
            };

            _mockDeadActivityRepository.Setup(x => x.SaveDeadActivityRange(It.IsAny<List<DeadActivity>>()))
                .ReturnsAsync(deadActivities);
            _mockDeadActivityRepository.Setup(x => x.GetDeadActivitiesBySourceIds(It.IsAny<List<string>>()))
                .ReturnsAsync(new List<DeadActivity>()
                {
                    new DeadActivity("1", SystemType.Action, DeadActivityReason.Other, "Oh"),
                    new DeadActivity("2", SystemType.Action, DeadActivityReason.Other, "No"),
                });

            var result = await _service.SaveDeadActivityRange(deadActivities);

            _mockDeadActivityRepository.Verify(x => x.SaveDeadActivityRange(It.Is<List<DeadActivity>>(x => x.Count == 2)));
            Assert.NotNull(result);
        }


        [Test]
        public async Task SaveDeadActivityRange_FilteredOutAll_OK()
        {
            var deadActivities = new List<DeadActivity>()
            {
                new DeadActivity("1", SystemType.Action, DeadActivityReason.Other, "Oh"),
                new DeadActivity("2", SystemType.Action, DeadActivityReason.Other, "No"),
                new DeadActivity("3", SystemType.Action, DeadActivityReason.Other, "Dead"),
                new DeadActivity("4", SystemType.Action, DeadActivityReason.Other, "Activity")
            };

            _mockDeadActivityRepository.Setup(x => x.SaveDeadActivityRange(It.IsAny<List<DeadActivity>>()))
                .ReturnsAsync(deadActivities);
            _mockDeadActivityRepository.Setup(x => x.GetDeadActivitiesBySourceIds(It.IsAny<List<string>>()))
                .ReturnsAsync(deadActivities);

            var result = await _service.SaveDeadActivityRange(deadActivities);

            Assert.NotNull(result);
            Assert.AreEqual(0, result.Count);
        }

        [TestCase("Product", Product.Mortgage, true)]
        [TestCase("Product", Product.Vehicle, false)]
        [TestCase("Product", null, false)]
        [TestCase("Type",ActivityType.Other, false)]
        [TestCase("Type",null, false)]
        [TestCase("SourceId", "1", false)]
        [TestCase("SourceSystem", SystemType.Redtail, false)]
        [TestCase("EmployeeId", "1234", false)]
        [TestCase("EmployeeId", null, true)]
        [TestCase("EmployeeEmail", "[email protected]", true)]
        [TestCase("EmployeeEmail", "[email protected]", true)]
        [TestCase("EmployeeEmail", "[email protected]", false)]
        [TestCase("EmployeeEmail", null, false)]
        [TestCase("DepartmentId", -1, false)]
        [TestCase("DepartmentId", null, true)]
        [TestCase("DepartmentId", 100, false)]
        public async Task FilterActivitiesByIdentifyingFields_OK(string property, object value, bool expectFilteredOut)
        {
            var deadActivities = new List<DeadActivity>()
            {
                new DeadActivity("1234", SystemType.Dna, DeadActivityReason.Other, "Missing Info")
                {
                    Product = Product.Mortgage,
                    Type = ActivityType.Sale,
                    SourceId = "1234",
                    SourceSystem = SystemType.Dna,
                    EmployeeId = null,
                    EmployeeEmail = "[email protected]",
                    DepartmentId = null,
                    DeadDetail = new DeadActivityDetail()
                    {
                        AgreementNumber = "abc"
                    }
                }
            };


            var existingActivity =
                new DeadActivity("1234", SystemType.Dna, DeadActivityReason.Other, "Missing Info")
                {
                    Product = Product.Mortgage,
                    Type = ActivityType.Sale,
                    SourceId = "1234",
                    SourceSystem = SystemType.Dna,
                    EmployeeId = null,
                    EmployeeEmail = "[email protected]",
                    DepartmentId = null,
                    DeadDetail = new DeadActivityDetail()
                    {
                        AgreementNumber = "abc"
                    }
                };

            existingActivity.GetType().GetProperty(property)?.SetValue(existingActivity, value, null);

            _mockDeadActivityRepository.Setup(x => x.SaveDeadActivityRange(It.IsAny<List<DeadActivity>>()))
                .ReturnsAsync(deadActivities);
            _mockDeadActivityRepository.Setup(x => x.GetDeadActivitiesBySourceIds(It.IsAny<List<string>>()))
                .ReturnsAsync(new List<DeadActivity>(){existingActivity});

           var results = await _service.SaveDeadActivityRange(deadActivities);
           Assert.AreEqual(expectFilteredOut, results.Count == 0);
        }

        [Test]
        public async Task FilterActivitiesByIdentifyingFields_Details_OK()
        {
            var deadActivities = new List<DeadActivity>()
            {
                new DeadActivity("1234", SystemType.Dna, DeadActivityReason.Other, "Missing Info")
                {
                    Product = Product.Mortgage,
                    Type = ActivityType.Sale,
                    SourceId = "1234",
                    SourceSystem = SystemType.Dna,
                    EmployeeId = null,
                    EmployeeEmail = "[email protected]",
                    DepartmentId = null,
                    DeadDetail = new DeadActivityDetail()
                    {
                        //We dont filter on this field
                        AgreementNumber = "abc"
                    }
                }
            };

            var existingActivity =
                new DeadActivity("1234", SystemType.Dna, DeadActivityReason.Other, "Missing Info")
                {
                    Product = Product.Mortgage,
                    Type = ActivityType.Sale,
                    SourceId = "1234",
                    SourceSystem = SystemType.Dna,
                    EmployeeId = null,
                    EmployeeEmail = "[email protected]",
                    DepartmentId = null,
                    DeadDetail = new DeadActivityDetail()
                    {
                        //We dont filter on this field
                        AgreementNumber = null
                    }
                };


            _mockDeadActivityRepository.Setup(x => x.SaveDeadActivityRange(It.IsAny<List<DeadActivity>>()))
                .ReturnsAsync(deadActivities);
            _mockDeadActivityRepository.Setup(x => x.GetDeadActivitiesBySourceIds(It.IsAny<List<string>>()))
                .ReturnsAsync(new List<DeadActivity>(){existingActivity});

           var results = await _service.SaveDeadActivityRange(deadActivities);
           Assert.AreEqual(true, results.Count == 0);
        }

        [Test]
        public async Task FilterActivitiesByIdentifyingFields_NullDetails_OK()
        {
            var deadActivities = new List<DeadActivity>()
            {
                new DeadActivity("1234", SystemType.Dna, DeadActivityReason.Other, "Missing Info")
                {
                    Product = Product.Mortgage,
                    Type = ActivityType.Sale,
                    SourceId = "1234",
                    SourceSystem = SystemType.Dna,
                    EmployeeId = null,
                    EmployeeEmail = "[email protected]",
                    DepartmentId = null,
                    DeadDetail = new DeadActivityDetail()
                    {
                        AccountNumber = "123"
                    }
                }
            };

            var existingActivity =
                new DeadActivity("1234", SystemType.Dna, DeadActivityReason.Other, "Missing Info")
                {
                    Product = Product.Mortgage,
                    Type = ActivityType.Sale,
                    SourceId = "1234",
                    SourceSystem = SystemType.Dna,
                    EmployeeId = null,
                    EmployeeEmail = "[email protected]",
                    DepartmentId = null,
                    DeadDetail = null
                };


            _mockDeadActivityRepository.Setup(x => x.SaveDeadActivityRange(It.IsAny<List<DeadActivity>>()))
                .ReturnsAsync(deadActivities);
            _mockDeadActivityRepository.Setup(x => x.GetDeadActivitiesBySourceIds(It.IsAny<List<string>>()))
                .ReturnsAsync(new List<DeadActivity>(){existingActivity});

            var results = await _service.SaveDeadActivityRange(deadActivities);
            Assert.AreEqual(false, results.Count == 0);
        }

        [Test]
        public async Task GetActivity_ReturnsActivity()
        {
            var activityFromRepo = new DeadActivity(new Activity
            {
                Id = 100,
                DepartmentId = 32,
                EmployeeId = "1",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                Detail = new ActivityDetail(),
                ActivityPayouts = new List<ActivityPayoutLineItem>()
            }, DeadActivityReason.Other, "Test");
            //pretend there is more than 1 in repository
            activityFromRepo.Id = 3;
            _mockDeadActivityRepository.Setup(mock => mock.GetDeadActivityById(3))
                .ReturnsAsync(activityFromRepo);

            var result = await _service.GetDeadActivity(3);

            Assert.NotNull(result);
            Assert.AreEqual(3, result.Id);
        }

        [Test]
        public async Task GetActivity_ThrowsWhenNull()
        {
            _mockDeadActivityRepository.Setup(mock => mock.GetDeadActivityById(3))
                .ReturnsAsync((DeadActivity) null);

            Assert.ThrowsAsync<NotFoundException>(async () => await _service.GetDeadActivity(3));
        }

        [Test]
        public async Task Updates_DeadActivity()
        {
            var activity = new DeadActivity("1234", SystemType.Action, DeadActivityReason.Other, "test");
            activity.Id = 4;
            activity.LivingActivityId = null;

            _mockDeadActivityRepository.Setup(mock => mock.GetDeadActivityById(4))
                .ReturnsAsync(activity);
            _mockUnitOfWork.Setup(x => x.CompleteAsync()).Verifiable();

            Assert.IsNull(activity.LivingActivityId);
            var activity2 = await _service.ProcessDeadActivity(4, 1);
            Assert.AreEqual(activity.Id,activity2.Id);
            Assert.AreEqual(1, activity2.LivingActivityId);
        }
    }
}