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); }