909 lines
41 KiB
C#
909 lines
41 KiB
C#
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>()));
|
|
}
|
|
}
|
|
} |