monorepo/LCU.API.Internal.DocumentIngestor/LCU.API.Internal.DocumentIngestorTests/Services/MemberNotificationInfoDeterminingServices/MemberNotificationInfoDeterminingServiceTest.cs

using LCU.API.Internal.DocumentIngestor.Models.MemberPreferencesDtos;
using LCU.API.Internal.DocumentIngestor.Services;
using LCU.API.Internal.DocumentIngestor.Services.MemberNotificationInfoDeterminingServices;
using LCU.API.Internal.DocumentIngestor.Services.MicroApiServices;
using LCU.Library.Internal.DocumentIngestorModels.Entities;
using LCU.Library.Internal.DocumentIngestorModels.Enums;
using LCU.Library.Internal.Exceptions;
using Moq;
using NUnit.Framework;
using System;
using System.Threading.Tasks;
using LCU.Library.DocumentType.Extensions;

namespace LCU.API.Internal.DocumentIngestorTests.Services.MemberNotificationInfoDeterminingServices;

public class MemberNotificationInfoDeterminingServiceTest
{
	private MemberNotificationInfoDeterminingService _memberNotificationInfoDeterminingService;
	private Mock<IAccountNotificationInfoDeterminingService> _mockAccountNotificationInfoDeterminingService;
	private Mock<IPrimaryNotificationInfoDeterminingService> _mockPrimaryNotificationInfoDeterminingService;
	private Mock<IMemberNotificationInfoService> _mockMemberNotificationInfoService;
	private Mock<IMemberPreferencesApiService> _mockMemberPreferencesApiService;
	private Mock<IDocumentProcessingInfoService> _mockDocumentProcessingInfoService;

	[SetUp]
	public void Setup()
	{
		_mockAccountNotificationInfoDeterminingService = new Mock<IAccountNotificationInfoDeterminingService>();
		_mockPrimaryNotificationInfoDeterminingService = new Mock<IPrimaryNotificationInfoDeterminingService>();
		_mockMemberNotificationInfoService = new Mock<IMemberNotificationInfoService>();
		_mockMemberPreferencesApiService = new Mock<IMemberPreferencesApiService>();
		_mockDocumentProcessingInfoService = new Mock<IDocumentProcessingInfoService>();
		_memberNotificationInfoDeterminingService = new MemberNotificationInfoDeterminingService(_mockAccountNotificationInfoDeterminingService.Object,
																								 _mockPrimaryNotificationInfoDeterminingService.Object,
																								 _mockMemberNotificationInfoService.Object,
																								 _mockMemberPreferencesApiService.Object,
																								 _mockDocumentProcessingInfoService.Object);
	}

	[Test]
	public async Task DetermineDeliveryMethod_UniversalOptIn_NotNull()
	{
		var memberNotificationInfoId = 10;
		var documentProcessingInfoId = 1;
		var userId = "555";
		var memberNotificationInfo = new MemberNotificationInfo()
		{
			AgreeUserId = userId,
			MemberNotificationInfoId = memberNotificationInfoId,
			DocumentProcessingInfoId = documentProcessingInfoId,
			UploadDate = Convert.ToDateTime("1/1/2022")
		};

		var memberOptInSettings = new MemberOptInInformation()
		{
			MemberOptinSettings = new MemberOptInSettings()
			{
				UniversalOptIn = "Electronic",
				UnifiedOptInEmail = "[email protected]"
			}
		};

		var contact = (EmailAddress: "[email protected]", DeliveryMethod: DeliveryMethod.Electronic);

		_mockMemberPreferencesApiService.Setup(x => x.GetMemberOptInSettingsByUserId(userId)).ReturnsAsync(memberOptInSettings);

		var result = await _memberNotificationInfoDeterminingService.DetermineDeliveryMethod(memberNotificationInfo);
		Assert.IsNotNull(result);
		Assert.AreEqual(result.DeliveryMethod, contact.DeliveryMethod);
		Assert.AreEqual(result.EmailAddress, contact.EmailAddress);
		_mockMemberPreferencesApiService.Verify(x => x.GetMemberOptInSettingsByUserId(It.IsAny<string>()), Times.Once);
		_mockDocumentProcessingInfoService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Never);
	}

	[Test]
	public async Task DetermineDeliveryMethod_UniversalOptIn_UserIdNull()
	{
		var memberNotificationInfoId = 10;
		var documentProcessingInfoId = 1;
		var memberNotificationInfo = new MemberNotificationInfo()
		{
			MemberNotificationInfoId = memberNotificationInfoId,
			DocumentProcessingInfoId = documentProcessingInfoId,
			UploadDate = Convert.ToDateTime("1/1/2022")
		};

		var contact = (EmailAddress: "", DeliveryMethod: DeliveryMethod.Paper);

		var result = await _memberNotificationInfoDeterminingService.DetermineDeliveryMethod(memberNotificationInfo);
		Assert.IsNotNull(result);
		Assert.AreEqual(result.DeliveryMethod, contact.DeliveryMethod);
		Assert.AreEqual(result.EmailAddress, contact.EmailAddress);
		_mockMemberPreferencesApiService.Verify(x => x.GetMemberOptInSettingsByUserId(It.IsAny<string>()), Times.Never);
		_mockDocumentProcessingInfoService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Never);
	}

	[Test]
	public async Task DetermineDeliveryMethod_UniversalOptInNull_ENotification()
	{
		var memberNotificationInfoId = 10;
		var documentProcessingInfoId = 1;
		var userId = "555";
		var memberNotificationInfo = new MemberNotificationInfo()
		{
			AgreeUserId = userId,
			MemberNotificationInfoId = memberNotificationInfoId,
			DocumentProcessingInfoId = documentProcessingInfoId,
			UploadDate = Convert.ToDateTime("1/1/2022")
		};

		var memberOptInSettings = new MemberOptInInformation()
		{
			MemberOptinSettings = new MemberOptInSettings()
			{
				ENotifications = "Electronic",
				ENotificationsEmail = "[email protected]"
			}
		};

		var documentProcessingInfo = new DocumentProcessingInfo()
		{
			DocumentType = "1099-NEC"
		};

		var contact = (EmailAddress: "[email protected]", DeliveryMethod: DeliveryMethod.Electronic);

		_mockMemberPreferencesApiService.Setup(x => x.GetMemberOptInSettingsByUserId(userId)).ReturnsAsync(memberOptInSettings);
		_mockDocumentProcessingInfoService.Setup(x => x.GetByIdAsync(documentProcessingInfoId)).ReturnsAsync(documentProcessingInfo);

		var result = await _memberNotificationInfoDeterminingService.DetermineDeliveryMethod(memberNotificationInfo);
		Assert.IsNotNull(result);
		Assert.AreEqual(result.DeliveryMethod, contact.DeliveryMethod);
		Assert.AreEqual(result.EmailAddress, contact.EmailAddress);
		_mockMemberPreferencesApiService.Verify(x => x.GetMemberOptInSettingsByUserId(It.IsAny<string>()), Times.Once);
		_mockDocumentProcessingInfoService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Once);
	}

	[Test]
	public async Task DetermineDeliveryMethod_UniversalOptInNull_EStatements_DocTypeNotStatement()
	{
		var memberNotificationInfoId = 10;
		var documentProcessingInfoId = 1;
		var userId = "555";
		var memberNotificationInfo = new MemberNotificationInfo
		{
			AgreeUserId = userId,
			MemberNotificationInfoId = memberNotificationInfoId,
			DocumentProcessingInfoId = documentProcessingInfoId,
			UploadDate = Convert.ToDateTime("1/1/2022")
		};
		var memberOptInSettings = new MemberOptInInformation
		{
			MemberOptinSettings = new MemberOptInSettings
			{
				ENotifications = "Paper"
			}
		};
		var documentProcessingInfo = new DocumentProcessingInfo
		{
			DocumentType = "1099-NEC"
		};
		var contact = (EmailAddress: "", DeliveryMethod: DeliveryMethod.Paper);
		_mockMemberPreferencesApiService
			.Setup(x => x.GetMemberOptInSettingsByUserId(userId))
			.ReturnsAsync(memberOptInSettings);
		_mockDocumentProcessingInfoService
			.Setup(x => x.GetByIdAsync(documentProcessingInfoId))
			.ReturnsAsync(documentProcessingInfo);

		var result = await _memberNotificationInfoDeterminingService.DetermineDeliveryMethod(memberNotificationInfo);

		Assert.IsNotNull(result);
		Assert.AreEqual(result.DeliveryMethod, contact.DeliveryMethod);
		Assert.AreEqual(result.EmailAddress, contact.EmailAddress);
	}

	[Test]
	[TestCase("Paper", "Electronic")]
	[TestCase("Electronic", "Paper")]
	public async Task DetermineDeliveryMethod_StatementAndUniversalOptInNotNull_ReturnsUniversalOptInPreferences(string universalPreference, string statementPreference)
	{
		var documentProcessingInfoId = DateTime.Now.Millisecond;
		var userId = DateTime.Now.Millisecond.ToString();
		var memberNotificationInfo = new MemberNotificationInfo
		{
			AgreeUserId = userId,
			MemberNotificationInfoId = DateTime.Now.Millisecond,
			DocumentProcessingInfoId = documentProcessingInfoId,
			UploadDate = DateTime.Now
		};
		var memberOptInSettings = new MemberOptInInformation
		{
			MemberOptinSettings = new MemberOptInSettings
			{
				UniversalOptIn = universalPreference,
				UnifiedOptInEmail = Guid.NewGuid().ToString(),
				ENotifications = statementPreference,
				ENotificationsEmail = Guid.NewGuid().ToString()
			}
		};
		var documentProcessingInfo = new DocumentProcessingInfo();
		_mockMemberPreferencesApiService
			.Setup(x => x.GetMemberOptInSettingsByUserId(userId))
			.ReturnsAsync(memberOptInSettings);
		_mockDocumentProcessingInfoService
			.Setup(x => x.GetByIdAsync(documentProcessingInfoId))
			.ReturnsAsync(documentProcessingInfo);

		var result = await _memberNotificationInfoDeterminingService.DetermineDeliveryMethod(memberNotificationInfo);

		Assert.IsNotNull(result);
		Assert.AreEqual(result.DeliveryMethod, universalPreference.GetValueFromName<DeliveryMethod>());
		Assert.AreEqual(result.EmailAddress, universalPreference == "Paper" ? string.Empty : memberOptInSettings.MemberOptinSettings.UnifiedOptInEmail);
	}

	[Test]
	[TestCase("Paper")]
	[TestCase("Electronic")]
	public async Task DetermineDeliveryMethod_StatementAndUniversalOptInNull_ReturnsEStatementPreferences(string statementPreference)
	{
		var documentProcessingInfoId = DateTime.Now.Millisecond;
		var userId = DateTime.Now.Millisecond.ToString();
		var memberNotificationInfo = new MemberNotificationInfo
		{
			AgreeUserId = userId,
			MemberNotificationInfoId = DateTime.Now.Millisecond,
			DocumentProcessingInfoId = documentProcessingInfoId,
			UploadDate = DateTime.Now
		};
		var memberOptInSettings = new MemberOptInInformation
		{
			MemberOptinSettings = new MemberOptInSettings
			{
				UniversalOptIn = null!,
				EStatements = statementPreference,
				EStatementsEmail = Guid.NewGuid().ToString()
			}
		};
		var documentProcessingInfo = new DocumentProcessingInfo
		{
			DocumentType = "Statement"
		};
		_mockMemberPreferencesApiService
			.Setup(x => x.GetMemberOptInSettingsByUserId(userId))
			.ReturnsAsync(memberOptInSettings);
		_mockDocumentProcessingInfoService
			.Setup(x => x.GetByIdAsync(documentProcessingInfoId))
			.ReturnsAsync(documentProcessingInfo);

		var result = await _memberNotificationInfoDeterminingService.DetermineDeliveryMethod(memberNotificationInfo);

		Assert.IsNotNull(result);
		Assert.AreEqual(result.DeliveryMethod, statementPreference.GetValueFromName<DeliveryMethod>());
		Assert.AreEqual(result.EmailAddress, statementPreference == "Paper" ? string.Empty : memberOptInSettings.MemberOptinSettings.EStatementsEmail);
	}

	[Test]
	[TestCase("Paper", "Electronic")]
	[TestCase("Electronic", "Paper")]
	[TestCase("Electronic", "Electronic")]
	public async Task DetermineDeliveryMethod_StatementAndUniversalOptInNullAndENotificationNotNull_ReturnsEStatementPreferences(string statementPreference, string notificationPreference)
	{
		var documentProcessingInfoId = DateTime.Now.Millisecond;
		var userId = DateTime.Now.Millisecond.ToString();
		var memberNotificationInfo = new MemberNotificationInfo
		{
			AgreeUserId = userId,
			MemberNotificationInfoId = DateTime.Now.Millisecond,
			DocumentProcessingInfoId = documentProcessingInfoId,
			UploadDate = DateTime.Now
		};
		var memberOptInSettings = new MemberOptInInformation
		{
			MemberOptinSettings = new MemberOptInSettings
			{
				UniversalOptIn = null!,
				EStatements = statementPreference,
				EStatementsEmail = Guid.NewGuid().ToString(),
				ENotifications = notificationPreference,
				ENotificationsEmail = Guid.NewGuid().ToString()
			}
		};
		var documentProcessingInfo = new DocumentProcessingInfo
		{
			DocumentType = "Statement"
		};
		_mockMemberPreferencesApiService
			.Setup(x => x.GetMemberOptInSettingsByUserId(userId))
			.ReturnsAsync(memberOptInSettings);
		_mockDocumentProcessingInfoService
			.Setup(x => x.GetByIdAsync(documentProcessingInfoId))
			.ReturnsAsync(documentProcessingInfo);

		var result = await _memberNotificationInfoDeterminingService.DetermineDeliveryMethod(memberNotificationInfo);

		Assert.IsNotNull(result);
		Assert.AreEqual(result.DeliveryMethod, statementPreference.GetValueFromName<DeliveryMethod>());
		Assert.AreEqual(result.EmailAddress, statementPreference == "Paper" ? string.Empty : memberOptInSettings.MemberOptinSettings.EStatementsEmail);
	}

	[Test]
	public async Task DetermineDeliveryMethod_StatementAndAllPreferencesNull_ReturnsPaper()
	{
		var documentProcessingInfoId = DateTime.Now.Millisecond;
		var userId = DateTime.Now.Millisecond.ToString();
		var memberNotificationInfo = new MemberNotificationInfo
		{
			AgreeUserId = userId,
			MemberNotificationInfoId = DateTime.Now.Millisecond,
			DocumentProcessingInfoId = documentProcessingInfoId,
			UploadDate = DateTime.Now
		};
		var memberOptInSettings = new MemberOptInInformation
		{
			MemberOptinSettings = new MemberOptInSettings
			{
				UniversalOptIn = null!,
				ENotifications = null!,
				EStatements = null!
			}
		};
		var documentProcessingInfo = new DocumentProcessingInfo
		{
			DocumentType = "Statement"
		};
		_mockMemberPreferencesApiService
			.Setup(x => x.GetMemberOptInSettingsByUserId(userId))
			.ReturnsAsync(memberOptInSettings);
		_mockDocumentProcessingInfoService
			.Setup(x => x.GetByIdAsync(documentProcessingInfoId))
			.ReturnsAsync(documentProcessingInfo);

		var result = await _memberNotificationInfoDeterminingService.DetermineDeliveryMethod(memberNotificationInfo);

		Assert.IsNotNull(result);
		Assert.AreEqual(result.DeliveryMethod, "Paper".GetValueFromName<DeliveryMethod>());
		Assert.AreEqual(result.EmailAddress, string.Empty);
	}

	[Test]
	public async Task DetermineDeliveryMethod_NotStatementAndAllPreferencesNull_ReturnsPaper()
	{
		var documentProcessingInfoId = DateTime.Now.Millisecond;
		var userId = DateTime.Now.Millisecond.ToString();
		var memberNotificationInfo = new MemberNotificationInfo
		{
			AgreeUserId = userId,
			MemberNotificationInfoId = DateTime.Now.Millisecond,
			DocumentProcessingInfoId = documentProcessingInfoId,
			UploadDate = DateTime.Now
		};
		var memberOptInSettings = new MemberOptInInformation
		{
			MemberOptinSettings = new MemberOptInSettings
			{
				UniversalOptIn = null!,
				ENotifications = null!,
				EStatements = null!
			}
		};
		var documentProcessingInfo = new DocumentProcessingInfo();
		_mockMemberPreferencesApiService
			.Setup(x => x.GetMemberOptInSettingsByUserId(userId))
			.ReturnsAsync(memberOptInSettings);
		_mockDocumentProcessingInfoService
			.Setup(x => x.GetByIdAsync(documentProcessingInfoId))
			.ReturnsAsync(documentProcessingInfo);

		var result = await _memberNotificationInfoDeterminingService.DetermineDeliveryMethod(memberNotificationInfo);

		Assert.IsNotNull(result);
		Assert.AreEqual(result.DeliveryMethod, "Paper".GetValueFromName<DeliveryMethod>());
		Assert.AreEqual(result.EmailAddress, string.Empty);
	}

	[Test]
	public void DetermineDeliveryMethod_Exception()
	{
		var memberNotificationInfo = new MemberNotificationInfo() { AgreeUserId = "1111" };
		_mockMemberPreferencesApiService.Setup(x => x.GetMemberOptInSettingsByUserId(memberNotificationInfo.AgreeUserId)).Throws(new Exception("Error"));

		Assert.ThrowsAsync<ServiceException>(async () => await _memberNotificationInfoDeterminingService.DetermineDeliveryMethod(memberNotificationInfo));
		_mockMemberPreferencesApiService.Verify(x => x.GetMemberOptInSettingsByUserId(It.IsAny<string>()), Times.Once);
		_mockDocumentProcessingInfoService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Never);
	}
}