1006 lines
40 KiB
C#
1006 lines
40 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using LCU.API.Internal.DocumentIngestor.Services.AttributeDeterminingServices;
|
|
using LCU.API.Internal.DocumentIngestor.Services.MicroApiServices;
|
|
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Accounts;
|
|
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Agreements;
|
|
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Mixed;
|
|
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Tax;
|
|
using LCU.Library.Internal.DocumentIngestorModels.Entities;
|
|
using LCU.Library.Internal.DocumentIngestorModels.Enums;
|
|
using LCU.Library.Internal.Exceptions;
|
|
using Moq;
|
|
using NUnit.Framework;
|
|
|
|
namespace LCU.API.Internal.DocumentIngestorTests.Services.AttributeDeterminingServices;
|
|
|
|
public class PrimaryOwnerDeterminingServiceTest
|
|
{
|
|
private PrimaryOwnerDeterminingService _primaryOwnerDeterminingService;
|
|
private Mock<ICoreApiWrapperService> _mockCoreApiWrapperService;
|
|
|
|
[SetUp]
|
|
public void Setup()
|
|
{
|
|
_mockCoreApiWrapperService = new Mock<ICoreApiWrapperService>();
|
|
_primaryOwnerDeterminingService = new PrimaryOwnerDeterminingService(_mockCoreApiWrapperService.Object);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttribute_PersonNumberFound_Success()
|
|
{
|
|
var taxId = "123245";
|
|
var fullName = "Tester Unit";
|
|
var accountNumber = "9999";
|
|
var personsTaxIdData = new List<PersonTaxIdDataResponse>
|
|
{
|
|
new()
|
|
{
|
|
PersonNumber = 1,
|
|
NameLastFirstMiddleSuffix = fullName,
|
|
}
|
|
};
|
|
_mockCoreApiWrapperService.Setup(x => x.GetPersonsTaxIdData(taxId)).ReturnsAsync(personsTaxIdData);
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, taxId, null);
|
|
var resultPayload = result.Payload;
|
|
Assert.True(result.Success);
|
|
Assert.AreEqual("1", resultPayload.PersonNumber);
|
|
Assert.IsNull(resultPayload.OrganizationNumber);
|
|
Assert.AreEqual(accountNumber, resultPayload.AccountNumber);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetPersonsTaxIdData(It.IsAny<string>()), Times.Once);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetOrganizationsTaxIdData(It.IsAny<string>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttribute_PersonNumberNotFound_OrganizationFound_Success()
|
|
{
|
|
var taxId = "123245";
|
|
var fullName = "Tester UnitOrg";
|
|
var accountNumber = "9999";
|
|
var personsTaxIdData = new List<PersonTaxIdDataResponse>();
|
|
_mockCoreApiWrapperService.Setup(x => x.GetPersonsTaxIdData(taxId)).ReturnsAsync(personsTaxIdData);
|
|
|
|
var organizationTaxIdData = new List<OrganizationTaxIdDataResponse>
|
|
{
|
|
new()
|
|
{
|
|
OrganizationNumber = 2,
|
|
Name = fullName
|
|
}
|
|
};
|
|
_mockCoreApiWrapperService.Setup(x => x.GetOrganizationsTaxIdData(taxId)).ReturnsAsync(organizationTaxIdData);
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, taxId, null);
|
|
var resultPayload = result.Payload;
|
|
Assert.True(result.Success);
|
|
Assert.AreEqual("2", resultPayload.OrganizationNumber);
|
|
Assert.IsNull(resultPayload.PersonNumber);
|
|
Assert.AreEqual(accountNumber, resultPayload.AccountNumber);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetPersonsTaxIdData(It.IsAny<string>()), Times.Once);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetOrganizationsTaxIdData(It.IsAny<string>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttribute_PersonNumberNotFound_OrganizationNotFound_Failure()
|
|
{
|
|
var taxId = "123245";
|
|
var fullName = "Tester UnitOrg";
|
|
var accountNumber = "9999";
|
|
var personsTaxIdData = new List<PersonTaxIdDataResponse>();
|
|
_mockCoreApiWrapperService.Setup(x => x.GetPersonsTaxIdData(taxId)).ReturnsAsync(personsTaxIdData);
|
|
|
|
var organizationTaxIdData = new List<OrganizationTaxIdDataResponse>();
|
|
_mockCoreApiWrapperService.Setup(x => x.GetOrganizationsTaxIdData(taxId)).ReturnsAsync(organizationTaxIdData);
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, taxId, null);
|
|
var resultPayload = result.Payload;
|
|
Assert.IsFalse(result.Success);
|
|
Assert.IsNull(resultPayload.OrganizationNumber);
|
|
Assert.IsNull(resultPayload.PersonNumber);
|
|
Assert.AreEqual(accountNumber, resultPayload.AccountNumber);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetPersonsTaxIdData(It.IsAny<string>()), Times.Once);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetOrganizationsTaxIdData(It.IsAny<string>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttribute_PersonNumberNotFound_FullNameNoMatch_Failure()
|
|
{
|
|
var taxId = "123245";
|
|
var fullName = "Tester Unit";
|
|
var accountNumber = "9999";
|
|
var personsTaxIdData = new List<PersonTaxIdDataResponse>
|
|
{
|
|
new()
|
|
{
|
|
PersonNumber = 1,
|
|
NameLastFirstMiddleSuffix = "Tester Unit Nope",
|
|
}
|
|
};
|
|
_mockCoreApiWrapperService.Setup(x => x.GetPersonsTaxIdData(taxId)).ReturnsAsync(personsTaxIdData);
|
|
|
|
var organizationTaxIdData = new List<OrganizationTaxIdDataResponse>();
|
|
_mockCoreApiWrapperService.Setup(x => x.GetOrganizationsTaxIdData(taxId)).ReturnsAsync(organizationTaxIdData);
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, taxId, null);
|
|
var resultPayload = result.Payload;
|
|
Assert.IsFalse(result.Success);
|
|
Assert.IsNull(resultPayload.OrganizationNumber);
|
|
Assert.IsNull(resultPayload.PersonNumber);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetPersonsTaxIdData(It.IsAny<string>()), Times.Once);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetOrganizationsTaxIdData(It.IsAny<string>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttribute_PersonNumberNotFound_FullNameNoMatch_MessageContainsPersonTaxData()
|
|
{
|
|
const string taxId = nameof(taxId);
|
|
var personNumbers = new Random(DateTime.Now.Millisecond);
|
|
var personsTaxIdData = Enumerable.Repeat
|
|
(
|
|
() => new PersonTaxIdDataResponse
|
|
{
|
|
PersonNumber = personNumbers.Next(),
|
|
NameLastFirstMiddleSuffix = Guid.NewGuid().ToString(),
|
|
FirstName = Guid.NewGuid().ToString(),
|
|
MiddleName = Guid.NewGuid().ToString(),
|
|
LastName = Guid.NewGuid().ToString()
|
|
},
|
|
5
|
|
)
|
|
.Select(f => f())
|
|
.ToArray();
|
|
_mockCoreApiWrapperService.Setup(x => x.GetPersonsTaxIdData(taxId)).ReturnsAsync(personsTaxIdData);
|
|
_mockCoreApiWrapperService.Setup(x => x.GetOrganizationsTaxIdData(taxId)).ReturnsAsync(Enumerable.Empty<OrganizationTaxIdDataResponse>());
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), taxId, null!);
|
|
|
|
var message = result.Message;
|
|
Assert.IsNotNull(message);
|
|
var personMessages = message!.Split("Person Detail:");
|
|
foreach (var person in personsTaxIdData)
|
|
{
|
|
var personsMessages = personMessages
|
|
.Where(o => o.Contains(person.PersonNumber.ToString()))
|
|
.ToArray();
|
|
Assert.AreEqual(1, personsMessages.Length);
|
|
var personMessage = personsMessages.Single();
|
|
StringAssert.Contains(person.FirstName, personMessage);
|
|
StringAssert.Contains(person.MiddleName, personMessage);
|
|
StringAssert.Contains(person.LastName, personMessage);
|
|
if (Array.IndexOf(personMessages, personMessage) != personMessages.Length - 1)
|
|
{
|
|
StringAssert.EndsWith(" ", personMessage);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttribute_OrganizationNotFound_FullNameNoMatch_Failure()
|
|
{
|
|
var taxId = "123245";
|
|
var fullName = "Tester UnitOrg";
|
|
var accountNumber = "9999";
|
|
var personsTaxIdData = new List<PersonTaxIdDataResponse>();
|
|
_mockCoreApiWrapperService.Setup(x => x.GetPersonsTaxIdData(taxId)).ReturnsAsync(personsTaxIdData);
|
|
|
|
var organizationTaxIdData = new List<OrganizationTaxIdDataResponse>
|
|
{
|
|
new()
|
|
{
|
|
OrganizationNumber = 2,
|
|
Name = "Tester UnitOrg Nope"
|
|
}
|
|
};
|
|
_mockCoreApiWrapperService.Setup(x => x.GetOrganizationsTaxIdData(taxId)).ReturnsAsync(organizationTaxIdData);
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, taxId, null);
|
|
var resultPayload = result.Payload;
|
|
Assert.IsFalse(result.Success);
|
|
Assert.IsNull(resultPayload.OrganizationNumber);
|
|
Assert.IsNull(resultPayload.PersonNumber);
|
|
Assert.AreEqual(accountNumber, resultPayload.AccountNumber);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetPersonsTaxIdData(It.IsAny<string>()), Times.Once);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetOrganizationsTaxIdData(It.IsAny<string>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttribute_OrganizationNotFound_FullNameNoMatch_MessageContainsOrganziationTaxData()
|
|
{
|
|
const string taxId = nameof(taxId);
|
|
var organizationNumbers = new Random(DateTime.Now.Millisecond);
|
|
var organizationTaxIdData = Enumerable.Repeat
|
|
(
|
|
() => new OrganizationTaxIdDataResponse
|
|
{
|
|
OrganizationNumber = organizationNumbers.Next(),
|
|
Name = Guid.NewGuid().ToString()
|
|
},
|
|
5
|
|
)
|
|
.Select(f => f())
|
|
.ToArray();
|
|
_mockCoreApiWrapperService.Setup(x => x.GetPersonsTaxIdData(taxId)).ReturnsAsync(Enumerable.Empty<PersonTaxIdDataResponse>());
|
|
_mockCoreApiWrapperService.Setup(x => x.GetOrganizationsTaxIdData(taxId)).ReturnsAsync(organizationTaxIdData);
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), taxId, null!);
|
|
|
|
var message = result.Message;
|
|
Assert.IsNotNull(message);
|
|
var organizationMessages = message!.Split("Organization Detail:");
|
|
foreach (var organization in organizationTaxIdData)
|
|
{
|
|
var organizationsMessages = organizationMessages
|
|
.Where(o => o.Contains(organization.Name))
|
|
.ToArray();
|
|
Assert.AreEqual(1, organizationsMessages.Length);
|
|
var organizationMessage = organizationsMessages.Single();
|
|
StringAssert.Contains(organization.OrganizationNumber.ToString(), organizationMessage);
|
|
if (Array.IndexOf(organizationMessages, organizationMessage) != organizationMessages.Length - 1)
|
|
{
|
|
StringAssert.EndsWith(" ", organizationMessage);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttribute_PersonFound_Success()
|
|
{
|
|
var fullName = "Bill B Billson";
|
|
var accountNumber = "9999";
|
|
var creationDate = new DateTime(2022, 01, 01);
|
|
var accountOwnership = new List<AccountOwnership>
|
|
{
|
|
new()
|
|
{
|
|
PersonNumber = 1,
|
|
FirstName = "Bill",
|
|
MiddleInitial = "B",
|
|
LastName = "Billson",
|
|
IsPrimaryOwner = true
|
|
}
|
|
};
|
|
_mockCoreApiWrapperService.Setup(x => x.GetOwnersByAccountNumber(accountNumber, creationDate.ToShortDateString())).ReturnsAsync(accountOwnership);
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, creationDate, null);
|
|
var resultPayload = result.Payload;
|
|
Assert.True(result.Success);
|
|
Assert.AreEqual("1", resultPayload.PersonNumber);
|
|
Assert.IsNull(resultPayload.OrganizationNumber);
|
|
Assert.AreEqual(accountNumber, resultPayload.AccountNumber);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetOwnersByAccountNumber(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetOwnersByPersonName(It.IsAny<string>()), Times.Never);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetOwnersByOrganizationName(It.IsAny<string>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttribute_PersonNumberNotFound_OrganizationNumberFound_Success()
|
|
{
|
|
var orgName = "The Big Company";
|
|
var accountNumber = "9999";
|
|
var creationDate = new DateTime(2022, 01, 01);
|
|
|
|
var accountOwnership = new List<AccountOwnership>
|
|
{
|
|
new()
|
|
{
|
|
ByOrgNbr = 2,
|
|
OrganizationName = orgName,
|
|
IsPrimaryOwner = true
|
|
}
|
|
};
|
|
_mockCoreApiWrapperService.Setup(x => x.GetOwnersByAccountNumber(accountNumber, creationDate.ToShortDateString())).ReturnsAsync(accountOwnership);
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(orgName, accountNumber, creationDate, null);
|
|
var resultPayload = result.Payload;
|
|
Assert.True(result.Success);
|
|
Assert.AreEqual("2", resultPayload.OrganizationNumber);
|
|
Assert.IsNull(resultPayload.PersonNumber);
|
|
Assert.AreEqual(accountNumber, resultPayload.AccountNumber);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetOwnersByAccountNumber(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
|
|
}
|
|
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttribute_EntityNameDoesNotMatch_Failure()
|
|
{
|
|
var fullName = "Bill B Billson";
|
|
var accountNumber = "9999";
|
|
var creationDate = new DateTime(2022, 01, 01);
|
|
|
|
var accountOwnership = new List<AccountOwnership>
|
|
{
|
|
new()
|
|
{
|
|
ByOrgNbr = 2,
|
|
FirstName = "Pete",
|
|
MiddleInitial = "P",
|
|
LastName = "Peterson",
|
|
IsPrimaryOwner = true
|
|
}
|
|
};
|
|
_mockCoreApiWrapperService.Setup(x => x.GetOwnersByAccountNumber(accountNumber, creationDate.ToShortDateString())).ReturnsAsync(accountOwnership);
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, creationDate, null);
|
|
var resultPayload = result.Payload;
|
|
Assert.IsFalse(result.Success);
|
|
Assert.IsNull(resultPayload.OrganizationNumber);
|
|
Assert.IsNull(resultPayload.PersonNumber);
|
|
Assert.AreEqual(accountNumber, resultPayload.AccountNumber);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetOwnersByAccountNumber(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttribute_PersonNumberNotFound_OrganizationNumberNotFound_Failure()
|
|
{
|
|
var fullName = "Bill B Billson";
|
|
var accountNumber = "9999";
|
|
var creationDate = new DateTime(2022, 01, 01);
|
|
var accountOwnership = new List<AccountOwnership>();
|
|
_mockCoreApiWrapperService.Setup(x => x.GetOwnersByAccountNumber(accountNumber, creationDate.ToShortDateString())).ReturnsAsync(accountOwnership);
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, creationDate, null);
|
|
var resultPayload = result.Payload;
|
|
Assert.IsFalse(result.Success);
|
|
Assert.IsNull(resultPayload.OrganizationNumber);
|
|
Assert.IsNull(resultPayload.PersonNumber);
|
|
Assert.AreEqual(accountNumber, resultPayload.AccountNumber);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetOwnersByAccountNumber(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttribute_TooManyOwners_Failure()
|
|
{
|
|
var fullName = "Bill B Billson";
|
|
var accountNumber = Guid.NewGuid().ToString();
|
|
var creationDate = new DateTime(2022, 01, 01);
|
|
var accountOwnership = new List<AccountOwnership>
|
|
{
|
|
new()
|
|
{
|
|
PersonNumber = 2,
|
|
FirstName = "Bill",
|
|
MiddleInitial = "B",
|
|
LastName = "Billson",
|
|
IsPrimaryOwner = true
|
|
},
|
|
new()
|
|
{
|
|
PersonNumber = 5,
|
|
FirstName = "Bill",
|
|
MiddleInitial = "B",
|
|
LastName = "Billson",
|
|
IsPrimaryOwner = true
|
|
}
|
|
};
|
|
_mockCoreApiWrapperService.Setup(x => x.GetOwnersByAccountNumber(accountNumber, creationDate.ToShortDateString())).ReturnsAsync(accountOwnership);
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, creationDate, null);
|
|
var resultPayload = result.Payload;
|
|
Assert.IsFalse(result.Success);
|
|
Assert.IsNull(result.EntityIsUnknown);
|
|
Assert.IsNull(resultPayload.OrganizationNumber);
|
|
Assert.IsNull(resultPayload.PersonNumber);
|
|
Assert.IsNotNull(resultPayload.AccountNumber);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetOwnersByPersonName(It.IsAny<string>()), Times.Never);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetOwnersByOrganizationName(It.IsAny<string>()), Times.Never);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetOwnersByAccountNumber(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttribute_NoPrimaryOwner_Failure()
|
|
{
|
|
var fullName = "Bill B Billson";
|
|
var creationDate = new DateTime(2022, 01, 01);
|
|
var accountNumber = "5";
|
|
var accountOwnership = new List<AccountOwnership>
|
|
{
|
|
new()
|
|
{
|
|
PersonNumber = 2,
|
|
FirstName = "Bill",
|
|
MiddleInitial = "B",
|
|
LastName = "Billson",
|
|
IsPrimaryOwner = false
|
|
}
|
|
};
|
|
_mockCoreApiWrapperService.Setup(x => x.GetOwnersByPersonName(fullName)).ReturnsAsync(accountOwnership);
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, creationDate, null);
|
|
var resultPayload = result.Payload;
|
|
Assert.IsFalse(result.Success);
|
|
Assert.IsNull(resultPayload.OrganizationNumber);
|
|
Assert.IsNull(resultPayload.PersonNumber);
|
|
Assert.AreEqual(accountNumber, resultPayload.AccountNumber);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetOwnersByPersonName(It.IsAny<string>()), Times.Never);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetOwnersByOrganizationName(It.IsAny<string>()), Times.Never);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetOwnersByAccountNumber(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttribute_OwnerOverridePerson_Success()
|
|
{
|
|
var taxId = "123245";
|
|
var fullName = "Tester Unit";
|
|
var accountNumber = "9999";
|
|
var documentProcessingInfoId = 123;
|
|
var personsTaxIdData = new List<PersonTaxIdDataResponse>
|
|
{
|
|
new()
|
|
{
|
|
PersonNumber = 1,
|
|
NameLastFirstMiddleSuffix = fullName,
|
|
}
|
|
};
|
|
var ownerOverride = new OwnerOverrideInfo()
|
|
{
|
|
DocumentProcessingInfoId = documentProcessingInfoId,
|
|
UserName = "Test Tester",
|
|
EntityId = "888888",
|
|
EntityType = EntityTypes.Person
|
|
};
|
|
_mockCoreApiWrapperService.Setup(x => x.GetPersonsTaxIdData(taxId)).ReturnsAsync(personsTaxIdData);
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, taxId, ownerOverride);
|
|
var resultPayload = result.Payload;
|
|
Assert.True(result.Success);
|
|
Assert.AreEqual("888888", resultPayload.PersonNumber);
|
|
Assert.IsNull(resultPayload.OrganizationNumber);
|
|
Assert.AreEqual(accountNumber, resultPayload.AccountNumber);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetPersonsTaxIdData(It.IsAny<string>()), Times.Never);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetOrganizationsTaxIdData(It.IsAny<string>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttribute_OwnerOverrideOrganization_Success()
|
|
{
|
|
var taxId = "123245";
|
|
var fullName = "Tester Unit";
|
|
var documentProcessingInfoId = 123;
|
|
var accountNumber = "9999";
|
|
var personsTaxIdData = new List<OrganizationTaxIdDataResponse>
|
|
{
|
|
new()
|
|
{
|
|
OrganizationNumber = 1,
|
|
Name = fullName,
|
|
}
|
|
};
|
|
var ownerOverride = new OwnerOverrideInfo()
|
|
{
|
|
DocumentProcessingInfoId = documentProcessingInfoId,
|
|
UserName = "Test Tester",
|
|
EntityId = "888888",
|
|
EntityType = EntityTypes.Organization
|
|
};
|
|
_mockCoreApiWrapperService.Setup(x => x.GetOrganizationsTaxIdData(taxId)).ReturnsAsync(personsTaxIdData);
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, taxId, ownerOverride);
|
|
var resultPayload = result.Payload;
|
|
Assert.True(result.Success);
|
|
Assert.AreEqual("888888", resultPayload.OrganizationNumber);
|
|
Assert.IsNull(resultPayload.PersonNumber);
|
|
Assert.AreEqual(accountNumber, resultPayload.AccountNumber);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetPersonsTaxIdData(It.IsAny<string>()), Times.Never);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetOrganizationsTaxIdData(It.IsAny<string>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttribute_OwnerOverrideUnknown_Success()
|
|
{
|
|
var taxId = "123245";
|
|
var fullName = "Tester Unit";
|
|
var accountNumber = "9999";
|
|
var documentProcessingInfoId = 123;
|
|
var personsTaxIdData = new List<PersonTaxIdDataResponse>
|
|
{
|
|
new()
|
|
{
|
|
PersonNumber = 1,
|
|
NameLastFirstMiddleSuffix = fullName,
|
|
}
|
|
};
|
|
var ownerOverride = new OwnerOverrideInfo()
|
|
{
|
|
DocumentProcessingInfoId = documentProcessingInfoId,
|
|
UserName = "Test Tester",
|
|
EntityId = "888888",
|
|
EntityType = EntityTypes.Unknown
|
|
};
|
|
_mockCoreApiWrapperService.Setup(x => x.GetPersonsTaxIdData(taxId)).ReturnsAsync(personsTaxIdData);
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, taxId, ownerOverride);
|
|
var resultPayload = result.Payload;
|
|
Assert.True(result.Success);
|
|
Assert.IsNull(resultPayload.PersonNumber);
|
|
Assert.IsNull(resultPayload.OrganizationNumber);
|
|
Assert.AreEqual(accountNumber, resultPayload.AccountNumber);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetPersonsTaxIdData(It.IsAny<string>()), Times.Never);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetOrganizationsTaxIdData(It.IsAny<string>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_PersonNumberFound_Success()
|
|
{
|
|
var memberNumberOrUserId = "M1234";
|
|
var accountNumber = "9999";
|
|
var docType = "LVI_LT_106_01";
|
|
var creationDate = new DateTime(2022, 01, 01);
|
|
|
|
var personOrganization = new PersonOrganization()
|
|
{
|
|
PersonNumber = "1",
|
|
OrganizationNumber = null
|
|
};
|
|
|
|
_mockCoreApiWrapperService.Setup(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>())).ReturnsAsync(personOrganization).Verifiable();
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId, accountNumber, docType, creationDate, null);
|
|
var resultPayload = result.Payload;
|
|
|
|
Assert.True(result.Success);
|
|
Assert.AreEqual("1", resultPayload.PersonNumber);
|
|
Assert.AreEqual(null, resultPayload.OrganizationNumber);
|
|
Assert.AreEqual("9999", resultPayload.AccountNumber);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>()), Times.Once);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_OrganizationFound_Success()
|
|
{
|
|
var memberNumberOrUserId = "M1234";
|
|
var accountNumber = "9999";
|
|
var docType = "LVI_LT_106_01";
|
|
var creationDate = new DateTime(2022, 01, 01);
|
|
|
|
var personOrganization = new PersonOrganization()
|
|
{
|
|
PersonNumber = null,
|
|
OrganizationNumber = "123"
|
|
};
|
|
|
|
_mockCoreApiWrapperService.Setup(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>())).ReturnsAsync(personOrganization).Verifiable();
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId, accountNumber, docType, creationDate, null);
|
|
var resultPayload = result.Payload;
|
|
|
|
Assert.True(result.Success);
|
|
Assert.AreEqual(null, resultPayload.PersonNumber);
|
|
Assert.AreEqual("123", resultPayload.OrganizationNumber);
|
|
Assert.AreEqual("9999", resultPayload.AccountNumber);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>()), Times.Once);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_AgreementFound_Success()
|
|
{
|
|
var memberNumberOrUserId = "1234";
|
|
var accountNumber = "9999";
|
|
var docType = "LVI_LT_106_01";
|
|
var creationDate = new DateTime(2022, 01, 01);
|
|
|
|
var agreement = new Agreement()
|
|
{
|
|
AgreementNumber = 123,
|
|
ByOrgNbr = 0,
|
|
FirstName = "Bill",
|
|
MiddleInitial = "B",
|
|
LastName = "Billson",
|
|
PersonNumber = 1234
|
|
};
|
|
|
|
_mockCoreApiWrapperService.Setup(x => x.GetAgreementByUserId(It.IsAny<string>())).ReturnsAsync(agreement);
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId, accountNumber, docType, creationDate, null);
|
|
var resultPayload = result.Payload;
|
|
|
|
Assert.True(result.Success);
|
|
Assert.AreEqual("1234", resultPayload.PersonNumber);
|
|
Assert.AreEqual(null, resultPayload.OrganizationNumber);
|
|
Assert.AreEqual("9999", resultPayload.AccountNumber);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetAgreementAccountByAccountId(It.IsAny<string>()), Times.Never);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_AgreementMmStmxtFound_Success()
|
|
{
|
|
var memberNumberOrUserId = "1234";
|
|
var accountNumber = "9999";
|
|
var docType = "MM_STMXT";
|
|
var creationDate = new DateTime(2022, 01, 01);
|
|
|
|
var agreement = new Agreement()
|
|
{
|
|
AgreementNumber = 123,
|
|
ByOrgNbr = 0,
|
|
FirstName = "Bill",
|
|
MiddleInitial = "B",
|
|
LastName = "Billson",
|
|
PersonNumber = 1234
|
|
};
|
|
|
|
var agreementAccount = new AgreementAccount()
|
|
{
|
|
AccountNumber = 9999,
|
|
AccountDescription = "PREMIUM CHECKING",
|
|
MajorAccountTypeCode = "CK",
|
|
TaxReportForPersonNumber = 1234,
|
|
TaxReportForOrgNumber = null,
|
|
OvrDeliveryMethCD = "PRNT",
|
|
AccountOwner = new AgreementAccountOwner
|
|
{
|
|
AccountNumber = 9999,
|
|
AgreementNumber = 0,
|
|
UserId = null,
|
|
PersonNumber = 0
|
|
}
|
|
};
|
|
|
|
var personOrganization = new PersonOrganization()
|
|
{
|
|
PersonNumber = "1234",
|
|
OrganizationNumber = null
|
|
};
|
|
|
|
_mockCoreApiWrapperService.Setup(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>())).ReturnsAsync(personOrganization).Verifiable();
|
|
_mockCoreApiWrapperService.Setup(x => x.GetAgreementAccountByAccountId(It.IsAny<string>())).ReturnsAsync(agreementAccount);
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId, accountNumber, docType, creationDate, null);
|
|
var resultPayload = result.Payload;
|
|
|
|
Assert.True(result.Success);
|
|
Assert.AreEqual("1234", resultPayload.PersonNumber);
|
|
Assert.AreEqual(null, resultPayload.OrganizationNumber);
|
|
Assert.AreEqual("9999", resultPayload.AccountNumber);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetAgreementAccountByAccountId(It.IsAny<string>()), Times.Once);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_PersonNotFound_OrganizationNotFound_Failure()
|
|
{
|
|
var memberNumberOrUserId = "M1234";
|
|
var accountNumber = "9999";
|
|
var docType = "LVI_LT_106_01";
|
|
var creationDate = new DateTime(2022, 01, 01);
|
|
var accountOwnership = new List<AccountOwnership>
|
|
{
|
|
new()
|
|
{
|
|
PersonNumber = 1,
|
|
FirstName = "Bill",
|
|
MiddleInitial = "B",
|
|
LastName = "Billson",
|
|
IsPrimaryOwner = true
|
|
}
|
|
};
|
|
|
|
var personOrganization = new PersonOrganization()
|
|
{
|
|
PersonNumber = null,
|
|
OrganizationNumber = null
|
|
};
|
|
|
|
_mockCoreApiWrapperService.Setup(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>())).ReturnsAsync(personOrganization).Verifiable();
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId, accountNumber, docType, creationDate, null);
|
|
var resultPayload = result.Payload;
|
|
|
|
Assert.IsFalse(result.Success);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetOwnersByAccountNumber(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>()), Times.Once);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_AgreementNotFound_Failure()
|
|
{
|
|
var memberNumberOrUserId = "1234";
|
|
var accountNumber = "9999";
|
|
var docType = "LVI_LT_106_01";
|
|
var creationDate = new DateTime(2022, 01, 01);
|
|
var accountOwnership = new List<AccountOwnership>
|
|
{
|
|
new()
|
|
{
|
|
PersonNumber = 1,
|
|
FirstName = "Bill",
|
|
MiddleInitial = "B",
|
|
LastName = "Billson",
|
|
IsPrimaryOwner = true
|
|
}
|
|
};
|
|
|
|
_mockCoreApiWrapperService.Setup(x => x.GetOwnersByAccountNumber(accountNumber, creationDate.ToShortDateString())).ReturnsAsync(accountOwnership);
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId, accountNumber, docType, creationDate, null);
|
|
var resultPayload = result.Payload;
|
|
|
|
Assert.IsFalse(result.Success);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetOwnersByAccountNumber(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_PersonNumberDoesNotMatch_MM_STMXT_Failure()
|
|
{
|
|
|
|
var memberNumberOrUserId = "M1234";
|
|
var accountNumber = "9999";
|
|
var docType = "MM_STMXT";
|
|
var creationDate = new DateTime(2022, 01, 01);
|
|
var accountOwnership = new List<AccountOwnership>
|
|
{
|
|
new()
|
|
{
|
|
PersonNumber = 1,
|
|
FirstName = "Bill",
|
|
MiddleInitial = "B",
|
|
LastName = "Billson",
|
|
IsPrimaryOwner = true
|
|
}
|
|
};
|
|
|
|
var personOrganization = new PersonOrganization()
|
|
{
|
|
PersonNumber = "2",
|
|
OrganizationNumber = null
|
|
};
|
|
|
|
var agreementAccount = new AgreementAccount()
|
|
{
|
|
AccountNumber = 9999,
|
|
AccountDescription = "PREMIUM CHECKING",
|
|
MajorAccountTypeCode = "CK",
|
|
TaxReportForPersonNumber = 5678,
|
|
TaxReportForOrgNumber = null,
|
|
OvrDeliveryMethCD = "PRNT",
|
|
AccountOwner = new AgreementAccountOwner
|
|
{
|
|
AccountNumber = 9999,
|
|
AgreementNumber = 0,
|
|
UserId = null,
|
|
PersonNumber = 0
|
|
}
|
|
};
|
|
|
|
_mockCoreApiWrapperService.Setup(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>())).ReturnsAsync(personOrganization).Verifiable();
|
|
_mockCoreApiWrapperService.Setup(x => x.GetAgreementAccountByAccountId(It.IsAny<string>())).ReturnsAsync(agreementAccount);
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId,
|
|
accountNumber,
|
|
docType,
|
|
creationDate,
|
|
null);
|
|
|
|
Assert.IsFalse(result.Success);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetOwnersByAccountNumber(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_Success_Agreement()
|
|
{
|
|
var memberNumberOrUserId = Guid.NewGuid().ToString();
|
|
var agreement = new Agreement()
|
|
{
|
|
UserId = memberNumberOrUserId,
|
|
AgreementNumber = 123,
|
|
ByOrgNbr = 0,
|
|
FirstName = Guid.NewGuid().ToString(),
|
|
MiddleInitial = Guid.NewGuid().ToString(),
|
|
LastName = Guid.NewGuid().ToString(),
|
|
Suffix = Guid.NewGuid().ToString(),
|
|
PersonNumber = 1234
|
|
};
|
|
|
|
var entityName = $"{agreement.FirstName} {agreement.MiddleInitial} {agreement.LastName} {agreement.Suffix}";
|
|
|
|
_mockCoreApiWrapperService.Setup(x => x.GetAgreementByUserId(It.IsAny<string>())).ReturnsAsync(agreement).Verifiable();
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId,
|
|
entityName,
|
|
null);
|
|
var resultPayload = result.Payload;
|
|
|
|
Assert.True(result.Success);
|
|
Assert.AreEqual(agreement.PersonNumber.ToString(), resultPayload.PersonNumber);
|
|
Assert.IsNull(resultPayload.OrganizationNumber);
|
|
Assert.IsNull(resultPayload.AccountNumber);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>()), Times.Never);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Once);
|
|
}
|
|
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_Success_Agreement_NoAgreement()
|
|
{
|
|
var memberNumberOrUserId = Guid.NewGuid().ToString();
|
|
var entityName = $"{Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()}";
|
|
Agreement nullAgreement = null;
|
|
var personOrganization = new PersonOrganization()
|
|
{
|
|
PersonNumber = DateTime.Now.Millisecond.ToString(),
|
|
OrganizationNumber = null,
|
|
EntityName = entityName
|
|
};
|
|
|
|
_mockCoreApiWrapperService.Setup(x => x.GetAgreementByUserId(It.IsAny<string>())).ReturnsAsync(nullAgreement).Verifiable();
|
|
_mockCoreApiWrapperService.Setup(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>())).ReturnsAsync(personOrganization).Verifiable();
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId,
|
|
entityName,
|
|
null);
|
|
var resultPayload = result.Payload;
|
|
|
|
Assert.True(result.Success);
|
|
Assert.AreEqual(personOrganization.PersonNumber, resultPayload.PersonNumber);
|
|
Assert.IsNull(resultPayload.OrganizationNumber);
|
|
Assert.IsNull(resultPayload.AccountNumber);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Once);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_Success_PersonOrganization_PersonNumber()
|
|
{
|
|
var memberNumberOrUserId = $"M{Guid.NewGuid().ToString()}";
|
|
var entityName = $"{Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()}";
|
|
|
|
var personOrganization = new PersonOrganization()
|
|
{
|
|
PersonNumber = DateTime.Now.Millisecond.ToString(),
|
|
OrganizationNumber = null,
|
|
EntityName = entityName
|
|
};
|
|
|
|
_mockCoreApiWrapperService.Setup(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>())).ReturnsAsync(personOrganization).Verifiable();
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId,
|
|
entityName,
|
|
null);
|
|
var resultPayload = result.Payload;
|
|
|
|
Assert.True(result.Success);
|
|
Assert.AreEqual(personOrganization.PersonNumber, resultPayload.PersonNumber);
|
|
Assert.IsNull(resultPayload.OrganizationNumber);
|
|
Assert.IsNull(resultPayload.AccountNumber);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>()), Times.Once);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_Success_PersonOrganization_OrganizationNumber()
|
|
{
|
|
var memberNumberOrUserId = $"M{Guid.NewGuid().ToString()}";
|
|
var entityName = $"{Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()}";
|
|
|
|
var personOrganization = new PersonOrganization
|
|
{
|
|
PersonNumber = null,
|
|
OrganizationNumber = DateTime.Now.Millisecond.ToString(),
|
|
EntityName = entityName
|
|
};
|
|
|
|
_mockCoreApiWrapperService.Setup(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>())).ReturnsAsync(personOrganization).Verifiable();
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId,
|
|
entityName,
|
|
null);
|
|
var resultPayload = result.Payload;
|
|
|
|
Assert.True(result.Success);
|
|
Assert.AreEqual(personOrganization.OrganizationNumber, resultPayload.OrganizationNumber);
|
|
Assert.IsNull(resultPayload.PersonNumber);
|
|
Assert.IsNull(resultPayload.AccountNumber);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>()), Times.Once);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_Failure_PersonOrganization_IsNull()
|
|
{
|
|
var memberNumberOrUserId = $"M{Guid.NewGuid().ToString()}";
|
|
var entityName = $"{Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()}";
|
|
|
|
var personOrganization = new PersonOrganization
|
|
{
|
|
PersonNumber = null,
|
|
OrganizationNumber = null,
|
|
EntityName = entityName
|
|
};
|
|
|
|
_mockCoreApiWrapperService.Setup(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>())).ReturnsAsync(personOrganization).Verifiable();
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId,
|
|
entityName,
|
|
null);
|
|
var resultPayload = result.Payload;
|
|
|
|
Assert.False(result.Success);
|
|
Assert.IsNull(resultPayload.OrganizationNumber);
|
|
Assert.IsNull(resultPayload.PersonNumber);
|
|
Assert.IsNull(resultPayload.AccountNumber);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>()), Times.Once);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_Failure_PersonOrganization_EntityNameDoesNotMatch()
|
|
{
|
|
var memberNumberOrUserId = $"M{Guid.NewGuid().ToString()}";
|
|
var entityName = $"{Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()}";
|
|
|
|
var personOrganization = new PersonOrganization
|
|
{
|
|
PersonNumber = null,
|
|
OrganizationNumber = DateTime.Now.Millisecond.ToString(),
|
|
EntityName = Guid.NewGuid().ToString()
|
|
};
|
|
|
|
_mockCoreApiWrapperService.Setup(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>())).ReturnsAsync(personOrganization).Verifiable();
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId,
|
|
entityName,
|
|
null);
|
|
|
|
Assert.False(result.Success);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>()), Times.Once);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_Failure_PersonOrganization_Exception()
|
|
{
|
|
var memberNumberOrUserId = $"M{Guid.NewGuid().ToString()}";
|
|
var entityName = $"{Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()}";
|
|
|
|
_mockCoreApiWrapperService.Setup(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>()))
|
|
.ThrowsAsync(new ServiceException("Test")).Verifiable();
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId,
|
|
entityName,
|
|
null);
|
|
|
|
Assert.IsFalse(result.Success);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>()), Times.Once);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_Success_PersonOrganization_OwnerOverride()
|
|
{
|
|
var memberNumberOrUserId = $"M{Guid.NewGuid().ToString()}";
|
|
var entityName = $"{Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()}";
|
|
|
|
var documentProcessingInfo = new DocumentProcessingInfo()
|
|
{
|
|
DocumentProcessingInfoId = DateTime.Now.Millisecond
|
|
};
|
|
|
|
var ownerOverrideInfo = new OwnerOverrideInfo()
|
|
{
|
|
DocumentProcessingInfoId = documentProcessingInfo.DocumentProcessingInfoId,
|
|
EntityType = EntityTypes.Organization,
|
|
EntityId = Guid.NewGuid().ToString(),
|
|
UserName = Guid.NewGuid().ToString()
|
|
};
|
|
|
|
var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId,
|
|
entityName,
|
|
ownerOverrideInfo);
|
|
var resultPayload = result.Payload;
|
|
|
|
Assert.True(result.Success);
|
|
Assert.AreEqual(ownerOverrideInfo.EntityId, resultPayload.OrganizationNumber);
|
|
Assert.IsNull(resultPayload.PersonNumber);
|
|
Assert.IsNull(resultPayload.AccountNumber);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>()), Times.Never);
|
|
_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never);
|
|
}
|
|
} |