public async Task Then_If_The_Reservation_Is_For_Levy_The_Event_Is_Created_With_Min_Dates()
{
//Arrange
_command.IsLevyAccount = true;
_command.StartDate = null;
_reservationCreated = new Reservation(null, _expectedReservationId, ExpectedAccountId, true, DateTime.UtcNow,
null, null, ReservationStatus.Pending, new Course
{
CourseId = "1",
Level = 1,
Title = "Test Course"
}, null, 198, "TestName", 0, null);
_accountReservationsService
.Setup(x => x.CreateAccountReservation(_command))
.ReturnsAsync(_reservationCreated);
_handler = new CreateAccountReservationCommandHandler(_accountReservationsService.Object, _validator.Object, _globalRulesService.Object, _unitOfWork.Object, _accountLegalEntitiesService.Object);
//Act
await _handler.Handle(_command, _cancellationToken);
//Assert
_unitOfWork.Verify(x => x.AddEvent(It.Is <Func <ReservationCreatedEvent> >(c =>
c.Invoke().Id.Equals(_expectedReservationId) &&
c.Invoke().AccountLegalEntityId.Equals(_reservationCreated.AccountLegalEntityId) &&
c.Invoke().AccountLegalEntityName.Equals(_reservationCreated.AccountLegalEntityName) &&
c.Invoke().StartDate.Equals(DateTime.MinValue) &&
c.Invoke().EndDate.Equals(DateTime.MinValue) &&
c.Invoke().CreatedDate.Equals(_reservationCreated.CreatedDate) &&
c.Invoke().AccountId.Equals(_reservationCreated.AccountId)
)), Times.Once);
}
public void Then_When_A_New_Reservation_It_Is_Initalised_Correctly()
{
//Arrange
var expectedId = Guid.NewGuid();
var expectedAccountId = 123;
var expectedStartDate = DateTime.UtcNow;
var expectedCourseId = "1-345-1";
var expiryPeriodInMonths = 2;
var expectedProviderId = 443322u;
var expectedLegalEntityAccountId = 339988;
var expectedLegalEntityAccountName = "TestName";
var expectedTransferSenderId = 48752;
//Act
_reservation = new Reservation(expectedId, expectedAccountId, expectedStartDate, expiryPeriodInMonths, expectedLegalEntityAccountName, expectedCourseId, expectedProviderId, expectedLegalEntityAccountId, transferSenderAccountId: expectedTransferSenderId);
//Assert
Assert.AreEqual(expectedId, _reservation.Id);
Assert.AreEqual(expectedAccountId, _reservation.AccountId);
Assert.AreEqual(expectedStartDate, _reservation.StartDate);
Assert.AreEqual(expectedCourseId, _reservation.CourseId);
Assert.AreEqual(expectedProviderId, _reservation.ProviderId);
Assert.AreEqual(expectedLegalEntityAccountId, _reservation.AccountLegalEntityId);
Assert.AreEqual(expectedLegalEntityAccountName, _reservation.AccountLegalEntityName);
Assert.AreEqual(expectedTransferSenderId, _reservation.TransferSenderAccountId);
}
public void Then_The_Reservation_Is_Expired_If_It_Is_Within_The_Expiry_Period_And_Is_Pending()
{
//Act
_reservation = CreateReservation();
//Assert
Assert.IsTrue(_reservation.IsExpired);
}
public void Then_The_Reservation_Is_Expired_If_It_Is_Not_Within_The_Expiry_Period_And_Is_Pending()
{
//Act
_reservation = new Reservation(null, Guid.NewGuid(), 1, false, DateTime.UtcNow, DateTime.UtcNow, DateTime.UtcNow.AddDays(1), ReservationStatus.Pending, new Course(), 0, 0, "", 0, null);
//Assert
Assert.IsFalse(_reservation.IsExpired);
}
public void Then_When_There_Is_No_Start_Date_The_Rules_Are_Not_Returned()
{
//Act
var reservation = new Reservation(_rules, Guid.NewGuid(), 1, true, DateTime.UtcNow, null, null, ReservationStatus.Pending, new Course(), 0, 0, "TestName", 32, null);
//Act
Assert.IsEmpty(reservation.Rules);
}
public void Then_The_Rules_For_That_Reservation_Period_Are_Taken_From_The_Repository_And_Filtered_By_Account_Type()
{
//Act
_reservation = CreateReservation();
//Assert
Assert.AreEqual(2, _reservation.Rules.Count);
Assert.IsTrue(_reservation.Rules.Any(c => c.Restriction.Equals(AccountRestriction.All)));
Assert.IsTrue(_reservation.Rules.Any(c => c.Restriction.Equals(AccountRestriction.Levy)));
}
public void Then_When_Creating_A_New_Reservation_The_Expiry_Is_Set_To_The_End_Of_The_Last_Day_Of_The_Month_With_Added_Expiry_Months(int year, int month, int day)
{
//Arrange
var expectedExpiryDate = new DateTime(year, month, day, 23, 59, 59);
var expiryPeriod = 1;
//Act
_reservation = new Reservation(Guid.NewGuid(), 123, new DateTime(2018, month - expiryPeriod, 03), expiryPeriod, "TestName");
//Assert
Assert.AreEqual(expectedExpiryDate, _reservation.ExpiryDate);
}
public void Arrange()
{
_cancellationToken = new CancellationToken();
_reservationCreated = new Reservation(null, _expectedReservationId, ExpectedAccountId, false, DateTime.UtcNow,
DateTime.UtcNow.AddMonths(1), DateTime.UtcNow.AddMonths(3), ReservationStatus.Pending, new Course
{
CourseId = "1",
Level = 1,
Title = "Test Course"
}, ExpectedProviderId, 198, "TestName", 0, null);
_validator = new Mock <IValidator <CreateAccountReservationCommand> >();
_validator.Setup(x => x.ValidateAsync(It.IsAny <CreateAccountReservationCommand>()))
.ReturnsAsync(new ValidationResult {
ValidationDictionary = new Dictionary <string, string> {
{ "", "" }
}
});
_validator.Setup(x => x.ValidateAsync(
It.Is <CreateAccountReservationCommand>(c => c.Id.Equals(_expectedReservationId))))
.ReturnsAsync(new ValidationResult());
_globalRulesService = new Mock <IGlobalRulesService>();
_globalRulesService.Setup(x => x.GetActiveRules(It.IsAny <DateTime>()))
.ReturnsAsync(new List <GlobalRule>());
_command = new CreateAccountReservationCommand
{
Id = _expectedReservationId,
AccountId = ExpectedAccountId,
AccountLegalEntityId = 198,
AccountLegalEntityName = "TestName",
StartDate = _expectedStartDate,
CreatedDate = _expectedExpiryDate,
ProviderId = ExpectedProviderId
};
_accountReservationsService = new Mock <IAccountReservationService>();
_accountReservationsService
.Setup(x => x.CreateAccountReservation(_command))
.ReturnsAsync(_reservationCreated);
_accountLegalEntitiesService = new Mock <IAccountLegalEntitiesService>();
_expectedAccountLegalEntity = new AccountLegalEntity(Guid.NewGuid(), _command.AccountId, "Test Name 2", 1, _command.AccountLegalEntityId, true, true);
_accountLegalEntitiesService.Setup(x => x.GetAccountLegalEntity(_command.AccountLegalEntityId))
.ReturnsAsync(_expectedAccountLegalEntity);
_unitOfWork = new Mock <IUnitOfWorkContext>();
_handler = new CreateAccountReservationCommandHandler(_accountReservationsService.Object, _validator.Object, _globalRulesService.Object, _unitOfWork.Object, _accountLegalEntitiesService.Object);
}
public void Then_The_Associated_Course_Is_Included()
{
//Act
_reservation = CreateReservation();
//Assert
Assert.AreEqual(2, _reservation.Rules.Count);
Assert.IsTrue(_reservation.Rules.All(c => c.Course != null));
var actualRuleCourse = _reservation.Rules.FirstOrDefault()?.Course;
Assert.IsNotNull(actualRuleCourse);
Assert.AreEqual(_expectedCourse.CourseId, actualRuleCourse.CourseId);
Assert.AreEqual(_expectedCourse.Title, actualRuleCourse.Title);
Assert.AreEqual(_expectedCourse.Level.ToString(), actualRuleCourse.Level);
}
public void Then_When_There_Is_No_StartDate_The_Expiry_Date_Is_Not_Set_And_No_Rules_Are_Retrieved()
{
//Arrange
var expectedId = Guid.NewGuid();
var expectedAccountId = 123;
var expiryPeriodInMonths = 2;
var expectedAccountLegalEntityId = 2524;
var expecteLegalEntityAccountName = "TestName";
//Act
_reservation = new Reservation(expectedId, expectedAccountId, null, expiryPeriodInMonths, expecteLegalEntityAccountName, accountLegalEntityId: expectedAccountLegalEntityId);
//Assert
Assert.IsNull(_reservation.ExpiryDate);
Assert.IsNull(_reservation.StartDate);
}
private Domain.Entities.Reservation MapReservation(Reservation reservation)
{
return(new Domain.Entities.Reservation
{
Id = reservation.Id,
ExpiryDate = reservation.ExpiryDate,
AccountId = reservation.AccountId,
CreatedDate = reservation.CreatedDate,
IsLevyAccount = reservation.IsLevyAccount,
StartDate = reservation.StartDate,
Status = (short)reservation.Status,
CourseId = reservation.CourseId,
AccountLegalEntityId = reservation.AccountLegalEntityId,
ProviderId = reservation.ProviderId,
AccountLegalEntityName = reservation.AccountLegalEntityName,
TransferSenderAccountId = reservation.TransferSenderAccountId,
UserId = reservation.UserId
});
}
private Reservation MapReservation(Domain.Entities.Reservation reservation)
{
var mapReservation = new Reservation(_ruleRepository.GetReservationRules,
reservation.Id,
reservation.AccountId,
reservation.IsLevyAccount,
reservation.CreatedDate,
reservation.StartDate,
reservation.ExpiryDate,
(ReservationStatus)reservation.Status,
reservation.Course,
reservation.ProviderId,
reservation.AccountLegalEntityId,
reservation.AccountLegalEntityName,
reservation.TransferSenderAccountId,
reservation.UserId
);
return(mapReservation);
}
public async Task <Reservation> CreateAccountReservation(IReservationRequest command)
{
var reservation = new Reservation(
command.Id,
command.AccountId,
command.StartDate,
_options.Value.ExpiryPeriodInMonths,
command.AccountLegalEntityName,
command.CourseId,
command.ProviderId,
command.AccountLegalEntityId,
command.IsLevyAccount,
command.TransferSenderAccountId,
command.UserId);
var entity = await _reservationRepository.CreateAccountReservation(MapReservation(reservation));
var result = MapReservation(entity);
return(result);
}
public void Then_When_A_New_Reservation_Is_Created_Default_Values_Are_Used_If_Not_Provided()
{
//Arrange
var expectedId = Guid.NewGuid();
var expectedAccountId = 123;
var expectedStartDate = DateTime.UtcNow;
var expiryPeriodInMonths = 2;
var expectedAccountLegalEntityId = 2524;
var expecteLegalEntityAccountName = "TestName";
//Act
_reservation = new Reservation(expectedId, expectedAccountId, expectedStartDate, expiryPeriodInMonths, expecteLegalEntityAccountName, accountLegalEntityId: expectedAccountLegalEntityId);
//Assert
Assert.AreEqual(expectedId, _reservation.Id);
Assert.AreEqual(expectedAccountId, _reservation.AccountId);
Assert.AreEqual(expectedStartDate, _reservation.StartDate);
Assert.AreEqual(expecteLegalEntityAccountName, _reservation.AccountLegalEntityName);
Assert.AreEqual(expectedAccountLegalEntityId, _reservation.AccountLegalEntityId);
Assert.IsNull(_reservation.CourseId);
Assert.IsNull(_reservation.ProviderId);
}
public async Task Then_Will_Not_Cause_A_Validation_Error_On_Start_Date_If_It_Is_A_Change_Reservation()
{
//Arrange
var startDate = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1).AddMonths(-6);
_reservation = new Reservation(time => Task.FromResult(new List <Rule>() as IList <Rule>), ReservationId, 1, false, DateTime.Now, startDate, startDate.AddMonths(3), ReservationStatus.Change, new Domain.Entities.Course(), 1, 1, "Legal Entity", 0, null);
_reservationService
.Setup(r => r.GetReservation(It.IsAny <Guid>()))
.ReturnsAsync(_reservation);
var request = new ValidateReservationQuery
{
CourseCode = CourseId,
ReservationId = ReservationId,
StartDate = _reservation.ExpiryDate.Value.AddMonths(1)
};
//Act
var result = await _handler.Handle(request, CancellationToken.None);
//Assert
Assert.IsNotNull(result);
Assert.IsEmpty(result.Errors);
}
public void Arrange()
{
var startDate = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1);
_course = new Course(CourseId, "Test Course", "1", DateTime.Today);
_courseService = new Mock <ICourseService>();
_courseService.Setup(s => s.GetCourseById(It.IsAny <string>()))
.ReturnsAsync(_course);
_reservation = new Reservation(time => Task.FromResult(new List <Rule>() as IList <Rule>), ReservationId, 1, false, DateTime.Now, startDate, startDate.AddMonths(3), ReservationStatus.Pending, new Domain.Entities.Course(), 1, 1, "Legal Entity", 0, null);
_reservationService = new Mock <IAccountReservationService>();
_reservationService
.Setup(r => r.GetReservation(It.IsAny <Guid>()))
.ReturnsAsync(_reservation);
_validator = new Mock <IValidator <ValidateReservationQuery> >();
_validator.Setup(v => v.ValidateAsync(It.IsAny <ValidateReservationQuery>()))
.ReturnsAsync(new ValidationResult());
_handler = new ValidateReservationQueryHandler(_reservationService.Object, _courseService.Object, _validator.Object);
}
public async Task And_Reservation_Is_Levy_Then_Valid()
{
//Arrange
var request = new ValidateReservationQuery
{
CourseCode = CourseId,
ReservationId = ReservationId,
StartDate = _reservation.StartDate.Value.AddDays(1)
};
_reservation = new Reservation(
time => Task.FromResult(new List <Rule>() as IList <Rule>),
ReservationId,
1,
true,
DateTime.Now,
null,
null,
ReservationStatus.Pending,
null,
null,
1,
"Legal Entity",
null,
null);
_reservationService
.Setup(r => r.GetReservation(It.IsAny <Guid>()))
.ReturnsAsync(_reservation);
//Act
var result = await _handler.Handle(request, CancellationToken.None);
//Assert
Assert.IsNotNull(result);
Assert.IsEmpty(result.Errors);
}
