409 lines
17 KiB
C#
409 lines
17 KiB
C#
using System;
|
|
using System.Linq;
|
|
using System.Collections.Generic;
|
|
using System.Threading.Tasks;
|
|
using NUnit.Framework;
|
|
using AutoMapper;
|
|
using Moq;
|
|
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
|
|
using LCU.Api.Internal.CoreApiWrapper.Mappers;
|
|
using LCU.Api.Internal.CoreApiWrapper.Services;
|
|
using LCU.Library.Internal.CoreApiWrapperModel.Constants;
|
|
using LCU.Library.Internal.CoreApiWrapperModel.Enums;
|
|
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.PostalAddresses;
|
|
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Persons;
|
|
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
|
|
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Identifications;
|
|
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Phones;
|
|
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.MemberAgreements;
|
|
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Accounts;
|
|
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Organizations;
|
|
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Mixed;
|
|
|
|
namespace LCU.Api.Internal.CoreApiWrapperTest.Service
|
|
{
|
|
public class MemberServiceTest
|
|
{
|
|
private readonly MemberService _memberService;
|
|
private readonly IMapper _mapper;
|
|
private readonly Mock<IPersonService> _mockPersonService;
|
|
private readonly Mock<IAccountService> _mockAccountService;
|
|
private readonly Mock<IOrganizationService> _mockOrganizationService;
|
|
|
|
public MemberServiceTest()
|
|
{
|
|
if (_mapper == null)
|
|
{
|
|
var mappingConfig = new MapperConfiguration(mc =>
|
|
{
|
|
mc.AddProfile(new MemberOwnerMapper());
|
|
mc.AddProfile(new MemberMapper());
|
|
mc.AddProfile(new AddressMapper());
|
|
});
|
|
IMapper mapper = mappingConfig.CreateMapper();
|
|
_mapper = mapper;
|
|
}
|
|
_mockPersonService = new Mock<IPersonService>();
|
|
_mockAccountService = new Mock<IAccountService>();
|
|
_mockOrganizationService = new Mock<IOrganizationService>();
|
|
|
|
_memberService = new MemberService(_mapper,
|
|
_mockPersonService.Object,
|
|
_mockAccountService.Object,
|
|
_mockOrganizationService.Object);
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetMember_Returns_FilledOutMember()
|
|
{
|
|
var testPostalAddress = new PostalAddress()
|
|
{
|
|
AddressUseCode = AddressConstants.PrimaryUseCode,
|
|
AddressNumber = 11,
|
|
AddressLine1 = "Test Street",
|
|
AddressLine2 = "",
|
|
AddressLine3 = "",
|
|
CityName = "City Test",
|
|
PostalCode = "53183",
|
|
ZipPlus = "3123",
|
|
CountrySubdivisionCode = "WI"
|
|
};
|
|
var testPostalAddressList = new List<PostalAddress>() { testPostalAddress };
|
|
|
|
var testId = 100;
|
|
var testPersonResult = new Person()
|
|
{
|
|
PersonNumber = 1,
|
|
FirstName = "Tester",
|
|
MiddleName = "Person",
|
|
LastName = "Guy",
|
|
NameFull = "Tester Person Guy",
|
|
Suffix = "",
|
|
TaxId = "1231232132",
|
|
BirthDate = "1/1/2021",
|
|
MemberNumber = 111111111,
|
|
PostalAddressList = testPostalAddressList
|
|
};
|
|
|
|
_mockPersonService.Setup(x => x.GetPersonsByMemberAgreementNbr(It.IsAny<CoreRequestParameters>(),
|
|
It.IsAny<MemberNbrRequest>())).ReturnsAsync(testPersonResult);
|
|
|
|
var result = await _memberService.GetMemberDetails(testId);
|
|
|
|
Assert.NotNull(result);
|
|
Assert.AreEqual("Tester Person Guy", result.MemberName);
|
|
Assert.AreEqual(111111111, result.MemberId);
|
|
Assert.AreEqual("Test Street", result.Address.Line1);
|
|
Assert.AreEqual("WI", result.Address.State);
|
|
_mockOrganizationService.Verify(x => x.GetMemberByMemberAgreeNbr(111111111), Times.Never());
|
|
}
|
|
|
|
[Test]
|
|
public void GetMemberDetails_Return_Exception()
|
|
{
|
|
var testId = 100;
|
|
_mockPersonService.Setup(x => x.GetPersonsByMemberAgreementNbr(It.IsAny<CoreRequestParameters>(),
|
|
It.IsAny<MemberNbrRequest>())).Throws(new Exception());
|
|
|
|
Assert.ThrowsAsync<Exception>(() => _memberService.GetMemberDetails(testId));
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetMemberByAccountNumber_Person_Returns_FilledOutMember()
|
|
{
|
|
var testAccountResult = new Account()
|
|
{
|
|
MemberAgreementNumber = 111111111,
|
|
ReportingForPersonNumber = 1
|
|
};
|
|
_mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
|
|
It.IsAny<AcctNbrRequest>())).ReturnsAsync(testAccountResult);
|
|
|
|
var testPostalAddress = new PostalAddress()
|
|
{
|
|
AddressUseCode = AddressConstants.PrimaryUseCode,
|
|
AddressNumber = 11,
|
|
AddressLine1 = "Test Street",
|
|
AddressLine2 = "",
|
|
AddressLine3 = "",
|
|
CityName = "City Test",
|
|
PostalCode = "53183",
|
|
ZipPlus = "3123",
|
|
CountrySubdivisionCode = "WI"
|
|
};
|
|
var testPostalAddressList = new List<PostalAddress>() { testPostalAddress };
|
|
|
|
var testId = 100;
|
|
var testPersonResult = new Person()
|
|
{
|
|
PersonNumber = 1,
|
|
FirstName = "Tester",
|
|
MiddleName = "Person",
|
|
LastName = "Guy",
|
|
NameFull = "Tester Person Guy",
|
|
Suffix = "",
|
|
TaxId = "1231232132",
|
|
BirthDate = "1/1/2021",
|
|
MemberNumber = 111111111,
|
|
PostalAddressList = testPostalAddressList
|
|
};
|
|
|
|
_mockPersonService.Setup(x => x.GetPersonsByMemberAgreementNbr(It.IsAny<CoreRequestParameters>(),
|
|
It.IsAny<MemberNbrRequest>())).ReturnsAsync(testPersonResult);
|
|
|
|
var result = await _memberService.GetMemberByAccountNumber(testId);
|
|
|
|
Assert.NotNull(result);
|
|
Assert.AreEqual("Tester Person Guy", result.MemberName);
|
|
Assert.AreEqual(111111111, result.MemberId);
|
|
Assert.AreEqual("Test Street", result.Address.Line1);
|
|
Assert.AreEqual("WI", result.Address.State);
|
|
}
|
|
|
|
[Test]
|
|
public void GetMemberDetailsByAccountNumber_Return_Exception_OnGetAccountDetails()
|
|
{
|
|
_mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
|
|
It.IsAny<AcctNbrRequest>())).Throws(new Exception());
|
|
var testId = 100;
|
|
Assert.ThrowsAsync<Exception>(() => _memberService.GetMemberByAccountNumber(testId));
|
|
}
|
|
|
|
|
|
[Test]
|
|
public void GetMemberDetailsByAccountNumber_Return_Exception_OnGetPersonsByMemberAgreementNbr()
|
|
{
|
|
var testAccountResult = new Account()
|
|
{
|
|
MemberAgreementNumber = 111111111
|
|
};
|
|
_mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
|
|
It.IsAny<AcctNbrRequest>())).ReturnsAsync(testAccountResult);
|
|
var testId = 100;
|
|
_mockPersonService.Setup(x => x.GetPersonsByMemberAgreementNbr(It.IsAny<CoreRequestParameters>(),
|
|
It.IsAny<MemberNbrRequest>())).Throws(new Exception());
|
|
|
|
Assert.ThrowsAsync<Exception>(() => _memberService.GetMemberByAccountNumber(testId));
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetMemberOwner_Returns_FilledOutMemberOwner()
|
|
{
|
|
var testPostalAddress = new PostalAddress()
|
|
{
|
|
AddressUseCode = AddressConstants.PrimaryUseCode,
|
|
AddressNumber = 11,
|
|
AddressLine1 = "Test Street",
|
|
AddressLine2 = "",
|
|
AddressLine3 = "",
|
|
CityName = "City Test",
|
|
PostalCode = "53183",
|
|
ZipPlus = "3123",
|
|
CountrySubdivisionCode = "WI"
|
|
};
|
|
var testPostalAddressList = new List<PostalAddress>() { testPostalAddress };
|
|
|
|
var identification = new Identification()
|
|
{
|
|
TypeCode = ((int)IdentificationTypeEnum.UnexpiredDriversLicense).ToString(),
|
|
CountryCode = AddressConstants.CountryUSA,
|
|
StateCode = "WI",
|
|
IdNumber = "A3243208fj213aupasdf"
|
|
};
|
|
var identificationList = new List<Identification>() { identification };
|
|
|
|
|
|
var phone1 = new Phone()
|
|
{
|
|
IsPreferred = true,
|
|
AreaCode = "262",
|
|
Exchange = "789",
|
|
PhoneNumber = "3321"
|
|
};
|
|
var testMemberAgreement = new MemberAgreement()
|
|
{
|
|
PrimaryPersonNumber = 1
|
|
};
|
|
|
|
var testId = 100;
|
|
var testPersonResult = new Person()
|
|
{
|
|
PersonNumber = 1,
|
|
FirstName = "Tester",
|
|
MiddleName = "Person",
|
|
LastName = "Guy",
|
|
NameFull = "Tester Person Guy",
|
|
Suffix = "",
|
|
TaxId = "1231232132",
|
|
BirthDate = "1/1/2021",
|
|
PostalAddressList = testPostalAddressList,
|
|
IsEmployee = true,
|
|
MemberAgreement = testMemberAgreement,
|
|
Identifications = identificationList
|
|
};
|
|
|
|
_mockPersonService.Setup(x => x.GetPersonsByMemberAgreementNbr(It.IsAny<CoreRequestParameters>(),
|
|
It.IsAny<MemberNbrRequest>())).ReturnsAsync(testPersonResult);
|
|
|
|
var results = await _memberService.GetMemberOwner(testId);
|
|
|
|
Assert.NotNull(results);
|
|
Assert.AreEqual(1, results.ToList().Count);
|
|
var result = results.FirstOrDefault();
|
|
|
|
Assert.AreEqual(1, result.IndividualId);
|
|
Assert.AreEqual("Tester Person Guy", result.Name);
|
|
Assert.AreEqual("1231232132", result.TaxId);
|
|
Assert.AreEqual("1/1/2021", result.BirthDate);
|
|
Assert.AreEqual("Primary", result.Type);
|
|
Assert.AreEqual("Test Street, City Test, WI 53183-3123", result.Address);
|
|
Assert.AreEqual("WI A3243208fj213aupasdf", result.DriverLicense);
|
|
}
|
|
|
|
[Test]
|
|
public void GetMemberOwner_Return_Exception()
|
|
{
|
|
var testId = 100;
|
|
_mockPersonService.Setup(x => x.GetPersonsByMemberAgreementNbr(It.IsAny<CoreRequestParameters>(),
|
|
It.IsAny<MemberNbrRequest>())).Throws(new Exception());
|
|
|
|
Assert.ThrowsAsync<Exception>(() => _memberService.GetMemberOwner(testId));
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetMemberByAccountNumber_Organization_Returns_FilledOutMember()
|
|
{
|
|
// Arrange
|
|
var testAccountResult = new Account()
|
|
{
|
|
MemberAgreementNumber = 111111111,
|
|
ReportingForOrganizationNumber = 1
|
|
};
|
|
_mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
|
|
It.IsAny<AcctNbrRequest>())).ReturnsAsync(testAccountResult);
|
|
|
|
var testPostalAddress = new PostalAddress()
|
|
{
|
|
AddressUseCode = AddressConstants.PrimaryUseCode,
|
|
AddressNumber = 11,
|
|
AddressLine1 = "Test Street",
|
|
AddressLine2 = "",
|
|
AddressLine3 = "",
|
|
CityName = "City Test",
|
|
PostalCode = "53183",
|
|
ZipPlus = "3123",
|
|
CountrySubdivisionCode = "WI"
|
|
};
|
|
var testPostalAddressList = new List<PostalAddress>() { testPostalAddress };
|
|
var testOrganization = new Organization
|
|
{
|
|
MemberAgreementNumber = 111111111,
|
|
Name = "Test Organization Name",
|
|
OrganizationNumber = 123,
|
|
PostalAddressList = testPostalAddressList
|
|
};
|
|
|
|
_mockOrganizationService.Setup(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>())).ReturnsAsync(testOrganization);
|
|
|
|
// Act
|
|
var result = await _memberService.GetMemberByAccountNumber(1);
|
|
|
|
// ASsert
|
|
Assert.IsNotNull(result);
|
|
Assert.AreEqual(result.MemberId, 111111111);
|
|
Assert.AreEqual(result.MemberName, "Test Organization Name");
|
|
Assert.AreEqual(result.PrimaryIndividualId, 123);
|
|
Assert.AreEqual("Test Street", result.Address.Line1);
|
|
Assert.AreEqual("WI", result.Address.State);
|
|
_mockPersonService.Verify(x => x.GetPersonsByMemberAgreementNbr(new CoreRequestParameters(), new MemberNbrRequest()), Times.Never());
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetPersonOrOrganizationNumberByMemberId_PersonFound()
|
|
{
|
|
// Arrange
|
|
_mockOrganizationService.Invocations.Clear();
|
|
|
|
long personMemberNumber = 123;
|
|
var personName = "John E Jacob Jr";
|
|
|
|
var person = new Person()
|
|
{
|
|
PersonNumber = (int)personMemberNumber,
|
|
FirstMiddleInitialLastSuffix = personName
|
|
};
|
|
|
|
_mockPersonService.Setup(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>())).ReturnsAsync(person).Verifiable();
|
|
|
|
// Act
|
|
var result = await _memberService.GetPersonOrOrganizationNumberByMemberId(personMemberNumber);
|
|
|
|
// Assert
|
|
Assert.IsNotNull(result);
|
|
Assert.AreEqual(result.PersonNumber, personMemberNumber.ToString());
|
|
Assert.AreEqual(result.EntityName, personName);
|
|
Assert.IsNull(result.OrganizationNumber);
|
|
_mockOrganizationService.Verify(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetPersonOrOrganizationNumberByMemberId_OrganizationFound()
|
|
{
|
|
// Arrange
|
|
_mockPersonService.Invocations.Clear();
|
|
_mockOrganizationService.Invocations.Clear();
|
|
|
|
long organizationMemberNumber = 123;
|
|
var organizationName = "John E Consulting LLC";
|
|
|
|
var organization = new Organization()
|
|
{
|
|
OrganizationNumber = organizationMemberNumber,
|
|
Name = organizationName
|
|
};
|
|
|
|
_mockPersonService.Setup(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>())).ThrowsAsync(new Exception());
|
|
_mockOrganizationService.Setup(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>())).ReturnsAsync(organization).Verifiable();
|
|
|
|
// Act
|
|
var result = await _memberService.GetPersonOrOrganizationNumberByMemberId(organizationMemberNumber);
|
|
|
|
// Assert
|
|
Assert.IsNotNull(result);
|
|
Assert.AreEqual(result.OrganizationNumber, organizationMemberNumber.ToString());
|
|
Assert.AreEqual(result.EntityName, organizationName);
|
|
Assert.IsNull(result.PersonNumber);
|
|
_mockPersonService.Verify(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>()), Times.Once);
|
|
_mockOrganizationService.Verify(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public void GetPersonOrOrganizationNumberByMemberId_NeitherFound_Exception()
|
|
{
|
|
// Arrange
|
|
_mockPersonService.Invocations.Clear();
|
|
_mockOrganizationService.Invocations.Clear();
|
|
|
|
var person = new Person()
|
|
{
|
|
PersonNumber = 0
|
|
};
|
|
|
|
var organization = new Organization()
|
|
{
|
|
OrganizationNumber = 0
|
|
};
|
|
|
|
_mockPersonService.Setup(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>())).ReturnsAsync(person).Verifiable();
|
|
_mockOrganizationService.Setup(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>())).ReturnsAsync(organization).Verifiable();
|
|
|
|
// Act
|
|
|
|
// Assert
|
|
Assert.ThrowsAsync<ArgumentNullException>(async () => await _memberService.GetPersonOrOrganizationNumberByMemberId(0));
|
|
_mockPersonService.Verify(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>()), Times.Once);
|
|
_mockOrganizationService.Verify(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>()), Times.Once);
|
|
}
|
|
}
|
|
}
|