monorepo/LCU.Api.Internal.DataCleanUp/LCU.Api.Internal.DataCleanUpTest/Services/UpdatePersonForAtmHoldsServiceTest.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.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
using System;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Persons;
using TimeZoneConverter;
using LCU.Library.Internal.ApiResponse.Models;
using Newtonsoft.Json;
using LCU.Api.Internal.DataCleanUp.Configuration;

namespace LCU.Api.Internal.DataCleanUpTest.Services;

public class UpdatePersonForAtmHoldsServiceTest
{
    private UpdatePersonForAtmHoldsService _updatePersonForAtmHoldsService;
    private Mock<ICoreApiWrapperService> _mockCoreApiWrapperService;
    private Mock<ICoreApiWrapperDao> _mockCoreApiWrapperDao;
    private DataCleanupDefaults _dataCleanUpDefaults;
    private DataCleanUpConfiguration _dataCleanUpConfiguration;

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

        _dataCleanUpDefaults = new DataCleanupDefaults()
        {
            MemberCheckHoldsUserFieldCode = "MBRH",
            MemberCheckHoldsDays = 29
        };

        _mockCoreApiWrapperDao = new Mock<ICoreApiWrapperDao>();
        _mockCoreApiWrapperService = new Mock<ICoreApiWrapperService>();
        _updatePersonForAtmHoldsService = new UpdatePersonForAtmHoldsService(_mockCoreApiWrapperService.Object, _dataCleanUpDefaults, _dataCleanUpConfiguration);
    }

    [Test]
    public async Task CleanUpPersonAtmCheckHoldUpdate_Success()
    {
        var listPersonCheckHoldsUserFields = new List<PersonCheckHoldsUserField>()
        {
            new PersonCheckHoldsUserField()
            {
                PersonNumber = 1,
                UserFieldExists = true,
                OldestActiveEffectiveDate = DateTime.Now,
                RecentClosedEffectiveDate = DateTime.Now
            }
        };
        _mockCoreApiWrapperService.Setup(x => x.GetAtmCheckHoldsForPersonNumbers(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<int?>())).ReturnsAsync(listPersonCheckHoldsUserFields);

        //Set Up Response
        var personUserField = new PersonUserField()
        {
            PersonNumber = 1,
            Value = "N"
        };

        _mockCoreApiWrapperService.Setup(x => x.UpdateAtmCheckHoldsForPersonNumbers(It.IsAny<int>(), It.IsAny<string>()))
                                 .ReturnsAsync(personUserField);

        var newCheckHoldRequest = new UpdatePersonForCheckHoldRequest();
        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.UpdatePersonForCheckHolds,
            DataCleanUpPayload = JsonConvert.SerializeObject(newCheckHoldRequest)
        };

        var result = await _updatePersonForAtmHoldsService.CleanUp(testRequest);

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

    }

    [Test]
    public async Task CleanUpPersonAtmCheckHoldUpdate_Fail()
    {
        //Set Up Response
        var listPersonUserFields = new PersonUserField();
       
        _mockCoreApiWrapperService.Setup(x => x.UpdateAtmCheckHoldsForPersonNumbers(It.IsAny<int>(), It.IsAny<string>()))
                                    .ReturnsAsync(listPersonUserFields);

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

        Assert.NotNull(result);
        Assert.AreEqual(testRequest, result.Request);
        Assert.AreEqual(1, result.ResponseStack.Count);
        _mockCoreApiWrapperDao.Verify(x => x.UpdateAtmCheckHoldsForPersonNumbers(It.IsAny<PersonUserFieldRequest>()), Times.Never);
    }

    [Test]
    public async Task CleanUpPersonAtmCheckHoldAdd_Success()
    {
        var listPersonCheckHoldsUserFields = new List<PersonCheckHoldsUserField>()
        {
            new PersonCheckHoldsUserField()
            {
                PersonNumber = 1,
                UserFieldExists = false,
                OldestActiveEffectiveDate = DateTime.Now,
                RecentClosedEffectiveDate = DateTime.Now
            }
        };
        _mockCoreApiWrapperService.Setup(x => x.GetAtmCheckHoldsForPersonNumbers(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<int?>())).ReturnsAsync(listPersonCheckHoldsUserFields);

        //Set Up Response
        var personUserField = new PersonUserField()
        {
            PersonNumber = 1,
            Value = "Y"
        };

        _mockCoreApiWrapperService.Setup(x => x.AddAtmCheckHoldsForPersonNumbers(It.IsAny<int>(), It.IsAny<string>()))
                                 .ReturnsAsync(personUserField);

        var newCheckHoldRequest = new UpdatePersonForCheckHoldRequest();
        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.UpdatePersonForCheckHolds,
            DataCleanUpPayload = JsonConvert.SerializeObject(newCheckHoldRequest)
        };
        var result = await _updatePersonForAtmHoldsService.CleanUp(testRequest);

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

    [Test]
    public async Task CleanUpPersonAtmCheckHoldAdd_Fail()
    {
        //Set Up Response
        var listPersonUserFields = new PersonUserField();

        _mockCoreApiWrapperService.Setup(x => x.AddAtmCheckHoldsForPersonNumbers(It.IsAny<int>(), It.IsAny<string>()))
                                    .ReturnsAsync(listPersonUserFields);

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

        Assert.NotNull(result);
        Assert.AreEqual(testRequest, result.Request);
        Assert.AreEqual(1, result.ResponseStack.Count);
        _mockCoreApiWrapperDao.Verify(x => x.AddAtmCheckHoldsForPersonNumbers(It.IsAny<PersonUserFieldRequest>()), Times.Never);
    }

    [Test]
    public async Task CleanUpPersonAtmCheckHoldAddFetchSize_Success()
    {
        var listPersonCheckHoldsUserFields = new List<PersonCheckHoldsUserField>()
        {
            new PersonCheckHoldsUserField()
            {
                PersonNumber = 1,
                UserFieldExists = false,
                OldestActiveEffectiveDate = DateTime.Now,
                RecentClosedEffectiveDate = DateTime.Now
            },

             new PersonCheckHoldsUserField()
            {
                PersonNumber = 2,
                UserFieldExists = false,
                OldestActiveEffectiveDate = DateTime.Now,
                RecentClosedEffectiveDate = DateTime.Now
            },

              new PersonCheckHoldsUserField()
            {
                PersonNumber = 3,
                UserFieldExists = false,
                OldestActiveEffectiveDate = DateTime.Now,
                RecentClosedEffectiveDate = DateTime.Now
            }
        };
        _mockCoreApiWrapperService.Setup(x => x.GetAtmCheckHoldsForPersonNumbers(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<int?>())).ReturnsAsync(listPersonCheckHoldsUserFields);

        //Set Up Response
        var personUserField = new PersonUserField()
        {
            PersonNumber = 1,
            Value = "Y"
        };

        _mockCoreApiWrapperService.Setup(x => x.AddAtmCheckHoldsForPersonNumbers(It.IsAny<int>(), It.IsAny<string>()))
                                 .ReturnsAsync(personUserField);

        var newCheckHoldRequest = new UpdatePersonForCheckHoldRequest();
        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.UpdatePersonForCheckHolds,
            DataCleanUpPayload = JsonConvert.SerializeObject(newCheckHoldRequest)
        };
        var result = await _updatePersonForAtmHoldsService.CleanUp(testRequest);

        Assert.NotNull(result);
        Assert.AreEqual(testRequest, result.Request);
        Assert.IsTrue(result.Successful);
        Assert.IsEmpty(result.ResponseStack);
        _mockCoreApiWrapperService.Verify(x => x.AddAtmCheckHoldsForPersonNumbers(It.IsAny<int>(), It.IsAny<string>()), Times.Exactly(3));
    }

    [Test]
    public async Task CleanUpPersonAtmCheckHoldUpdate_NoAccounts_YesValue_Success()
    {
        var listPersonCheckHoldsUserFields = new List<PersonCheckHoldsUserField>()
        {
            new PersonCheckHoldsUserField()
            {
                PersonNumber = 1,
                UserFieldExists = true,
                OldestActiveEffectiveDate = null,
                RecentClosedEffectiveDate = null
            }
        };
        _mockCoreApiWrapperService.Setup(x => x.GetAtmCheckHoldsForPersonNumbers(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<int>())).ReturnsAsync(listPersonCheckHoldsUserFields);

        var newCheckHoldRequest = new UpdatePersonForCheckHoldRequest();
        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.UpdatePersonForCheckHolds,
            DataCleanUpPayload = JsonConvert.SerializeObject(newCheckHoldRequest)
        };

        var dataCleanUpResult = await _updatePersonForAtmHoldsService.CleanUp(testRequest);
        var userValueResult = _updatePersonForAtmHoldsService.DeterminePersonUserFieldValue(listPersonCheckHoldsUserFields[0]);

        Assert.NotNull(dataCleanUpResult);
        Assert.AreEqual(testRequest, dataCleanUpResult.Request);
        Assert.IsTrue(userValueResult.Equals("Y"));
    }

    [Test]
    public async Task CleanUpPersonAtmCheckHoldUpdate_ActiveInValidClosedInValid_YesValue_Success()
    {
        var assumedTimezone = TZConvert.GetTimeZoneInfo("America/Chicago");
        DateTime checkHoldDateToConvert = Convert.ToDateTime(DateTime.Now.AddDays(-29));
        var checkHoldDate = TimeZoneInfo.ConvertTime(checkHoldDateToConvert, assumedTimezone).Date;
        DateTime oldestActiveDate = checkHoldDate.AddDays(1);
        DateTime newestClosedDate = checkHoldDate.AddDays(-1);

        var listPersonCheckHoldsUserFields = new List<PersonCheckHoldsUserField>()
        {
            new PersonCheckHoldsUserField()
            {
                PersonNumber = 1,
                UserFieldExists = true,
                OldestActiveEffectiveDate = oldestActiveDate, //older active account date, invalid check hold timeframe
                RecentClosedEffectiveDate = newestClosedDate, //newer closed account date, invalid check hold timeframe
            }
        };
        _mockCoreApiWrapperService.Setup(x => x.GetAtmCheckHoldsForPersonNumbers(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<int>())).ReturnsAsync(listPersonCheckHoldsUserFields);

        var newCheckHoldRequest = new UpdatePersonForCheckHoldRequest();
        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.UpdatePersonForCheckHolds,
            DataCleanUpPayload = JsonConvert.SerializeObject(newCheckHoldRequest)
        };

        var dataCleanUpResult = await _updatePersonForAtmHoldsService.CleanUp(testRequest);
        var userValueResult = _updatePersonForAtmHoldsService.DeterminePersonUserFieldValue(listPersonCheckHoldsUserFields[0]);

        Assert.NotNull(dataCleanUpResult);
        Assert.AreEqual(testRequest, dataCleanUpResult.Request);
        Assert.IsTrue(userValueResult.Equals("Y"));
    }

    [Test]
    public async Task CleanUpPersonAtmCheckHoldUpdate_NoClosedInvalidActive_YesValue_Success()
    {
        var assumedTimezone = TZConvert.GetTimeZoneInfo("America/Chicago");
        DateTime checkHoldDateToConvert = Convert.ToDateTime(DateTime.Now.AddDays(-28));
        var checkHoldDate = TimeZoneInfo.ConvertTime(checkHoldDateToConvert, assumedTimezone).Date;
        DateTime oldestActiveDate = checkHoldDate.AddDays(0);

        var listPersonCheckHoldsUserFields = new List<PersonCheckHoldsUserField>()
        {
            new PersonCheckHoldsUserField()
            {
                PersonNumber = 1,
                UserFieldExists = true,
                OldestActiveEffectiveDate = oldestActiveDate, //more recent active account date, valid check hold timeframe
                RecentClosedEffectiveDate = null // no closed account, invalid check hold timeframe
            }
        };
        _mockCoreApiWrapperService.Setup(x => x.GetAtmCheckHoldsForPersonNumbers(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<int>())).ReturnsAsync(listPersonCheckHoldsUserFields);

        var newCheckHoldRequest = new UpdatePersonForCheckHoldRequest();
        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.UpdatePersonForCheckHolds,
            DataCleanUpPayload = JsonConvert.SerializeObject(newCheckHoldRequest)
        };

        var dataCleanUpResult = await _updatePersonForAtmHoldsService.CleanUp(testRequest);
        var userValueResult = _updatePersonForAtmHoldsService.DeterminePersonUserFieldValue(listPersonCheckHoldsUserFields[0]);

        Assert.NotNull(dataCleanUpResult);
        Assert.AreEqual(testRequest, dataCleanUpResult.Request);
        Assert.IsTrue(userValueResult.Equals("Y"));
    }

    [Test] 
    public async Task CleanUpPersonAtmCheckHoldUpdate_NoActiveInvalidClosed_YesValue_Success()
    {
        var assumedTimezone = TZConvert.GetTimeZoneInfo("America/Chicago");
        DateTime checkHoldDateToConvert = Convert.ToDateTime(DateTime.Now.AddDays(-30));
        var checkHoldDate = TimeZoneInfo.ConvertTime(checkHoldDateToConvert, assumedTimezone).Date;
        DateTime recentClosedDate = checkHoldDate.AddDays(0);

        var listPersonCheckHoldsUserFields = new List<PersonCheckHoldsUserField>()
        {
            new PersonCheckHoldsUserField()
            {
                PersonNumber = 1,
                UserFieldExists = true,
                OldestActiveEffectiveDate = null, // no active account, invalid check hold timeframe
                RecentClosedEffectiveDate = recentClosedDate, //oldest closed account date, invalid check hold timeframe
            }
        };
        _mockCoreApiWrapperService.Setup(x => x.GetAtmCheckHoldsForPersonNumbers(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<int>())).ReturnsAsync(listPersonCheckHoldsUserFields);

        var newCheckHoldRequest = new UpdatePersonForCheckHoldRequest();
        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.UpdatePersonForCheckHolds,
            DataCleanUpPayload = JsonConvert.SerializeObject(newCheckHoldRequest)
        };

        var dataCleanUpResult = await _updatePersonForAtmHoldsService.CleanUp(testRequest);
        var userValueResult = _updatePersonForAtmHoldsService.DeterminePersonUserFieldValue(listPersonCheckHoldsUserFields[0]);

        Assert.NotNull(dataCleanUpResult);
        Assert.AreEqual(testRequest, dataCleanUpResult.Request);
        Assert.IsTrue(userValueResult.Equals("Y"));
    }

    [Test] 
    public async Task CleanUpPersonAtmCheckHoldUpdate_NoActiveClosedValid_NoValue_Success() 
    {
        var assumedTimezone = TZConvert.GetTimeZoneInfo("America/Chicago");
        DateTime checkHoldDateToConvert = Convert.ToDateTime(DateTime.Now.AddDays(-28));
        var checkHoldDate = TimeZoneInfo.ConvertTime(checkHoldDateToConvert, assumedTimezone).Date;
        DateTime recentClosedDate = checkHoldDate.AddDays(0);

        var listPersonCheckHoldsUserFields = new List<PersonCheckHoldsUserField>()
        {
            new PersonCheckHoldsUserField()
            {
                PersonNumber = 1,
                UserFieldExists = true,
                OldestActiveEffectiveDate = null, //no active account date, invalid check hold timeframe
                RecentClosedEffectiveDate = recentClosedDate, //newer closed account date, valid check hold timeframe
            }
        };
        _mockCoreApiWrapperService.Setup(x => x.GetAtmCheckHoldsForPersonNumbers(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<int>())).ReturnsAsync(listPersonCheckHoldsUserFields);

        var newCheckHoldRequest = new UpdatePersonForCheckHoldRequest();
        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.UpdatePersonForCheckHolds,
            DataCleanUpPayload = JsonConvert.SerializeObject(newCheckHoldRequest)
        };

        var dataCleanUpResult = await _updatePersonForAtmHoldsService.CleanUp(testRequest);
        var userValueResult = _updatePersonForAtmHoldsService.DeterminePersonUserFieldValue(listPersonCheckHoldsUserFields[0]);

        Assert.NotNull(dataCleanUpResult);
        Assert.AreEqual(testRequest, dataCleanUpResult.Request);
        Assert.IsTrue(userValueResult.Equals("N"));
    }

    [Test] 
    public async Task CleanUpPersonAtmCheckHoldUpdate_NoClosedActiveValid_NoValue_Success() 
    {
        var assumedTimezone = TZConvert.GetTimeZoneInfo("America/Chicago");
        DateTime checkHoldDateToConvert = Convert.ToDateTime(DateTime.Now.AddDays(-29));
        var checkHoldDate = TimeZoneInfo.ConvertTime(checkHoldDateToConvert, assumedTimezone).Date;
        DateTime oldestActiveDate = checkHoldDate.AddDays(0);
     
        var listPersonCheckHoldsUserFields = new List<PersonCheckHoldsUserField>()
        {
            new PersonCheckHoldsUserField()
            {
                PersonNumber = 1,
                UserFieldExists = true,
                OldestActiveEffectiveDate = oldestActiveDate, //older active account date, valid check hold timeframe
                RecentClosedEffectiveDate = null, //no closed account date, invalid check hold timeframe
            }
        };
        _mockCoreApiWrapperService.Setup(x => x.GetAtmCheckHoldsForPersonNumbers(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<int>())).ReturnsAsync(listPersonCheckHoldsUserFields);

        var newCheckHoldRequest = new UpdatePersonForCheckHoldRequest();
        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.UpdatePersonForCheckHolds,
            DataCleanUpPayload = JsonConvert.SerializeObject(newCheckHoldRequest)
        };

        var dataCleanUpResult = await _updatePersonForAtmHoldsService.CleanUp(testRequest);
        var userValueResult = _updatePersonForAtmHoldsService.DeterminePersonUserFieldValue(listPersonCheckHoldsUserFields[0]);

        Assert.NotNull(dataCleanUpResult);
        Assert.AreEqual(testRequest, dataCleanUpResult.Request);
        Assert.IsTrue(userValueResult.Equals("N"));
    }

    [Test] 
    public async Task CleanUpPersonAtmCheckHoldUpdate_ActiveClosedValid_NoValue_Success()
    {
        var assumedTimezone = TZConvert.GetTimeZoneInfo("America/Chicago");
        DateTime checkHoldDateToConvert = Convert.ToDateTime(DateTime.Now.AddDays(-29));
        var checkHoldDate = TimeZoneInfo.ConvertTime(checkHoldDateToConvert, assumedTimezone).Date;
        DateTime oldestActiveDate = checkHoldDate.AddDays(0);
        DateTime newestClosedDate = checkHoldDate.AddDays(0);

        var listPersonCheckHoldsUserFields = new List<PersonCheckHoldsUserField>()
        {
            new PersonCheckHoldsUserField()
            {
                PersonNumber = 1,
                UserFieldExists = true,
                OldestActiveEffectiveDate = oldestActiveDate, //older active account date, valid check hold timeframe
                RecentClosedEffectiveDate = newestClosedDate, //newer closed account date, valid check hold timeframe
            }
        };
        _mockCoreApiWrapperService.Setup(x => x.GetAtmCheckHoldsForPersonNumbers(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<int>())).ReturnsAsync(listPersonCheckHoldsUserFields);

        var newCheckHoldRequest = new UpdatePersonForCheckHoldRequest();
        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.UpdatePersonForCheckHolds,
            DataCleanUpPayload = JsonConvert.SerializeObject(newCheckHoldRequest)
        };

        var dataCleanUpResult = await _updatePersonForAtmHoldsService.CleanUp(testRequest);
        var userValueResult = _updatePersonForAtmHoldsService.DeterminePersonUserFieldValue(listPersonCheckHoldsUserFields[0]);

        Assert.NotNull(dataCleanUpResult);
        Assert.AreEqual(testRequest, dataCleanUpResult.Request);
        Assert.IsTrue(userValueResult.Equals("N"));
    }

    [Test]
    public async Task CleanUpPersonAtmCheckHoldUpdate_ActiveInvalidClosedValid_NoValue_Success()
    {
        var assumedTimezone = TZConvert.GetTimeZoneInfo("America/Chicago");
        DateTime checkHoldDateToConvert = Convert.ToDateTime(DateTime.Now.AddDays(-28));
        var checkHoldDate = TimeZoneInfo.ConvertTime(checkHoldDateToConvert, assumedTimezone).Date;
        DateTime olderActiveDate = checkHoldDate.AddDays(28);
        DateTime recentClosedDate = checkHoldDate.AddDays(0);

        var listPersonCheckHoldsUserFields = new List<PersonCheckHoldsUserField>()
        {
            new PersonCheckHoldsUserField()
            {
                PersonNumber = 1,
                UserFieldExists = true,
                OldestActiveEffectiveDate = olderActiveDate, //more recent active account date, invalid check hold timeframe
                RecentClosedEffectiveDate = recentClosedDate, //newer closed account date, valid check hold timeframe
            }
        };
        _mockCoreApiWrapperService.Setup(x => x.GetAtmCheckHoldsForPersonNumbers(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<int>())).ReturnsAsync(listPersonCheckHoldsUserFields);

        var newCheckHoldRequest = new UpdatePersonForCheckHoldRequest();
        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.UpdatePersonForCheckHolds,
            DataCleanUpPayload = JsonConvert.SerializeObject(newCheckHoldRequest)
        };

        var dataCleanUpResult = await _updatePersonForAtmHoldsService.CleanUp(testRequest);
        var userValueResult = _updatePersonForAtmHoldsService.DeterminePersonUserFieldValue(listPersonCheckHoldsUserFields[0]);

        Assert.NotNull(dataCleanUpResult);
        Assert.AreEqual(testRequest, dataCleanUpResult.Request);
        Assert.IsTrue(userValueResult.Equals("N"));
    }

    [Test]
    public async Task CleanUpPersonAtmCheckHoldUpdate_ActiveValidClosedInValid_NoValue_Success()
    {
        var assumedTimezone = TZConvert.GetTimeZoneInfo("America/Chicago");
        DateTime checkHoldDateToConvert = Convert.ToDateTime(DateTime.Now.AddDays(-29));
        var checkHoldDate = TimeZoneInfo.ConvertTime(checkHoldDateToConvert, assumedTimezone).Date;
        DateTime olderActiveDate = checkHoldDate.AddDays(29);
        DateTime recentClosedDate = checkHoldDate.AddDays(29);

        var listPersonCheckHoldsUserFields = new List<PersonCheckHoldsUserField>()
        {
            new PersonCheckHoldsUserField()
            {
                PersonNumber = 1,
                UserFieldExists = true,
                OldestActiveEffectiveDate = olderActiveDate, //more recent active account date, valid check hold timeframe
                RecentClosedEffectiveDate = recentClosedDate, //newer closed account date, invalid check hold timeframe
            }
        };
        _mockCoreApiWrapperService.Setup(x => x.GetAtmCheckHoldsForPersonNumbers(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<int>())).ReturnsAsync(listPersonCheckHoldsUserFields);

        var newCheckHoldRequest = new UpdatePersonForCheckHoldRequest();
        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.UpdatePersonForCheckHolds,
            DataCleanUpPayload = JsonConvert.SerializeObject(newCheckHoldRequest)
        };

        var dataCleanUpResult = await _updatePersonForAtmHoldsService.CleanUp(testRequest);
        var userValueResult = _updatePersonForAtmHoldsService.DeterminePersonUserFieldValue(listPersonCheckHoldsUserFields[0]);

        Assert.NotNull(dataCleanUpResult);
        Assert.AreEqual(testRequest, dataCleanUpResult.Request);
        Assert.IsTrue(userValueResult.Equals("N"));
    }
}