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