public async Task Then_The_Repository_Is_Called_To_Create_A_Reservation_Mapping_To_The_Entity()
{
//Arrange
var expectedUserId = Guid.NewGuid();
var createReservation = new CreateAccountReservationCommand
{
AccountId = ExpectedAccountId,
StartDate = _expectedStartDate,
Id = _expectedReservationId,
AccountLegalEntityName = ExpectedAccountLegalEntityName,
IsLevyAccount = true,
TransferSenderAccountId = ExpectedTransferSenderAccountId,
UserId = expectedUserId
};
//Act
await _accountReservationService.CreateAccountReservation(createReservation);
//Assert
_reservationRepository.Verify(x => x.CreateAccountReservation(It.Is <Domain.Entities.Reservation>(c =>
c.Id.Equals(_expectedReservationId) &&
c.AccountId.Equals(ExpectedAccountId) &&
c.StartDate.Equals(_expectedStartDate) &&
!c.CreatedDate.Equals(DateTime.MinValue) &&
c.ExpiryDate.Equals(_expectedExpiryDate) &&
c.Status.Equals((short)ReservationStatus.Pending) &&
c.IsLevyAccount.Equals(true) &&
c.TransferSenderAccountId.Equals(ExpectedTransferSenderAccountId) &&
c.UserId.Equals(expectedUserId) &&
c.AccountLegalEntityName.Equals(ExpectedAccountLegalEntityName)
)));
}
public async Task Then_The_New_Reservation_With_Course_Is_Returned_Mapped_From_The_Entity()
{
//Arrange
var createReservation = new CreateAccountReservationCommand
{
AccountId = ExpectedAccountId,
StartDate = _expectedStartDate,
Id = _expectedReservationId,
CourseId = _expectedCourse.CourseId,
AccountLegalEntityId = ExpectedAccountLegalEntityId,
ProviderId = ExpectedProviderId,
TransferSenderAccountId = ExpectedTransferSenderAccountId
};
//Act
var actual = await _accountReservationService.CreateAccountReservation(createReservation);
//Assert
Assert.IsAssignableFrom <Reservation>(actual);
Assert.AreEqual(_expectedReservationId, actual.Id);
Assert.AreEqual(ExpectedAccountId, actual.AccountId);
Assert.AreEqual(_expectedCourse.CourseId, actual.Course.CourseId);
Assert.AreEqual(_expectedCourse.Title, actual.Course.Title);
Assert.AreEqual(ExpectedProviderId, actual.ProviderId);
Assert.AreEqual(ExpectedAccountLegalEntityId, actual.AccountLegalEntityId);
Assert.AreEqual(_expectedCourse.Level.ToString(), actual.Course.Level);
Assert.AreEqual(ExpectedTransferSenderAccountId, actual.TransferSenderAccountId);
Assert.IsNotNull(actual.Rules);
}
public async Task Then_The_Repository_Is_Called_To_Create_A_Reservation_With_Course_Mapping_To_The_Entity()
{
//Arrange
var createReservation = new CreateAccountReservationCommand
{
AccountId = ExpectedAccountId,
StartDate = _expectedStartDate,
Id = _expectedReservationId,
CourseId = _expectedCourse.CourseId,
AccountLegalEntityId = ExpectedAccountLegalEntityId,
ProviderId = ExpectedProviderId
};
//Act
await _accountReservationService.CreateAccountReservation(createReservation);
//Assert
_reservationRepository.Verify(x => x.CreateAccountReservation(It.Is <Domain.Entities.Reservation>(
c => c.AccountId.Equals(ExpectedAccountId) &&
c.StartDate.Equals(_expectedStartDate) &&
!c.CreatedDate.Equals(DateTime.MinValue) &&
c.ExpiryDate.Equals(_expectedExpiryDate) &&
c.Status.Equals((short)ReservationStatus.Pending) &&
c.CourseId.Equals(_expectedCourse.CourseId) &&
c.Course == null &&
c.ProviderId.Equals(ExpectedProviderId) &&
c.AccountLegalEntityId.Equals(ExpectedAccountLegalEntityId)
)));
}
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_Command_Is_Validated_And_The_Service_Not_Called_If_Not_Valid()
{
//Arrange
var expectedCommand = new CreateAccountReservationCommand {
AccountId = 1
};
//Act Assert
Assert.ThrowsAsync <ArgumentException>(async() =>
{
await _handler.Handle(expectedCommand, _cancellationToken);
});
_accountReservationsService.Verify(x =>
x.CreateAccountReservation(It.IsAny <CreateAccountReservationCommand>()), Times.Never);
_unitOfWork.Verify(x => x.AddEvent(It.IsAny <ReservationCreatedEvent>()), Times.Never);
}
public async Task Then_The_Expiry_Period_For_The_Reservation_Is_Taken_From_Configuration()
{
//Arrange
var createReservation = new CreateAccountReservationCommand
{
AccountId = ExpectedAccountId,
StartDate = _expectedStartDate,
Id = _expectedReservationId
};
//Act
await _accountReservationService.CreateAccountReservation(createReservation);
//Assert
_options.Verify(x => x.Value.ExpiryPeriodInMonths, Times.Once);
}
public async Task Then_The_New_Reservation_Is_Returned_Mapped_From_The_Entity()
{
//Arrange
var createReservation = new CreateAccountReservationCommand
{
AccountId = ExpectedAccountId,
StartDate = _expectedStartDate,
Id = _expectedReservationId
};
//Act
var actual = await _accountReservationService.CreateAccountReservation(createReservation);
//Assert
Assert.IsAssignableFrom <Reservation>(actual);
Assert.AreEqual(_expectedReservationId, actual.Id);
Assert.AreEqual(ExpectedAccountId, actual.AccountId);
Assert.IsNotNull(actual.Rules);
}
public async Task Then_If_The_Optional_Values_Are_Not_Supplied_They_Are_Defaulted_To_Null()
{
//Arrange
var createReservation = new CreateAccountReservationCommand
{
AccountId = ExpectedAccountId,
StartDate = _expectedStartDate,
Id = _expectedReservationId
};
//Act
await _accountReservationService.CreateAccountReservation(createReservation);
//Assert
_reservationRepository.Verify(x => x.CreateAccountReservation(It.Is <Domain.Entities.Reservation>(
c => c.CourseId == null &&
c.Course == null &&
c.ProviderId == null
)));
}
public async Task Then_The_Restriction_Type_Is_Checked_Against_The_Reservation()
{
//Arrange
var reservation = new CreateAccountReservationCommand
{
Id = Guid.NewGuid(),
AccountId = 1,
AccountLegalEntityId = 123,
AccountLegalEntityName = "Test",
StartDate = DateTime.UtcNow,
CourseId = "13",
IsLevyAccount = true,
CreatedDate = DateTime.UtcNow
};
//Act
var actual = await _globalRulesService.CheckReservationAgainstRules(reservation);
//Assert
Assert.IsNull(actual);
}
