Adding
This commit is contained in:
Zeeshaun
+125
@@ -0,0 +1,125 @@
|
||||
using System;
|
||||
using System.Linq;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading.Tasks;
|
||||
using NUnit.Framework;
|
||||
using Moq;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
|
||||
using LCU.Api.Internal.CoreApiWrapper.Services;
|
||||
using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.AccessChannelPersons;
|
||||
|
||||
namespace LCU.Api.Internal.CoreApiWrapperTest.Service
|
||||
{
|
||||
public class AccessChannelPersonsServiceTest
|
||||
{
|
||||
private readonly AccessChannelPersonsService _accessChannelPersonsService;
|
||||
private readonly Mock<IAccessChannelPersonsDao> _mockAccessChannelPersonsDao;
|
||||
|
||||
public AccessChannelPersonsServiceTest()
|
||||
{
|
||||
_mockAccessChannelPersonsDao = new Mock<IAccessChannelPersonsDao>();
|
||||
_accessChannelPersonsService = new AccessChannelPersonsService(_mockAccessChannelPersonsDao.Object);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetAccessChannelPersonCoreApiResponseAsync_ExceptionThrown()
|
||||
{
|
||||
_mockAccessChannelPersonsDao.Setup(x => x.FindAccessChannelPersonsByPerson(It.IsAny<CoreRequestParameters>(),
|
||||
It.IsAny<AccessChannelPersonsByPersonRequest>()))
|
||||
.Throws(new Exception("Oops"));
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _accessChannelPersonsService.GetAccessChannelPersonCoreApiResponseAsync(new AccessChannelPersonsByPersonRequest()));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetAccessChannelPersonCoreApiResponseAsync_UserFieldsReturned()
|
||||
{
|
||||
var accessChannelPersons = new List<AccessChannelPerson>()
|
||||
{
|
||||
new AccessChannelPerson()
|
||||
{
|
||||
ChannelNumber = 1,
|
||||
PersonNumber = 2,
|
||||
UserId = "3"
|
||||
},
|
||||
new AccessChannelPerson()
|
||||
{
|
||||
ChannelNumber = 4,
|
||||
PersonNumber = 5,
|
||||
UserId = "6"
|
||||
}
|
||||
};
|
||||
var coreMessageheader = new CoreMessageHeader();
|
||||
var coreApiResponse = new CoreApiMessage<IEnumerable<AccessChannelPerson>>(coreMessageheader, accessChannelPersons);
|
||||
_mockAccessChannelPersonsDao.Setup(x => x.FindAccessChannelPersonsByPerson(It.IsAny<CoreRequestParameters>(),
|
||||
It.IsAny<AccessChannelPersonsByPersonRequest>()))
|
||||
.ReturnsAsync(coreApiResponse);
|
||||
|
||||
|
||||
var accessChannelPersonsByPersonRequest = new AccessChannelPersonsByPersonRequest();
|
||||
|
||||
var result = await _accessChannelPersonsService.GetAccessChannelPersonCoreApiResponseAsync(accessChannelPersonsByPersonRequest);
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual(2, result.MessageBody.Count());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void UpdateAccountChannelPersonAsync_ExceptionThrown()
|
||||
{
|
||||
_mockAccessChannelPersonsDao.Setup(x => x.UpdateAccessChannelPerson(It.IsAny<CoreApiMessage<AccessChannelPerson>>()))
|
||||
.Throws(new Exception("Oops"));
|
||||
|
||||
var request = new AccessChannelPerson()
|
||||
{
|
||||
ChannelNumber = 1,
|
||||
PersonNumber = 2,
|
||||
UserId = "3"
|
||||
};
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _accessChannelPersonsService.UpdateAccessChannelPersonAsync(request, 10002312312));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void UpdateAccountChannelPersonAsync_NullResult_ExceptionThrown()
|
||||
{
|
||||
AccessChannelPerson response = null;
|
||||
_mockAccessChannelPersonsDao.Setup(x => x.UpdateAccessChannelPerson(It.IsAny<CoreApiMessage<AccessChannelPerson>>()))
|
||||
.ReturnsAsync(response);
|
||||
|
||||
var request = new AccessChannelPerson()
|
||||
{
|
||||
ChannelNumber = 1,
|
||||
PersonNumber = 2,
|
||||
UserId = "3"
|
||||
};
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _accessChannelPersonsService.UpdateAccessChannelPersonAsync(request, 10002312312));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task UpdateAccountChannelPersonAsync_UpdatedUserFieldsReturned()
|
||||
{
|
||||
var response = new AccessChannelPerson()
|
||||
{
|
||||
ChannelNumber = 1,
|
||||
PersonNumber = 2,
|
||||
UserId = "3"
|
||||
};
|
||||
_mockAccessChannelPersonsDao.Setup(x => x.UpdateAccessChannelPerson(It.IsAny<CoreApiMessage<AccessChannelPerson>>()))
|
||||
.ReturnsAsync(response);
|
||||
|
||||
var request = new AccessChannelPerson()
|
||||
{
|
||||
ChannelNumber = 1,
|
||||
PersonNumber = 2,
|
||||
UserId = "3"
|
||||
};
|
||||
var result = await _accessChannelPersonsService.UpdateAccessChannelPersonAsync(request, 10002312312);
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual(response, result);
|
||||
}
|
||||
}
|
||||
}
|
||||
+98
@@ -0,0 +1,98 @@
|
||||
using System;
|
||||
using System.Threading.Tasks;
|
||||
using NUnit.Framework;
|
||||
using Moq;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
|
||||
using LCU.Api.Internal.CoreApiWrapper.Services;
|
||||
using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.AccessTypes;
|
||||
|
||||
namespace LCU.Api.Internal.CoreApiWrapperTest.Service
|
||||
{
|
||||
public class AccessTypeServiceTest
|
||||
{
|
||||
private readonly AccessTypeService _accessTypeService;
|
||||
private readonly Mock<IAccessTypeDao> _mockAccessTypeDao;
|
||||
|
||||
public AccessTypeServiceTest()
|
||||
{
|
||||
_mockAccessTypeDao = new Mock<IAccessTypeDao>();
|
||||
_accessTypeService = new AccessTypeService(_mockAccessTypeDao.Object);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void UpdateAccountTypeAsync_ExceptionThrown()
|
||||
{
|
||||
_mockAccessTypeDao.Setup(x => x.UpdateAccessType(It.IsAny<CoreApiMessage<AccessType>>(), It.IsAny<string>()))
|
||||
.Throws(new Exception("Oops"));
|
||||
|
||||
var accessType = new AccessType()
|
||||
{
|
||||
ChannelNumber = 1,
|
||||
PersonNumber = 2,
|
||||
Id = "WWW"
|
||||
};
|
||||
var request = new AccessTypeUpdateRequest()
|
||||
{
|
||||
AccessType = accessType,
|
||||
AccessChannelPersonId = "1_2",
|
||||
UpdateKey = 123213131
|
||||
};
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _accessTypeService.UpdateAccessTypeAsync(request));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void UpdateAccountUserFieldAsync_NullResult_ExceptionThrown()
|
||||
{
|
||||
AccessType response = null;
|
||||
_mockAccessTypeDao.Setup(x => x.UpdateAccessType(It.IsAny<CoreApiMessage<AccessType>>(), It.IsAny<string>()))
|
||||
.ReturnsAsync(response);
|
||||
|
||||
var accessType = new AccessType()
|
||||
{
|
||||
ChannelNumber = 1,
|
||||
PersonNumber = 2,
|
||||
Id = "WWW"
|
||||
};
|
||||
var request = new AccessTypeUpdateRequest()
|
||||
{
|
||||
AccessType = accessType,
|
||||
AccessChannelPersonId = "1_2",
|
||||
UpdateKey = 123213131
|
||||
};
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _accessTypeService.UpdateAccessTypeAsync(request));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task UpdateAccountUserFieldAsync_UpdatedUserFieldsReturned()
|
||||
{
|
||||
var response = new AccessType()
|
||||
{
|
||||
ChannelNumber = 1,
|
||||
PersonNumber = 2,
|
||||
Id = "WWW"
|
||||
};
|
||||
_mockAccessTypeDao.Setup(x => x.UpdateAccessType(It.IsAny<CoreApiMessage<AccessType>>(), It.IsAny<string>()))
|
||||
.ReturnsAsync(response);
|
||||
|
||||
var accessType = new AccessType()
|
||||
{
|
||||
ChannelNumber = 1,
|
||||
PersonNumber = 2,
|
||||
Id = "WWW"
|
||||
};
|
||||
var request = new AccessTypeUpdateRequest()
|
||||
{
|
||||
AccessType = accessType,
|
||||
AccessChannelPersonId = "1_2",
|
||||
UpdateKey = 123213131
|
||||
};
|
||||
var result = await _accessTypeService.UpdateAccessTypeAsync(request);
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual(response, result);
|
||||
}
|
||||
}
|
||||
}
|
||||
+743
@@ -0,0 +1,743 @@
|
||||
using System;
|
||||
using System.Linq;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading.Tasks;
|
||||
using NUnit.Framework;
|
||||
using Moq;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
|
||||
using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
|
||||
using LCU.Library.Internal.CoreApiWrapperLib.Exceptions;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Accounts;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
|
||||
using LCU.Library.Internal.Exceptions;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreResponses;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreSoapResponses;
|
||||
using LCU.Api.Internal.CoreApiWrapper.Services;
|
||||
|
||||
namespace LCU.Api.Internal.CoreApiWrapperTest.Service
|
||||
{
|
||||
public class AccountServiceTest
|
||||
{
|
||||
private readonly AccountService _accountService;
|
||||
private readonly Mock<IAccountDao> _mockAccountDao;
|
||||
|
||||
public AccountServiceTest()
|
||||
{
|
||||
_mockAccountDao = new Mock<IAccountDao>();
|
||||
_accountService = new AccountService(_mockAccountDao.Object);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetAccountDetailsByAccountNumber_Returns_AccountDetails()
|
||||
{
|
||||
var testAccount = new Account()
|
||||
{
|
||||
Id = "fasd;fljqer8-3418-3824-8dsfjas;djf",
|
||||
ContractDate = "1/1/2021"
|
||||
};
|
||||
_mockAccountDao.Setup(x => x.FindByAcctNbr(It.IsAny<CoreRequestParameters>(), It.IsAny<AcctNbrRequest>())).ReturnsAsync(testAccount);
|
||||
var testAccountNumber = 1000143;
|
||||
var result = await _accountService.GetAccountDetailsByAccountNumber(testAccountNumber);
|
||||
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual("fasd;fljqer8-3418-3824-8dsfjas;djf", result.Id);
|
||||
Assert.AreEqual("1/1/2021", result.ContractDate);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task PutAccountMaintenanceRequest_UpdateSuccessful()
|
||||
{
|
||||
var accountMaintenanceRequest = new List<AccountMaintenanceRequest>
|
||||
{
|
||||
new() {
|
||||
AccountNumber = 123,
|
||||
DeliveryMethod = "PRNT"
|
||||
}
|
||||
};
|
||||
|
||||
await _accountService.PutAccountMaintenanceRequest(accountMaintenanceRequest);
|
||||
_mockAccountDao.Verify(x => x.PutAccountMaintenanceRequest(accountMaintenanceRequest), Times.Once);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void PutAccountMaintenanceRequest_ExceptionThrown()
|
||||
{
|
||||
var accountMaintenanceRequest = new List<AccountMaintenanceRequest>
|
||||
{
|
||||
new() {
|
||||
AccountNumber = 123,
|
||||
DeliveryMethod = "PRNT"
|
||||
}
|
||||
};
|
||||
|
||||
_mockAccountDao.Setup(x => x.PutAccountMaintenanceRequest(accountMaintenanceRequest)).ThrowsAsync(new AccountMaintenanceRequestException("Test exception"));
|
||||
|
||||
Assert.ThrowsAsync<AccountMaintenanceRequestException>(async () => await _accountService.PutAccountMaintenanceRequest(accountMaintenanceRequest));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetActivityAccountDetailsByAccountNumbers_OK()
|
||||
{
|
||||
_mockAccountDao.Setup(x => x.GetActivityAccountDetailsByAccountNumbers(It.IsAny<List<string>>()))
|
||||
.ReturnsAsync(new List<ActivityAccountDetails>()
|
||||
{
|
||||
new ActivityAccountDetails()
|
||||
{
|
||||
AccountNumber = 12345,
|
||||
MinorAccountType = "DV01",
|
||||
CurrentAccountStatus = "ACT"
|
||||
},
|
||||
new ActivityAccountDetails()
|
||||
{
|
||||
AccountNumber = 6789,
|
||||
MinorAccountType = "DV01",
|
||||
CurrentAccountStatus = "ACT"
|
||||
}
|
||||
});
|
||||
|
||||
var results =
|
||||
await _accountService.GetActivityAccountDetailsByAccountNumbers(new List<long>() { 12345, 6789 });
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(2, results.Count);
|
||||
_mockAccountDao.Verify(x =>
|
||||
x.GetActivityAccountDetailsByAccountNumbers(It.Is<List<string>>(x =>
|
||||
x.Contains("12345") && x.Contains("6789"))));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetActivityAccountDetailsByAccountNumbers_NoSearch_OK()
|
||||
{
|
||||
_mockAccountDao.Setup(x => x.GetActivityAccountDetailsByAccountNumbers(It.IsAny<List<string>>()))
|
||||
.ReturnsAsync(new List<ActivityAccountDetails>()
|
||||
{
|
||||
new()
|
||||
{
|
||||
AccountNumber = 12345,
|
||||
MinorAccountType = "DV01",
|
||||
CurrentAccountStatus = "ACT"
|
||||
},
|
||||
new()
|
||||
{
|
||||
AccountNumber = 6789,
|
||||
MinorAccountType = "DV01",
|
||||
CurrentAccountStatus = "ACT"
|
||||
}
|
||||
});
|
||||
|
||||
var results = await _accountService.GetActivityAccountDetailsByAccountNumbers(new List<long>() { });
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(0, results.Count);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetActivityAccountDetailsByAccountNumbers_Exception_OK()
|
||||
{
|
||||
_mockAccountDao.Setup(x => x.GetActivityAccountDetailsByAccountNumbers(It.IsAny<List<string>>()))
|
||||
.ThrowsAsync(new Exception("Boo"));
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _accountService.GetActivityAccountDetailsByAccountNumbers(new List<long>() { 1, 2, 3 }));
|
||||
_mockAccountDao.Verify(x =>
|
||||
x.GetActivityAccountDetailsByAccountNumbers(It.Is<List<string>>(x =>
|
||||
x.Contains("1") && x.Contains("2") && x.Contains("3"))));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetOwnersByAccountNumber_OK()
|
||||
{
|
||||
var returnedAccountNumbers = new List<AccountOwnership>
|
||||
{
|
||||
new AccountOwnership
|
||||
{
|
||||
FirstName = "Pete",
|
||||
LastName = "Peterson",
|
||||
PersonNumber = 12345,
|
||||
IsPrimaryOwner = true
|
||||
},
|
||||
new AccountOwnership
|
||||
{
|
||||
FirstName = "Bill",
|
||||
LastName = "Billson",
|
||||
PersonNumber = 98765,
|
||||
}
|
||||
};
|
||||
|
||||
_mockAccountDao
|
||||
.Setup(x => x.FindOwnersByAccountNumber(It.IsAny<long>(), It.IsAny<DateTime>()))
|
||||
.ReturnsAsync(returnedAccountNumbers).Verifiable();
|
||||
|
||||
var result = await _accountService.GetOwnersByAccountNumber(12345, DateTime.Now);
|
||||
Assert.NotNull(result);
|
||||
|
||||
Assert.AreEqual(result.First().PersonNumber, 12345);
|
||||
Assert.AreEqual(result.First().IsPrimaryOwner, true);
|
||||
Assert.AreEqual(result.Last().PersonNumber, 98765);
|
||||
Assert.AreEqual(result.Last().IsPrimaryOwner, false);
|
||||
Assert.AreEqual(result.Count(), 2);
|
||||
|
||||
_mockAccountDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetOwnersByAccountNumber_Exception()
|
||||
{
|
||||
_mockAccountDao.Setup(x => x.FindOwnersByAccountNumber(It.IsAny<long>(), It.IsAny<DateTime>()))
|
||||
.Throws(new Exception("Exception from unit test")).Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () => await _accountService.GetOwnersByAccountNumber(12345, DateTime.Now));
|
||||
_mockAccountDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetPrimaryOwnersByPersonName_OK()
|
||||
{
|
||||
var personName = "Peterson";
|
||||
|
||||
var returnedAccountNumbers = new List<AccountOwnership>
|
||||
{
|
||||
new AccountOwnership
|
||||
{
|
||||
FirstName = "Pete",
|
||||
LastName = "Peterson",
|
||||
PersonNumber = 12345,
|
||||
IsPrimaryOwner = true
|
||||
},
|
||||
new AccountOwnership
|
||||
{
|
||||
FirstName = "Paul",
|
||||
LastName = "Peterson",
|
||||
PersonNumber = 98765,
|
||||
}
|
||||
};
|
||||
|
||||
_mockAccountDao
|
||||
.Setup(x => x.FindPrimaryOwnersByPersonName(It.IsAny<string>()))
|
||||
.ReturnsAsync(returnedAccountNumbers).Verifiable();
|
||||
|
||||
var result = await _accountService.GetPrimaryOwnersByPersonName(personName);
|
||||
Assert.NotNull(result);
|
||||
|
||||
var firstNameConcat = returnedAccountNumbers.First().FirstName + " " + returnedAccountNumbers.First().LastName;
|
||||
var secondNameConcat = returnedAccountNumbers.Last().FirstName + " " + returnedAccountNumbers.Last().LastName;
|
||||
Assert.IsTrue(firstNameConcat.Contains(personName));
|
||||
Assert.IsTrue(secondNameConcat.Contains(personName));
|
||||
Assert.AreEqual(result.First().IsPrimaryOwner, true);
|
||||
Assert.AreEqual(result.Last().PersonNumber, 98765);
|
||||
Assert.AreEqual(result.Last().IsPrimaryOwner, false);
|
||||
Assert.AreEqual(result.Count(), 2);
|
||||
|
||||
_mockAccountDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetPrimaryOwnersByPersonName_Exception()
|
||||
{
|
||||
var personName = "Pete Peterson";
|
||||
|
||||
_mockAccountDao.Setup(x => x.FindPrimaryOwnersByPersonName(It.IsAny<string>()))
|
||||
.Throws(new ServiceException("Exception from unit test")).Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(async () => await _accountService.GetPrimaryOwnersByPersonName(personName));
|
||||
_mockAccountDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetPrimaryOwnersByOrganizationName_OK()
|
||||
{
|
||||
var organizationName = "The Big Company";
|
||||
|
||||
var returnedAccountNumbers = new List<AccountOwnership>
|
||||
{
|
||||
new AccountOwnership
|
||||
{
|
||||
OrganizationName = organizationName,
|
||||
ByOrgNbr = 12345,
|
||||
IsPrimaryOwner = true
|
||||
}
|
||||
};
|
||||
|
||||
_mockAccountDao
|
||||
.Setup(x => x.FindPrimaryOwnersByOrganizationName(It.IsAny<string>()))
|
||||
.ReturnsAsync(returnedAccountNumbers).Verifiable();
|
||||
|
||||
var result = await _accountService.GetPrimaryOwnersByOrganizationName(organizationName);
|
||||
Assert.NotNull(result);
|
||||
|
||||
Assert.AreEqual(result.First().OrganizationName, organizationName);
|
||||
Assert.AreEqual(result.First().IsPrimaryOwner, true);
|
||||
|
||||
_mockAccountDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetPrimaryOwnersByOrganizationName_Exception()
|
||||
{
|
||||
var organizationName = "The Big Company";
|
||||
|
||||
_mockAccountDao.Setup(x => x.FindPrimaryOwnersByOrganizationName(It.IsAny<string>()))
|
||||
.Throws(new ServiceException("Exception from unit test")).Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(async () => await _accountService.GetPrimaryOwnersByOrganizationName(organizationName));
|
||||
_mockAccountDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetAccountsForAccoutGroupMaintenance_OK()
|
||||
{
|
||||
|
||||
IEnumerable<string> returnedAccountNumbers = new List<string>
|
||||
{
|
||||
"22",
|
||||
"44"
|
||||
};
|
||||
|
||||
_mockAccountDao.Setup(x => x.FindAccountsToUpdateAccountAnalysis())
|
||||
.ReturnsAsync(returnedAccountNumbers).Verifiable();
|
||||
|
||||
IEnumerable<string> result = await _accountService.GetAccountsForGroupAnalysisMaintenance();
|
||||
Assert.NotNull(result);
|
||||
Assert.IsTrue(result.ToList().Count > 1);
|
||||
_mockAccountDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetAccountsForAccoutGroupMaintenance_Exception()
|
||||
{
|
||||
_mockAccountDao.Setup(x => x.FindAccountsToUpdateAccountAnalysis())
|
||||
.Throws(new ServiceException("Exception from unit test")).Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(async () => await _accountService.GetAccountsForGroupAnalysisMaintenance());
|
||||
_mockAccountDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task UpdateAccountsForAccoutGroupMaintenance_OK()
|
||||
{
|
||||
var accountAnalysisGroupMaintenanceRequest = new AccountAnalysisGroupMaintenanceRequest()
|
||||
{
|
||||
AccountNumber = 123,
|
||||
IsGenerateAnalysisStatement = true,
|
||||
IsPrintAnalysisStatement = true,
|
||||
IsUseForServiceCharge = true
|
||||
};
|
||||
|
||||
var returnedAccountNumbers = new List<string>
|
||||
{
|
||||
"22",
|
||||
"44"
|
||||
};
|
||||
|
||||
var response = new BasicResponse()
|
||||
{
|
||||
Success = true
|
||||
};
|
||||
|
||||
_mockAccountDao
|
||||
.Setup(x => x.UpdateAccountAnalysis(accountAnalysisGroupMaintenanceRequest))
|
||||
.ReturnsAsync(response).Verifiable();
|
||||
|
||||
var result = await _accountService.UpdateAccountAnalysisMaintenance(accountAnalysisGroupMaintenanceRequest);
|
||||
Assert.NotNull(result);
|
||||
|
||||
Assert.AreEqual(result.Success, true);
|
||||
_mockAccountDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void UpdateAccountsForAccoutGroupMaintenance_Exception()
|
||||
{
|
||||
var accountAnalysisGroupMaintenanceRequest = new AccountAnalysisGroupMaintenanceRequest()
|
||||
{
|
||||
AccountNumber = 123,
|
||||
IsGenerateAnalysisStatement = true,
|
||||
IsPrintAnalysisStatement = true,
|
||||
IsUseForServiceCharge = true
|
||||
};
|
||||
_mockAccountDao.Setup(x => x.UpdateAccountAnalysis(accountAnalysisGroupMaintenanceRequest))
|
||||
.Throws(new ServiceException("Exception from unit test")).Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(async () => await _accountService.UpdateAccountAnalysisMaintenance(accountAnalysisGroupMaintenanceRequest));
|
||||
_mockAccountDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task PostAccountsForPerson_OK()
|
||||
{
|
||||
var request = new CreatePersonAccountRequest()
|
||||
{
|
||||
PersonNumber = 1,
|
||||
FirstName = "Test",
|
||||
LastName = "Test"
|
||||
};
|
||||
|
||||
var returnedAccountNumbers = new List<long>
|
||||
{
|
||||
22
|
||||
};
|
||||
|
||||
var response = new CreatedAccountResponse()
|
||||
{
|
||||
AccountNumber = returnedAccountNumbers[0],
|
||||
BasicResponse = new BasicResponse() { Success = true }
|
||||
};
|
||||
|
||||
_mockAccountDao
|
||||
.Setup(x => x.AddPersonAccount(request))
|
||||
.ReturnsAsync(response).Verifiable();
|
||||
|
||||
var result = await _accountService.AddPersonAccount(request);
|
||||
Assert.NotNull(result);
|
||||
|
||||
Assert.AreEqual(result.BasicResponse.Success, true);
|
||||
_mockAccountDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void PostAccountsForPerson_Exception()
|
||||
{
|
||||
var request = new CreatePersonAccountRequest()
|
||||
{
|
||||
PersonNumber = 1,
|
||||
FirstName = "Test",
|
||||
LastName = "Test"
|
||||
};
|
||||
|
||||
var returnedAccountNumbers = new List<long>
|
||||
{
|
||||
22
|
||||
};
|
||||
|
||||
var response = new CreatedAccountResponse()
|
||||
{
|
||||
AccountNumber = returnedAccountNumbers[0],
|
||||
BasicResponse = new BasicResponse() { Success = true }
|
||||
};
|
||||
|
||||
_mockAccountDao
|
||||
.Setup(x => x.AddPersonAccount(request))
|
||||
.Throws(new ServiceException("Exception from unit test")).Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(async () => await _accountService.AddPersonAccount(request));
|
||||
_mockAccountDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task PostAccountsForOrganization_OK()
|
||||
{
|
||||
var request = new CreateOrganizationAccountRequest()
|
||||
{
|
||||
OrganizationNumber = 1
|
||||
};
|
||||
|
||||
var returnedAccountNumbers = new List<long>
|
||||
{
|
||||
22
|
||||
};
|
||||
|
||||
var response = new CreatedAccountResponse()
|
||||
{
|
||||
AccountNumber = returnedAccountNumbers[0],
|
||||
BasicResponse = new BasicResponse() { Success = true }
|
||||
};
|
||||
|
||||
_mockAccountDao
|
||||
.Setup(x => x.AddOrganizationAccount(request))
|
||||
.ReturnsAsync(response).Verifiable();
|
||||
|
||||
var result = await _accountService.AddOrganizationAccount(request);
|
||||
Assert.NotNull(result);
|
||||
|
||||
Assert.AreEqual(result.BasicResponse.Success, true);
|
||||
_mockAccountDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void PostAccountsForOrganization_Exception()
|
||||
{
|
||||
var request = new CreateOrganizationAccountRequest()
|
||||
{
|
||||
OrganizationNumber = 1
|
||||
};
|
||||
|
||||
var returnedAccountNumbers = new List<long>
|
||||
{
|
||||
22
|
||||
};
|
||||
|
||||
var response = new CreatedAccountResponse()
|
||||
{
|
||||
AccountNumber = returnedAccountNumbers[0],
|
||||
BasicResponse = new BasicResponse() { Success = true }
|
||||
};
|
||||
|
||||
_mockAccountDao
|
||||
.Setup(x => x.AddOrganizationAccount(request))
|
||||
.Throws(new ServiceException("Exception from unit test")).Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(async () => await _accountService.AddOrganizationAccount(request));
|
||||
_mockAccountDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task AddControlPersonOrgMaintenance_OK()
|
||||
{
|
||||
var request = new OrganizationMaintenanceRequest()
|
||||
{
|
||||
ControllingPersonNumber = 1,
|
||||
OrganizationNumber = 12
|
||||
};
|
||||
|
||||
var returnedAccountNumbers = new List<long>
|
||||
{
|
||||
22
|
||||
};
|
||||
|
||||
var response = new BasicResponse()
|
||||
{
|
||||
Success = true
|
||||
};
|
||||
|
||||
_mockAccountDao
|
||||
.Setup(x => x.PutOrganizationMaintenanceRequest(request))
|
||||
.ReturnsAsync(response).Verifiable();
|
||||
|
||||
var result = await _accountService.PutOrganizationMaintenanceRequest(request);
|
||||
Assert.NotNull(result);
|
||||
|
||||
Assert.AreEqual(result.Success, true);
|
||||
_mockAccountDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void AddControlPersonOrgMaintenance_Exception()
|
||||
{
|
||||
var request = new OrganizationMaintenanceRequest()
|
||||
{
|
||||
ControllingPersonNumber = 1,
|
||||
OrganizationNumber = 12
|
||||
};
|
||||
|
||||
var returnedAccountNumbers = new List<long>
|
||||
{
|
||||
22
|
||||
};
|
||||
|
||||
var response = new BasicResponse()
|
||||
{
|
||||
Success = true
|
||||
};
|
||||
|
||||
_mockAccountDao
|
||||
.Setup(x => x.PutOrganizationMaintenanceRequest(request))
|
||||
.Throws(new ServiceException("Exception from unit test")).Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(async () => await _accountService.PutOrganizationMaintenanceRequest(request));
|
||||
_mockAccountDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task AccountNickNameUpdateRequest_OK()
|
||||
{
|
||||
var accountRequest = new AccountNickNameUpdateRequest()
|
||||
{
|
||||
AccountNumber = 123,
|
||||
AccountDescription = "TestOK"
|
||||
};
|
||||
|
||||
var response = new BasicResponse()
|
||||
{
|
||||
Success = true
|
||||
};
|
||||
|
||||
_mockAccountDao
|
||||
.Setup(x => x.UpdateAccountNickName(accountRequest))
|
||||
.ReturnsAsync(response).Verifiable();
|
||||
|
||||
var result = await _accountService.UpdateAccountNickName(accountRequest);
|
||||
Assert.NotNull(result);
|
||||
|
||||
Assert.AreEqual(result.Success, true);
|
||||
_mockAccountDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void AccountNickNameUpdateRequest_Exception()
|
||||
{
|
||||
var accountRequest = new AccountNickNameUpdateRequest()
|
||||
{
|
||||
AccountNumber = 123,
|
||||
AccountDescription = "TestException"
|
||||
};
|
||||
|
||||
_mockAccountDao.Setup(x => x.UpdateAccountNickName(accountRequest))
|
||||
.Throws(new ServiceException("Exception from unit test")).Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(async () => await _accountService.UpdateAccountNickName(accountRequest));
|
||||
_mockAccountDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task AccountCreditReportTypeUpdateRequest_OK()
|
||||
{
|
||||
var accountRequest = new AccountCreditReportTypeUpdateRequest()
|
||||
{
|
||||
AccountNumber = 123,
|
||||
CreditReportType = "EXCL"
|
||||
};
|
||||
|
||||
var response = new BasicResponse()
|
||||
{
|
||||
Success = true
|
||||
};
|
||||
|
||||
_mockAccountDao
|
||||
.Setup(x => x.UpdateAccountCreditReportType(accountRequest))
|
||||
.ReturnsAsync(response).Verifiable();
|
||||
|
||||
var result = await _accountService.UpdateAccountCreditReportType(accountRequest);
|
||||
Assert.NotNull(result);
|
||||
|
||||
Assert.AreEqual(result.Success, true);
|
||||
_mockAccountDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void AccountCreditReportTypeUpdateRequest_Exception()
|
||||
{
|
||||
var accountRequest = new AccountCreditReportTypeUpdateRequest()
|
||||
{
|
||||
AccountNumber = 123,
|
||||
CreditReportType = "EXCL"
|
||||
};
|
||||
|
||||
_mockAccountDao.Setup(x => x.UpdateAccountCreditReportType(accountRequest))
|
||||
.Throws(new ServiceException("Exception from unit test")).Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(async () => await _accountService.UpdateAccountCreditReportType(accountRequest));
|
||||
_mockAccountDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetAccountsByMajorMinorBranchAndStatus_Ok()
|
||||
{
|
||||
var request = new AccountsByMajorMinorBranchAndStatusRequest()
|
||||
{
|
||||
BranchCodes = new List<long>()
|
||||
{
|
||||
1234,
|
||||
1235
|
||||
},
|
||||
AccountStatuses = new List<string>()
|
||||
{
|
||||
"Status"
|
||||
},
|
||||
MajorTypes = new List<string>()
|
||||
{
|
||||
"Major"
|
||||
},
|
||||
MinorTypes = new List<string>()
|
||||
{
|
||||
"MinorOne",
|
||||
"MinorTwo"
|
||||
}
|
||||
};
|
||||
|
||||
var response = new List<AccountsByMajorMinorBranchAndStatusResponse>()
|
||||
{
|
||||
new AccountsByMajorMinorBranchAndStatusResponse()
|
||||
{
|
||||
AccountNumber = 1234,
|
||||
BranchCode = 987654321,
|
||||
Name = "Test Name"
|
||||
},
|
||||
new AccountsByMajorMinorBranchAndStatusResponse()
|
||||
{
|
||||
AccountNumber = 5678,
|
||||
BranchCode = 987654321,
|
||||
Name = "Test Name Two"
|
||||
}
|
||||
};
|
||||
|
||||
_mockAccountDao.Setup(x => x.GetAccountsByMajorMinorBranchAndStatus(request)).ReturnsAsync(response).Verifiable();
|
||||
|
||||
var result = await _accountService.GetAccountsByMajorMinorBranchAndStatus(request);
|
||||
Assert.NotNull(result);
|
||||
|
||||
Assert.AreEqual(result.Count(), 2);
|
||||
Assert.AreEqual(result.FirstOrDefault().AccountNumber, 1234);
|
||||
_mockAccountDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetAccountsByMajorMinorBranchAndStatus_Exception()
|
||||
{
|
||||
var request = new AccountsByMajorMinorBranchAndStatusRequest()
|
||||
{
|
||||
BranchCodes = new List<long>()
|
||||
{
|
||||
1234,
|
||||
1235
|
||||
},
|
||||
AccountStatuses = new List<string>()
|
||||
{
|
||||
"Status"
|
||||
},
|
||||
MajorTypes = new List<string>()
|
||||
{
|
||||
"Major"
|
||||
},
|
||||
MinorTypes = new List<string>()
|
||||
{
|
||||
"MinorOne",
|
||||
"MinorTwo"
|
||||
}
|
||||
};
|
||||
|
||||
_mockAccountDao.Setup(x => x.GetAccountsByMajorMinorBranchAndStatus(request)).Throws(new ServiceException("Exception from unit test")).Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(async () => await _accountService.GetAccountsByMajorMinorBranchAndStatus(request));
|
||||
_mockAccountDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task AccountContractDateUpdateRequest_OK()
|
||||
{
|
||||
var accountRequest = new AccountContractDateUpdateRequest
|
||||
{
|
||||
AccountNumber = 123,
|
||||
ContractDate = DateTime.Now
|
||||
};
|
||||
|
||||
var response = new BasicResponse()
|
||||
{
|
||||
Success = true
|
||||
};
|
||||
|
||||
_mockAccountDao
|
||||
.Setup(x => x.UpdateAccountContractDate(accountRequest))
|
||||
.ReturnsAsync(response).Verifiable();
|
||||
|
||||
var result = await _accountService.UpdateAccountContractDate(accountRequest);
|
||||
Assert.NotNull(result);
|
||||
|
||||
Assert.AreEqual(result.Success, true);
|
||||
_mockAccountDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void AccountContractDateUpdateRequest_Exception()
|
||||
{
|
||||
var accountRequest = new AccountContractDateUpdateRequest
|
||||
{
|
||||
AccountNumber = 123,
|
||||
ContractDate = DateTime.Now
|
||||
};
|
||||
|
||||
_mockAccountDao.Setup(x => x.UpdateAccountContractDate(accountRequest))
|
||||
.Throws(new ServiceException("Exception from unit test")).Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(async () => await _accountService.UpdateAccountContractDate(accountRequest));
|
||||
_mockAccountDao.Verify();
|
||||
}
|
||||
}
|
||||
}
|
||||
+419
@@ -0,0 +1,419 @@
|
||||
using System;
|
||||
using System.Linq;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading.Tasks;
|
||||
using NUnit.Framework;
|
||||
using Moq;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
|
||||
using LCU.Api.Internal.CoreApiWrapper.Services;
|
||||
using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Accounts;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
|
||||
|
||||
namespace LCU.Api.Internal.CoreApiWrapperTest.Service
|
||||
{
|
||||
public class AccountUserFieldServiceTest
|
||||
{
|
||||
private readonly AccountUserFieldService _accountUserFieldService;
|
||||
private readonly Mock<IAccountService> _mockAccountService;
|
||||
private readonly Mock<IAccountUserFieldDao> _mockAccountUserFieldDao;
|
||||
|
||||
public AccountUserFieldServiceTest()
|
||||
{
|
||||
_mockAccountService = new Mock<IAccountService>();
|
||||
_mockAccountUserFieldDao = new Mock<IAccountUserFieldDao>();
|
||||
_accountUserFieldService = new AccountUserFieldService(_mockAccountService.Object,_mockAccountUserFieldDao.Object);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetAccountUserFieldCoreApiResponseAsync_ExceptionThrown()
|
||||
{
|
||||
_mockAccountUserFieldDao.Setup(x => x.FindAccountUserFieldCoreApiResponseByAccountId(It.IsAny<CoreRequestParameters>(), It.IsAny<string>())).Throws(new Exception("Oops"));
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _accountUserFieldService.GetAccountUserFieldCoreApiResponseAsync("testaccountiddsafasfsadfsdfsdafsd"));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetAccountUserFieldCoreApiResponseAsync_UserFieldsReturned()
|
||||
{
|
||||
var accountUserFields = new List<AccountUserField>()
|
||||
{
|
||||
new AccountUserField()
|
||||
{
|
||||
AccountNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
|
||||
},
|
||||
new AccountUserField()
|
||||
{
|
||||
AccountNumber = 100002,
|
||||
UserFieldCode = "TEST2",
|
||||
Value = "N"
|
||||
}
|
||||
};
|
||||
var coreMessageheader = new CoreMessageHeader();
|
||||
var accountUserFieldCoreApiResponse = new CoreApiMessage<IEnumerable<AccountUserField>>(coreMessageheader, accountUserFields);
|
||||
_mockAccountUserFieldDao.Setup(x => x.FindAccountUserFieldCoreApiResponseByAccountId(It.IsAny<CoreRequestParameters>(), It.IsAny<string>())).ReturnsAsync(accountUserFieldCoreApiResponse);
|
||||
|
||||
|
||||
var result = await _accountUserFieldService.GetAccountUserFieldCoreApiResponseAsync("testaccountidasfasdfsdfsadfsdfsdf");
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual(2, result.MessageBody.Count());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void UpdateAccountUserFieldAsync_ExceptionThrown()
|
||||
{
|
||||
_mockAccountUserFieldDao.Setup(x => x.UpdateAccountUserField(It.IsAny<CoreApiMessage<AccountUserFieldRequest>>(), It.IsAny<string>(), It.IsAny<string>())).Throws(new Exception("Oops"));
|
||||
|
||||
var accountUserUpdateRequest = new AccountUserFieldRequest()
|
||||
{
|
||||
AccountNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
};
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _accountUserFieldService.UpdateAccountUserFieldAsync(accountUserUpdateRequest, 10002312312, "testaccountidfdafdfasfdsf", "TEST1"));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task UpdateAccountUserFieldAsync_UpdatedUserFieldsReturned()
|
||||
{
|
||||
var updatedAccountUserField = new AccountUserField()
|
||||
{
|
||||
AccountNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y",
|
||||
LastMaintained = Convert.ToDateTime("9/1/2001")
|
||||
};
|
||||
_mockAccountUserFieldDao.Setup(x => x.UpdateAccountUserField(It.IsAny<CoreApiMessage<AccountUserFieldRequest>>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<string>())).ReturnsAsync(updatedAccountUserField);
|
||||
|
||||
var accountUserUpdateRequest = new AccountUserFieldRequest()
|
||||
{
|
||||
AccountNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
};
|
||||
var result = await _accountUserFieldService.UpdateAccountUserFieldAsync(accountUserUpdateRequest, 10002312312, "testaccountidfdafdfasfdsf", "TEST1");
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual(updatedAccountUserField, result);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void InsertAccountUserFieldAsync_ExceptionThrown()
|
||||
{
|
||||
_mockAccountUserFieldDao.Setup(x => x.InsertAccountUserField(It.IsAny<CoreApiMessage<AccountUserFieldRequest>>(), It.IsAny<string>())).Throws(new Exception("Oops"));
|
||||
|
||||
var accountUserUpdateRequest = new AccountUserFieldRequest()
|
||||
{
|
||||
AccountNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
};
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _accountUserFieldService.InsertAccountUserFieldAsync(accountUserUpdateRequest, "testaccountidfdafdfasfdsf"));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task InsertAccountUserFieldAsync_InsertUserFieldsReturned()
|
||||
{
|
||||
var createdAccountUserField = new AccountUserField()
|
||||
{
|
||||
AccountNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y",
|
||||
LastMaintained = Convert.ToDateTime("9/1/2001")
|
||||
};
|
||||
_mockAccountUserFieldDao.Setup(x => x.InsertAccountUserField(It.IsAny<CoreApiMessage<AccountUserFieldRequest>>(),
|
||||
It.IsAny<string>())).ReturnsAsync(createdAccountUserField);
|
||||
|
||||
var accountUserUpdateRequest = new AccountUserFieldRequest()
|
||||
{
|
||||
AccountNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
};
|
||||
var result = await _accountUserFieldService.InsertAccountUserFieldAsync(accountUserUpdateRequest, "testaccountidfdafdfasfdsf");
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual(createdAccountUserField, result);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void UpdateAccountUserFieldsAsync_AccountNull_NullExceptionThrown()
|
||||
{
|
||||
var accountUserFieldUpdateRequests = new List<AccountUserFieldRequest>()
|
||||
{
|
||||
new AccountUserFieldRequest()
|
||||
{
|
||||
AccountNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
|
||||
},
|
||||
new AccountUserFieldRequest()
|
||||
{
|
||||
AccountNumber = 100002,
|
||||
UserFieldCode = "TEST2",
|
||||
Value = "N"
|
||||
}
|
||||
};
|
||||
Account testAccount = null;
|
||||
_mockAccountService.Setup(x => x.GetAccountDetailsByAccountNumber(It.IsAny<long>())).ReturnsAsync(testAccount);
|
||||
|
||||
Assert.ThrowsAsync<NullReferenceException>(async () =>
|
||||
await _accountUserFieldService.UpdateAccountUserFieldsAsync(accountUserFieldUpdateRequests));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void UpdateAccountUserFieldsAsync_ExistingUserFieldNull_NullExceptionThrown()
|
||||
{
|
||||
var accountUserFieldUpdateRequests = new List<AccountUserFieldRequest>()
|
||||
{
|
||||
new AccountUserFieldRequest()
|
||||
{
|
||||
AccountNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
|
||||
},
|
||||
new AccountUserFieldRequest()
|
||||
{
|
||||
AccountNumber = 100002,
|
||||
UserFieldCode = "TEST2",
|
||||
Value = "N"
|
||||
}
|
||||
};
|
||||
Account testAccount = new Account()
|
||||
{
|
||||
Id = "TEST-adsfasdfas[]djfas"
|
||||
};
|
||||
_mockAccountService.Setup(x => x.GetAccountDetailsByAccountNumber(It.IsAny<long>())).ReturnsAsync(testAccount);
|
||||
|
||||
IEnumerable<AccountUserField> accountUserFields = new List<AccountUserField>();
|
||||
CoreMessageHeader coreMessageHeader = new CoreMessageHeader();
|
||||
CoreApiMessage<IEnumerable<AccountUserField>> coreApiMessageAccountUserFields = new CoreApiMessage<IEnumerable<AccountUserField>>(coreMessageHeader, accountUserFields);
|
||||
_mockAccountUserFieldDao.Setup(x => x.FindAccountUserFieldCoreApiResponseByAccountId(It.IsAny<CoreRequestParameters>(),
|
||||
It.IsAny<string>())).ReturnsAsync(coreApiMessageAccountUserFields);
|
||||
|
||||
Assert.ThrowsAsync<NullReferenceException>(async () =>
|
||||
await _accountUserFieldService.UpdateAccountUserFieldsAsync(accountUserFieldUpdateRequests));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void UpdateAccountUserFieldsAsync_UpdateUserFieldNull_NullExceptionThrown()
|
||||
{
|
||||
var accountUserFieldUpdateRequests = new List<AccountUserFieldRequest>()
|
||||
{
|
||||
new AccountUserFieldRequest()
|
||||
{
|
||||
AccountNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
|
||||
},
|
||||
new AccountUserFieldRequest()
|
||||
{
|
||||
AccountNumber = 100002,
|
||||
UserFieldCode = "TEST2",
|
||||
Value = "N"
|
||||
}
|
||||
};
|
||||
Account testAccount = new Account()
|
||||
{
|
||||
Id = "TEST-adsfasdfas[]djfas"
|
||||
};
|
||||
_mockAccountService.Setup(x => x.GetAccountDetailsByAccountNumber(It.IsAny<long>())).ReturnsAsync(testAccount);
|
||||
|
||||
IEnumerable<AccountUserField> accountUserFields = new List<AccountUserField>()
|
||||
{
|
||||
new AccountUserField()
|
||||
{
|
||||
Id = "TEST1",
|
||||
AccountNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "N"
|
||||
},
|
||||
new AccountUserField()
|
||||
{
|
||||
Id = "TEST2",
|
||||
AccountNumber = 100002,
|
||||
UserFieldCode = "TEST2",
|
||||
Value = "Y"
|
||||
}
|
||||
};
|
||||
CoreMessageHeader coreMessageHeader = new CoreMessageHeader(1122000321);
|
||||
CoreApiMessage<IEnumerable<AccountUserField>> coreApiMessageAccountUserFields = new CoreApiMessage<IEnumerable<AccountUserField>>(coreMessageHeader, accountUserFields);
|
||||
_mockAccountUserFieldDao.Setup(x => x.FindAccountUserFieldCoreApiResponseByAccountId(It.IsAny<CoreRequestParameters>(),
|
||||
It.IsAny<string>())).ReturnsAsync(coreApiMessageAccountUserFields);
|
||||
|
||||
AccountUserField updatedAccountUserField = null;
|
||||
_mockAccountUserFieldDao.Setup(x => x.UpdateAccountUserField(It.IsAny<CoreApiMessage<AccountUserFieldRequest>>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<string>())).ReturnsAsync(updatedAccountUserField);
|
||||
|
||||
Assert.ThrowsAsync<NullReferenceException>(async () =>
|
||||
await _accountUserFieldService.UpdateAccountUserFieldsAsync(accountUserFieldUpdateRequests));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task UpdateAccountUserFieldsAsync_ListofUpdateduserfields()
|
||||
{
|
||||
var request1 = new AccountUserFieldRequest()
|
||||
{
|
||||
AccountNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
|
||||
};
|
||||
var request2 = new AccountUserFieldRequest()
|
||||
{
|
||||
AccountNumber = 100002,
|
||||
UserFieldCode = "TEST2",
|
||||
Value = "N"
|
||||
};
|
||||
|
||||
var accountUserFieldUpdateRequests = new List<AccountUserFieldRequest>()
|
||||
{
|
||||
request1,
|
||||
request2
|
||||
};
|
||||
|
||||
Account testAccount = new Account()
|
||||
{
|
||||
Id = "TEST-adsfasdfas[]djfas"
|
||||
};
|
||||
_mockAccountService.Setup(x => x.GetAccountDetailsByAccountNumber(It.IsAny<long>())).ReturnsAsync(testAccount);
|
||||
|
||||
|
||||
var accountUserField1 = new AccountUserField()
|
||||
{
|
||||
Id = "TEST1",
|
||||
AccountNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "N"
|
||||
};
|
||||
var accountUserField2 = new AccountUserField()
|
||||
{
|
||||
Id = "TEST2",
|
||||
AccountNumber = 100002,
|
||||
UserFieldCode = "TEST2",
|
||||
Value = "Y"
|
||||
};
|
||||
|
||||
IEnumerable<AccountUserField> accountUserFields = new List<AccountUserField>()
|
||||
{
|
||||
accountUserField1,
|
||||
accountUserField2
|
||||
};
|
||||
CoreMessageHeader coreMessageHeader = new CoreMessageHeader(1122000321);
|
||||
CoreApiMessage<IEnumerable<AccountUserField>> coreApiMessageAccountUserFields = new CoreApiMessage<IEnumerable<AccountUserField>>(coreMessageHeader, accountUserFields);
|
||||
_mockAccountUserFieldDao.Setup(x => x.FindAccountUserFieldCoreApiResponseByAccountId(It.IsAny<CoreRequestParameters>(),
|
||||
It.IsAny<string>())).ReturnsAsync(coreApiMessageAccountUserFields);
|
||||
|
||||
AccountUserField updatedAccountUserField1 = new AccountUserField()
|
||||
{
|
||||
AccountNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
};
|
||||
_mockAccountUserFieldDao.Setup(x => x.UpdateAccountUserField(It.IsAny<CoreApiMessage<AccountUserFieldRequest>>(),
|
||||
It.IsAny<string>(),
|
||||
accountUserField1.Id)).ReturnsAsync(updatedAccountUserField1);
|
||||
|
||||
AccountUserField updatedAccountUserField2 = new AccountUserField()
|
||||
{
|
||||
AccountNumber = 100002,
|
||||
UserFieldCode = "TEST2",
|
||||
Value = "N"
|
||||
};
|
||||
_mockAccountUserFieldDao.Setup(x => x.UpdateAccountUserField(It.IsAny<CoreApiMessage<AccountUserFieldRequest>>(),
|
||||
It.IsAny<string>(),
|
||||
accountUserField2.Id)).ReturnsAsync(updatedAccountUserField2);
|
||||
|
||||
var result = await _accountUserFieldService.UpdateAccountUserFieldsAsync(accountUserFieldUpdateRequests);
|
||||
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual(2, result.Count());
|
||||
var result1 = result.FirstOrDefault(r => r.UserFieldCode == "TEST1");
|
||||
Assert.NotNull(result1);
|
||||
Assert.AreEqual("Y", result1.Value);
|
||||
Assert.AreEqual(100001, result1.AccountNumber);
|
||||
|
||||
var result2 = result.FirstOrDefault(r => r.UserFieldCode == "TEST2");
|
||||
Assert.NotNull(result2);
|
||||
Assert.AreEqual("N", result2.Value);
|
||||
Assert.AreEqual(100002, result2.AccountNumber);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void InsertAccountUserFieldsAsync_AccountNull_NullExceptionThrown()
|
||||
{
|
||||
var accountUserFieldUpdateRequests = new List<AccountUserFieldRequest>()
|
||||
{
|
||||
new AccountUserFieldRequest()
|
||||
{
|
||||
AccountNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
|
||||
},
|
||||
new AccountUserFieldRequest()
|
||||
{
|
||||
AccountNumber = 100002,
|
||||
UserFieldCode = "TEST2",
|
||||
Value = "N"
|
||||
}
|
||||
};
|
||||
Account testAccount = null;
|
||||
_mockAccountService.Setup(x => x.GetAccountDetailsByAccountNumber(It.IsAny<long>())).ReturnsAsync(testAccount);
|
||||
|
||||
Assert.ThrowsAsync<NullReferenceException>(async () =>
|
||||
await _accountUserFieldService.InsertAccountUserFieldsAsync(accountUserFieldUpdateRequests));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task InsertAccountUserFieldsAsync_ListofInsertedUserfields()
|
||||
{
|
||||
|
||||
var testAccount = new Account()
|
||||
{
|
||||
Id = "TEST-adsfasdfas[]djfas"
|
||||
};
|
||||
_mockAccountService.Setup(x => x.GetAccountDetailsByAccountNumber(It.IsAny<long>())).ReturnsAsync(testAccount);
|
||||
|
||||
var messageHeader = new CoreMessageHeader() { };
|
||||
var accountUserFieldRequest1 = new AccountUserFieldRequest()
|
||||
{
|
||||
AccountNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
};
|
||||
var coreApiMessage = new CoreApiMessage<AccountUserFieldRequest>(messageHeader, accountUserFieldRequest1);
|
||||
var createdAccountUserField1 = new AccountUserField()
|
||||
{
|
||||
AccountNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
};
|
||||
_mockAccountUserFieldDao.Setup(x => x.InsertAccountUserField(It.IsAny<CoreApiMessage<AccountUserFieldRequest>>(),
|
||||
testAccount.Id)).ReturnsAsync(createdAccountUserField1);
|
||||
|
||||
var accountUserFieldUpdateRequests = new List<AccountUserFieldRequest>()
|
||||
{
|
||||
accountUserFieldRequest1
|
||||
};
|
||||
var result = await _accountUserFieldService.InsertAccountUserFieldsAsync(accountUserFieldUpdateRequests);
|
||||
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual(1, result.Count());
|
||||
var result1 = result.FirstOrDefault(r => r.UserFieldCode == "TEST1");
|
||||
Assert.NotNull(result1);
|
||||
Assert.AreEqual("Y", result1.Value);
|
||||
Assert.AreEqual(100001, result1.AccountNumber);
|
||||
}
|
||||
}
|
||||
}
|
||||
+909
@@ -0,0 +1,909 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using LCU.Api.Internal.CoreApiWrapper.Services;
|
||||
using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Activity;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Tax;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.LcuModels.Activity;
|
||||
using LCU.Library.Internal.Exceptions;
|
||||
using Moq;
|
||||
using NUnit.Framework;
|
||||
using FailedToParseException = LCU.Library.Internal.CoreApiWrapperLib.Exceptions.FailedToParseException;
|
||||
|
||||
namespace LCU.Api.Internal.CoreApiWrapperTest.Service
|
||||
{
|
||||
public class ActivityServiceTest
|
||||
{
|
||||
private ActivityService _activityService;
|
||||
private Mock<ITaxService> _mockTaxService;
|
||||
private Mock<IActivityDao> _mockActivityDao;
|
||||
|
||||
[SetUp]
|
||||
public void SetUp()
|
||||
{
|
||||
_mockActivityDao = new Mock<IActivityDao>();
|
||||
_mockTaxService = new Mock<ITaxService>();
|
||||
_activityService = new ActivityService(_mockActivityDao.Object, _mockTaxService.Object);
|
||||
|
||||
_mockActivityDao.Setup(x => x.GetNewCheckingActivities(It.IsAny<DateTime>(), It.IsAny<long>(), It.IsAny<int>())).ReturnsAsync(
|
||||
new List<NewCheckingAccountActivity>()
|
||||
{
|
||||
new NewCheckingAccountActivity() { ActivityNbr = 1 },
|
||||
new NewCheckingAccountActivity() { ActivityNbr = 2 },
|
||||
new NewCheckingAccountActivity() { ActivityNbr = 3 }
|
||||
}).Verifiable();
|
||||
|
||||
_mockActivityDao.Setup(x => x.GetNewCheckingActivitiesNewerThanDate(It.IsAny<DateTime>(), It.IsAny<int>())).ReturnsAsync(
|
||||
new List<NewCheckingAccountActivity>()
|
||||
{
|
||||
new NewCheckingAccountActivity() { ActivityNbr = 1 },
|
||||
new NewCheckingAccountActivity() { ActivityNbr = 2 },
|
||||
new NewCheckingAccountActivity() { ActivityNbr = 3 }
|
||||
}).Verifiable();
|
||||
|
||||
|
||||
_mockActivityDao.Setup(x => x.GetNewCheckingActivitiesAfterActivityNbr(It.IsAny<long>(), It.IsAny<int>())).ReturnsAsync(
|
||||
new List<NewCheckingAccountActivity>()
|
||||
{
|
||||
new NewCheckingAccountActivity() { ActivityNbr = 1 },
|
||||
new NewCheckingAccountActivity() { ActivityNbr = 2 },
|
||||
new NewCheckingAccountActivity() { ActivityNbr = 3 }
|
||||
}).Verifiable();
|
||||
|
||||
_mockActivityDao.Setup(x => x.GetNewAtmCheckCardActivities(It.IsAny<DateTime>(), It.IsAny<long>(), It.IsAny<int>())).ReturnsAsync(
|
||||
new List<NewAtmCheckCardActivity>()
|
||||
{
|
||||
new NewAtmCheckCardActivity() { ActivityNbr = 1 },
|
||||
new NewAtmCheckCardActivity() { ActivityNbr = 2 },
|
||||
new NewAtmCheckCardActivity() { ActivityNbr = 3 }
|
||||
}).Verifiable();
|
||||
|
||||
_mockActivityDao.Setup(x => x.GetNewAtmCheckCardActivitiesNewerThanDate(It.IsAny<DateTime>(), It.IsAny<int>())).ReturnsAsync(
|
||||
new List<NewAtmCheckCardActivity>()
|
||||
{
|
||||
new NewAtmCheckCardActivity() { ActivityNbr = 1 },
|
||||
new NewAtmCheckCardActivity() { ActivityNbr = 2 },
|
||||
new NewAtmCheckCardActivity() { ActivityNbr = 3 }
|
||||
}).Verifiable();
|
||||
|
||||
|
||||
_mockActivityDao.Setup(x => x.GetNewAtmCheckCardActivitiesAfterActivityNbr(It.IsAny<long>(), It.IsAny<int>())).ReturnsAsync(
|
||||
new List<NewAtmCheckCardActivity>()
|
||||
{
|
||||
new NewAtmCheckCardActivity() { ActivityNbr = 1 },
|
||||
new NewAtmCheckCardActivity() { ActivityNbr = 2 },
|
||||
new NewAtmCheckCardActivity() { ActivityNbr = 3 }
|
||||
}).Verifiable();
|
||||
|
||||
_mockActivityDao.Setup(x => x.GetNewActivityManagerReferrals(It.IsAny<DateTime>(), It.IsAny<long>())).ReturnsAsync(
|
||||
new List<NewActivityManagerIncentiveReferral>()
|
||||
{
|
||||
new NewActivityManagerIncentiveReferral() { ActivityId = 1 },
|
||||
new NewActivityManagerIncentiveReferral() { ActivityId = 2 },
|
||||
new NewActivityManagerIncentiveReferral() { ActivityId = 3 }
|
||||
}).Verifiable();
|
||||
|
||||
_mockActivityDao.Setup(x => x.QueryActivityManagerActivity(It.IsAny<ActivityQueryRequest>())).ReturnsAsync(
|
||||
new List<NewActivityManagerIncentiveReferral>()
|
||||
{
|
||||
new NewActivityManagerIncentiveReferral() { ActivityId = 1 },
|
||||
new NewActivityManagerIncentiveReferral() { ActivityId = 2 },
|
||||
new NewActivityManagerIncentiveReferral() { ActivityId = 3 }
|
||||
}).Verifiable();
|
||||
|
||||
_mockActivityDao.Setup(x => x.GetNewActivityManagerReferralsNewerThan(It.IsAny<DateTime>())).ReturnsAsync(
|
||||
new List<NewActivityManagerIncentiveReferral>()
|
||||
{
|
||||
new NewActivityManagerIncentiveReferral() { ActivityId = 1 },
|
||||
new NewActivityManagerIncentiveReferral() { ActivityId = 2 },
|
||||
new NewActivityManagerIncentiveReferral() { ActivityId = 3 }
|
||||
}).Verifiable();
|
||||
|
||||
|
||||
_mockActivityDao.Setup(x => x.GetNewActivityManagerReferralsAfterActivityId(It.IsAny<long>())).ReturnsAsync(
|
||||
new List<NewActivityManagerIncentiveReferral>()
|
||||
{
|
||||
new NewActivityManagerIncentiveReferral() { ActivityId = 1 },
|
||||
new NewActivityManagerIncentiveReferral() { ActivityId = 2 },
|
||||
new NewActivityManagerIncentiveReferral() { ActivityId = 3 }
|
||||
}).Verifiable();
|
||||
|
||||
_mockActivityDao.Setup(x => x.GetNewMortgageSaleActivities(It.IsAny<DateTime?>(), It.IsAny<long?>())).ReturnsAsync(
|
||||
new List<NewLoanSaleActivity>()
|
||||
{
|
||||
new NewLoanSaleActivity() { ActivityNbr = 1 },
|
||||
new NewLoanSaleActivity() { ActivityNbr = 2 },
|
||||
new NewLoanSaleActivity() { ActivityNbr = 3 }
|
||||
}).Verifiable();
|
||||
|
||||
_mockActivityDao.Setup(x => x.GetNewVehicleSaleActivities(It.IsAny<DateTime?>(), It.IsAny<long?>())).ReturnsAsync(
|
||||
new List<NewLoanSaleActivity>()
|
||||
{
|
||||
new NewLoanSaleActivity() { ActivityNbr = 1 },
|
||||
new NewLoanSaleActivity() { ActivityNbr = 2 },
|
||||
new NewLoanSaleActivity() { ActivityNbr = 3 }
|
||||
}).Verifiable();
|
||||
|
||||
_mockActivityDao.Setup(x => x.GetNewDebtProtectedLoanSaleActivities(It.IsAny<DateTime?>(), It.IsAny<long?>())).ReturnsAsync(
|
||||
new List<NewLoanSaleActivity>()
|
||||
{
|
||||
new NewLoanSaleActivity() { ActivityNbr = 1 },
|
||||
new NewLoanSaleActivity() { ActivityNbr = 2 },
|
||||
new NewLoanSaleActivity() { ActivityNbr = 3 }
|
||||
}).Verifiable();
|
||||
|
||||
_mockActivityDao.Setup(x => x.GetEStatementDeliveryActivity(It.IsAny<DateTime?>())).ReturnsAsync(
|
||||
new List<EStatementDeliveryMethod>()
|
||||
{
|
||||
new EStatementDeliveryMethod() { ActivityNumber = 1 },
|
||||
new EStatementDeliveryMethod() { ActivityNumber = 2 },
|
||||
new EStatementDeliveryMethod() { ActivityNumber = 3 }
|
||||
}).Verifiable();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewCheckingAccountActivities_Both_Ok()
|
||||
{
|
||||
var results = await _activityService.GetNewCheckingAccountActivities("2020-04-15T11:00:00", 5, 100);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(3, results.Count);
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 1));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 2));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 3));
|
||||
|
||||
_mockActivityDao.Verify(x =>
|
||||
x.GetNewCheckingActivities(
|
||||
It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
|
||||
It.Is<long>(actvnbr => actvnbr == 5), 100));
|
||||
|
||||
_mockActivityDao.Verify(x => x.GetNewCheckingActivities(It.IsAny<DateTime>(), It.IsAny<long>(), It.IsAny<int>()), Times.Once);
|
||||
_mockActivityDao.Verify(x => x.GetNewCheckingActivitiesAfterActivityNbr(It.IsAny<long>(), It.IsAny<int>()), Times.Never);
|
||||
_mockActivityDao.Verify(x => x.GetNewCheckingActivitiesNewerThanDate(It.IsAny<DateTime>(), It.IsAny<int>()), Times.Never);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewCheckingAccountActivities_No_ActvNbr_Ok()
|
||||
{
|
||||
var results = await _activityService.GetNewCheckingAccountActivities("2020-04-15T11:00:00", null, 100);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(3, results.Count);
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 1));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 2));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 3));
|
||||
|
||||
_mockActivityDao.Verify(x =>
|
||||
x.GetNewCheckingActivitiesNewerThanDate(
|
||||
It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0), 100));
|
||||
|
||||
_mockActivityDao.Verify(x => x.GetNewCheckingActivities(It.IsAny<DateTime>(), It.IsAny<long>(), It.IsAny<int>()), Times.Never);
|
||||
_mockActivityDao.Verify(x => x.GetNewCheckingActivitiesAfterActivityNbr(It.IsAny<long>(), It.IsAny<int>()), Times.Never);
|
||||
_mockActivityDao.Verify(x => x.GetNewCheckingActivitiesNewerThanDate(It.IsAny<DateTime>(), It.IsAny<int>()), Times.Once);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewCheckingAccountActivities_No_Date_Ok()
|
||||
{
|
||||
var results = await _activityService.GetNewCheckingAccountActivities(null, 5, 100);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(3, results.Count);
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 1));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 2));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 3));
|
||||
|
||||
_mockActivityDao.Verify(x => x.GetNewCheckingActivitiesAfterActivityNbr(It.Is<long>(nbr => nbr == 5), 100));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewCheckingAccountActivities_No_Params_Exception()
|
||||
{
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _activityService.GetNewCheckingAccountActivities(null, null, 100));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewCheckingAccountActivities_FailedToParse_BadDateTime()
|
||||
{
|
||||
Assert.ThrowsAsync<FailedToParseException>(async () =>
|
||||
await _activityService.GetNewCheckingAccountActivities("DateTimes are a Devs Best Friend", 1, 100));
|
||||
|
||||
Assert.ThrowsAsync<FailedToParseException>(async () =>
|
||||
await _activityService.GetNewCheckingAccountActivities("DateTimes are a Devs Best Friend", null, 100));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewCheckingAccountActivities_Exception()
|
||||
{
|
||||
_mockActivityDao.Setup(x => x.GetNewCheckingActivities(It.IsAny<DateTime>(), It.IsAny<long>(), It.IsAny<int>())).Throws(new Exception("Oops"));
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _activityService.GetNewCheckingAccountActivities("2020-04-15T11:00:00", 10, 100));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewAtmCheckCardActivities_Both_Ok()
|
||||
{
|
||||
var results = await _activityService.GetNewAtmCheckCardActivities("2020-04-15T11:00:00", 5, 100);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(3, results.Count);
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 1));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 2));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 3));
|
||||
|
||||
_mockActivityDao.Verify(x =>
|
||||
x.GetNewAtmCheckCardActivities(
|
||||
It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
|
||||
It.Is<long>(actvnbr => actvnbr == 5), 100));
|
||||
|
||||
_mockActivityDao.Verify(x => x.GetNewAtmCheckCardActivities(It.IsAny<DateTime>(), It.IsAny<long>(), It.IsAny<int>()), Times.Once);
|
||||
_mockActivityDao.Verify(x => x.GetNewAtmCheckCardActivitiesAfterActivityNbr(It.IsAny<long>(), It.IsAny<int>()), Times.Never);
|
||||
_mockActivityDao.Verify(x => x.GetNewAtmCheckCardActivitiesNewerThanDate(It.IsAny<DateTime>(), It.IsAny<int>()), Times.Never);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewAtmCheckCardActivities_No_ActvNbr_Ok()
|
||||
{
|
||||
var results = await _activityService.GetNewAtmCheckCardActivities("2020-04-15T11:00:00", null, 100);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(3, results.Count);
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 1));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 2));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 3));
|
||||
|
||||
_mockActivityDao.Verify(x =>
|
||||
x.GetNewAtmCheckCardActivitiesNewerThanDate(
|
||||
It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0), 100));
|
||||
|
||||
_mockActivityDao.Verify(x => x.GetNewAtmCheckCardActivities(It.IsAny<DateTime>(), It.IsAny<long>(), It.IsAny<int>()), Times.Never);
|
||||
_mockActivityDao.Verify(x => x.GetNewAtmCheckCardActivitiesAfterActivityNbr(It.IsAny<long>(), It.IsAny<int>()), Times.Never);
|
||||
_mockActivityDao.Verify(x => x.GetNewAtmCheckCardActivitiesNewerThanDate(It.IsAny<DateTime>(), It.IsAny<int>()), Times.Once);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewAtmCheckCardActivities_No_Date_Ok()
|
||||
{
|
||||
var results = await _activityService.GetNewAtmCheckCardActivities(null, 5, 100);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(3, results.Count);
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 1));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 2));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 3));
|
||||
|
||||
_mockActivityDao.Verify(x => x.GetNewAtmCheckCardActivitiesAfterActivityNbr(It.Is<long>(nbr => nbr == 5), 100));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewAtmCheckCardActivities_No_Params_Exception()
|
||||
{
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _activityService.GetNewAtmCheckCardActivities(null, null, 100));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewAtmCheckCardActivities_FailedToParse_BadDateTime()
|
||||
{
|
||||
Assert.ThrowsAsync<FailedToParseException>(async () =>
|
||||
await _activityService.GetNewAtmCheckCardActivities("DateTimes are a Devs Best Friend", 1, 100));
|
||||
|
||||
Assert.ThrowsAsync<FailedToParseException>(async () =>
|
||||
await _activityService.GetNewAtmCheckCardActivities("DateTimes are a Devs Best Friend", null, 100));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewAtmCheckCardActivities_Exception()
|
||||
{
|
||||
_mockActivityDao.Setup(x => x.GetNewAtmCheckCardActivities(It.IsAny<DateTime>(), It.IsAny<long>(), It.IsAny<int>())).Throws(new Exception("Oops"));
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _activityService.GetNewAtmCheckCardActivities("2020-04-15T11:00:00", 10, 100));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewEDeliveryStatementSaleActivities_Ok()
|
||||
{
|
||||
var results = await _activityService.GetEStatementDeliveryActivity("2020-04-15T11:00:00");
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(3, results.Count);
|
||||
Assert.True(results.Any(x => x.ActivityNumber == 1));
|
||||
Assert.True(results.Any(x => x.ActivityNumber == 2));
|
||||
Assert.True(results.Any(x => x.ActivityNumber == 3));
|
||||
|
||||
_mockActivityDao.Verify(x =>
|
||||
x.GetEStatementDeliveryActivity(
|
||||
It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0)
|
||||
));
|
||||
|
||||
_mockActivityDao.Verify(x => x.GetEStatementDeliveryActivity(It.IsAny<DateTime>()), Times.Once);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewEDeliveryStatementSaleActivities_Exception()
|
||||
{
|
||||
_mockActivityDao.Setup(x => x.GetEStatementDeliveryActivity(It.IsAny<DateTime>())).Throws(new Exception("Oops"));
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _activityService.GetEStatementDeliveryActivity("2020-04-15T11:00:00"));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewActivityManagerIncentiveReferrals_Both_Ok()
|
||||
{
|
||||
var results = await _activityService.GetNewActivityManagerIncentiveReferrals("2020-04-15T11:00:00", 5);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(3, results.Count);
|
||||
Assert.True(results.Any(x => x.ActivityId == 1));
|
||||
Assert.True(results.Any(x => x.ActivityId == 2));
|
||||
Assert.True(results.Any(x => x.ActivityId == 3));
|
||||
|
||||
_mockActivityDao.Verify(x =>
|
||||
x.GetNewActivityManagerReferrals(
|
||||
It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
|
||||
It.Is<long>(actvnbr => actvnbr == 5)));
|
||||
|
||||
_mockActivityDao.Verify(x => x.GetNewActivityManagerReferrals(It.IsAny<DateTime>(), It.IsAny<long>()), Times.Once);
|
||||
_mockActivityDao.Verify(x => x.GetNewActivityManagerReferralsAfterActivityId(It.IsAny<long>()), Times.Never);
|
||||
_mockActivityDao.Verify(x => x.GetNewActivityManagerReferralsNewerThan(It.IsAny<DateTime>()), Times.Never);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewActivityManagerIncentiveReferrals_No_ActvNbr_Ok()
|
||||
{
|
||||
var results = await _activityService.GetNewActivityManagerIncentiveReferrals("2020-04-15T11:00:00", null);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(3, results.Count);
|
||||
Assert.True(results.Any(x => x.ActivityId == 1));
|
||||
Assert.True(results.Any(x => x.ActivityId == 2));
|
||||
Assert.True(results.Any(x => x.ActivityId == 3));
|
||||
|
||||
_mockActivityDao.Verify(x =>
|
||||
x.GetNewActivityManagerReferralsNewerThan(
|
||||
It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0)));
|
||||
|
||||
_mockActivityDao.Verify(x => x.GetNewActivityManagerReferrals(It.IsAny<DateTime>(), It.IsAny<long>()), Times.Never);
|
||||
_mockActivityDao.Verify(x => x.GetNewActivityManagerReferralsAfterActivityId(It.IsAny<long>()), Times.Never);
|
||||
_mockActivityDao.Verify(x => x.GetNewActivityManagerReferralsNewerThan(It.IsAny<DateTime>()), Times.Once);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewActivityManagerIncentiveReferrals_No_Date_Ok()
|
||||
{
|
||||
var results = await _activityService.GetNewActivityManagerIncentiveReferrals(null, 5);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(3, results.Count);
|
||||
Assert.True(results.Any(x => x.ActivityId == 1));
|
||||
Assert.True(results.Any(x => x.ActivityId == 2));
|
||||
Assert.True(results.Any(x => x.ActivityId == 3));
|
||||
|
||||
_mockActivityDao.Verify(x =>
|
||||
x.GetNewActivityManagerReferralsAfterActivityId(
|
||||
It.Is<long>(nbr => nbr == 5)));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewActivityManagerIncentiveReferrals_No_Params_Exception()
|
||||
{
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _activityService.GetNewActivityManagerIncentiveReferrals(null, null));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewActivityManagerIncentiveReferrals_FailedToParse_BadDateTime()
|
||||
{
|
||||
Assert.ThrowsAsync<FailedToParseException>(async () =>
|
||||
await _activityService.GetNewActivityManagerIncentiveReferrals("DateTimes are a Devs Best Friend", 1));
|
||||
|
||||
Assert.ThrowsAsync<FailedToParseException>(async () =>
|
||||
await _activityService.GetNewActivityManagerIncentiveReferrals("DateTimes are a Devs Best Friend", null));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewActivityManagerIncentiveReferrals_Exception()
|
||||
{
|
||||
_mockActivityDao.Setup(x => x.GetNewActivityManagerReferrals(It.IsAny<DateTime>(), It.IsAny<long>())).Throws(new Exception("Oops"));
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _activityService.GetNewActivityManagerIncentiveReferrals("2020-04-15T11:00:00", 10));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewMortgageSalesActivities_Ok()
|
||||
{
|
||||
var results = await _activityService.GetNewMortgageSaleActivities("2020-04-15T11:00:00", 5);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(3, results.Count);
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 1));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 2));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 3));
|
||||
|
||||
_mockActivityDao.Verify(x =>
|
||||
x.GetNewMortgageSaleActivities(
|
||||
It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
|
||||
It.Is<long>(actvnbr => actvnbr == 5)));
|
||||
|
||||
_mockActivityDao.Verify(x => x.GetNewMortgageSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>()), Times.Once);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewMortgageSaleActivities_No_ActvNbr_Ok()
|
||||
{
|
||||
var results = await _activityService.GetNewMortgageSaleActivities("2020-04-15T11:00:00", null);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(3, results.Count);
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 1));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 2));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 3));
|
||||
|
||||
_mockActivityDao.Verify(x => x.GetNewMortgageSaleActivities(It.IsAny<DateTime>(), It.Is<long?>(x => x == null)), Times.Once);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewMortgageSaleActivities_No_Date_Ok()
|
||||
{
|
||||
var results = await _activityService.GetNewMortgageSaleActivities(null, 5);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(3, results.Count);
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 1));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 2));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 3));
|
||||
|
||||
_mockActivityDao.Verify(x => x.GetNewMortgageSaleActivities(It.Is<DateTime?>(x => x.HasValue == false), It.IsAny<long>()), Times.Once);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewMortgageSaleActivities_No_Params_Exception()
|
||||
{
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _activityService.GetNewMortgageSaleActivities(null, null));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewMortgageSaleActivities_FailedToParse_BadDateTime()
|
||||
{
|
||||
Assert.ThrowsAsync<FailedToParseException>(async () =>
|
||||
await _activityService.GetNewMortgageSaleActivities("DateTimes are a Devs Best Friend", 1));
|
||||
|
||||
Assert.ThrowsAsync<FailedToParseException>(async () =>
|
||||
await _activityService.GetNewMortgageSaleActivities("DateTimes are a Devs Best Friend", null));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewMortgageSaleActivities_Exception()
|
||||
{
|
||||
_mockActivityDao.Setup(x => x.GetNewMortgageSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>())).Throws(new Exception("Oops"));
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _activityService.GetNewMortgageSaleActivities("2020-04-15T11:00:00", 10));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewMortgageSaleActivities_Both_Ok()
|
||||
{
|
||||
var results = await _activityService.GetNewMortgageSaleActivities("2020-04-15T11:00:00", 5);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(3, results.Count);
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 1));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 2));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 3));
|
||||
|
||||
_mockActivityDao.Verify(x =>
|
||||
x.GetNewMortgageSaleActivities(
|
||||
It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
|
||||
It.Is<long>(actvnbr => actvnbr == 5)));
|
||||
|
||||
_mockActivityDao.Verify(x => x.GetNewMortgageSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>()), Times.Once);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewVehicleSaleActivities_Ok()
|
||||
{
|
||||
var results = await _activityService.GetNewVehicleSaleActivities("2020-04-15T11:00:00", 5);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(3, results.Count);
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 1));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 2));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 3));
|
||||
|
||||
_mockActivityDao.Verify(x =>
|
||||
x.GetNewVehicleSaleActivities(
|
||||
It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
|
||||
It.Is<long>(actvnbr => actvnbr == 5)));
|
||||
|
||||
_mockActivityDao.Verify(x => x.GetNewVehicleSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>()), Times.Once);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewVehicleSaleActivities_No_ActvNbr_Ok()
|
||||
{
|
||||
var results = await _activityService.GetNewVehicleSaleActivities("2020-04-15T11:00:00", null);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(3, results.Count);
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 1));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 2));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 3));
|
||||
|
||||
_mockActivityDao.Verify(x => x.GetNewVehicleSaleActivities(It.IsAny<DateTime>(), It.Is<long?>(x => x == null)), Times.Once);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewVehicleSaleActivities_No_Date_Ok()
|
||||
{
|
||||
var results = await _activityService.GetNewVehicleSaleActivities(null, 5);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(3, results.Count);
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 1));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 2));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 3));
|
||||
|
||||
_mockActivityDao.Verify(x => x.GetNewVehicleSaleActivities(It.Is<DateTime?>(x => x.HasValue == false), It.IsAny<long>()), Times.Once);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewVehicleSaleActivities_No_Params_Exception()
|
||||
{
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _activityService.GetNewVehicleSaleActivities(null, null));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewVehicleSaleActivities_FailedToParse_BadDateTime()
|
||||
{
|
||||
Assert.ThrowsAsync<FailedToParseException>(async () =>
|
||||
await _activityService.GetNewVehicleSaleActivities("DateTimes are a Devs Best Friend", 1));
|
||||
|
||||
Assert.ThrowsAsync<FailedToParseException>(async () =>
|
||||
await _activityService.GetNewVehicleSaleActivities("DateTimes are a Devs Best Friend", null));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewVehicleSaleActivities_Exception()
|
||||
{
|
||||
_mockActivityDao.Setup(x => x.GetNewVehicleSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>())).Throws(new Exception("Oops"));
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _activityService.GetNewVehicleSaleActivities("2020-04-15T11:00:00", 10));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewVehicleSaleActivities_Both_Ok()
|
||||
{
|
||||
var results = await _activityService.GetNewVehicleSaleActivities("2020-04-15T11:00:00", 5);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(3, results.Count);
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 1));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 2));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 3));
|
||||
|
||||
_mockActivityDao.Verify(x =>
|
||||
x.GetNewVehicleSaleActivities(
|
||||
It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
|
||||
It.Is<long>(actvnbr => actvnbr == 5)));
|
||||
|
||||
_mockActivityDao.Verify(x => x.GetNewVehicleSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>()), Times.Once);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewDebtProtectedLoanSaleActivities_Ok()
|
||||
{
|
||||
var results = await _activityService.GetNewDebtProtectedLoanSaleActivities("2020-04-15T11:00:00", 5);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(3, results.Count);
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 1));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 2));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 3));
|
||||
|
||||
_mockActivityDao.Verify(x =>
|
||||
x.GetNewDebtProtectedLoanSaleActivities(
|
||||
It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
|
||||
It.Is<long>(actvnbr => actvnbr == 5)));
|
||||
|
||||
_mockActivityDao.Verify(x => x.GetNewDebtProtectedLoanSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>()), Times.Once);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewDebtProtectedLoanSaleActivities_No_ActvNbr_Ok()
|
||||
{
|
||||
var results = await _activityService.GetNewDebtProtectedLoanSaleActivities("2020-04-15T11:00:00", null);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(3, results.Count);
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 1));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 2));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 3));
|
||||
|
||||
_mockActivityDao.Verify(x => x.GetNewDebtProtectedLoanSaleActivities(It.IsAny<DateTime>(), It.Is<long?>(x => x == null)), Times.Once);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewDebtProtectedLoanSaleActivities_No_Date_Ok()
|
||||
{
|
||||
var results = await _activityService.GetNewDebtProtectedLoanSaleActivities(null, 5);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(3, results.Count);
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 1));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 2));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 3));
|
||||
|
||||
_mockActivityDao.Verify(x => x.GetNewDebtProtectedLoanSaleActivities(It.Is<DateTime?>(x => x.HasValue == false), It.IsAny<long>()), Times.Once);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewDebtProtectedLoanSaleActivities_No_Params_Exception()
|
||||
{
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _activityService.GetNewDebtProtectedLoanSaleActivities(null, null));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewDebtProtectedLoanSaleActivities_FailedToParse_BadDateTime()
|
||||
{
|
||||
Assert.ThrowsAsync<FailedToParseException>(async () =>
|
||||
await _activityService.GetNewDebtProtectedLoanSaleActivities("DateTimes are a Devs Best Friend", 1));
|
||||
|
||||
Assert.ThrowsAsync<FailedToParseException>(async () =>
|
||||
await _activityService.GetNewDebtProtectedLoanSaleActivities("DateTimes are a Devs Best Friend", null));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewDebtProtectedLoanSaleActivities_Exception()
|
||||
{
|
||||
_mockActivityDao.Setup(x => x.GetNewDebtProtectedLoanSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>())).Throws(new Exception("Oops"));
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _activityService.GetNewDebtProtectedLoanSaleActivities("2020-04-15T11:00:00", 10));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetNewDebtProtectedLoanSaleActivities_Both_Ok()
|
||||
{
|
||||
var results = await _activityService.GetNewDebtProtectedLoanSaleActivities("2020-04-15T11:00:00", 5);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(3, results.Count);
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 1));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 2));
|
||||
Assert.True(results.Any(x => x.ActivityNbr == 3));
|
||||
|
||||
_mockActivityDao.Verify(x =>
|
||||
x.GetNewDebtProtectedLoanSaleActivities(
|
||||
It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
|
||||
It.Is<long>(actvnbr => actvnbr == 5)));
|
||||
|
||||
_mockActivityDao.Verify(x => x.GetNewDebtProtectedLoanSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>()), Times.Once);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task QueryActivityManagerActivity_Ok()
|
||||
{
|
||||
var results = await _activityService.QueryActivityManagerActivity(new ActivityQueryRequest()
|
||||
{
|
||||
ActivityIds = new List<long>() { 1, 2, 3 }
|
||||
});
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(3, results.Count);
|
||||
Assert.True(results.Any(x => x.ActivityId == 1));
|
||||
Assert.True(results.Any(x => x.ActivityId == 2));
|
||||
Assert.True(results.Any(x => x.ActivityId == 3));
|
||||
|
||||
_mockActivityDao.Verify(x =>
|
||||
x.QueryActivityManagerActivity(It.IsAny<ActivityQueryRequest>()));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task QueryActivityManagerActivity_Exception()
|
||||
{
|
||||
_mockActivityDao.Setup(x => x.QueryActivityManagerActivity(It.IsAny<ActivityQueryRequest>())).ThrowsAsync(new Exception("Oops"));
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _activityService.QueryActivityManagerActivity(new ActivityQueryRequest()
|
||||
{
|
||||
ActivityIds = new List<long>() { 1, 2, 3, 4, 5, 6, 7 }
|
||||
}));
|
||||
|
||||
_mockActivityDao.Verify(x =>
|
||||
x.QueryActivityManagerActivity(It.IsAny<ActivityQueryRequest>()));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task QueryActivityManagerActivity_DontHitCoreWhenEmpty()
|
||||
{
|
||||
_mockActivityDao.Setup(x => x.QueryActivityManagerActivity(It.IsAny<ActivityQueryRequest>())).ThrowsAsync(new Exception("Oops"));
|
||||
|
||||
|
||||
var result = await _activityService.QueryActivityManagerActivity(new ActivityQueryRequest()
|
||||
{
|
||||
ActivityIds = new List<long>()
|
||||
});
|
||||
|
||||
Assert.NotNull(result);
|
||||
|
||||
_mockActivityDao.Verify(x =>
|
||||
x.QueryActivityManagerActivity(It.IsAny<ActivityQueryRequest>()), Times.Never());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetPersonActivityByPhoneNumber_OK()
|
||||
{
|
||||
var phoneNumber = Guid.NewGuid().ToString();
|
||||
_mockActivityDao
|
||||
.Setup(x => x.GetPersonActivityByPhoneNumber(It.IsAny<string>()))
|
||||
.ReturnsAsync(new List<PersonRecentActivity>
|
||||
{
|
||||
new () { PersonNumber = DateTime.Now.Millisecond, HomePhone = phoneNumber }
|
||||
}).Verifiable();
|
||||
|
||||
var result = await _activityService.GetPersonActivityByPhoneNumber(phoneNumber);
|
||||
|
||||
Assert.NotNull(result);
|
||||
Assert.IsTrue(result.Success);
|
||||
Assert.AreEqual(phoneNumber, result.PersonRecentActivity?.HomePhone);
|
||||
_mockActivityDao.Verify(x => x.GetPersonActivityByPhoneNumber(It.IsAny<string>()), Times.Once);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetPersonActivityByPhoneNumber_MultipleReturn()
|
||||
{
|
||||
var phoneNumber = Guid.NewGuid().ToString();
|
||||
_mockActivityDao
|
||||
.Setup(x => x.GetPersonActivityByPhoneNumber(It.IsAny<string>()))
|
||||
.ReturnsAsync(new List<PersonRecentActivity>
|
||||
{
|
||||
new () { PersonNumber = DateTime.Now.Millisecond, HomePhone = phoneNumber },
|
||||
new () { PersonNumber = DateTime.Now.Millisecond, HomePhone = phoneNumber }
|
||||
}).Verifiable();
|
||||
|
||||
var result = await _activityService.GetPersonActivityByPhoneNumber(phoneNumber);
|
||||
|
||||
Assert.NotNull(result);
|
||||
Assert.IsFalse(result.Success);
|
||||
Assert.IsNotNull(result.Message);
|
||||
Assert.IsNull(result.PersonRecentActivity);
|
||||
_mockActivityDao.Verify(x => x.GetPersonActivityByPersonNumber(It.IsAny<string>()), Times.Never);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetPersonActivityByPhoneNumber_NoContent()
|
||||
{
|
||||
var phoneNumber = Guid.NewGuid().ToString();
|
||||
_mockActivityDao
|
||||
.Setup(x => x.GetPersonActivityByPhoneNumber(It.IsAny<string>()))
|
||||
.ReturnsAsync(new List<PersonRecentActivity>()).Verifiable();
|
||||
|
||||
var result = await _activityService.GetPersonActivityByPhoneNumber(phoneNumber);
|
||||
|
||||
Assert.NotNull(result);
|
||||
Assert.IsFalse(result.Success);
|
||||
Assert.IsNotNull(result.Message);
|
||||
Assert.IsNull(result.PersonRecentActivity);
|
||||
_mockActivityDao.Verify(x => x.GetPersonActivityByPersonNumber(It.IsAny<string>()), Times.Never);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetPersonActivityByPhoneNumber_Exception()
|
||||
{
|
||||
_mockActivityDao
|
||||
.Setup(x => x.GetPersonActivityByPhoneNumber(It.IsAny<string>()))
|
||||
.ThrowsAsync(new Exception());
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(async () =>
|
||||
await _activityService.GetPersonActivityByPhoneNumber(It.IsAny<string>()));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetPersonActivityByTaxId_OK()
|
||||
{
|
||||
var personNumber = DateTime.Now.Millisecond;
|
||||
var taxId = Guid.NewGuid().ToString();
|
||||
var persons = new List<PersonTaxIdDataResponse>
|
||||
{
|
||||
new()
|
||||
{
|
||||
PersonNumber = personNumber
|
||||
}
|
||||
};
|
||||
_mockTaxService.Setup(x => x.GetPersonsTaxIdData(It.IsAny<string>()))
|
||||
.ReturnsAsync(persons).Verifiable();
|
||||
_mockActivityDao
|
||||
.Setup(x => x.GetPersonActivityByPersonNumber(It.IsAny<string>()))
|
||||
.ReturnsAsync(new PersonRecentActivity
|
||||
{
|
||||
PersonNumber = personNumber
|
||||
}).Verifiable();
|
||||
|
||||
var result = await _activityService.GetPersonActivityByTaxId(taxId);
|
||||
|
||||
Assert.NotNull(result);
|
||||
Assert.IsTrue(result.Success);
|
||||
Assert.NotNull(result.PersonRecentActivity);
|
||||
Assert.AreEqual(personNumber, result.PersonRecentActivity?.PersonNumber);
|
||||
_mockActivityDao.Verify(x => x.GetPersonActivityByPersonNumber(It.IsAny<string>()), Times.Once);
|
||||
_mockTaxService.Verify(x => x.GetPersonsTaxIdData(It.IsAny<string>()), Times.Once);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetPersonActivityByTaxId_MultipleReturn()
|
||||
{
|
||||
var personNumber = DateTime.Now.Millisecond;
|
||||
var taxId = Guid.NewGuid().ToString();
|
||||
var persons = new List<PersonTaxIdDataResponse>
|
||||
{
|
||||
new() { PersonNumber = personNumber },
|
||||
new() { PersonNumber = personNumber }
|
||||
};
|
||||
_mockTaxService.Setup(x => x.GetPersonsTaxIdData(It.IsAny<string>()))
|
||||
.ReturnsAsync(persons).Verifiable();
|
||||
_mockActivityDao
|
||||
.Setup(x => x.GetPersonActivityByPersonNumber(It.IsAny<string>()))
|
||||
.ReturnsAsync(new PersonRecentActivity
|
||||
{
|
||||
PersonNumber = personNumber
|
||||
}).Verifiable();
|
||||
|
||||
var result = await _activityService.GetPersonActivityByTaxId(taxId);
|
||||
|
||||
Assert.NotNull(result);
|
||||
Assert.IsFalse(result.Success);
|
||||
Assert.IsNotNull(result.Message);
|
||||
Assert.IsNull(result.PersonRecentActivity);
|
||||
_mockTaxService.Verify(x => x.GetPersonsTaxIdData(It.IsAny<string>()), Times.Once);
|
||||
_mockActivityDao.Verify(x => x.GetPersonActivityByPersonNumber(It.IsAny<string>()), Times.Never);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetPersonActivityByTaxId_NoContent()
|
||||
{
|
||||
var personNumber = DateTime.Now.Millisecond;
|
||||
var taxId = Guid.NewGuid().ToString();
|
||||
var persons = new List<PersonTaxIdDataResponse>();
|
||||
_mockTaxService.Setup(x => x.GetPersonsTaxIdData(It.IsAny<string>()))
|
||||
.ReturnsAsync(persons).Verifiable();
|
||||
_mockActivityDao
|
||||
.Setup(x => x.GetPersonActivityByPersonNumber(It.IsAny<string>()))
|
||||
.ReturnsAsync(new PersonRecentActivity
|
||||
{
|
||||
PersonNumber = personNumber
|
||||
}).Verifiable();
|
||||
|
||||
var result = await _activityService.GetPersonActivityByTaxId(taxId);
|
||||
|
||||
Assert.NotNull(result);
|
||||
Assert.IsFalse(result.Success);
|
||||
Assert.IsNotNull(result.Message);
|
||||
Assert.IsNull(result.PersonRecentActivity);
|
||||
_mockTaxService.Verify(x => x.GetPersonsTaxIdData(It.IsAny<string>()), Times.Once);
|
||||
_mockActivityDao.Verify(x => x.GetPersonActivityByPersonNumber(It.IsAny<string>()), Times.Never);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetPersonActivityByTaxId_Exception()
|
||||
{
|
||||
_mockTaxService
|
||||
.Setup(x => x.GetPersonsTaxIdData(It.IsAny<string>()))
|
||||
.ThrowsAsync(new Exception());
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(async () =>
|
||||
await _activityService.GetPersonActivityByTaxId(It.IsAny<string>()));
|
||||
}
|
||||
}
|
||||
}
|
||||
+177
@@ -0,0 +1,177 @@
|
||||
using LCU.Api.Internal.CoreApiWrapper.Services;
|
||||
using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.PostalAddresses;
|
||||
using LCU.Library.Internal.Exceptions;
|
||||
using Moq;
|
||||
using NUnit.Framework;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace LCU.Api.Internal.CoreApiWrapperTest.Service
|
||||
{
|
||||
public class AddressServiceTest
|
||||
{
|
||||
private AddressService _addressService;
|
||||
private Mock<IAddressDao> _mockAddressDao;
|
||||
private PersonAddrLine _updatedPersonAddrLineOneAddressLine = new PersonAddrLine()
|
||||
{
|
||||
PersonNumber = 111,
|
||||
AddressNumber = 222,
|
||||
AddressUseCode = "PRI",
|
||||
AddressLine1 = "1 Imaginary Street",
|
||||
AddressLineTypeCode1 = "ST",
|
||||
CityName = "Milwaukee",
|
||||
PostalCode = "53220",
|
||||
CountrySubdivisionCode = "WI",
|
||||
CountryCode = "USA",
|
||||
};
|
||||
|
||||
[SetUp]
|
||||
public void SetUp()
|
||||
{
|
||||
_mockAddressDao = new Mock<IAddressDao>();
|
||||
_addressService = new AddressService(_mockAddressDao.Object);
|
||||
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task UpdateAddrLine_ok()
|
||||
{
|
||||
_mockAddressDao.Setup(x => x.UpdatePersonAddrLine(It.IsAny<CoreApiMessage<PersonAddrLine>>())).ReturnsAsync(
|
||||
_updatedPersonAddrLineOneAddressLine).Verifiable();
|
||||
|
||||
var personpostal = new PersonPostalAddress()
|
||||
{
|
||||
PersonNumber = 111,
|
||||
AddressNumber = 222
|
||||
};
|
||||
|
||||
var header = new CoreMessageHeader()
|
||||
{
|
||||
UpdateKey = 123456
|
||||
};
|
||||
|
||||
var personList = new List<PersonPostalAddress>()
|
||||
{
|
||||
personpostal
|
||||
}
|
||||
.AsReadOnly();
|
||||
|
||||
var response = new CoreApiMessage<IReadOnlyCollection<PersonPostalAddress>>(header, personList);
|
||||
|
||||
_mockAddressDao.Setup(x => x.FindByPersonNumber(It.IsAny<CoreRequestParameters>(), It.IsAny<string>())).ReturnsAsync(
|
||||
response);
|
||||
|
||||
var personAddrLine = _updatedPersonAddrLineOneAddressLine;
|
||||
|
||||
var result = await _addressService.UpdatePersonAddrLine(personAddrLine);
|
||||
|
||||
_mockAddressDao.Verify(x => x.FindByPersonNumber(It.IsAny<CoreRequestParameters>(), It.IsAny<string>()), Times.Once);
|
||||
_mockAddressDao.Verify(x => x.UpdatePersonAddrLine(It.IsAny<CoreApiMessage<PersonAddrLine>>()), Times.Once);
|
||||
Assert.AreEqual(_updatedPersonAddrLineOneAddressLine, result);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task UpdateAddrLine_Fail_WrongPersonId()
|
||||
{
|
||||
_mockAddressDao.Setup(x => x.UpdatePersonAddrLine(It.IsAny<CoreApiMessage<PersonAddrLine>>())).ReturnsAsync(
|
||||
_updatedPersonAddrLineOneAddressLine).Verifiable();
|
||||
|
||||
var personpostal = new PersonPostalAddress()
|
||||
{
|
||||
PersonNumber = 999,
|
||||
AddressNumber = 888
|
||||
};
|
||||
|
||||
var header = new CoreMessageHeader()
|
||||
{
|
||||
UpdateKey = 123456
|
||||
};
|
||||
|
||||
var personList = new List<PersonPostalAddress>()
|
||||
{
|
||||
personpostal
|
||||
}
|
||||
.AsReadOnly();
|
||||
|
||||
var response = new CoreApiMessage<IReadOnlyCollection<PersonPostalAddress>>(header, personList);
|
||||
|
||||
_mockAddressDao.Setup(x => x.FindByPersonNumber(It.IsAny<CoreRequestParameters>(), It.IsAny<string>())).ReturnsAsync(
|
||||
response);
|
||||
|
||||
var personAddrLine = _updatedPersonAddrLineOneAddressLine;
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(async () => await _addressService.UpdatePersonAddrLine(personAddrLine));
|
||||
|
||||
_mockAddressDao.Verify(x => x.FindByPersonNumber(It.IsAny<CoreRequestParameters>(), It.IsAny<string>()), Times.Once);
|
||||
_mockAddressDao.Verify(x => x.UpdatePersonAddrLine(It.IsAny<CoreApiMessage<PersonAddrLine>>()), Times.Never);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task UpdateAddrLine_Fail_NullPerson()
|
||||
{
|
||||
_mockAddressDao.Setup(x => x.UpdatePersonAddrLine(It.IsAny<CoreApiMessage<PersonAddrLine>>())).ReturnsAsync(
|
||||
_updatedPersonAddrLineOneAddressLine).Verifiable();
|
||||
|
||||
var header = new CoreMessageHeader()
|
||||
{
|
||||
UpdateKey = 123456
|
||||
};
|
||||
|
||||
var personList = new List<PersonPostalAddress>().AsReadOnly();
|
||||
|
||||
var response = new CoreApiMessage<IReadOnlyCollection<PersonPostalAddress>>(header, personList);
|
||||
|
||||
_mockAddressDao.Setup(x => x.FindByPersonNumber(It.IsAny<CoreRequestParameters>(), It.IsAny<string>())).ReturnsAsync(
|
||||
response);
|
||||
|
||||
var personAddrLine = _updatedPersonAddrLineOneAddressLine;
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(async () => await _addressService.UpdatePersonAddrLine(personAddrLine));
|
||||
|
||||
_mockAddressDao.Verify(x => x.FindByPersonNumber(It.IsAny<CoreRequestParameters>(), It.IsAny<string>()), Times.Once);
|
||||
_mockAddressDao.Verify(x => x.UpdatePersonAddrLine(It.IsAny<CoreApiMessage<PersonAddrLine>>()), Times.Never);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task UpdateAddrLine_Fail_NullResponse()
|
||||
{
|
||||
_mockAddressDao.Setup(x => x.UpdatePersonAddrLine(It.IsAny<CoreApiMessage<PersonAddrLine>>())).Returns(
|
||||
Task.FromResult((PersonAddrLine)null)).Verifiable();
|
||||
|
||||
var personpostal = new PersonPostalAddress()
|
||||
{
|
||||
PersonNumber = 111,
|
||||
AddressNumber = 222
|
||||
};
|
||||
|
||||
var header = new CoreMessageHeader()
|
||||
{
|
||||
UpdateKey = 123456
|
||||
};
|
||||
|
||||
var personList = new List<PersonPostalAddress>()
|
||||
{
|
||||
personpostal
|
||||
}
|
||||
.AsReadOnly();
|
||||
|
||||
var response = new CoreApiMessage<IReadOnlyCollection<PersonPostalAddress>>(header, personList);
|
||||
|
||||
_mockAddressDao.Setup(x => x.FindByPersonNumber(It.IsAny<CoreRequestParameters>(), It.IsAny<string>())).ReturnsAsync(
|
||||
response);
|
||||
|
||||
var personAddrLine = _updatedPersonAddrLineOneAddressLine;
|
||||
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(async () => await _addressService.UpdatePersonAddrLine(personAddrLine));
|
||||
|
||||
_mockAddressDao.Verify(x => x.FindByPersonNumber(It.IsAny<CoreRequestParameters>(), It.IsAny<string>()), Times.Once);
|
||||
_mockAddressDao.Verify(x => x.UpdatePersonAddrLine(It.IsAny<CoreApiMessage<PersonAddrLine>>()), Times.Once);
|
||||
}
|
||||
}
|
||||
}
|
||||
+190
@@ -0,0 +1,190 @@
|
||||
using System;
|
||||
using System.Threading.Tasks;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Moq;
|
||||
using NUnit.Framework;
|
||||
using LCU.Api.Internal.CoreApiWrapper.Services;
|
||||
using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.MemberAgreements;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreSoapRequests;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreResponses;
|
||||
|
||||
namespace LCU.Api.Internal.CoreApiWrapperTest.Service
|
||||
{
|
||||
public class AgreePersonServiceTest
|
||||
{
|
||||
private AgreePersonService _agreePersonService;
|
||||
private Mock<IAgreePersonDao> _mockAgreePersonDao;
|
||||
|
||||
[SetUp]
|
||||
public void SetUp()
|
||||
{
|
||||
_mockAgreePersonDao = new Mock<IAgreePersonDao>();
|
||||
_agreePersonService = new AgreePersonService(_mockAgreePersonDao.Object);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetByUserId_OK()
|
||||
{
|
||||
_mockAgreePersonDao.Setup(x => x.FindByUserId(It.IsAny<string>())).ReturnsAsync(
|
||||
new AgreePerson()
|
||||
{
|
||||
AgreeNumber = 100,
|
||||
PersonNumber = 10,
|
||||
UserId = "1"
|
||||
}).Verifiable();
|
||||
|
||||
var result = await _agreePersonService.GetByUserId("1");
|
||||
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual(100, result.AgreeNumber);
|
||||
Assert.AreEqual(10, result.PersonNumber);
|
||||
Assert.AreEqual("1", result.UserId);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetByUserId_Exception()
|
||||
{
|
||||
_mockAgreePersonDao.Setup(x => x.FindByUserId(It.IsAny<string>())).Throws(new Exception("Dang"));
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _agreePersonService.GetByUserId("1"));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetAgreePersonsWithHyphenatedUserId_OK()
|
||||
{
|
||||
_mockAgreePersonDao.Setup(x => x.FindAgreePersonsWithHyphenatedUserId()).ReturnsAsync(
|
||||
new List<AgreePerson>()
|
||||
{
|
||||
new AgreePerson()
|
||||
{
|
||||
AgreeNumber = 100,
|
||||
PersonNumber = 10,
|
||||
UserId = "1-1"
|
||||
},
|
||||
new AgreePerson()
|
||||
{
|
||||
AgreeNumber = 200,
|
||||
PersonNumber = 20,
|
||||
UserId = "2-2"
|
||||
}
|
||||
}).Verifiable();
|
||||
|
||||
var results = await _agreePersonService.GetAgreePersonsWithHyphenatedUserId();
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(2, results.Count());
|
||||
var result1 = results.FirstOrDefault();
|
||||
Assert.AreEqual(100, result1.AgreeNumber);
|
||||
Assert.AreEqual(10, result1.PersonNumber);
|
||||
Assert.AreEqual("1-1", result1.UserId);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetAgreePersonsWithHyphenatedUserId_Exception()
|
||||
{
|
||||
_mockAgreePersonDao.Setup(x => x.FindAgreePersonsWithHyphenatedUserId())
|
||||
.Throws(new Exception("Dang"));
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _agreePersonService.GetAgreePersonsWithHyphenatedUserId());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetActiveCustodialVruCardAgreementAgreePersons_OK()
|
||||
{
|
||||
_mockAgreePersonDao.Setup(x => x.FindActiveCustodialVruCardAgreementAgreePersons()).ReturnsAsync(
|
||||
new List<AgreePerson>()
|
||||
{
|
||||
new AgreePerson()
|
||||
{
|
||||
AgreeNumber = 100,
|
||||
PersonNumber = 10,
|
||||
UserId = "11"
|
||||
},
|
||||
new AgreePerson()
|
||||
{
|
||||
AgreeNumber = 200,
|
||||
PersonNumber = 20,
|
||||
UserId = null
|
||||
}
|
||||
}).Verifiable();
|
||||
|
||||
var results = await _agreePersonService.GetActiveCustodialVruCardAgreementAgreePersons();
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(2, results.Count());
|
||||
var result1 = results.FirstOrDefault();
|
||||
Assert.AreEqual(100, result1.AgreeNumber);
|
||||
Assert.AreEqual(10, result1.PersonNumber);
|
||||
Assert.AreEqual("11", result1.UserId);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetActiveCustodialVruCardAgreementAgreePersons_Exception()
|
||||
{
|
||||
_mockAgreePersonDao.Setup(x => x.FindActiveCustodialVruCardAgreementAgreePersons())
|
||||
.Throws(new Exception("Dang"));
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _agreePersonService.GetActiveCustodialVruCardAgreementAgreePersons());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task UpdatePersonAgreementDetailTypes_OK()
|
||||
{
|
||||
_mockAgreePersonDao.Setup(x => x.UpdatePersonAgreementDetailTypes(It.IsAny<PersonAgreementDetailTypeRequest>())).ReturnsAsync(
|
||||
new BasicResponse
|
||||
{
|
||||
Success = true,
|
||||
Errors = new List<string>()
|
||||
}).Verifiable();
|
||||
|
||||
var personAgreementDetailTypeRequest = new PersonAgreementDetailTypeRequest()
|
||||
{
|
||||
PersonNumber = 1,
|
||||
AgreeNumber = 2,
|
||||
AgreeTypeCode = "VRUTEST",
|
||||
DetailTypes = new List<DetailType>()
|
||||
{
|
||||
new DetailType()
|
||||
{
|
||||
DetailTypeCode = "STATUSTEST",
|
||||
DetailValue = "CLOSTEST"
|
||||
}
|
||||
}
|
||||
};
|
||||
var result = await _agreePersonService.UpdatePersonAgreementDetailTypes(personAgreementDetailTypeRequest);
|
||||
|
||||
Assert.NotNull(result);
|
||||
Assert.IsTrue(result.Success);
|
||||
Assert.IsEmpty(result.Errors);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void UpdatePersonAgreementDetailTypes_Exception()
|
||||
{
|
||||
_mockAgreePersonDao.Setup(x => x.UpdatePersonAgreementDetailTypes(It.IsAny<PersonAgreementDetailTypeRequest>()))
|
||||
.Throws(new Exception("Dang"));
|
||||
|
||||
var personAgreementDetailTypeRequest = new PersonAgreementDetailTypeRequest()
|
||||
{
|
||||
PersonNumber = 1,
|
||||
AgreeNumber = 2,
|
||||
AgreeTypeCode = "VRUTEST",
|
||||
DetailTypes = new List<DetailType>()
|
||||
{
|
||||
new DetailType()
|
||||
{
|
||||
DetailTypeCode = "STATUSTEST",
|
||||
DetailValue = "CLOSTEST"
|
||||
}
|
||||
}
|
||||
};
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _agreePersonService.UpdatePersonAgreementDetailTypes(personAgreementDetailTypeRequest));
|
||||
}
|
||||
}
|
||||
}
|
||||
+547
@@ -0,0 +1,547 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Moq;
|
||||
using NUnit.Framework;
|
||||
using LCU.Api.Internal.CoreApiWrapper.Services;
|
||||
using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Agreements;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.MemberAgreements;
|
||||
|
||||
namespace LCU.Api.Internal.CoreApiWrapperTest.Service
|
||||
{
|
||||
public class AgreeServiceTest
|
||||
{
|
||||
private AgreeService _agreeService;
|
||||
private Mock<IAgreeDao> _mockAgreeDao;
|
||||
|
||||
[SetUp]
|
||||
public void SetUp()
|
||||
{
|
||||
_mockAgreeDao = new Mock<IAgreeDao>();
|
||||
_agreeService = new AgreeService(_mockAgreeDao.Object);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetAgreeUsersByAccountNumbers_OK()
|
||||
{
|
||||
_mockAgreeDao
|
||||
.Setup(x => x.FindAgreeUsersByAccountNumbers(It.IsAny<List<string>>()))
|
||||
.ReturnsAsync(
|
||||
new List<AgreeUserAccount>()
|
||||
{
|
||||
new AgreeUserAccount()
|
||||
{
|
||||
AccountNumber = 100010,
|
||||
AgreeNumber = 1000,
|
||||
UserId = "101010"
|
||||
},
|
||||
new AgreeUserAccount()
|
||||
{
|
||||
AccountNumber = 200020,
|
||||
AgreeNumber = 2000,
|
||||
UserId = "202020"
|
||||
}
|
||||
})
|
||||
.Verifiable();
|
||||
|
||||
var accountNumbers = new List<string>()
|
||||
{
|
||||
"100010",
|
||||
"200020"
|
||||
};
|
||||
var results = await _agreeService.GetAgreeUsersByAccountNumbers(accountNumbers);
|
||||
|
||||
var resultsList = results.ToList();
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(2, resultsList.Count);
|
||||
Assert.True(resultsList.Any(x => x.AccountNumber == 100010));
|
||||
Assert.True(resultsList.Any(x => x.AccountNumber == 200020));
|
||||
Assert.True(resultsList.Any(x => x.AgreeNumber == 1000));
|
||||
Assert.True(resultsList.Any(x => x.AgreeNumber == 2000));
|
||||
Assert.True(resultsList.Any(x => x.UserId == "101010"));
|
||||
Assert.True(resultsList.Any(x => x.UserId == "202020"));
|
||||
|
||||
_mockAgreeDao.Verify(x =>
|
||||
x.FindAgreeUsersByAccountNumbers(
|
||||
It.Is<List<string>>(ls => ls.Count == 2 && ls.Contains("100010") && ls.Contains("200020"))));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetAgreeUsersByAccountNumbers_Exception()
|
||||
{
|
||||
_mockAgreeDao.Setup(x => x.FindAgreeUsersByAccountNumbers(It.IsAny<List<string>>()))
|
||||
.Throws(new Exception("Ohh nooo"));
|
||||
|
||||
var accountNumbers = new List<string>()
|
||||
{
|
||||
"100010",
|
||||
"200020"
|
||||
};
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _agreeService.GetAgreeUsersByAccountNumbers(accountNumbers));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetAgreeUsersByPersonNumber_OK()
|
||||
{
|
||||
var personNumbers = new List<string> { "5436", "44889" };
|
||||
_mockAgreeDao
|
||||
.Setup(x => x.FindAgreeUserByPersonNumber(123L))
|
||||
.ReturnsAsync(personNumbers).Verifiable();
|
||||
|
||||
var result = await _agreeService.GetAgreeUsersByPersonNumber(123L);
|
||||
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual("5436", result.FirstOrDefault());
|
||||
_mockAgreeDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetAgreeUsersByPersonNumber_Exception()
|
||||
{
|
||||
_mockAgreeDao.Setup(x => x.FindAgreeUserByPersonNumber(123L))
|
||||
.Throws(new Exception("Exception from unit test")).Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () => await _agreeService.GetAgreeUsersByPersonNumber(123L));
|
||||
_mockAgreeDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetAgreeUserByOrganizationNumber_OK()
|
||||
{
|
||||
_mockAgreeDao
|
||||
.Setup(x => x.FindAgreeUserByOrganizationNumber(123L))
|
||||
.ReturnsAsync("5436").Verifiable();
|
||||
|
||||
var result = await _agreeService.GetAgreeUserByOrganizationNumber(123L);
|
||||
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual("5436", result);
|
||||
_mockAgreeDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetAgreeUserByOrganizationNumber_Exception()
|
||||
{
|
||||
_mockAgreeDao.Setup(x => x.FindAgreeUserByOrganizationNumber(123L))
|
||||
.Throws(new Exception("Exception from unit test")).Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () => await _agreeService.GetAgreeUserByOrganizationNumber(123L));
|
||||
_mockAgreeDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetEAgreementsByAccountId_OK()
|
||||
{
|
||||
var returnedEAgreements = new List<Agreement>()
|
||||
{
|
||||
new()
|
||||
{
|
||||
UserId = "101010",
|
||||
AgreementNumber = 123,
|
||||
PersonNumber = 1234,
|
||||
FirstName = "John",
|
||||
MiddleName = "Doe",
|
||||
MiddleInitial = "D",
|
||||
LastName = "Smith",
|
||||
Suffix = "Jr.",
|
||||
},
|
||||
new()
|
||||
{
|
||||
UserId = "101011"
|
||||
}
|
||||
};
|
||||
|
||||
_mockAgreeDao
|
||||
.Setup(x => x.FindAgreementsByAccountId(123))
|
||||
.ReturnsAsync(returnedEAgreements).Verifiable();
|
||||
|
||||
var results = await _agreeService.GetAgreementsByAccountId(123);
|
||||
|
||||
var resultsList = results.ToList();
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(2, resultsList.Count);
|
||||
|
||||
var firstResult = resultsList.First();
|
||||
Assert.AreEqual(firstResult.AgreementNumber, 123L);
|
||||
Assert.AreEqual(firstResult.UserId, "101010");
|
||||
Assert.AreEqual(firstResult.PersonNumber, 1234L);
|
||||
Assert.AreEqual(firstResult.FirstName, "John");
|
||||
Assert.AreEqual(firstResult.MiddleName, "Doe");
|
||||
Assert.AreEqual(firstResult.MiddleInitial, "D");
|
||||
Assert.AreEqual(firstResult.LastName, "Smith");
|
||||
Assert.AreEqual(firstResult.Suffix, "Jr.");
|
||||
|
||||
var secondResult = resultsList.Last();
|
||||
Assert.AreEqual(secondResult.UserId, "101011");
|
||||
_mockAgreeDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetEAgreementsByAccountId_Exception()
|
||||
{
|
||||
_mockAgreeDao.Setup(x => x.FindAgreementsByAccountId(123))
|
||||
.Throws(new Exception("Exception from unit test")).Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () => await _agreeService.GetAgreementsByAccountId(123));
|
||||
_mockAgreeDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetEAgreementByUserId_OK()
|
||||
{
|
||||
var returnedEAgreement = new Agreement()
|
||||
{
|
||||
UserId = "101010",
|
||||
AgreementNumber = 123,
|
||||
PersonNumber = 1234,
|
||||
FirstName = "John",
|
||||
MiddleName = "Doe",
|
||||
MiddleInitial = "D",
|
||||
LastName = "Smith",
|
||||
Suffix = "Jr.",
|
||||
};
|
||||
|
||||
_mockAgreeDao
|
||||
.Setup(x => x.FindAgreementByUserId("123"))
|
||||
.ReturnsAsync(returnedEAgreement).Verifiable();
|
||||
|
||||
var result = await _agreeService.GetAgreementByUserId("123");
|
||||
|
||||
Assert.NotNull(result);
|
||||
|
||||
Assert.AreEqual(result.AgreementNumber, 123L);
|
||||
Assert.AreEqual(result.UserId, "101010");
|
||||
Assert.AreEqual(result.PersonNumber, 1234L);
|
||||
Assert.AreEqual(result.FirstName, "John");
|
||||
Assert.AreEqual(result.MiddleName, "Doe");
|
||||
Assert.AreEqual(result.MiddleInitial, "D");
|
||||
Assert.AreEqual(result.LastName, "Smith");
|
||||
Assert.AreEqual(result.Suffix, "Jr.");
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetEAgreementByUserId_Exception()
|
||||
{
|
||||
_mockAgreeDao.Setup(x => x.FindAgreementByUserId("123"))
|
||||
.Throws(new Exception("Exception from unit test")).Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () => await _agreeService.GetAgreementByUserId("123"));
|
||||
_mockAgreeDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetEAgreementByAgreementId_OK()
|
||||
{
|
||||
var returnedEAgreement = new Agreement
|
||||
{
|
||||
UserId = "101010",
|
||||
AgreementNumber = 123,
|
||||
PersonNumber = 1234,
|
||||
FirstName = "John",
|
||||
MiddleName = "Doe",
|
||||
MiddleInitial = "D",
|
||||
LastName = "Smith",
|
||||
Suffix = "Jr.",
|
||||
};
|
||||
|
||||
_mockAgreeDao
|
||||
.Setup(x => x.FindAgreementByAgreementId(123))
|
||||
.ReturnsAsync(returnedEAgreement).Verifiable();
|
||||
|
||||
var result = await _agreeService.GetAgreementByAgreementId(123);
|
||||
|
||||
Assert.NotNull(result);
|
||||
|
||||
Assert.AreEqual(result.AgreementNumber, 123L);
|
||||
Assert.AreEqual(result.UserId, "101010");
|
||||
Assert.AreEqual(result.PersonNumber, 1234L);
|
||||
Assert.AreEqual(result.FirstName, "John");
|
||||
Assert.AreEqual(result.MiddleName, "Doe");
|
||||
Assert.AreEqual(result.MiddleInitial, "D");
|
||||
Assert.AreEqual(result.LastName, "Smith");
|
||||
Assert.AreEqual(result.Suffix, "Jr.");
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetEAgreementByAgreementId_Exception()
|
||||
{
|
||||
_mockAgreeDao.Setup(x => x.FindAgreementByAgreementId(123))
|
||||
.Throws(new Exception("Exception from unit test")).Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () => await _agreeService.GetAgreementByAgreementId(123));
|
||||
_mockAgreeDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetEAgreementAccountsByUserId_OK()
|
||||
{
|
||||
var returnedAgreementAccounts = new List<AgreementAccount>
|
||||
{
|
||||
new()
|
||||
{
|
||||
AccountDescription = "Test Account",
|
||||
AccountNumber = 12345,
|
||||
TaxReportForPersonNumber = 12345666,
|
||||
TaxReportForOrgNumber = null,
|
||||
OvrDeliveryMethCD = "PRNT"
|
||||
},
|
||||
new()
|
||||
{
|
||||
AccountDescription = "Test Account 2",
|
||||
AccountNumber = 12346,
|
||||
TaxReportForPersonNumber = null,
|
||||
TaxReportForOrgNumber = 12345666,
|
||||
OvrDeliveryMethCD = "WWW"
|
||||
}
|
||||
};
|
||||
|
||||
var returnedAccountOwners = new List<AgreementAccountOwner>
|
||||
{
|
||||
new()
|
||||
{
|
||||
AccountNumber = 12345,
|
||||
PersonNumber = 123,
|
||||
UserId = "111"
|
||||
},
|
||||
new()
|
||||
{
|
||||
AccountNumber = 12346,
|
||||
PersonNumber = 124,
|
||||
UserId = "222"
|
||||
}
|
||||
};
|
||||
|
||||
_mockAgreeDao
|
||||
.Setup(x => x.FindAgreementAccountsByUserId("123"))
|
||||
.ReturnsAsync(returnedAgreementAccounts).Verifiable();
|
||||
|
||||
_mockAgreeDao
|
||||
.Setup(x => x.FindAgreementOwnerByAccountNumbers(It.Is<IEnumerable<long>>(x => x.Contains(12345L) && x.Contains(12346L))))
|
||||
.ReturnsAsync(returnedAccountOwners).Verifiable();
|
||||
|
||||
var results = await _agreeService.GetAgreementAccountsByUserId("123");
|
||||
|
||||
var resultsList = results.ToList();
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(2, resultsList.Count);
|
||||
|
||||
var firstResult = resultsList.First();
|
||||
Assert.AreEqual(firstResult.AccountNumber, 12345L);
|
||||
Assert.AreEqual(firstResult.AccountDescription, "Test Account");
|
||||
Assert.AreEqual(firstResult.TaxReportForPersonNumber, 12345666);
|
||||
Assert.IsNull(firstResult.TaxReportForOrgNumber);
|
||||
Assert.AreEqual(firstResult.OvrDeliveryMethCD, "PRNT");
|
||||
Assert.AreEqual(firstResult.AccountOwner.PersonNumber, 123);
|
||||
|
||||
var secondResult = resultsList.Last();
|
||||
Assert.AreEqual(secondResult.AccountNumber, 12346L);
|
||||
Assert.AreEqual(secondResult.AccountDescription, "Test Account 2");
|
||||
Assert.AreEqual(secondResult.TaxReportForOrgNumber, 12345666);
|
||||
Assert.IsNull(secondResult.TaxReportForPersonNumber);
|
||||
Assert.AreEqual(secondResult.OvrDeliveryMethCD, "WWW");
|
||||
Assert.AreEqual(secondResult.AccountOwner.PersonNumber, 124);
|
||||
|
||||
_mockAgreeDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetEAgreementAccountsByOrganizationId_OK()
|
||||
{
|
||||
var returnedAgreementAccounts = new List<AgreementAccount>
|
||||
{
|
||||
new()
|
||||
{
|
||||
AccountDescription = "Test Account",
|
||||
AccountNumber = 12345,
|
||||
TaxReportForPersonNumber = null,
|
||||
TaxReportForOrgNumber = 12345666,
|
||||
OvrDeliveryMethCD = "PRNT"
|
||||
},
|
||||
new()
|
||||
{
|
||||
AccountDescription = "Test Account 2",
|
||||
AccountNumber = 12346,
|
||||
TaxReportForPersonNumber = null,
|
||||
TaxReportForOrgNumber = 12345667,
|
||||
OvrDeliveryMethCD = "WWW"
|
||||
}
|
||||
};
|
||||
|
||||
var returnedAccountOwners = new List<AgreementAccountOwner>
|
||||
{
|
||||
new()
|
||||
{
|
||||
AccountNumber = 12345,
|
||||
PersonNumber = 123,
|
||||
UserId = "111"
|
||||
}
|
||||
};
|
||||
|
||||
_mockAgreeDao
|
||||
.Setup(x => x.FindAgreementAccountsByOrganizationId(123))
|
||||
.ReturnsAsync(returnedAgreementAccounts).Verifiable();
|
||||
|
||||
_mockAgreeDao
|
||||
.Setup(x => x.FindAgreementOwnerByAccountNumbers(It.Is<IEnumerable<long>>(x => x.Contains(12345L) && x.Contains(12346L))))
|
||||
.ReturnsAsync(returnedAccountOwners).Verifiable();
|
||||
|
||||
var results = await _agreeService.GetAgreementAccountsByOrganizationId(123);
|
||||
|
||||
var resultsList = results.ToList();
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(2, resultsList.Count);
|
||||
|
||||
var firstResult = resultsList.First();
|
||||
Assert.AreEqual(firstResult.AccountNumber, 12345L);
|
||||
Assert.AreEqual(firstResult.AccountDescription, "Test Account");
|
||||
Assert.IsNull(firstResult.TaxReportForPersonNumber);
|
||||
Assert.AreEqual(firstResult.TaxReportForOrgNumber, 12345666L);
|
||||
Assert.AreEqual(firstResult.OvrDeliveryMethCD, "PRNT");
|
||||
Assert.AreEqual(firstResult.AccountOwner.PersonNumber, 123);
|
||||
|
||||
var secondResult = resultsList.Last();
|
||||
Assert.AreEqual(secondResult.AccountNumber, 12346L);
|
||||
Assert.AreEqual(secondResult.AccountDescription, "Test Account 2");
|
||||
Assert.IsNull(secondResult.TaxReportForPersonNumber);
|
||||
Assert.AreEqual(secondResult.TaxReportForOrgNumber, 12345667L);
|
||||
Assert.AreEqual(secondResult.OvrDeliveryMethCD, "WWW");
|
||||
Assert.IsNull(secondResult.AccountOwner);
|
||||
|
||||
_mockAgreeDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetEAgreementAccountsByOrganizationId_Exception()
|
||||
{
|
||||
_mockAgreeDao.Setup(x => x.FindAgreementAccountsByOrganizationId(123))
|
||||
.Throws(new Exception("Exception from unit test")).Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () => await _agreeService.GetAgreementAccountsByOrganizationId(123));
|
||||
_mockAgreeDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetEAgreementAccountsByUserId_Exception()
|
||||
{
|
||||
_mockAgreeDao.Setup(x => x.FindAgreementAccountsByUserId("123"))
|
||||
.Throws(new Exception("Exception from unit test")).Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () => await _agreeService.GetAgreementAccountsByUserId("123"));
|
||||
_mockAgreeDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task AuditAccountDeliveryMethodAndOwnerChangesByDateLastMaintained_OK()
|
||||
{
|
||||
var returnedAccountNumbers = new List<long>
|
||||
{
|
||||
12345,
|
||||
12346
|
||||
};
|
||||
|
||||
_mockAgreeDao
|
||||
.Setup(x => x.AuditAccountDeliveryMethodAndOwnerChangesByDateLastMaintained(It.IsAny<DateTime>()))
|
||||
.ReturnsAsync(returnedAccountNumbers).Verifiable();
|
||||
|
||||
var results = await _agreeService.AuditAccountDeliveryMethodAndOwnerChangesByDateLastMaintained(DateTime.Now);
|
||||
|
||||
var resultsList = results.ToList();
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(2, resultsList.Count);
|
||||
|
||||
var firstResult = resultsList.First();
|
||||
Assert.AreEqual(firstResult, 12345L);
|
||||
|
||||
var secondResult = resultsList.Last();
|
||||
Assert.AreEqual(secondResult, 12346L);
|
||||
_mockAgreeDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void AuditAccountDeliveryMethodAndOwnerChangesByDateLastMaintained_Exception()
|
||||
{
|
||||
_mockAgreeDao.Setup(x => x.AuditAccountDeliveryMethodAndOwnerChangesByDateLastMaintained(It.IsAny<DateTime>()))
|
||||
.Throws(new Exception("Exception from unit test")).Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () => await _agreeService.AuditAccountDeliveryMethodAndOwnerChangesByDateLastMaintained(DateTime.Now));
|
||||
_mockAgreeDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task AuditOrganizationChangesByDateLastMaintained_OK()
|
||||
{
|
||||
var returnedAccountNumbers = new List<long>
|
||||
{
|
||||
12345,
|
||||
12346
|
||||
};
|
||||
|
||||
_mockAgreeDao
|
||||
.Setup(x => x.AuditAccountOrganizationChangesByDateLastMaintained(It.IsAny<DateTime>()))
|
||||
.ReturnsAsync(returnedAccountNumbers).Verifiable();
|
||||
|
||||
var results = await _agreeService.AuditOrganizationChangesByDateLastMaintained(DateTime.Now);
|
||||
|
||||
var resultsList = results.ToList();
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(2, resultsList.Count);
|
||||
|
||||
var firstResult = resultsList.First();
|
||||
Assert.AreEqual(firstResult, 12345L);
|
||||
|
||||
var secondResult = resultsList.Last();
|
||||
Assert.AreEqual(secondResult, 12346L);
|
||||
_mockAgreeDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void AuditOrganizationChangesByDateLastMaintained_Exception()
|
||||
{
|
||||
_mockAgreeDao.Setup(x => x.AuditAccountOrganizationChangesByDateLastMaintained(It.IsAny<DateTime>()))
|
||||
.Throws(new Exception("Exception from unit test")).Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () => await _agreeService.AuditOrganizationChangesByDateLastMaintained(DateTime.Now));
|
||||
_mockAgreeDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task AuditAgreementChangesByDateLastMaintained_OK()
|
||||
{
|
||||
var returnedAccountNumbers = new List<long>
|
||||
{
|
||||
12345,
|
||||
12346
|
||||
};
|
||||
|
||||
_mockAgreeDao
|
||||
.Setup(x => x.AuditAccountAgreementChangesByDateLastMaintained(It.IsAny<DateTime>()))
|
||||
.ReturnsAsync(returnedAccountNumbers).Verifiable();
|
||||
|
||||
var results = await _agreeService.AuditAgreementChangesByDateLastMaintained(DateTime.Now);
|
||||
|
||||
var resultsList = results.ToList();
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(2, resultsList.Count);
|
||||
|
||||
var firstResult = resultsList.First();
|
||||
Assert.AreEqual(firstResult, 12345L);
|
||||
|
||||
var secondResult = resultsList.Last();
|
||||
Assert.AreEqual(secondResult, 12346L);
|
||||
_mockAgreeDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void AuditAgreementChangesByDateLastMaintained_Exception()
|
||||
{
|
||||
_mockAgreeDao.Setup(x => x.AuditAccountAgreementChangesByDateLastMaintained(It.IsAny<DateTime>()))
|
||||
.Throws(new Exception("Exception from unit test")).Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () => await _agreeService.AuditAgreementChangesByDateLastMaintained(DateTime.Now));
|
||||
_mockAgreeDao.Verify();
|
||||
}
|
||||
}
|
||||
}
|
||||
+149
@@ -0,0 +1,149 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Moq;
|
||||
using NUnit.Framework;
|
||||
using LCU.Api.Internal.CoreApiWrapper.Services;
|
||||
using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
|
||||
using LCU.Library.Internal.CoreApiWrapperLib.Exceptions;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.ApplicationHistories;
|
||||
|
||||
namespace LCU.Api.Internal.CoreApiWrapperTest.Service
|
||||
{
|
||||
public class ApplicationHistoryServiceTest
|
||||
{
|
||||
private ApplicationHistoryService _applicationHistoryService;
|
||||
private Mock<IApplicationHistoryDao> _mockApplicationHistoryDao;
|
||||
|
||||
[SetUp]
|
||||
public void SetUp()
|
||||
{
|
||||
_mockApplicationHistoryDao = new Mock<IApplicationHistoryDao>();
|
||||
_applicationHistoryService = new ApplicationHistoryService(_mockApplicationHistoryDao.Object);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetApplicationHistory_OK()
|
||||
{
|
||||
_mockApplicationHistoryDao
|
||||
.Setup(x => x.FindApplicationHistory(It.IsAny<List<string>>(), It.IsAny<DateTime>()))
|
||||
.ReturnsAsync(
|
||||
new List<ApplicationHistory>()
|
||||
{
|
||||
new ApplicationHistory()
|
||||
{
|
||||
ApplicationName = "Test",
|
||||
ApplicationNumber = 1,
|
||||
QueueNumber = 10,
|
||||
StopDateTime = Convert.ToDateTime("1/1/2021")
|
||||
},
|
||||
new ApplicationHistory()
|
||||
{
|
||||
ApplicationName = "Test2",
|
||||
ApplicationNumber = 2,
|
||||
QueueNumber = 20,
|
||||
StopDateTime = Convert.ToDateTime("1/1/2021")
|
||||
}
|
||||
})
|
||||
.Verifiable();
|
||||
|
||||
var applicationTestNumbers = new List<string>()
|
||||
{
|
||||
"1",
|
||||
"2"
|
||||
};
|
||||
var results = await _applicationHistoryService.GetApplicationHistory(applicationTestNumbers, "1/2/2021");
|
||||
|
||||
var resultsList = results.ToList();
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(2, resultsList.Count);
|
||||
Assert.True(resultsList.Any(x => x.ApplicationName == "Test"));
|
||||
Assert.True(resultsList.Any(x => x.ApplicationName == "Test"));
|
||||
Assert.True(resultsList.Any(x => x.ApplicationNumber == 1));
|
||||
Assert.True(resultsList.Any(x => x.ApplicationNumber == 2));
|
||||
Assert.True(resultsList.Any(x => x.QueueNumber == 10));
|
||||
Assert.True(resultsList.Any(x => x.QueueNumber == 20));
|
||||
Assert.True(resultsList.Any(x => x.StopDateTime == Convert.ToDateTime("1/1/2021")));
|
||||
Assert.AreEqual(2, resultsList.Where(r => r.StopDateTime == Convert.ToDateTime("1/1/2021")).ToList().Count);
|
||||
|
||||
_mockApplicationHistoryDao.Verify(x =>
|
||||
x.FindApplicationHistory( It.Is<List<string>>( ls => ls.Count == 2 && ls.Contains("1") && ls.Contains("2")),
|
||||
It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("1/2/2021")) == 0)));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetApplicationHistory_FailedToParse_Null()
|
||||
{
|
||||
_mockApplicationHistoryDao
|
||||
.Setup(x => x.FindApplicationHistory(It.IsAny<List<string>>(), It.IsAny<DateTime>()))
|
||||
.ReturnsAsync(
|
||||
new List<ApplicationHistory>()
|
||||
{
|
||||
new ApplicationHistory()
|
||||
{
|
||||
ApplicationName = "Test",
|
||||
ApplicationNumber = 1,
|
||||
QueueNumber = 10,
|
||||
StopDateTime = Convert.ToDateTime("1/1/2021")
|
||||
},
|
||||
new ApplicationHistory()
|
||||
{
|
||||
ApplicationName = "Test2",
|
||||
ApplicationNumber = 2,
|
||||
QueueNumber = 20,
|
||||
StopDateTime = Convert.ToDateTime("1/1/2021")
|
||||
}
|
||||
})
|
||||
.Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<FailedToParseException>(async () =>
|
||||
await _applicationHistoryService.GetApplicationHistory(null, null));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetApplicationHistory_FailedToParse_BadDateTime()
|
||||
{
|
||||
_mockApplicationHistoryDao
|
||||
.Setup(x => x.FindApplicationHistory(It.IsAny<List<string>>(), It.IsAny<DateTime>()))
|
||||
.ReturnsAsync(
|
||||
new List<ApplicationHistory>()
|
||||
{
|
||||
new ApplicationHistory()
|
||||
{
|
||||
ApplicationName = "Test",
|
||||
ApplicationNumber = 1,
|
||||
QueueNumber = 10,
|
||||
StopDateTime = Convert.ToDateTime("1/1/2021")
|
||||
},
|
||||
new ApplicationHistory()
|
||||
{
|
||||
ApplicationName = "Test2",
|
||||
ApplicationNumber = 2,
|
||||
QueueNumber = 20,
|
||||
StopDateTime = Convert.ToDateTime("1/1/2021")
|
||||
}
|
||||
})
|
||||
.Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<FailedToParseException>(async () =>
|
||||
await _applicationHistoryService.GetApplicationHistory(null, ":-)"));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetApplicationHistory_Exception()
|
||||
{
|
||||
_mockApplicationHistoryDao
|
||||
.Setup(x => x.FindApplicationHistory(It.IsAny<List<string>>(),
|
||||
It.IsAny<DateTime>())).Throws(new Exception("Ohh nooo"));
|
||||
|
||||
var applicationTestNumbers = new List<string>()
|
||||
{
|
||||
"1",
|
||||
"2"
|
||||
};
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _applicationHistoryService.GetApplicationHistory(applicationTestNumbers, "1/2/2021"));
|
||||
}
|
||||
}
|
||||
}
|
||||
+52
@@ -0,0 +1,52 @@
|
||||
using System;
|
||||
using System.Threading.Tasks;
|
||||
using NUnit.Framework;
|
||||
using Moq;
|
||||
using LCU.Api.Internal.CoreApiWrapper.Services;
|
||||
using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Associate;
|
||||
using LCU.Library.Internal.Exceptions;
|
||||
|
||||
namespace LCU.Api.Internal.CoreApiWrapperTest.Service
|
||||
{
|
||||
public class AssociateServiceTest
|
||||
{
|
||||
private readonly AssociateService _associateService;
|
||||
private readonly Mock<IAssociateDao> _mockAssociateDao;
|
||||
|
||||
public AssociateServiceTest()
|
||||
{
|
||||
_mockAssociateDao = new Mock<IAssociateDao>();
|
||||
_associateService = new AssociateService(_mockAssociateDao.Object);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetAssociateDetailsBySsn_Exception_Returns_Null()
|
||||
{
|
||||
var taxId = Guid.NewGuid().ToString();
|
||||
|
||||
_mockAssociateDao.Setup(x => x.GetAssociateDetailsBySsn(It.IsAny<string>())).Throws(new Exception());
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(() => _associateService.GetAssociateDetailsBySsn(taxId));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetAssociateDetailsBySsn_Returns_PersonAssociateDetails()
|
||||
{
|
||||
var taxId = Guid.NewGuid().ToString();
|
||||
|
||||
var associateDetails = new AssociateDetails
|
||||
{
|
||||
PersonNumber = DateTime.Now.Millisecond
|
||||
};
|
||||
|
||||
_mockAssociateDao.Setup(x => x.GetAssociateDetailsBySsn(It.IsAny<string>())).ReturnsAsync(associateDetails).Verifiable();
|
||||
|
||||
var result = await _associateService.GetAssociateDetailsBySsn(taxId);
|
||||
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual(associateDetails.PersonNumber, result.PersonNumber);
|
||||
_mockAssociateDao.Verify();
|
||||
}
|
||||
}
|
||||
}
|
||||
+73
@@ -0,0 +1,73 @@
|
||||
using System;
|
||||
using System.Linq;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading.Tasks;
|
||||
using NUnit.Framework;
|
||||
using AutoMapper;
|
||||
using Moq;
|
||||
using LCU.Api.Internal.CoreApiWrapper.Mappers;
|
||||
using LCU.Api.Internal.CoreApiWrapper.Services;
|
||||
using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Branches;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
|
||||
|
||||
namespace LCU.Api.Internal.CoreApiWrapperTest.Service
|
||||
{
|
||||
public class BranchServiceTest
|
||||
{
|
||||
private readonly BranchService _branchService;
|
||||
private readonly IMapper _mapper;
|
||||
private readonly Mock<IBranchDao> _mockBranchDao;
|
||||
|
||||
public BranchServiceTest()
|
||||
{
|
||||
|
||||
if (_mapper == null)
|
||||
{
|
||||
var mappingConfig = new MapperConfiguration(mc =>
|
||||
{
|
||||
mc.AddProfile(new BranchMapper());
|
||||
});
|
||||
IMapper mapper = mappingConfig.CreateMapper();
|
||||
_mapper = mapper;
|
||||
}
|
||||
|
||||
_mockBranchDao = new Mock<IBranchDao>();
|
||||
_branchService = new BranchService(_mapper, _mockBranchDao.Object);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetBranches_Returns_FilledOutBranches()
|
||||
{
|
||||
var testBranch = new List<Branch>()
|
||||
{
|
||||
new Branch()
|
||||
{
|
||||
BranchNumber = 1,
|
||||
BranchName = "Test Branch One"
|
||||
},
|
||||
new Branch()
|
||||
{
|
||||
BranchNumber = 2,
|
||||
BranchName = "Test Branch Two"
|
||||
}
|
||||
};
|
||||
_mockBranchDao.Setup(x => x.FindBranches(It.IsAny<CoreRequestParameters>())).ReturnsAsync(testBranch);
|
||||
|
||||
var result = await _branchService.GetBranches();
|
||||
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual(2, result.Count());
|
||||
Assert.AreEqual(1, result.FirstOrDefault().BranchId);
|
||||
Assert.AreEqual("Test Branch One", result.FirstOrDefault().BranchName);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetBranches_Exception()
|
||||
{
|
||||
_mockBranchDao.Setup(x => x.FindBranches(It.IsAny<CoreRequestParameters>())).Throws(new Exception());
|
||||
|
||||
Assert.ThrowsAsync<Exception>(() => _branchService.GetBranches());
|
||||
}
|
||||
}
|
||||
}
|
||||
+154
@@ -0,0 +1,154 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using NUnit.Framework;
|
||||
using AutoMapper;
|
||||
using Moq;
|
||||
using System.Threading.Tasks;
|
||||
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.CoreModels.MemberAgreements;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.PostalAddresses;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.EmailAddress;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Phones;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Persons;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
|
||||
|
||||
namespace LCU.Api.Internal.CoreApiWrapperTest.Service
|
||||
{
|
||||
public class IndividualServiceTest
|
||||
{
|
||||
private readonly IndividualService _individualService;
|
||||
private readonly IMapper _mapper;
|
||||
private readonly Mock<IPersonService> _mockPersonService;
|
||||
private readonly Mock<IAgreePersonService> _mockAgreePersonService;
|
||||
|
||||
public IndividualServiceTest()
|
||||
{
|
||||
if (_mapper == null)
|
||||
{
|
||||
var mappingConfig = new MapperConfiguration(mc =>
|
||||
{
|
||||
mc.AddProfile(new IndividualMapper());
|
||||
mc.AddProfile(new AddressMapper());
|
||||
mc.AddProfile(new PhoneMapper());
|
||||
});
|
||||
IMapper mapper = mappingConfig.CreateMapper();
|
||||
_mapper = mapper;
|
||||
}
|
||||
_mockPersonService = new Mock<IPersonService>();
|
||||
_mockAgreePersonService = new Mock<IAgreePersonService>();
|
||||
|
||||
_individualService = new IndividualService(_mapper,
|
||||
_mockPersonService.Object,
|
||||
_mockAgreePersonService.Object);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetIndividual_Returns_FilledOutIndividual()
|
||||
{
|
||||
var agreePerson = new AgreePerson()
|
||||
{
|
||||
AgreeNumber = 100,
|
||||
PersonNumber = 10,
|
||||
UserId = "1"
|
||||
};
|
||||
_mockAgreePersonService.Setup(x => x.GetByUserId(It.IsAny<string>())).ReturnsAsync(agreePerson);
|
||||
|
||||
var testPostalAddress = new PostalAddress()
|
||||
{
|
||||
AddressUseCode = AddressConstants.PrimaryUseCode,
|
||||
AddressNumber = 11
|
||||
};
|
||||
var testPostalAddressList = new List<PostalAddress>() { testPostalAddress };
|
||||
|
||||
var email1 = new Email()
|
||||
{
|
||||
EmailAddress = "[email protected]"
|
||||
};
|
||||
var email2 = new Email()
|
||||
{
|
||||
EmailAddress = "[email protected]"
|
||||
};
|
||||
var testEmailAddressList = new List<Email>() { email1, email2 };
|
||||
|
||||
var phone1 = new Phone()
|
||||
{
|
||||
IsPreferred = true,
|
||||
AreaCode = "262",
|
||||
Exchange = "789",
|
||||
PhoneNumber = "3321"
|
||||
};
|
||||
var phone2 = new Phone()
|
||||
{
|
||||
IsPreferred = false,
|
||||
AreaCode = "626",
|
||||
Exchange = "987",
|
||||
PhoneNumber = "1123"
|
||||
};
|
||||
var testPhoneList = new List<Phone>() { phone1, phone2 };
|
||||
|
||||
var testPersonResult = new Person()
|
||||
{
|
||||
PersonNumber = 10,
|
||||
FirstName = "Tester",
|
||||
MiddleName = "Person",
|
||||
MiddleInitial = "P",
|
||||
LastName = "Guy",
|
||||
Suffix = "Jr",
|
||||
TaxId = "1231232132",
|
||||
BirthDate = "1/1/2021",
|
||||
PostalAddressList = testPostalAddressList,
|
||||
IsEmployee = true,
|
||||
EmailAddressList = testEmailAddressList,
|
||||
Phones = testPhoneList
|
||||
};
|
||||
var testPersonsResult = new List<Person>();
|
||||
testPersonsResult.Add(testPersonResult);
|
||||
_mockPersonService.Setup(x => x.GetPersonsBySearch(It.IsAny<CoreRequestParameters>(),
|
||||
It.IsAny<PersonSearchRequest>())).ReturnsAsync(testPersonsResult);
|
||||
|
||||
var result = await _individualService.GetIndividualByUserId("1111");
|
||||
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual(10, result.IndividualId);
|
||||
Assert.AreEqual("Tester", result.FirstName);
|
||||
Assert.AreEqual("P", result.MiddleName);
|
||||
Assert.AreEqual("Guy", result.LastName);
|
||||
Assert.AreEqual("Jr", result.NameSuffix);
|
||||
Assert.AreEqual("1231232132", result.TaxId);
|
||||
Assert.AreEqual(Convert.ToDateTime("1/1/2021"), result.BirthDate);
|
||||
Assert.AreEqual(11, result.PrimaryAddressId);
|
||||
Assert.IsTrue(result.IsEmployee);
|
||||
Assert.AreEqual(1, result.Address.Count);
|
||||
Assert.AreEqual("[email protected]", result.Email1);
|
||||
Assert.AreEqual(2, result.Phone.Count);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetPersonsByMemberAgreementNbr_Exception_InGetByUserId()
|
||||
{
|
||||
_mockAgreePersonService.Setup(x => x.GetByUserId(It.IsAny<string>())).Throws(new Exception());
|
||||
var testId = "1";
|
||||
Assert.ThrowsAsync<Exception>(() => _individualService.GetIndividualByUserId(testId));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetPersonsByMemberAgreementNbr_Exception_InGetPersonBySearch()
|
||||
{
|
||||
var agreePerson = new AgreePerson()
|
||||
{
|
||||
AgreeNumber = 100,
|
||||
PersonNumber = 10,
|
||||
UserId = "1"
|
||||
};
|
||||
_mockAgreePersonService.Setup(x => x.GetByUserId(It.IsAny<string>())).ReturnsAsync(agreePerson);
|
||||
_mockPersonService.Setup(x => x.GetPersonsBySearch(It.IsAny<CoreRequestParameters>(),
|
||||
It.IsAny<PersonSearchRequest>())).Throws(new Exception());
|
||||
|
||||
var testId = "1";
|
||||
Assert.ThrowsAsync<Exception>(() => _individualService.GetIndividualByUserId(testId));
|
||||
}
|
||||
}
|
||||
}
|
||||
+274
@@ -0,0 +1,274 @@
|
||||
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.CoreModels.Accounts;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Loans;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Properties;
|
||||
|
||||
namespace LCU.Api.Internal.CoreApiWrapperTest.Service
|
||||
{
|
||||
public class LoanServiceTest
|
||||
{
|
||||
private readonly LoanService _loanService;
|
||||
private readonly IMapper _mapper;
|
||||
private readonly Mock<IAccountService> _mockAccountService;
|
||||
private readonly Mock<IPropertyService> _mockPropertyService;
|
||||
private readonly Mock<IAccountHistoryService> _mockAccountHistoryService;
|
||||
|
||||
public LoanServiceTest()
|
||||
{
|
||||
|
||||
if (_mapper == null)
|
||||
{
|
||||
var mappingConfig = new MapperConfiguration(mc =>
|
||||
{
|
||||
mc.AddProfile(new LoanDetailMapper());
|
||||
mc.AddProfile(new CollateralDetailMapper());
|
||||
mc.AddProfile(new OtherCollateralMapper());
|
||||
mc.AddProfile(new VehicleMapper());
|
||||
});
|
||||
IMapper mapper = mappingConfig.CreateMapper();
|
||||
_mapper = mapper;
|
||||
}
|
||||
|
||||
_mockAccountService = new Mock<IAccountService>();
|
||||
_mockPropertyService = new Mock<IPropertyService>();
|
||||
_mockAccountHistoryService = new Mock<IAccountHistoryService>();
|
||||
_loanService = new LoanService(_mapper, _mockAccountService.Object, _mockPropertyService.Object, _mockAccountHistoryService.Object);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetLoanDetail_Returns_FilledOutAccount_WrittenOffStatus()
|
||||
{
|
||||
var testAccountRolesInfos = new List<AccountRolesInfo>()
|
||||
{
|
||||
new AccountRolesInfo()
|
||||
{
|
||||
AccountRoleDescription = AccountRoleConstants.LoanOfficer
|
||||
},
|
||||
new AccountRolesInfo()
|
||||
{
|
||||
PersonNumber = 1,
|
||||
RoleName = "Tester One"
|
||||
},
|
||||
new AccountRolesInfo()
|
||||
{
|
||||
PersonNumber = 2,
|
||||
RoleName = "Tester Two"
|
||||
}
|
||||
};
|
||||
|
||||
var testLoanInfo = new LoanInfo()
|
||||
{
|
||||
NextDueDate = Convert.ToDateTime("1/1/2021"),
|
||||
CurrentDueDate = Convert.ToDateTime("1/1/2020")
|
||||
};
|
||||
|
||||
var account = new Account()
|
||||
{
|
||||
MemberAgreementNumber = 100,
|
||||
AccountNumber = 1000143,
|
||||
ReportingForPersonNumber = 1,
|
||||
CurrentAccountStatusDescription = AccountStatusConstants.CoreChargeOffAccount,
|
||||
CurrentAccountStatusDateTime = Convert.ToDateTime("1/1/2021"),
|
||||
Balance = 100.10M,
|
||||
AccountRolesInfo = testAccountRolesInfos,
|
||||
LoanInfo = testLoanInfo
|
||||
|
||||
};
|
||||
_mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
|
||||
It.IsAny<AcctNbrRequest>())).ReturnsAsync(account);
|
||||
|
||||
_mockAccountHistoryService.Setup(x => x.GetChargeoffDateTimesByAccountNumber(It.IsAny<string>())).ReturnsAsync(new List<DateTime>() { Convert.ToDateTime("1/1/2021") });
|
||||
|
||||
var testLoanId = 1000143;
|
||||
var result = await _loanService.GetLoanDetail(testLoanId);
|
||||
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual(2, result.IndividualId.Length);
|
||||
Assert.AreEqual(1, result.IndividualId[0]);
|
||||
Assert.AreEqual(2, result.Borrowers.Count);
|
||||
Assert.AreEqual(AccountRoleConstants.Borrower, result.Borrowers.FirstOrDefault().Type);
|
||||
Assert.AreEqual(1, result.Borrowers.FirstOrDefault().IndividualId);
|
||||
Assert.AreEqual("Tester One", result.Borrowers.FirstOrDefault().Name);
|
||||
Assert.AreEqual(AccountStatusConstants.WrittenOffStatus, result.Status);
|
||||
Assert.AreEqual(Convert.ToDateTime("1/1/2021"), result.WrittenOffDate);
|
||||
Assert.AreEqual(Convert.ToDateTime("1/1/2020"), result.NextDueDate);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetLoanDetail_Returns_FilledOutAccount_OpenStatus()
|
||||
{
|
||||
var testAccountRolesInfos = new List<AccountRolesInfo>()
|
||||
{
|
||||
new AccountRolesInfo()
|
||||
{
|
||||
AccountRoleDescription = AccountRoleConstants.LoanOfficer
|
||||
},
|
||||
new AccountRolesInfo()
|
||||
{
|
||||
PersonNumber = 1,
|
||||
RoleName = "Tester One"
|
||||
},
|
||||
new AccountRolesInfo()
|
||||
{
|
||||
PersonNumber = 2,
|
||||
RoleName = "Tester Two"
|
||||
}
|
||||
};
|
||||
|
||||
var testLoanInfo = new LoanInfo()
|
||||
{
|
||||
NextDueDate = Convert.ToDateTime("1/1/2021"),
|
||||
CurrentDueDate = Convert.ToDateTime("1/1/2020")
|
||||
};
|
||||
|
||||
var account = new Account()
|
||||
{
|
||||
MemberAgreementNumber = 100,
|
||||
AccountNumber = 1000143,
|
||||
ReportingForPersonNumber = 1,
|
||||
CurrentAccountStatusDescription = AccountStatusConstants.CoreActiveAccount,
|
||||
Balance = 100.10M,
|
||||
AccountRolesInfo = testAccountRolesInfos,
|
||||
LoanInfo = testLoanInfo
|
||||
|
||||
};
|
||||
_mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
|
||||
It.IsAny<AcctNbrRequest>())).ReturnsAsync(account);
|
||||
|
||||
var testLoanId = 1000143;
|
||||
var result = await _loanService.GetLoanDetail(testLoanId);
|
||||
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual(2, result.IndividualId.Length);
|
||||
Assert.AreEqual(1, result.IndividualId[0]);
|
||||
Assert.AreEqual(2, result.Borrowers.Count);
|
||||
Assert.AreEqual(AccountRoleConstants.Borrower, result.Borrowers.FirstOrDefault().Type);
|
||||
Assert.AreEqual(1, result.Borrowers.FirstOrDefault().IndividualId);
|
||||
Assert.AreEqual("Tester One", result.Borrowers.FirstOrDefault().Name);
|
||||
Assert.AreEqual(AccountStatusConstants.OpenStatus, result.Status);
|
||||
Assert.AreEqual(DateTime.MinValue, result.WrittenOffDate);
|
||||
Assert.AreEqual(Convert.ToDateTime("1/1/2020"), result.NextDueDate);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetLoanDetail_Exception()
|
||||
{
|
||||
_mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
|
||||
It.IsAny<AcctNbrRequest>())).Throws(new Exception());
|
||||
|
||||
var testLoanId = 1000143;
|
||||
Assert.ThrowsAsync<Exception>(async () => await _loanService.GetLoanDetail(testLoanId));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetCollateralDetails_Returns_CollateralDetails_OneVehicle_OneNoneVehicle()
|
||||
{
|
||||
var testProperty1 = new Property()
|
||||
{
|
||||
TypeCode= "AUTU",
|
||||
Value = 100,
|
||||
Make ="Test Make",
|
||||
Model = "Test Model",
|
||||
PropertyNumber = 1,
|
||||
PropertyId = "dfjadf12083213"
|
||||
};
|
||||
var testProperty2 = new Property()
|
||||
{
|
||||
TypeCode = "TEST",
|
||||
Value = 1000,
|
||||
PropertyId = "2"
|
||||
};
|
||||
List<Property> testProperties = new List<Property>() { testProperty1, testProperty2 };
|
||||
_mockPropertyService.Setup(x => x.GetAccountProperties(It.IsAny<long>())).ReturnsAsync(testProperties);
|
||||
|
||||
var testLoanId = 1000143;
|
||||
var results = await _loanService.GetCollateralDetails(testLoanId);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(2, results.Count());
|
||||
var resultVehicle = results.FirstOrDefault(p => p.Vehicle != null);
|
||||
Assert.NotNull(resultVehicle);
|
||||
Assert.AreEqual("Test Make", resultVehicle.Vehicle.Make);
|
||||
Assert.AreEqual("Test Model", resultVehicle.Vehicle.Model);
|
||||
Assert.AreEqual("dfjadf12083213", resultVehicle.Vehicle.VIN);
|
||||
Assert.AreEqual(1, resultVehicle.CollateralId);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetCollateralDetails_Returns_CollateralDetails_AllNoneVehicle()
|
||||
{
|
||||
var testProperty1 = new Property()
|
||||
{
|
||||
TypeCode = "TEST 1",
|
||||
Value = 10001.99,
|
||||
PropertyId = "1"
|
||||
};
|
||||
var testProperty2 = new Property()
|
||||
{
|
||||
TypeCode = "TEST 2",
|
||||
Value = 10002.01,
|
||||
PropertyId = "2"
|
||||
};
|
||||
List<Property> testProperties = new List<Property>() { testProperty1, testProperty2 };
|
||||
_mockPropertyService.Setup(x => x.GetAccountProperties(It.IsAny<long>())).ReturnsAsync(testProperties);
|
||||
|
||||
var testLoanId = 1000143;
|
||||
var results = await _loanService.GetCollateralDetails(testLoanId);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(2, results.Count());
|
||||
var resultVehicle = results.FirstOrDefault(p => p.Vehicle != null);
|
||||
Assert.Null(resultVehicle);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetCollateralDetails_Exception()
|
||||
{
|
||||
_mockPropertyService.Setup(x => x.GetAccountProperties(It.IsAny<long>())).Throws(new Exception());
|
||||
|
||||
var testLoanId = 1000143;
|
||||
Assert.ThrowsAsync<Exception>(async () => await _loanService.GetCollateralDetails( testLoanId));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetPropertyInformation_OkAsync()
|
||||
{
|
||||
var testProperty1 = new Property()
|
||||
{
|
||||
PropertyNumber = 1000
|
||||
};
|
||||
var testProperty2 = new Property()
|
||||
{
|
||||
PropertyNumber = 1001
|
||||
};
|
||||
List<Property> testProperties = new List<Property>() { testProperty1, testProperty2 };
|
||||
_mockPropertyService.Setup(x => x.GetAccountProperties(It.IsAny<long>())).ReturnsAsync(testProperties);
|
||||
|
||||
var testLoanId = 1000143;
|
||||
var results = await _loanService.GetPropertyInformation(testLoanId);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(2, results.Count());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetPropertyInformation_Exception()
|
||||
{
|
||||
_mockPropertyService.Setup(x => x.GetAccountProperties(It.IsAny<long>())).Throws(new Exception());
|
||||
|
||||
var testaccountId = 1000;
|
||||
Assert.ThrowsAsync<Exception>(async () => await _loanService.GetPropertyInformation(testaccountId));
|
||||
}
|
||||
}
|
||||
}
|
||||
+408
@@ -0,0 +1,408 @@
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
+228
@@ -0,0 +1,228 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using NUnit.Framework;
|
||||
using Moq;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
|
||||
using LCU.Api.Internal.CoreApiWrapper.Services;
|
||||
using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Organizations;
|
||||
using LCU.Library.Internal.Exceptions;
|
||||
|
||||
namespace LCU.Api.Internal.CoreApiWrapperTest.Service
|
||||
{
|
||||
public class OrganizationServiceTest
|
||||
{
|
||||
private readonly IOrganizationService _organizationService;
|
||||
private readonly Mock<IOrganizationDao> _mockOrganizationDao;
|
||||
|
||||
public OrganizationServiceTest()
|
||||
{
|
||||
_mockOrganizationDao = new Mock<IOrganizationDao>();
|
||||
|
||||
_organizationService = new OrganizationService(_mockOrganizationDao.Object);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetOrganizationByOrganizationNumber_Returns_Organization()
|
||||
{
|
||||
var testOrganizationResult = OrganizationFactory();
|
||||
var testOrganizationsResult = new List<Organization> { testOrganizationResult };
|
||||
|
||||
_mockOrganizationDao.Setup(x => x.FindByOrganizationsSearch(It.IsAny<CoreRequestParameters>(),
|
||||
It.Is<OrganizationSearchRequest>(request => request.OrgNbr == 1234))).ReturnsAsync(testOrganizationsResult).Verifiable();
|
||||
|
||||
var results = await _organizationService.GetOrganizationByOrganizationNumber(1234);
|
||||
|
||||
Assert.NotNull(results);
|
||||
var organizations = results.ToList();
|
||||
Assert.AreEqual(1, organizations.Count);
|
||||
var result = organizations.FirstOrDefault();
|
||||
|
||||
Assert.AreEqual(testOrganizationResult.Name, result?.Name);
|
||||
_mockOrganizationDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetOrganizationByOrganizationNumber_Exception_ThrowsServiceException()
|
||||
{
|
||||
|
||||
_mockOrganizationDao.Setup(x => x.FindByOrganizationsSearch(It.IsAny<CoreRequestParameters>(),
|
||||
It.Is<OrganizationSearchRequest>(request => request.OrgNbr == 1234))).ThrowsAsync(new Exception("Exception thrown from unit test.")).Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(() => _organizationService.GetOrganizationByOrganizationNumber(1234));
|
||||
_mockOrganizationDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetOrganizationByMemberAgreementNbr_Returns_Organization()
|
||||
{
|
||||
var testOrganizationResult = OrganizationFactory();
|
||||
|
||||
_mockOrganizationDao.Setup(x => x.FindOrganizationByMemberAgreeNbr(It.IsAny<CoreRequestParameters>(),
|
||||
It.Is<MemberNbrRequest>(request => request.MemberNbr == 12345))).ReturnsAsync(testOrganizationResult).Verifiable();
|
||||
|
||||
var result = await _organizationService.GetMemberByMemberAgreeNbr(12345);
|
||||
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual(testOrganizationResult.Name, result.Name);
|
||||
_mockOrganizationDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetOrganizationByMemberAgreementNbr_Exception_ThrowsServiceException()
|
||||
{
|
||||
_mockOrganizationDao.Setup(x => x.FindOrganizationByMemberAgreeNbr(It.IsAny<CoreRequestParameters>(),
|
||||
It.Is<MemberNbrRequest>(request => request.MemberNbr == 12345))).ThrowsAsync(new Exception("Exception thrown from unit test")).Verifiable();
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(() => _organizationService.GetMemberByMemberAgreeNbr(12345));
|
||||
_mockOrganizationDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetOrganizationByName_SearchThrowsException_ThrowsServiceException()
|
||||
{
|
||||
var organizationName = Guid.NewGuid().ToString();
|
||||
var searchException = new Exception(Guid.NewGuid().ToString());
|
||||
_mockOrganizationDao
|
||||
.Setup(o => o.FindByOrganizationsSearch
|
||||
(
|
||||
It.IsAny<CoreRequestParameters>(),
|
||||
It.Is<OrganizationSearchRequest>(r => r.OrgName == organizationName)
|
||||
))
|
||||
.ThrowsAsync(searchException);
|
||||
|
||||
var thrownException = Assert.ThrowsAsync<ServiceException>(() => _organizationService.GetOrganizationByName(organizationName));
|
||||
|
||||
StringAssert.Contains(organizationName, thrownException.Message);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetOrganizationByName_SearchSucceeds_ReturnsResults()
|
||||
{
|
||||
var organizationName = Guid.NewGuid().ToString();
|
||||
var actualOrganizations = new[]
|
||||
{
|
||||
OrganizationFactory()
|
||||
};
|
||||
_mockOrganizationDao
|
||||
.Setup(o => o.FindByOrganizationsSearch
|
||||
(
|
||||
It.IsAny<CoreRequestParameters>(),
|
||||
It.Is<OrganizationSearchRequest>(r => r.OrgName == organizationName)
|
||||
))
|
||||
.ReturnsAsync(actualOrganizations);
|
||||
|
||||
var organizations = await _organizationService.GetOrganizationByName(organizationName);
|
||||
|
||||
Assert.AreSame(actualOrganizations, organizations);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetOrganizationByNameLike_DaoReturnsOrgNumbersAndOrgsForNumbers_ReturnsOrganizations()
|
||||
{
|
||||
var organizationName = Guid.NewGuid().ToString();
|
||||
var partialName = organizationName[5..^5];
|
||||
var organizations = new []
|
||||
{
|
||||
OrganizationFactory(organizationName),
|
||||
OrganizationFactory(),
|
||||
OrganizationFactory(organizationName)
|
||||
};
|
||||
var nameMatchedOrganizations = organizations
|
||||
.Where(o => o.Name == organizationName)
|
||||
.ToArray();
|
||||
var limit = nameMatchedOrganizations.Length / 2;
|
||||
_mockOrganizationDao
|
||||
.Setup(dao => dao.FindOrganizationNumbersByNameSearch(It.IsAny<string>(), It.IsAny<int>()))
|
||||
.Returns<string, int>((name, count) => Task.FromResult(organizations.Where(o => o.Name.Contains(name)).Take(count).Select(o => o.OrganizationNumber)));
|
||||
_mockOrganizationDao
|
||||
.Setup(dao => dao.FindByOrganizationsSearch(It.IsAny<CoreRequestParameters>(), It.IsAny<OrganizationSearchRequest>()))
|
||||
.Returns<CoreRequestParameters, OrganizationSearchRequest>((_, search) => Task.FromResult(nameMatchedOrganizations.Where(o => search.OrgNbr == o.OrganizationNumber)));
|
||||
|
||||
var foundOrganizations = await _organizationService.GetOrganizationByNameLike(partialName, limit);
|
||||
|
||||
CollectionAssert.AreEquivalent(nameMatchedOrganizations.Take(limit), foundOrganizations);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetOrganizationByNameLike_DaoThrowsFromFindOrganizationNumbersByNameSearch_ThrowsServiceException()
|
||||
{
|
||||
var organizationName = Guid.NewGuid().ToString();
|
||||
var limit = DateTime.Now.Millisecond;
|
||||
_mockOrganizationDao
|
||||
.Setup(dao => dao.FindOrganizationNumbersByNameSearch(organizationName, limit))
|
||||
.ThrowsAsync(new Exception());
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(() => _organizationService.GetOrganizationByNameLike(organizationName, limit));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetOrganizationByNameLike_DaoThrowsFromFindByOrganizationsSearch_ThrowsServiceException()
|
||||
{
|
||||
var organizationName = Guid.NewGuid().ToString();
|
||||
var limit = DateTime.Now.Millisecond;
|
||||
var organizations = new []
|
||||
{
|
||||
OrganizationFactory(organizationName),
|
||||
OrganizationFactory(),
|
||||
OrganizationFactory(organizationName)
|
||||
};
|
||||
_mockOrganizationDao
|
||||
.Setup(dao => dao.FindOrganizationNumbersByNameSearch(It.IsAny<string>(), It.IsAny<int>()))
|
||||
.Returns<string, int>((name, count) => Task.FromResult(organizations.Where(o => o.Name.Contains(name)).Take(count).Select(o => o.OrganizationNumber)));
|
||||
_mockOrganizationDao
|
||||
.Setup(dao => dao.FindByOrganizationsSearch(It.IsAny<CoreRequestParameters>(), It.IsAny<OrganizationSearchRequest>()))
|
||||
.ThrowsAsync(new Exception());
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(() => _organizationService.GetOrganizationByNameLike(organizationName, limit));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task CountOrganizationNumbersByName_DaoReturnsCount_ReturnsCount()
|
||||
{
|
||||
var organizationName = Guid.NewGuid().ToString();
|
||||
var partialName = organizationName[5..^5];
|
||||
var organizations = new []
|
||||
{
|
||||
OrganizationFactory(organizationName),
|
||||
OrganizationFactory(),
|
||||
OrganizationFactory(organizationName)
|
||||
};
|
||||
var nameMatchedOrganizations = organizations
|
||||
.Where(o => o.Name == organizationName)
|
||||
.ToArray();
|
||||
_mockOrganizationDao
|
||||
.Setup(dao => dao.CountOrganizationNumbersByName(It.IsAny<string>()))
|
||||
.Returns<string>(name => Task.FromResult<long>(organizations.Count(o => o.Name.Contains(name))));
|
||||
|
||||
var count = await _organizationService.CountOrganizationNumbersByName(partialName);
|
||||
|
||||
Assert.AreEqual(count, nameMatchedOrganizations.Length);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void CountOrganizationNumbersByName_DaoThrowsFromCountOrganizationNumbersByName_ThrowsServiceException()
|
||||
{
|
||||
var organizationName = Guid.NewGuid().ToString();
|
||||
_mockOrganizationDao
|
||||
.Setup(dao => dao.CountOrganizationNumbersByName(organizationName))
|
||||
.ThrowsAsync(new Exception());
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(() => _organizationService.CountOrganizationNumbersByName(organizationName));
|
||||
}
|
||||
|
||||
private static Random _organizationNumberSeries = new Random(DateTime.Now.Millisecond);
|
||||
|
||||
private static Organization OrganizationFactory(string name = null, long? number = null)
|
||||
{
|
||||
return new Organization
|
||||
{
|
||||
Name = name ?? "Test Organization",
|
||||
OrganizationNumber = number ?? _organizationNumberSeries.Next()
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
+269
@@ -0,0 +1,269 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using NUnit.Framework;
|
||||
using Moq;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
|
||||
using LCU.Api.Internal.CoreApiWrapper.Services;
|
||||
using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Persons;
|
||||
using LCU.Library.Internal.Exceptions;
|
||||
|
||||
namespace LCU.Api.Internal.CoreApiWrapperTest.Service
|
||||
{
|
||||
public class PersonServiceTest
|
||||
{
|
||||
private readonly PersonService _personService;
|
||||
private readonly Mock<IPersonDao> _mockPersonDao;
|
||||
|
||||
public PersonServiceTest()
|
||||
{
|
||||
_mockPersonDao = new Mock<IPersonDao>();
|
||||
_personService = new PersonService(_mockPersonDao.Object);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetPersonsByName_Returns_Person()
|
||||
{
|
||||
var coreRequestParameters = new CoreRequestParameters();
|
||||
var personNameRequest = new PersonNameRequest
|
||||
{
|
||||
FirstName = "Tester"
|
||||
};
|
||||
|
||||
var testPersonResult = new Person
|
||||
{
|
||||
PersonNumber = 1,
|
||||
FirstName = "Tester",
|
||||
MiddleName = "Person",
|
||||
LastName = "Guy",
|
||||
NameFull = "Tester Person Guy",
|
||||
Suffix = "",
|
||||
TaxId = "1231232132",
|
||||
BirthDate = "1/1/2021"
|
||||
};
|
||||
var testPersonsResult = new List<Person> { testPersonResult };
|
||||
|
||||
_mockPersonDao.Setup(x => x.FindByPersonsName(It.IsAny<CoreRequestParameters>(),
|
||||
It.IsAny<PersonNameRequest>())).ReturnsAsync(testPersonsResult);
|
||||
|
||||
var results = await _personService.GetPersonsByName(coreRequestParameters, personNameRequest);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(1, results.ToList().Count);
|
||||
var result = results.FirstOrDefault();
|
||||
|
||||
Assert.AreEqual(1, result.PersonNumber);
|
||||
Assert.AreEqual("Tester", result.FirstName);
|
||||
Assert.AreEqual("Person", result.MiddleName);
|
||||
Assert.AreEqual("Guy", result.LastName);
|
||||
Assert.AreEqual("1231232132", result.TaxId);
|
||||
Assert.AreEqual("1/1/2021", result.BirthDate);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetPersonsByName_Exception_Returns_Null()
|
||||
{
|
||||
var coreRequestParameters = new CoreRequestParameters();
|
||||
var personNameRequest = new PersonNameRequest
|
||||
{
|
||||
FirstName = "Tester"
|
||||
};
|
||||
|
||||
_mockPersonDao.Setup(x => x.FindByPersonsName(It.IsAny<CoreRequestParameters>(),
|
||||
It.IsAny<PersonNameRequest>())).Throws(new Exception());
|
||||
|
||||
Assert.ThrowsAsync<Exception>(() => _personService.GetPersonsByName(coreRequestParameters, personNameRequest));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetPersonsBySearch_Returns_Person()
|
||||
{
|
||||
var coreRequestParameters = new CoreRequestParameters();
|
||||
var personSearchRequest = new PersonSearchRequest
|
||||
{
|
||||
PersNbr = 1
|
||||
};
|
||||
|
||||
var testPersonResult = new Person
|
||||
{
|
||||
PersonNumber = 1,
|
||||
FirstName = "Tester",
|
||||
MiddleName = "Person",
|
||||
LastName = "Guy",
|
||||
NameFull = "Tester Person Guy",
|
||||
Suffix = "",
|
||||
TaxId = "1231232132",
|
||||
BirthDate = "1/1/2021"
|
||||
};
|
||||
var testPersonsResult = new List<Person> { testPersonResult };
|
||||
|
||||
_mockPersonDao.Setup(x => x.FindByPersonsSearch(It.IsAny<CoreRequestParameters>(),
|
||||
It.IsAny<PersonSearchRequest>())).ReturnsAsync(testPersonsResult);
|
||||
|
||||
var results = await _personService.GetPersonsBySearch(coreRequestParameters, personSearchRequest);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(1, results.ToList().Count);
|
||||
var result = results.FirstOrDefault();
|
||||
|
||||
Assert.AreEqual(1, result.PersonNumber);
|
||||
Assert.AreEqual("Tester", result.FirstName);
|
||||
Assert.AreEqual("Person", result.MiddleName);
|
||||
Assert.AreEqual("Guy", result.LastName);
|
||||
Assert.AreEqual("1231232132", result.TaxId);
|
||||
Assert.AreEqual("1/1/2021", result.BirthDate);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetPersonsBySearch_Exception_Returns_Null()
|
||||
{
|
||||
var coreRequestParameters = new CoreRequestParameters();
|
||||
var personSearchRequest = new PersonSearchRequest
|
||||
{
|
||||
FirstName = "Tester"
|
||||
};
|
||||
|
||||
_mockPersonDao.Setup(x => x.FindByPersonsSearch(It.IsAny<CoreRequestParameters>(),
|
||||
It.IsAny<PersonSearchRequest>())).Throws(new Exception());
|
||||
|
||||
Assert.ThrowsAsync<Exception>(() => _personService.GetPersonsBySearch(coreRequestParameters, personSearchRequest));
|
||||
}
|
||||
|
||||
|
||||
[Test]
|
||||
public async Task GetPersonsByMemberAgreementNbr_Returns_Person()
|
||||
{
|
||||
var coreRequestParameters = new CoreRequestParameters();
|
||||
var personMemberAgreementNbrRequest = new MemberNbrRequest
|
||||
{
|
||||
MemberNbr = 100
|
||||
};
|
||||
|
||||
var testPersonResult = new Person
|
||||
{
|
||||
PersonNumber = 1,
|
||||
FirstName = "Tester",
|
||||
MiddleName = "Person",
|
||||
LastName = "Guy",
|
||||
NameFull = "Tester Person Guy",
|
||||
Suffix = "",
|
||||
TaxId = "1231232132",
|
||||
BirthDate = "1/1/2021"
|
||||
};
|
||||
|
||||
_mockPersonDao.Setup(x => x.FindByPersonMemberAgreementNbr(It.IsAny<CoreRequestParameters>(),
|
||||
It.IsAny<MemberNbrRequest>())).ReturnsAsync(testPersonResult);
|
||||
|
||||
var result = await _personService.GetPersonsByMemberAgreementNbr(coreRequestParameters, personMemberAgreementNbrRequest);
|
||||
|
||||
Assert.NotNull(result);
|
||||
|
||||
Assert.AreEqual(1, result.PersonNumber);
|
||||
Assert.AreEqual("Tester", result.FirstName);
|
||||
Assert.AreEqual("Person", result.MiddleName);
|
||||
Assert.AreEqual("Guy", result.LastName);
|
||||
Assert.AreEqual("1231232132", result.TaxId);
|
||||
Assert.AreEqual("1/1/2021", result.BirthDate);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetPersonsByMemberAgreementNbr_Exception_Returns_Null()
|
||||
{
|
||||
var coreRequestParameters = new CoreRequestParameters();
|
||||
var personMemberAgreementNbrRequest = new MemberNbrRequest
|
||||
{
|
||||
MemberNbr = 100
|
||||
};
|
||||
|
||||
_mockPersonDao.Setup(x => x.FindByPersonMemberAgreementNbr(It.IsAny<CoreRequestParameters>(),
|
||||
It.IsAny<MemberNbrRequest>())).Throws(new Exception());
|
||||
|
||||
Assert.ThrowsAsync<Exception>(() => _personService.GetPersonsByMemberAgreementNbr(coreRequestParameters, personMemberAgreementNbrRequest));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetPersonByMemberAgreementNbr_Returns_Person()
|
||||
{
|
||||
var testPersonResult = PersonFactory();
|
||||
|
||||
_mockPersonDao.Setup(x => x.FindByPersonMemberAgreementNbr(It.IsAny<CoreRequestParameters>(),
|
||||
It.Is<MemberNbrRequest>(request => request.MemberNbr == 12345))).ReturnsAsync(testPersonResult).Verifiable();
|
||||
|
||||
var result = await _personService.GetMemberByMemberAgreeNbr(12345);
|
||||
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual(testPersonResult.FirstName, result.FirstName);
|
||||
_mockPersonDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetPersonsByNameLike_LimitSupplied_GetsUpToLimitPersons()
|
||||
{
|
||||
var request = PersonNameRequestFactory();
|
||||
var limit = DateTime.Now.Millisecond;
|
||||
var people = Enumerable.Repeat<Func<Person>>(PersonFactory, limit).Select(f => f()).ToArray();
|
||||
_mockPersonDao
|
||||
.Setup(d => d.GetPersonNumbersByNameLike(request.FirstName, request.MdlName, request.LastName, limit))
|
||||
.ReturnsAsync(people.Select(p => (long)p.PersonNumber));
|
||||
_mockPersonDao
|
||||
.Setup(d => d.FindByPersonsSearch(It.IsAny<CoreRequestParameters>(), It.IsAny<PersonSearchRequest>()))
|
||||
.Returns<CoreRequestParameters, PersonSearchRequest>((_, search) => Task.FromResult(people.Where(p => search.PersNbr == p.PersonNumber)));
|
||||
|
||||
var actualPeople = await _personService.GetPersonsByNameLike(request, limit);
|
||||
|
||||
CollectionAssert.AreEquivalent(people, actualPeople);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetPersonsByNameLike_LimitNotSupplied_GetsUpTo1000Persons()
|
||||
{
|
||||
var request = PersonNameRequestFactory();
|
||||
var people = Enumerable.Repeat<Func<Person>>(PersonFactory, 1000).Select(f => f()).ToArray();
|
||||
_mockPersonDao
|
||||
.Setup(d => d.GetPersonNumbersByNameLike(request.FirstName, request.MdlName, request.LastName, 1000))
|
||||
.ReturnsAsync(people.Select(p => (long)p.PersonNumber));
|
||||
_mockPersonDao
|
||||
.Setup(d => d.FindByPersonsSearch(It.IsAny<CoreRequestParameters>(), It.IsAny<PersonSearchRequest>()))
|
||||
.Returns<CoreRequestParameters, PersonSearchRequest>((_, search) => Task.FromResult(people.Where(p => search.PersNbr == p.PersonNumber)));
|
||||
|
||||
var actualPeople = await _personService.GetPersonsByNameLike(request, null);
|
||||
|
||||
CollectionAssert.AreEquivalent(people, actualPeople);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task CountPersonsByNameLike_AllCases_ReturnsPersonDaoCount()
|
||||
{
|
||||
var request = PersonNameRequestFactory();
|
||||
var count = DateTime.Now.Millisecond;
|
||||
_mockPersonDao
|
||||
.Setup(d => d.CountPersonsByNameLike(request.FirstName, request.MdlName, request.LastName))
|
||||
.ReturnsAsync(count);
|
||||
|
||||
var actualCount = await _personService.CountPersonsByNameLike(request);
|
||||
|
||||
Assert.AreEqual(count, actualCount);
|
||||
}
|
||||
|
||||
private static PersonNameRequest PersonNameRequestFactory()
|
||||
=> new()
|
||||
{
|
||||
FirstName = Guid.NewGuid().ToString(),
|
||||
MdlName = Guid.NewGuid().ToString(),
|
||||
LastName = Guid.NewGuid().ToString()
|
||||
};
|
||||
|
||||
private static Random _personNumberSeries = new(DateTime.Now.Millisecond);
|
||||
private static Person PersonFactory()
|
||||
{
|
||||
return new Person
|
||||
{
|
||||
FirstName = "Test Organization",
|
||||
PersonNumber = _personNumberSeries.Next()
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
+402
@@ -0,0 +1,402 @@
|
||||
using System;
|
||||
using System.Linq;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading.Tasks;
|
||||
using NUnit.Framework;
|
||||
using Moq;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
|
||||
using LCU.Api.Internal.CoreApiWrapper.Services;
|
||||
using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Persons;
|
||||
using LCU.Library.Internal.Exceptions;
|
||||
|
||||
namespace LCU.Api.Internal.CoreApiWrapperTest.Service
|
||||
{
|
||||
public class PersonUserFieldServiceTest
|
||||
{
|
||||
private readonly PersonUserFieldService _personUserFieldService;
|
||||
private readonly Mock<IPersonService> _mockPersonService;
|
||||
private readonly Mock<IPersonUserFieldDao> _mockPersonUserFieldDao;
|
||||
|
||||
public PersonUserFieldServiceTest()
|
||||
{
|
||||
_mockPersonService = new Mock<IPersonService>();
|
||||
_mockPersonUserFieldDao = new Mock<IPersonUserFieldDao>();
|
||||
_personUserFieldService = new PersonUserFieldService(_mockPersonService.Object, _mockPersonUserFieldDao.Object);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetPersonUserFieldCoreApiResponseAsync_ExceptionThrown()
|
||||
{
|
||||
_mockPersonUserFieldDao.Setup(x => x.FindPersonUserFieldCoreApiResponseByPersonId(It.IsAny<CoreRequestParameters>(), It.IsAny<int>())).Throws(new ServiceException("Nope"));
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(async () =>
|
||||
await _personUserFieldService.GetPersonUserFieldCoreApiResponseAsync(00000000));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetPersonUserFieldCoreApiResponseAsync_UserFieldsReturned()
|
||||
{
|
||||
var personUserFields = new List<PersonUserField>()
|
||||
{
|
||||
new PersonUserField()
|
||||
{
|
||||
PersonNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
|
||||
},
|
||||
new PersonUserField()
|
||||
{
|
||||
PersonNumber = 200001,
|
||||
UserFieldCode = "TEST2",
|
||||
Value = "N"
|
||||
}
|
||||
};
|
||||
var coreMessageheader = new CoreMessageHeader();
|
||||
var personUserFieldCoreApiResponse = new CoreApiMessage<IEnumerable<PersonUserField>>(coreMessageheader, personUserFields);
|
||||
_mockPersonUserFieldDao.Setup(x => x.FindPersonUserFieldCoreApiResponseByPersonId(It.IsAny<CoreRequestParameters>(), It.IsAny<int>())).ReturnsAsync(personUserFieldCoreApiResponse);
|
||||
|
||||
|
||||
var result = await _personUserFieldService.GetPersonUserFieldCoreApiResponseAsync(100001);
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual(2, result.MessageBody.Count());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void UpdatePersonUserFieldAsync_ExceptionThrown()
|
||||
{
|
||||
_mockPersonUserFieldDao.Setup(x => x.UpdatePersonUserField(It.IsAny<CoreApiMessage<PersonUserFieldRequest>>(), It.IsAny<int>(), It.IsAny<string>())).Throws(new ServiceException("Nope"));
|
||||
|
||||
var personUserUpdateRequest = new PersonUserFieldRequest()
|
||||
{
|
||||
PersonNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
};
|
||||
Assert.ThrowsAsync<ServiceException>(async () =>
|
||||
await _personUserFieldService.UpdatePersonUserFieldAsync(personUserUpdateRequest));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task UpdatePersonUserFieldAsync_UpdatedUserFieldsReturned()
|
||||
{
|
||||
var testPerson = new Person()
|
||||
{
|
||||
PersonNumber = 100001
|
||||
};
|
||||
|
||||
var updatedPersonUserField = new PersonUserField()
|
||||
{
|
||||
PersonNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y",
|
||||
LastMaintained = Convert.ToDateTime("9/1/2001")
|
||||
};
|
||||
|
||||
var listexistingPersonUserField = new List<PersonUserField>()
|
||||
{
|
||||
new PersonUserField()
|
||||
{
|
||||
PersonNumber = 100001,
|
||||
Id = updatedPersonUserField.Id,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "N",
|
||||
LastMaintained = Convert.ToDateTime("8/1/2001")
|
||||
}
|
||||
};
|
||||
var coreMessageheader = new CoreMessageHeader();
|
||||
var coreApiResponse = new CoreApiMessage<IEnumerable<PersonUserField>>(coreMessageheader, listexistingPersonUserField);
|
||||
|
||||
_mockPersonUserFieldDao.Setup(x => x.FindPersonUserFieldCoreApiResponseByPersonId(It.IsAny<CoreRequestParameters>(),It.IsAny<int>())).ReturnsAsync(coreApiResponse);
|
||||
|
||||
_mockPersonUserFieldDao.Setup(x => x.UpdatePersonUserField(It.IsAny<CoreApiMessage<PersonUserFieldRequest>>(),
|
||||
It.IsAny<int>(),
|
||||
It.IsAny<string>())).ReturnsAsync(updatedPersonUserField);
|
||||
|
||||
_mockPersonService.Setup(x => x.GetPersonByPersonNumber(It.IsAny<long>())).ReturnsAsync(new List<Person>() { testPerson });
|
||||
|
||||
var personUserUpdateRequest = new PersonUserFieldRequest()
|
||||
{
|
||||
PersonNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
};
|
||||
var result = await _personUserFieldService.UpdatePersonUserFieldAsync(personUserUpdateRequest);
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual(updatedPersonUserField, result);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void InsertPersonUserFieldAsync_ExceptionThrown()
|
||||
{
|
||||
_mockPersonUserFieldDao.Setup(x => x.InsertPersonUserField(It.IsAny<CoreApiMessage<PersonUserFieldRequest>>(), It.IsAny<int>())).Throws(new ServiceException("Oops"));
|
||||
|
||||
var personUserUpdateRequest = new PersonUserFieldRequest()
|
||||
{
|
||||
PersonNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
};
|
||||
Assert.ThrowsAsync<ServiceException>(async () =>
|
||||
await _personUserFieldService.InsertPersonUserFieldAsync(personUserUpdateRequest));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task InsertPersonUserFieldAsync_InsertUserFieldsReturned()
|
||||
{
|
||||
var person = new Person()
|
||||
{
|
||||
Id = "TEST-adsfasdfas[]djfas"
|
||||
};
|
||||
|
||||
var personList = new List<Person> { person };
|
||||
|
||||
_mockPersonService.Setup(x => x.GetPersonByPersonNumber(It.IsAny<long>())).ReturnsAsync(personList);
|
||||
|
||||
var createdPersonUserField = new PersonUserField()
|
||||
{
|
||||
PersonNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y",
|
||||
LastMaintained = Convert.ToDateTime("9/1/2001")
|
||||
};
|
||||
_mockPersonUserFieldDao.Setup(x => x.InsertPersonUserField(It.IsAny<CoreApiMessage<PersonUserFieldRequest>>(),
|
||||
It.IsAny<int>())).ReturnsAsync(createdPersonUserField);
|
||||
|
||||
var personUserUpdateRequest = new PersonUserFieldRequest()
|
||||
{
|
||||
PersonNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
};
|
||||
var result = await _personUserFieldService.InsertPersonUserFieldAsync(personUserUpdateRequest);
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual(createdPersonUserField, result);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void UpdatePersonUserFieldsAsync_NullPerson_ExceptionThrown()
|
||||
{
|
||||
var personUserFieldUpdateRequest = new PersonUserFieldRequest()
|
||||
{
|
||||
PersonNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
|
||||
};
|
||||
|
||||
var personList = new List<Person>();
|
||||
_mockPersonService.Setup(x => x.GetPersonByPersonNumber(It.IsAny<long>())).ReturnsAsync(personList);
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(async () =>
|
||||
await _personUserFieldService.UpdatePersonUserFieldAsync(personUserFieldUpdateRequest));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void UpdatePersonUserFieldsAsync_ExistingUserFieldNull_NullExceptionThrown()
|
||||
{
|
||||
var personUserFieldUpdateRequest = new PersonUserFieldRequest()
|
||||
{
|
||||
PersonNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
|
||||
};
|
||||
|
||||
var person = new Person()
|
||||
{
|
||||
Id = "TEST-adsfasdfas[]djfas"
|
||||
};
|
||||
|
||||
var personList = new List<Person> { person };
|
||||
|
||||
_mockPersonService.Setup(x => x.GetPersonByPersonNumber(It.IsAny<long>())).ReturnsAsync(personList);
|
||||
|
||||
IEnumerable<PersonUserField> PersonUserFields = new List<PersonUserField>();
|
||||
CoreMessageHeader coreMessageHeader = new CoreMessageHeader();
|
||||
CoreApiMessage<IEnumerable<PersonUserField>> coreApiMessagePersonUserFields = new CoreApiMessage<IEnumerable<PersonUserField>>(coreMessageHeader, PersonUserFields);
|
||||
_mockPersonUserFieldDao.Setup(x => x.FindPersonUserFieldCoreApiResponseByPersonId(It.IsAny<CoreRequestParameters>(),
|
||||
It.IsAny<int>())).ReturnsAsync(coreApiMessagePersonUserFields);
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(async () =>
|
||||
await _personUserFieldService.UpdatePersonUserFieldAsync(personUserFieldUpdateRequest));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void UpdatePersonUserFieldsAsync_UpdateUserFieldNull_NullExceptionThrown()
|
||||
{
|
||||
var personUserFieldUpdateRequest = new PersonUserFieldRequest()
|
||||
{
|
||||
PersonNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
|
||||
};
|
||||
|
||||
var personList = new List<Person>();
|
||||
|
||||
_mockPersonService.Setup(x => x.GetPersonByPersonNumber(It.IsAny<long>())).ReturnsAsync(personList);
|
||||
|
||||
IEnumerable<PersonUserField> PersonUserFields = new List<PersonUserField>()
|
||||
{
|
||||
new PersonUserField()
|
||||
{
|
||||
Id = "TEST1",
|
||||
PersonNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "N"
|
||||
},
|
||||
new PersonUserField()
|
||||
{
|
||||
Id = "TEST2",
|
||||
PersonNumber = 100002,
|
||||
UserFieldCode = "TEST2",
|
||||
Value = "Y"
|
||||
}
|
||||
};
|
||||
CoreMessageHeader coreMessageHeader = new CoreMessageHeader(1122000321);
|
||||
CoreApiMessage<IEnumerable<PersonUserField>> coreApiMessagePersonUserFields = new CoreApiMessage<IEnumerable<PersonUserField>>(coreMessageHeader, PersonUserFields);
|
||||
_mockPersonUserFieldDao.Setup(x => x.FindPersonUserFieldCoreApiResponseByPersonId(It.IsAny<CoreRequestParameters>(),
|
||||
It.IsAny<int>())).ReturnsAsync(coreApiMessagePersonUserFields);
|
||||
|
||||
PersonUserField updatedPersonUserField = null;
|
||||
_mockPersonUserFieldDao.Setup(x => x.UpdatePersonUserField(It.IsAny<CoreApiMessage<PersonUserFieldRequest>>(),
|
||||
It.IsAny<int>(),
|
||||
It.IsAny<string>())).ReturnsAsync(updatedPersonUserField);
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(async () =>
|
||||
await _personUserFieldService.UpdatePersonUserFieldAsync(personUserFieldUpdateRequest));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task UpdatePersonUserFieldsAsync_UpdatedUserField()
|
||||
{
|
||||
var personUserFieldUpdateRequest = new PersonUserFieldRequest()
|
||||
{
|
||||
PersonNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
|
||||
};
|
||||
|
||||
var person = new Person()
|
||||
{
|
||||
Id = "TEST-adsfasdfas[]djfas"
|
||||
};
|
||||
|
||||
var personList = new List<Person> { person };
|
||||
|
||||
_mockPersonService.Setup(x => x.GetPersonByPersonNumber(It.IsAny<long>())).ReturnsAsync(personList);
|
||||
|
||||
|
||||
var personUserField1 = new PersonUserField()
|
||||
{
|
||||
Id = "TEST1",
|
||||
PersonNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "N"
|
||||
};
|
||||
var personUserField2 = new PersonUserField()
|
||||
{
|
||||
Id = "TEST2",
|
||||
PersonNumber = 100002,
|
||||
UserFieldCode = "TEST2",
|
||||
Value = "Y"
|
||||
};
|
||||
|
||||
IEnumerable<PersonUserField> personUserFields = new List<PersonUserField>()
|
||||
{
|
||||
personUserField1,
|
||||
personUserField2
|
||||
};
|
||||
CoreMessageHeader coreMessageHeader = new CoreMessageHeader(1122000321);
|
||||
CoreApiMessage<IEnumerable<PersonUserField>> coreApiMessagePersonUserFields = new CoreApiMessage<IEnumerable<PersonUserField>>(coreMessageHeader, personUserFields);
|
||||
_mockPersonUserFieldDao.Setup(x => x.FindPersonUserFieldCoreApiResponseByPersonId(It.IsAny<CoreRequestParameters>(),
|
||||
It.IsAny<int>())).ReturnsAsync(coreApiMessagePersonUserFields);
|
||||
|
||||
PersonUserField updatedPersonUserField1 = new PersonUserField()
|
||||
{
|
||||
PersonNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
};
|
||||
_mockPersonUserFieldDao.Setup(x => x.UpdatePersonUserField(It.IsAny<CoreApiMessage<PersonUserFieldRequest>>(),
|
||||
It.IsAny<int>(),
|
||||
personUserField1.Id)).ReturnsAsync(updatedPersonUserField1);
|
||||
|
||||
PersonUserField updatedPersonUserField2 = new PersonUserField()
|
||||
{
|
||||
PersonNumber = 100002,
|
||||
UserFieldCode = "TEST2",
|
||||
Value = "N"
|
||||
};
|
||||
_mockPersonUserFieldDao.Setup(x => x.UpdatePersonUserField(It.IsAny<CoreApiMessage<PersonUserFieldRequest>>(),
|
||||
It.IsAny<int>(),
|
||||
personUserField2.Id)).ReturnsAsync(updatedPersonUserField2);
|
||||
|
||||
var result = await _personUserFieldService.UpdatePersonUserFieldAsync(personUserFieldUpdateRequest);
|
||||
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual("Y", result.Value);
|
||||
Assert.AreEqual(100001, result.PersonNumber);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void InsertPersonUserFieldsAsync_NullPerson_ExceptionThrown()
|
||||
{
|
||||
var personUserFieldUpdateRequest = new PersonUserFieldRequest()
|
||||
{
|
||||
PersonNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
};
|
||||
|
||||
var personList = new List<Person>();
|
||||
|
||||
_mockPersonService.Setup(x => x.GetPersonByPersonNumber(It.IsAny<long>())).ReturnsAsync(personList);
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(async () =>
|
||||
await _personUserFieldService.InsertPersonUserFieldAsync(personUserFieldUpdateRequest));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task InsertPersonUserFieldsAsync_InsertedUserField()
|
||||
{
|
||||
|
||||
var person = new Person()
|
||||
{
|
||||
Id = "TEST-adsfasdfas[]djfas"
|
||||
};
|
||||
|
||||
var personList = new List<Person> { person };
|
||||
|
||||
_mockPersonService.Setup(x => x.GetPersonByPersonNumber(It.IsAny<long>())).ReturnsAsync(personList);
|
||||
|
||||
var messageHeader = new CoreMessageHeader() { };
|
||||
var personUserFieldRequest = new PersonUserFieldRequest()
|
||||
{
|
||||
PersonNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
};
|
||||
var coreApiMessage = new CoreApiMessage<PersonUserFieldRequest>(messageHeader, personUserFieldRequest);
|
||||
var createdPersonUserField1 = new PersonUserField()
|
||||
{
|
||||
PersonNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
};
|
||||
_mockPersonUserFieldDao.Setup(x => x.InsertPersonUserField(It.IsAny<CoreApiMessage<PersonUserFieldRequest>>(),
|
||||
personUserFieldRequest.PersonNumber)).ReturnsAsync(createdPersonUserField1);
|
||||
|
||||
|
||||
var result = await _personUserFieldService.InsertPersonUserFieldAsync(personUserFieldRequest);
|
||||
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual("Y", result.Value);
|
||||
Assert.AreEqual(100001, result.PersonNumber);
|
||||
}
|
||||
}
|
||||
}
|
||||
+157
@@ -0,0 +1,157 @@
|
||||
using LCU.Api.Internal.CoreApiWrapper.Services;
|
||||
using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreResponses;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Persons;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Properties;
|
||||
using LCU.Library.Internal.Exceptions;
|
||||
using Moq;
|
||||
using NUnit.Framework;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace LCU.Api.Internal.CoreApiWrapperTest.Service
|
||||
{
|
||||
public class PropertyUserFieldServiceTest
|
||||
{
|
||||
private readonly PropertyUserFieldService _propertyUserFieldService;
|
||||
private readonly Mock<IPropertyService> _mockPropertyService;
|
||||
private readonly Mock<IPropertyUserFieldDao> _mockPropertyUserFieldDao;
|
||||
|
||||
public PropertyUserFieldServiceTest()
|
||||
{
|
||||
_mockPropertyService = new Mock<IPropertyService>();
|
||||
_mockPropertyUserFieldDao = new Mock<IPropertyUserFieldDao>();
|
||||
_propertyUserFieldService = new PropertyUserFieldService(_mockPropertyService.Object, _mockPropertyUserFieldDao.Object);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetPropertyUserFieldCoreApiResponseAsync_ExceptionThrown()
|
||||
{
|
||||
_mockPropertyUserFieldDao.Setup(x => x.FindPropertyUserFieldCoreApiResponseByPersonId(It.IsAny<CoreRequestParameters>(), It.IsAny<int>())).Throws(new ServiceException("Nope"));
|
||||
|
||||
Assert.ThrowsAsync<ServiceException>(async () =>
|
||||
await _propertyUserFieldService.GetPropertyUserFieldsAsync(0));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void UpdatePropertyUserFieldAsync_ExceptionThrown()
|
||||
{
|
||||
_mockPropertyUserFieldDao.Setup(x => x.UpdatePropertyUserField(It.IsAny<UserFieldRequest>())).Throws(new ServiceException("Unit Test Failed"));
|
||||
|
||||
var propertyUserUpdateRequest = new PropertyUserField()
|
||||
{
|
||||
PropertyNumber = 100001,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
};
|
||||
Assert.ThrowsAsync<ServiceException>(async () =>
|
||||
await _propertyUserFieldService.UpdatePropertyUserFieldAsync(propertyUserUpdateRequest));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task UpdatePropertyUserFieldAsync_Ok()
|
||||
{
|
||||
var testProperty = new Property()
|
||||
{
|
||||
PropertyNumber = 1000
|
||||
};
|
||||
|
||||
var updatedPropertyUserField = new PropertyUserField()
|
||||
{
|
||||
PropertyNumber = 1000L,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y",
|
||||
LastMaintained = Convert.ToDateTime("9/1/2001")
|
||||
};
|
||||
|
||||
var listExistingPropertyUserField = new List<PropertyUserField>()
|
||||
{
|
||||
new PropertyUserField()
|
||||
{
|
||||
PropertyNumber = 1000L,
|
||||
Id = updatedPropertyUserField.Id,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "N",
|
||||
LastMaintained = Convert.ToDateTime("8/1/2001")
|
||||
}
|
||||
};
|
||||
var coreMessageheader = new CoreMessageHeader();
|
||||
var coreApiResponse = new CoreApiMessage<IEnumerable<PropertyUserField>>(coreMessageheader, listExistingPropertyUserField);
|
||||
|
||||
BasicResponse response = new BasicResponse()
|
||||
{
|
||||
Success = true
|
||||
};
|
||||
|
||||
_mockPropertyUserFieldDao.Setup(x => x.FindPropertyUserFieldCoreApiResponseByPersonId(It.IsAny<CoreRequestParameters>(), It.IsAny<int>())).ReturnsAsync(coreApiResponse);
|
||||
|
||||
_mockPropertyUserFieldDao.Setup(x => x.UpdatePropertyUserField(It.IsAny<UserFieldRequest>())).ReturnsAsync(response);
|
||||
|
||||
_mockPropertyService.Setup(x => x.GetProperty(It.IsAny<int>())).ReturnsAsync(testProperty);
|
||||
|
||||
var propertyUserUpdateRequest = new PropertyUserField()
|
||||
{
|
||||
PropertyNumber = 1000L,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
};
|
||||
var result = await _propertyUserFieldService.UpdatePropertyUserFieldAsync(propertyUserUpdateRequest);
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual(response.Success, result.Success);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void InsertPersonUserFieldAsync_ExceptionThrown()
|
||||
{
|
||||
_mockPropertyUserFieldDao.Setup(x => x.InsertPropertyUserField(It.IsAny<UserFieldRequest>())).Throws(new ServiceException("Oops"));
|
||||
|
||||
var propertyUserUpdateRequest = new PropertyUserField()
|
||||
{
|
||||
PropertyNumber = 1000,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
};
|
||||
Assert.ThrowsAsync<ServiceException>(async () =>
|
||||
await _propertyUserFieldService.InsertPropertyUserFieldAsync(propertyUserUpdateRequest));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task InsertPropertyUserFieldAsync_InsertUserFieldsReturned()
|
||||
{
|
||||
var property = new Property()
|
||||
{
|
||||
PropertyNumber = 1000
|
||||
};
|
||||
|
||||
_mockPropertyService.Setup(x => x.GetProperty(1000)).ReturnsAsync(property);
|
||||
|
||||
var createdPropertyUserField = new PropertyUserField()
|
||||
{
|
||||
PropertyNumber = 1000L,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y",
|
||||
LastMaintained = Convert.ToDateTime("9/1/2001")
|
||||
};
|
||||
BasicResponse response = new BasicResponse()
|
||||
{
|
||||
Success = true,
|
||||
};
|
||||
_mockPropertyUserFieldDao.Setup(x => x.InsertPropertyUserField(It.IsAny<UserFieldRequest>())).ReturnsAsync(response);
|
||||
|
||||
var personUserUpdateRequest = new PropertyUserField()
|
||||
{
|
||||
PropertyNumber = 1000,
|
||||
UserFieldCode = "TEST1",
|
||||
Value = "Y"
|
||||
};
|
||||
var result = await _propertyUserFieldService.InsertPropertyUserFieldAsync(personUserUpdateRequest);
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual(response.Success, result.Success);
|
||||
}
|
||||
}
|
||||
}
|
||||
+76
@@ -0,0 +1,76 @@
|
||||
using System.Linq;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading.Tasks;
|
||||
using NUnit.Framework;
|
||||
using Moq;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
|
||||
using LCU.Api.Internal.CoreApiWrapper.Services;
|
||||
using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Tax;
|
||||
|
||||
namespace LCU.Api.Internal.CoreApiWrapperTest.Service
|
||||
{
|
||||
public class TaxServiceTest
|
||||
{
|
||||
private readonly TaxService _taxService;
|
||||
private readonly Mock<ITaxDao> _mockTaxDao;
|
||||
|
||||
public TaxServiceTest()
|
||||
{
|
||||
_mockTaxDao = new Mock<ITaxDao>();
|
||||
_taxService = new TaxService(_mockTaxDao.Object);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetPersonsTaxIdData_Returns_PersonTaxIdData()
|
||||
{
|
||||
var personTaxIdDataResponse = new List<PersonTaxIdDataResponse>
|
||||
{
|
||||
new() {
|
||||
FirstName = "Greg",
|
||||
MiddleInitial = "H",
|
||||
LastName = "Stevens",
|
||||
Suffix = "Jr.",
|
||||
NameFull = "Greg H. Stevens Jr.",
|
||||
PersonNumber = 123
|
||||
}
|
||||
};
|
||||
|
||||
_mockTaxDao.Setup(x => x.GetPersonTaxIdData(It.IsAny<CoreRequestParameters>(), It.Is<string>(x => x == "123"))).ReturnsAsync(personTaxIdDataResponse).Verifiable();
|
||||
var result = await _taxService.GetPersonsTaxIdData("123");
|
||||
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual(1, result.Count());
|
||||
var firstResponse = result.First();
|
||||
Assert.AreEqual("Greg",firstResponse.FirstName);
|
||||
Assert.AreEqual("H", firstResponse.MiddleInitial);
|
||||
Assert.AreEqual("Stevens", firstResponse.LastName);
|
||||
Assert.AreEqual("Jr.", firstResponse.Suffix);
|
||||
Assert.AreEqual("Greg H. Stevens Jr.", firstResponse.NameFull);
|
||||
Assert.AreEqual(123, firstResponse.PersonNumber);
|
||||
_mockTaxDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetOrganizationsTaxIdData_Returns_OrganizationTaxIdData()
|
||||
{
|
||||
var organizationsTaxIdDataResponse = new List<OrganizationTaxIdDataResponse>
|
||||
{
|
||||
new() {
|
||||
Name = "Electric Company",
|
||||
OrganizationNumber = 123
|
||||
}
|
||||
};
|
||||
|
||||
_mockTaxDao.Setup(x => x.GetOrganizationTaxIdData(It.IsAny<CoreRequestParameters>(), It.Is<string>(x => x == "123"))).ReturnsAsync(organizationsTaxIdDataResponse).Verifiable();
|
||||
var result = await _taxService.GetOrganizationsTaxIdData("123");
|
||||
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual(1, result.Count());
|
||||
var firstResponse = result.First();
|
||||
Assert.AreEqual("Electric Company",firstResponse.Name);
|
||||
Assert.AreEqual(123, firstResponse.OrganizationNumber);
|
||||
_mockTaxDao.Verify();
|
||||
}
|
||||
}
|
||||
}
|
||||
+202
@@ -0,0 +1,202 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Castle.Core.Internal;
|
||||
using Moq;
|
||||
using NUnit.Framework;
|
||||
using LCU.Api.Internal.CoreApiWrapper.Services;
|
||||
using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Transaction;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
|
||||
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Accounts;
|
||||
|
||||
namespace LCU.Api.Internal.CoreApiWrapperTest.Service
|
||||
{
|
||||
public class TransactionServiceTest
|
||||
{
|
||||
private TransactionService _transactionService;
|
||||
private Mock<ITransactionDao> _mockTransactionDao;
|
||||
private Mock<IAccountService> _mockAccountService;
|
||||
|
||||
[SetUp]
|
||||
public void SetUp()
|
||||
{
|
||||
_mockTransactionDao = new Mock<ITransactionDao>();
|
||||
_mockAccountService = new Mock<IAccountService>();
|
||||
_transactionService = new TransactionService(_mockTransactionDao.Object, _mockAccountService.Object);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetTransactionHistory_Return_Two()
|
||||
{
|
||||
var setupAccountNumber = 8675309143;
|
||||
|
||||
var accountResponse = new Account()
|
||||
{
|
||||
Id="fasdfsda;fjsdipfu0-231231"
|
||||
};
|
||||
_mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
|
||||
It.IsAny<AcctNbrRequest>())).ReturnsAsync(accountResponse).Verifiable();
|
||||
|
||||
_mockTransactionDao
|
||||
.Setup(x => x.FindTransactionHistoryById(It.IsAny<CoreRequestParameters>(), It.IsAny<TransactionHistoryRequest>(), It.IsAny<string>()))
|
||||
.ReturnsAsync(
|
||||
new List<TransactionHistory>()
|
||||
{
|
||||
new TransactionHistory()
|
||||
{
|
||||
AccountNumber = setupAccountNumber,
|
||||
ActivityDateTime = Convert.ToDateTime("1/1/2021"),
|
||||
AllowCustomerView = true,
|
||||
Amount = 220,
|
||||
BalanceAccountNumber = 2,
|
||||
BalanceTypeDescription = "Note Interest (Excess)",
|
||||
CurrTransactionStatusCode = "C",
|
||||
DueDate = null,
|
||||
EffectiveDate = "2021-10-14",
|
||||
ExternalTransactionDescription = null,
|
||||
Id = "22",
|
||||
IsDisputedTransaction = false,
|
||||
OnlineCheckTraceNumber = 0,
|
||||
PostingDate = "2021-10-15",
|
||||
RunningBalance = (decimal?)3529.53,
|
||||
TimeUniqueNumber = 86570239,
|
||||
TransactionNumber = 22,
|
||||
TransactionReference = $"{setupAccountNumber} - 22",
|
||||
TransactionStatusDescription = "Completed",
|
||||
TransactionTypeCode = "SPMT",
|
||||
TransactionTypeDescription = "Regular Payment LandmarkCU TRANSFER 12345",
|
||||
Uid = "abcd77299_sABCDMD]MYo5crdZyPN3s2QAHx[CHxgigabcdeYuALuVGL9Jklm_22"
|
||||
},
|
||||
new TransactionHistory()
|
||||
{
|
||||
AccountNumber = setupAccountNumber,
|
||||
ActivityDateTime = Convert.ToDateTime("1/2/2021"),
|
||||
AllowCustomerView = true,
|
||||
Amount = 30,
|
||||
BalanceAccountNumber = 2,
|
||||
BalanceTypeDescription = "Note Interest (Excess)",
|
||||
CurrTransactionStatusCode = "C",
|
||||
DueDate = null,
|
||||
EffectiveDate = "2021-10-14",
|
||||
ExternalTransactionDescription = null,
|
||||
Id = "23",
|
||||
IsDisputedTransaction = false,
|
||||
OnlineCheckTraceNumber = 0,
|
||||
PostingDate = "2021-10-15",
|
||||
RunningBalance = (decimal?)3559.53,
|
||||
TimeUniqueNumber = 86570239,
|
||||
TransactionNumber = 23,
|
||||
TransactionReference = $"{setupAccountNumber} - 23",
|
||||
TransactionStatusDescription = "Completed",
|
||||
TransactionTypeCode = "SPMT",
|
||||
TransactionTypeDescription = "Regular Payment LandmarkCU TRANSFER 12346",
|
||||
Uid = "abcd77299_sABCDMD]MYo5crdZyPN3s2QAHx[CHxgigabcdeYuALuVGL9Jklm_23"
|
||||
}
|
||||
})
|
||||
.Verifiable();
|
||||
|
||||
var results = await _transactionService.GetTransactionHistory(1234555, Convert.ToDateTime("12/25/2020"), Convert.ToDateTime("2/2/2021"), null);
|
||||
|
||||
var resultsList = results.ToList();
|
||||
Assert.NotNull(results);
|
||||
Assert.AreEqual(2, resultsList.Count);
|
||||
Assert.True(resultsList.Any(x => x.AccountNumber == setupAccountNumber));
|
||||
|
||||
_mockAccountService.Verify();
|
||||
_mockTransactionDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetTransactionHistory_NullTransactions_EmptyList()
|
||||
{
|
||||
var setupAccountNumber = 8675309143;
|
||||
|
||||
var accountResponse = new Account()
|
||||
{
|
||||
Id="fasdfsda;fjsdipfu0-231231"
|
||||
};
|
||||
|
||||
_mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
|
||||
It.IsAny<AcctNbrRequest>())).ReturnsAsync(accountResponse).Verifiable();
|
||||
|
||||
_mockTransactionDao
|
||||
.Setup(x => x.FindTransactionHistoryById(It.IsAny<CoreRequestParameters>(), It.IsAny<TransactionHistoryRequest>(), It.IsAny<string>()))
|
||||
.ReturnsAsync((IEnumerable<TransactionHistory>)null)
|
||||
.Verifiable();
|
||||
|
||||
var results = await _transactionService.GetTransactionHistory(1234555, Convert.ToDateTime("12/25/2020"), Convert.ToDateTime("2/2/2021"), null);
|
||||
Assert.NotNull(results);
|
||||
var resultsList = results.ToList();
|
||||
Assert.IsEmpty(resultsList);
|
||||
|
||||
_mockAccountService.Verify();
|
||||
_mockTransactionDao.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetTransactionHistory_NoAccount_ReturnNull()
|
||||
{
|
||||
_mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
|
||||
It.IsAny<AcctNbrRequest>())).ReturnsAsync((Account)null).Verifiable();
|
||||
|
||||
var results = await _transactionService.GetTransactionHistory(1234555, Convert.ToDateTime("12/25/2020"), Convert.ToDateTime("2/2/2021"), null);
|
||||
|
||||
Assert.Null(results);
|
||||
|
||||
_mockAccountService.Verify();
|
||||
_mockTransactionDao.Verify( x => x.FindTransactionHistoryById(It.IsAny<CoreRequestParameters>(), It.IsAny<TransactionHistoryRequest>(), It.IsAny<string>()), Times.Never);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetTransactionHistory_TransactionDao_Exception()
|
||||
{
|
||||
var accountResponse = new Account()
|
||||
{
|
||||
Id = "fasdfsda;fjsdipfu0-231231"
|
||||
};
|
||||
_mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
|
||||
It.IsAny<AcctNbrRequest>())).ReturnsAsync(accountResponse).Verifiable();
|
||||
_mockTransactionDao.Setup(x => x.FindTransactionHistoryById(It.IsAny<CoreRequestParameters>(), It.IsAny<TransactionHistoryRequest>(), It.IsAny<string>()))
|
||||
.Throws(new Exception("Ohh nooo"));
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _transactionService.GetTransactionHistory(1234555, Convert.ToDateTime("12/25/2020"), Convert.ToDateTime("2/2/2021"), null));
|
||||
_mockAccountService.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetTransactionHistory_AccountService_Exception()
|
||||
{
|
||||
_mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
|
||||
It.IsAny<AcctNbrRequest>())).Throws(new Exception("Ohh nooo"));
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _transactionService.GetTransactionHistory(1234555, Convert.ToDateTime("12/25/2020"), Convert.ToDateTime("2/2/2021"), null));
|
||||
_mockAccountService.Verify();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetTransactionsByDateSpan_OK()
|
||||
{
|
||||
_mockTransactionDao.Setup(x => x.GetTransactionsByDateSpan(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>())).ReturnsAsync(new List<TransactionAlertInfo>() { new TransactionAlertInfo() });
|
||||
|
||||
var results = await _transactionService.GetTransactionsByDateSpan(DateTime.UtcNow.AddMinutes(-1), DateTime.UtcNow, new string[1]);
|
||||
|
||||
Assert.NotNull(results);
|
||||
var resultsList = results.ToList();
|
||||
Assert.AreEqual(1, resultsList.Count);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task GetTransactionsByDateSpan_Exception()
|
||||
{
|
||||
_mockTransactionDao.Setup(x => x.GetTransactionsByDateSpan(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>())).ThrowsAsync(new Exception("Exception!"));
|
||||
|
||||
Assert.ThrowsAsync<Exception>(async () =>
|
||||
await _transactionService.GetTransactionsByDateSpan(DateTime.UtcNow.AddMinutes(-1), DateTime.UtcNow, new string[1]));
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user