monorepo/LCU.Api.Internal.DataCleanUp/LCU.Api.Internal.DataCleanUpTest/Services/UpdateMissingSavingsAccountServiceTest.cs

using Moq;
using NUnit.Framework;
using System.Collections.Generic;
using System.Threading.Tasks;
using LCU.Api.Internal.DataCleanUp.Services;
using LCU.Api.Internal.DataCleanUp.DataAccess;
using LCU.Library.Internal.DataCleanUpModel.Enum;
using LCU.Library.Internal.DataCleanUpModel.Models;
using LCU.Api.Internal.DataCleanUp.Models;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreSoapResponses;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreResponses;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
using System;
using System.Linq;
using LCU.Api.Internal.DataCleanUp.Configuration;

namespace LCU.Api.Internal.DataCleanUpTest.Services;

public class UpdateMissingSavingsAccountServiceTest
{
    private UpdateMissingBatchSavingsService _updateMissingBatchSavingsService;
    private Mock<ICoreApiWrapperService> _mockCoreApiWrapperService;
    private Mock<IFileOperationsService> _mockFileOperationsService;
    private DataCleanupDefaults _dataCleanUpDefaults;
    private SavingsMissingRequirementsDefaults _savingsDefaults;
    private DataCleanUpConfiguration _dataCleanUpConfiguration;
    private FileOperationsConfiguration _fileOperationsConfiguration;

    [SetUp]
    public void Setup()
    {
        _dataCleanUpConfiguration = new DataCleanUpConfiguration()
        {
            TimeZone = "America/Chicago"
        };

        _dataCleanUpDefaults = new DataCleanupDefaults()
        {
            MemberCheckHoldsUserFieldCode = "MBRH",
            MemberCheckHoldsDays = 30,
            BatchSavingsSourcePath = "\\\\zeus\\DataIntegrationsQA\\DataCleanUp\\BatchSavings\\MissingBatchSavings.csv",
            BatchSavingsSummarySourcePath = "\\\\zeus\\DataIntegrationsQA\\DataCleanUp\\BatchSavings\\"
        };

        _savingsDefaults = new SavingsMissingRequirementsDefaults()
        {
            FundsToAccountDefaults = new FundsToAccountDefaults()
            {

            },
            SavingDefaults = new SavingsDefaults()
            {
                BankOrganizationNumber = "1",
                BatchAccountDescription = "test",
                CurrentAccountStatusCode = "Z",
                CurrentMinorAccountTypeCode = "X",
                DeliveryMethodCode = "DD",
                OwnershipCode = "OW",
                IsTaxReportedForOwner = true,
                IsTaxReportedForSigner = true,
                IsValid = true,
                MajorAccountTypeCode = "MM"
            }

        };

        _mockCoreApiWrapperService = new Mock<ICoreApiWrapperService>();
        _mockFileOperationsService = new Mock<IFileOperationsService>();
        _updateMissingBatchSavingsService = new UpdateMissingBatchSavingsService(_mockCoreApiWrapperService.Object, _mockFileOperationsService.Object, _dataCleanUpDefaults, _savingsDefaults);
    }

    [Test]
    public async Task CleanUpPersonMissingBatchSavingsUpdate_Success()
    {

        string strFileData = "CUSTOMERNUMBER,FIRSTNAME,LASTNAME,CUSTOMERTYPE,ORGANIZATIONNAME,CORESAVINGSCOUNT,SAVINGSACCOUNTNUMBER,SAVINGSACCOUNTBALANCE,BRANCHCODE,CONTROLPERSON,ControlPersonNeeded,CustomerAddress1,CustomerAddress2,CustomerCity,CustomerState,CustomerZip,ControlPersonAssigned" + "\r\n" +
        "111,SOFIA,Test,Person,,0,,0,1123,0,N,444 S Zero Pl, ,NOWHERE,WI,55555,Y"; 

        var testFilePath = _dataCleanUpDefaults.BatchSavingsSourcePath;
     
        _mockFileOperationsService.Setup(x => x.GetContentData(testFilePath)).ReturnsAsync(strFileData);

        //Set Up Response
        var response = new CreatedAccountResponse()
        {
            AccountNumber = 1,
            BasicResponse = new BasicResponse { Errors = new List<string>(), Success = true }
        };

        _mockCoreApiWrapperService.Setup(x => x.CreatePersonAccount(It.IsAny<CreatePersonAccountRequest>()))
                                 .ReturnsAsync(response);

        //Set Up Response
        var basicResponse = new BasicResponse()
        {
            Success = true,
            Errors = new List<string>()
        };

        var basicResponseList = new List<BasicResponse>() { basicResponse };

        _mockCoreApiWrapperService.Setup(x => x.PostFundsToAccount(response.AccountNumber.ToString(), 5))
                               .ReturnsAsync(basicResponseList);

        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.UpdateMissingBatchSavings
        };
       
        var result = await _updateMissingBatchSavingsService.CleanUp(testRequest);

        Assert.NotNull(result);
        Assert.AreEqual(testRequest, result.Request);
        Assert.IsTrue(result.Successful);
        Assert.IsEmpty(result.ResponseStack);
        _mockCoreApiWrapperService.Verify(x => x.CreatePersonAccount(It.IsAny<CreatePersonAccountRequest>()), Times.Once);
    }

    [Test]
    public async Task CleanUpPersonMissingBatchSavingsUpdate_Fail()
    {
        var testFilePath = _dataCleanUpDefaults.BatchSavingsSourcePath;
        _mockFileOperationsService.Setup(x => x.GetContentData(testFilePath)).ThrowsAsync(new Exception("Nope"));

        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.UpdateMissingBatchSavings
        };

        var result = await _updateMissingBatchSavingsService.CleanUp(testRequest);

        Assert.NotNull(result);
        Assert.AreEqual(testRequest, result.Request);
        Assert.IsFalse(result.Successful);
        Assert.AreEqual(1, result.ResponseStack.Count());
        _mockCoreApiWrapperService.Verify(x => x.CreatePersonAccount(It.IsAny<CreatePersonAccountRequest>()), Times.Never);
    }

    [Test]
    public async Task CleanUpOrganizationMissingBatchSavingsUpdate_Success()
    {
        string strFileData = "CUSTOMERNUMBER,FIRSTNAME,LASTNAME,CUSTOMERTYPE,ORGANIZATIONNAME,CORESAVINGSCOUNT,SAVINGSACCOUNTNUMBER,SAVINGSACCOUNTBALANCE,BRANCHCODE,CONTROLPERSON,ControlPersonNeeded,CustomerAddress1,CustomerAddress2,CustomerCity,CustomerState,CustomerZip,ControlPersonAssigned" + "\r\n" +
        "555,,,Organization,No Company,0,,0,1122,112826,N,Test Ave, ,TestTown,WI,55555,Y";

        var testFilePath = _dataCleanUpDefaults.BatchSavingsSourcePath;

        _mockFileOperationsService.Setup(x => x.GetContentData(testFilePath)).ReturnsAsync(strFileData);

        //Set Up Response
        var response = new CreatedAccountResponse()
        {
            AccountNumber = 1,
            BasicResponse = new BasicResponse { Errors = new List<string>(), Success = true }
        };

        _mockCoreApiWrapperService.Setup(x => x.CreateOrganizationAccount(It.IsAny<CreateOrganizationAccountRequest>()))
                                 .ReturnsAsync(response);

        //Set Up Response
        var basicResponse = new BasicResponse()
        {
            Success = true,
            Errors = new List<string>()
        };

        var basicResponseList = new List<BasicResponse>() { basicResponse };

        _mockCoreApiWrapperService.Setup(x => x.PostFundsToAccount(response.AccountNumber.ToString(), 5))
                               .ReturnsAsync(basicResponseList);

        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.UpdateMissingBatchSavings
        };

        var result = await _updateMissingBatchSavingsService.CleanUp(testRequest);

        Assert.NotNull(result);
        Assert.AreEqual(testRequest, result.Request);
        Assert.IsTrue(result.Successful);
        Assert.IsEmpty(result.ResponseStack);
        _mockCoreApiWrapperService.Verify(x => x.CreateOrganizationAccount(It.IsAny<CreateOrganizationAccountRequest>()), Times.Once);
    }

    [Test]
    public async Task CleanUpOrganizationMissingBatchSavingsUpdate_Fail()
    {
        var testFilePath = _dataCleanUpDefaults.BatchSavingsSourcePath;
        _mockFileOperationsService.Setup(x => x.GetContentData(testFilePath)).ThrowsAsync(new Exception("Nope"));

        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.UpdateMissingBatchSavings
        };

        var result = await _updateMissingBatchSavingsService.CleanUp(testRequest);

        Assert.NotNull(result);
        Assert.AreEqual(testRequest, result.Request);
        Assert.IsFalse(result.Successful);
        Assert.AreEqual(1, result.ResponseStack.Count());
        _mockCoreApiWrapperService.Verify(x => x.CreateOrganizationAccount(It.IsAny<CreateOrganizationAccountRequest>()), Times.Never);
    }

    [Test]
    public async Task CleanUpAddControllingPersonToOrganizationUpdate_Success()
    {
        string strFileData = "CUSTOMERNUMBER,FIRSTNAME,LASTNAME,CUSTOMERTYPE,ORGANIZATIONNAME,CORESAVINGSCOUNT,SAVINGSACCOUNTNUMBER,SAVINGSACCOUNTBALANCE,BRANCHCODE,CONTROLPERSON,ControlPersonNeeded,CustomerAddress1,CustomerAddress2,CustomerCity,CustomerState,CustomerZip,ControlPersonAssigned" + "\r\n" +
        "555,,,Organization,No Company,0,,0,1122,112826,Y,Test Ave, ,TestTown,WI,55555,N";

        var testFilePath = _dataCleanUpDefaults.BatchSavingsSourcePath;

        _mockFileOperationsService.Setup(x => x.GetContentData(testFilePath)).ReturnsAsync(strFileData);

        //Set Up Response
        var response = new BasicResponse()
        {
            Errors = new List<string>(),
            Success = true
        };

        _mockCoreApiWrapperService.Setup(x => x.AddControllingPersonOrganizationMaintenance(It.IsAny<OrganizationMaintenanceRequest>()))
                                 .ReturnsAsync(response);

        //Set Up Response
        var acctresponse = new CreatedAccountResponse()
        {
            AccountNumber = 1,
            BasicResponse = new BasicResponse { Errors = new List<string>(), Success = true }
        };

        _mockCoreApiWrapperService.Setup(x => x.CreateOrganizationAccount(It.IsAny<CreateOrganizationAccountRequest>()))
                                 .ReturnsAsync(acctresponse);

        //Set Up Response
        var basicResponse = new BasicResponse()
        {
            Success = true,
            Errors = new List<string>()
        };

        var basicResponseList = new List<BasicResponse>() { basicResponse };

        _mockCoreApiWrapperService.Setup(x => x.PostFundsToAccount(It.IsAny<string>(), It.IsAny<double>()))
                               .ReturnsAsync(basicResponseList);

        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.UpdateMissingBatchSavings
        };

        var result = await _updateMissingBatchSavingsService.CleanUp(testRequest);

        Assert.NotNull(result);
        Assert.AreEqual(testRequest, result.Request);
        Assert.IsTrue(result.Successful);
        Assert.IsEmpty(result.ResponseStack);
        _mockCoreApiWrapperService.Verify(x => x.CreateOrganizationAccount(It.IsAny<CreateOrganizationAccountRequest>()), Times.Once);
    }

    [Test]
    public async Task CleanUpAddControllingPersonToOrganizationUpdate_Fail()
    {
        var testFilePath = _dataCleanUpDefaults.BatchSavingsSourcePath;
        _mockFileOperationsService.Setup(x => x.GetContentData(testFilePath)).ThrowsAsync(new Exception("Nope"));

        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.UpdateMissingBatchSavings
        };

        var result = await _updateMissingBatchSavingsService.CleanUp(testRequest);

        Assert.NotNull(result);
        Assert.AreEqual(testRequest, result.Request);
        Assert.IsFalse(result.Successful);
        Assert.AreEqual(1, result.ResponseStack.Count());
        _mockCoreApiWrapperService.Verify(x => x.CreateOrganizationAccount(It.IsAny<CreateOrganizationAccountRequest>()), Times.Never);
        _mockCoreApiWrapperService.Verify(x => x.AddControllingPersonOrganizationMaintenance(It.IsAny<OrganizationMaintenanceRequest>()), Times.Never);
    }

    [Test]
    public async Task CleanUpPersonAndAddFundsForMissingBatchSavingsUpdate_Success()
    {
        string strFileData = "CUSTOMERNUMBER,FIRSTNAME,LASTNAME,CUSTOMERTYPE,ORGANIZATIONNAME,CORESAVINGSCOUNT,SAVINGSACCOUNTNUMBER,SAVINGSACCOUNTBALANCE,BRANCHCODE,CONTROLPERSON,ControlPersonNeeded,CustomerAddress1,CustomerAddress2,CustomerCity,CustomerState,CustomerZip,ControlPersonAssigned" + "\r\n" +
        "111,SOFIA,Test,Person,,0,,0,1123,0,N,444 S Zero Pl, ,NOWHERE,WI,55555,Y";

        var testFilePath = _dataCleanUpDefaults.BatchSavingsSourcePath;

        _mockFileOperationsService.Setup(x => x.GetContentData(testFilePath)).ReturnsAsync(strFileData);

        //Set Up Response
        var response = new CreatedAccountResponse()
        {
            AccountNumber = 1,
            BasicResponse = new BasicResponse { Errors = new List<string>(), Success = true }
        };

        _mockCoreApiWrapperService.Setup(x => x.CreatePersonAccount(It.IsAny<CreatePersonAccountRequest>()))
                                 .ReturnsAsync(response);

        //Set Up Funds Response
        var basicResponseFunds = new BasicResponse()
        {
            Success = true,
            Errors = new List<string>()
        };

        var basicResponseList = new List<BasicResponse>() { basicResponseFunds };

        _mockCoreApiWrapperService.Setup(x => x.PostFundsToAccount(response.AccountNumber.ToString(), 5))
                                .ReturnsAsync(basicResponseList);


        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.UpdateMissingBatchSavings
        };

        var result = await _updateMissingBatchSavingsService.CleanUp(testRequest);

        Assert.NotNull(result);
        Assert.AreEqual(testRequest, result.Request);
        Assert.IsTrue(result.Successful);
        Assert.IsEmpty(result.ResponseStack);
        _mockCoreApiWrapperService.Verify(x => x.CreatePersonAccount(It.IsAny<CreatePersonAccountRequest>()), Times.Once);
    }

    [Test]
    public async Task CleanUpPersonAndAddFundsForMissingBatchSavingsUpdateWithBalance_Success()
    {
        string strFileData = "CUSTOMERNUMBER,FIRSTNAME,LASTNAME,CUSTOMERTYPE,ORGANIZATIONNAME,CORESAVINGSCOUNT,SAVINGSACCOUNTNUMBER,SAVINGSACCOUNTBALANCE,BRANCHCODE,CONTROLPERSON,ControlPersonNeeded,CustomerAddress1,CustomerAddress2,CustomerCity,CustomerState,CustomerZip,ControlPersonAssigned" + "\r\n" +
        "111,SOFIA,Test,Person,,1,223344,1.25,1123,0,N,444 S Zero Pl, ,NOWHERE,WI,55555,Y";

        var testFilePath = _dataCleanUpDefaults.BatchSavingsSourcePath;

        _mockFileOperationsService.Setup(x => x.GetContentData(testFilePath)).ReturnsAsync(strFileData);

        //Set Up Funds Response
        var basicResponseFunds = new BasicResponse()
        {
            Success = true,
            Errors = new List<string>()
        };

        var basicResponseList = new List<BasicResponse>() { basicResponseFunds };

        _mockCoreApiWrapperService.Setup(x => x.PostFundsToAccount("223344", 3.75))
                                .ReturnsAsync(basicResponseList);


        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.UpdateMissingBatchSavings
        };

        var result = await _updateMissingBatchSavingsService.CleanUp(testRequest);

        Assert.NotNull(result);
        Assert.AreEqual(testRequest, result.Request);
        Assert.IsTrue(result.Successful);
        Assert.IsEmpty(result.ResponseStack);
        _mockCoreApiWrapperService.Verify(x => x.PostFundsToAccount(It.IsAny<string>(), It.IsAny<double>()), Times.Once);
    }

    [Test]
    public async Task CleanUpPersonAndAddFundsForMissingBatchSavingsUpdate_Fail()
    {
        var testFilePath = _dataCleanUpDefaults.BatchSavingsSourcePath;
        _mockFileOperationsService.Setup(x => x.GetContentData(testFilePath)).ThrowsAsync(new Exception("Nope"));

        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.UpdateMissingBatchSavings
        };

        var result = await _updateMissingBatchSavingsService.CleanUp(testRequest);

        Assert.NotNull(result);
        Assert.AreEqual(testRequest, result.Request);
        Assert.IsFalse(result.Successful);
        Assert.AreEqual(1, result.ResponseStack.Count());
        _mockCoreApiWrapperService.Verify(x => x.CreatePersonAccount(It.IsAny<CreatePersonAccountRequest>()), Times.Never);
        _mockCoreApiWrapperService.Verify(x => x.PostFundsToAccount(It.IsAny<string>(), It.IsAny<double>()), Times.Never);
    }

    [Test]
    public async Task CleanUpOrganizationAndAddFundsForMissingBatchSavingsUpdate_Success()
    {
        string strFileData = "CUSTOMERNUMBER,FIRSTNAME,LASTNAME,CUSTOMERTYPE,ORGANIZATIONNAME,CORESAVINGSCOUNT,SAVINGSACCOUNTNUMBER,SAVINGSACCOUNTBALANCE,BRANCHCODE,CONTROLPERSON,ControlPersonNeeded,CustomerAddress1,CustomerAddress2,CustomerCity,CustomerState,CustomerZip,ControlPersonAssigned" + "\r\n" +
        "555,,,Organization,No Company,0,,0,1122,112826,N,Test Ave, ,TestTown,WI,55555,Y";

        var testFilePath = _dataCleanUpDefaults.BatchSavingsSourcePath;

        _mockFileOperationsService.Setup(x => x.GetContentData(testFilePath)).ReturnsAsync(strFileData);

        //Set Up Response
        var response = new CreatedAccountResponse()
        {
            AccountNumber = 1,
            BasicResponse = new BasicResponse { Errors = new List<string>(), Success = true }
        };

        _mockCoreApiWrapperService.Setup(x => x.CreateOrganizationAccount(It.IsAny<CreateOrganizationAccountRequest>()))
                                 .ReturnsAsync(response);

        //Set Up Funds Response
        var basicResponseFunds = new BasicResponse()
        {
            Success = true,
            Errors = new List<string>()
        };

        var basicResponseList = new List<BasicResponse>() { basicResponseFunds };

        _mockCoreApiWrapperService.Setup(x => x.PostFundsToAccount(It.IsAny<string>(), It.IsAny<double>()))
                                .ReturnsAsync(basicResponseList);

        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.UpdateMissingBatchSavings
        };

        var result = await _updateMissingBatchSavingsService.CleanUp(testRequest);

        Assert.NotNull(result);
        Assert.AreEqual(testRequest, result.Request);
        Assert.IsTrue(result.Successful);
        Assert.IsEmpty(result.ResponseStack);
        _mockCoreApiWrapperService.Verify(x => x.CreateOrganizationAccount(It.IsAny<CreateOrganizationAccountRequest>()), Times.Once);
    }

    [Test]
    public async Task CleanUpOrganizationAndAddFundsForMissingBatchSavingsUpdate_Fail()
    {
        var testFilePath = _dataCleanUpDefaults.BatchSavingsSourcePath;
        _mockFileOperationsService.Setup(x => x.GetContentData(testFilePath)).ThrowsAsync(new Exception("Nope"));

        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.UpdateMissingBatchSavings
        };

        var result = await _updateMissingBatchSavingsService.CleanUp(testRequest);

        Assert.NotNull(result);
        Assert.AreEqual(testRequest, result.Request);
        Assert.IsFalse(result.Successful);
        Assert.AreEqual(1, result.ResponseStack.Count());
        _mockCoreApiWrapperService.Verify(x => x.CreateOrganizationAccount(It.IsAny<CreateOrganizationAccountRequest>()), Times.Never);
        _mockCoreApiWrapperService.Verify(x => x.PostFundsToAccount(It.IsAny<string>(), It.IsAny<double>()), Times.Never);
    }

}