public async Task Then_If_The_Command_Is_Valid_And_The_RegisteredName_Is_Used_Then_Employer_Profile_Updated( Vacancy vacancy, CreateVacancyCommand command, TrainingProvider provider, EmployerProfile employerProfile, [Frozen] Mock <IEmployerVacancyClient> employerVacancyClient, [Frozen] Mock <IRecruitVacancyClient> recruitVacancyClient, [Frozen] Mock <IMessaging> messaging, [Frozen] Mock <ITrainingProviderService> trainingProviderService, CreateVacancyCommandHandler handler) { command.ValidateOnly = false; command.Vacancy.EmployerNameOption = EmployerNameOption.TradingName; trainingProviderService.Setup(x => x.GetProviderAsync(command.VacancyUserDetails.Ukprn.Value)) .ReturnsAsync(provider); recruitVacancyClient.Setup(x => x.Validate(It.IsAny <Vacancy>(), VacancyRuleSet.All)) .Returns(new EntityValidationResult()); recruitVacancyClient.Setup(x => x.GetVacancyAsync(command.Vacancy.Id)).ReturnsAsync(vacancy); recruitVacancyClient .Setup(x => x.GetEmployerProfileAsync(command.Vacancy.EmployerAccountId, command.Vacancy.AccountLegalEntityPublicHashedId)).ReturnsAsync(employerProfile); await handler.Handle(command, CancellationToken.None); recruitVacancyClient.Verify(x => x.UpdateEmployerProfileAsync(It.Is <EmployerProfile>(c => c.TradingName.Equals(command.Vacancy.EmployerName) ), It.IsAny <VacancyUser>()), Times.Once); }
public async Task Then_If_Not_Valid_Then_Returns_Response_With_Errors( EntityValidationError entityValidationError, CreateVacancyCommand command, [Frozen] Mock <IRecruitVacancyClient> recruitVacancyClient, CreateVacancyCommandHandler handler) { command.ValidateOnly = false; var entityValidationResult = new EntityValidationResult { Errors = new List <EntityValidationError> { entityValidationError } }; recruitVacancyClient.Setup(x => x.Validate(It.IsAny <Vacancy>(), VacancyRuleSet.All)) .Returns(entityValidationResult); var actual = await handler.Handle(command, CancellationToken.None); actual.ValidationErrors.Should().BeEquivalentTo( entityValidationResult.Errors.Select(error => new DetailedValidationError { Field = error.PropertyName, Message = error.ErrorMessage })); actual.ResultCode.Should().Be(ResponseCode.InvalidRequest); }
public async Task Then_If_Provider_Owned_And_Employer_Has_To_Review_Then_Review_Event_Is_Submitted( Vacancy vacancy, CreateVacancyCommand command, TrainingProvider provider, [Frozen] Mock <IEmployerVacancyClient> employerVacancyClient, [Frozen] Mock <IRecruitVacancyClient> recruitVacancyClient, [Frozen] Mock <IMessaging> messaging, [Frozen] Mock <ITrainingProviderService> trainingProviderService, [Frozen] Mock <IProviderRelationshipsService> providerRelationshipsService, CreateVacancyCommandHandler handler) { command.ValidateOnly = false; providerRelationshipsService.Setup(x => x.HasProviderGotEmployersPermissionAsync( provider.Ukprn.Value, command.Vacancy.EmployerAccountId, command.Vacancy.AccountLegalEntityPublicHashedId, OperationType.RecruitmentRequiresReview)) .ReturnsAsync(true); command.VacancyUserDetails.Email = string.Empty; trainingProviderService.Setup(x => x.GetProviderAsync(command.VacancyUserDetails.Ukprn.Value)) .ReturnsAsync(provider); recruitVacancyClient.Setup(x => x.Validate(It.IsAny <Vacancy>(), VacancyRuleSet.All)) .Returns(new EntityValidationResult()); recruitVacancyClient.Setup(x => x.GetVacancyAsync(command.Vacancy.Id)).ReturnsAsync(vacancy); await handler.Handle(command, CancellationToken.None); messaging.Verify(x => x.PublishEvent(It.Is <VacancyReviewedEvent>(c => c.VacancyId.Equals(command.Vacancy.Id) && c.VacancyReference.Equals(vacancy.VacancyReference) && c.Ukprn.Equals(provider.Ukprn) ))); }
public async Task And_ValidateOnly_True_And_Submitted_By_Employer_Then_Returns_After_Validation( CreateVacancyCommand command, TrainingProvider provider, Vacancy vacancy, DateTime timeNow, [Frozen] Mock <ITimeProvider> timeProvider, [Frozen] Mock <IProviderVacancyClient> providerVacancyClient, [Frozen] Mock <IEmployerVacancyClient> employerVacancyClient, [Frozen] Mock <IRecruitVacancyClient> recruitVacancyClient, [Frozen] Mock <IVacancyRepository> vacancyRepository, [Frozen] Mock <ITrainingProviderService> trainingProviderService, [Frozen] Mock <IProviderRelationshipsService> providerRelationshipsService, CreateVacancyCommandHandler handler) { command.ValidateOnly = true; vacancy.Id = command.Vacancy.Id; vacancy.ProgrammeId = command.Vacancy.ProgrammeId; trainingProviderService.Setup(x => x.GetProviderAsync(command.VacancyUserDetails.Ukprn.Value)) .ReturnsAsync(provider); recruitVacancyClient.Setup(x => x.Validate(It.IsAny <Vacancy>(), VacancyRuleSet.All)) .Returns(new EntityValidationResult()); var actual = await handler.Handle(command, CancellationToken.None); actual.ResultCode.Should().Be(ResponseCode.Created); actual.Data.Should().Be(1000000001); employerVacancyClient.Verify(x => x.CreateEmployerApiVacancy( It.IsAny <Guid>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <VacancyUser>(), It.IsAny <TrainingProvider>(), It.IsAny <string>()), Times.Never); vacancyRepository.Verify(x => x.UpdateAsync(It.IsAny <Vacancy>()), Times.Never); }
public void Then_If_There_Is_An_Error_From_The_Api_A_Exception_Is_Returned( string errorContent, CreateVacancyCommand command, GetProviderAccountLegalEntitiesResponse response, [Frozen] Mock <IProviderRelationshipsApiClient <ProviderRelationshipsApiConfiguration> > providerRelationshipsApiClient, [Frozen] Mock <IRecruitApiClient <RecruitApiConfiguration> > recruitApiClient, CreateVacancyCommandHandler handler) { //Arrange command.PostVacancyRequestData.OwnerType = OwnerType.Provider; response.AccountProviderLegalEntities.First().AccountLegalEntityPublicHashedId = command.PostVacancyRequestData.AccountLegalEntityPublicHashedId; command.IsSandbox = false; var apiResponse = new ApiResponse <string>(null, HttpStatusCode.InternalServerError, errorContent); recruitApiClient .Setup(client => client.PostWithResponseCode <string>(It.IsAny <PostVacancyRequest>())) .ReturnsAsync(apiResponse); providerRelationshipsApiClient.Setup(x => x.Get <GetProviderAccountLegalEntitiesResponse>(It.IsAny <GetProviderAccountLegalEntitiesRequest>())).ReturnsAsync(response); //Act Func <Task> act = async() => await handler.Handle(command, CancellationToken.None); //Assert act.Should().Throw <Exception>() .WithMessage($"Response status code does not indicate success: {(int)HttpStatusCode.InternalServerError} ({HttpStatusCode.InternalServerError})"); }
public async Task And_IsSandbox_Then_Api_Called_To_Validate_Request( string responseValue, CreateVacancyCommand command, [Frozen] Mock <IRecruitApiClient <RecruitApiConfiguration> > mockRecruitApiClient, CreateVacancyCommandHandler handler) { //Arrange command.IsSandbox = true; var apiResponse = new ApiResponse <string>(responseValue, HttpStatusCode.Created, ""); mockRecruitApiClient .Setup(x => x.PostWithResponseCode <string>( It.Is <PostValidateVacancyRequest>(c => c.PostUrl.Contains($"{command.Id.ToString()}/validate?ukprn={command.PostVacancyRequestData.User.Ukprn}&userEmail={command.PostVacancyRequestData.User.Email}") && ((PostVacancyRequestData)c.Data).Title.Equals(command.PostVacancyRequestData.Title) ))) .ReturnsAsync(apiResponse); //Act var result = await handler.Handle(command, CancellationToken.None); //Assert result.VacancyReference.Should().Be(apiResponse.Body); mockRecruitApiClient.Verify(client => client.PostWithResponseCode <string>(It.IsAny <PostVacancyRequest>()), Times.Never); }
public async Task Then_The_Command_Is_Validated_For_EmployerOwner( CreateVacancyCommand command, [Frozen] Mock <IRecruitVacancyClient> recruitVacancyClient, CreateVacancyCommandHandler handler) { command.ValidateOnly = false; await handler.Handle(command, CancellationToken.None); recruitVacancyClient.Verify(x => x.Validate(command.Vacancy, VacancyRuleSet.All), Times.Once); recruitVacancyClient.Verify(x => x.Validate(It.Is <Vacancy>(c => c.OwnerType == OwnerType.Employer), VacancyRuleSet.All), Times.Once); }
public async Task Then_If_The_Command_Is_Valid_The_Vacancy_Is_Created_And_Submitted_For_Provider( CreateVacancyCommand command, TrainingProvider provider, Vacancy vacancy, DateTime timeNow, [Frozen] Mock <ITimeProvider> timeProvider, [Frozen] Mock <IProviderVacancyClient> providerVacancyClient, [Frozen] Mock <IRecruitVacancyClient> recruitVacancyClient, [Frozen] Mock <IVacancyRepository> vacancyRepository, [Frozen] Mock <ITrainingProviderService> trainingProviderService, [Frozen] Mock <IProviderRelationshipsService> providerRelationshipsService, CreateVacancyCommandHandler handler) { command.ValidateOnly = false; command.VacancyUserDetails.Email = null; vacancy.Id = command.Vacancy.Id; vacancy.ProgrammeId = command.Vacancy.ProgrammeId; trainingProviderService.Setup(x => x.GetProviderAsync(command.VacancyUserDetails.Ukprn.Value)) .ReturnsAsync(provider); recruitVacancyClient.Setup(x => x.Validate(It.IsAny <Vacancy>(), VacancyRuleSet.All)) .Returns(new EntityValidationResult()); recruitVacancyClient.Setup(x => x.GetVacancyAsync(command.Vacancy.Id)).ReturnsAsync(vacancy); timeProvider.Setup(x => x.Now).Returns(timeNow); providerRelationshipsService.Setup(x => x.HasProviderGotEmployersPermissionAsync( provider.Ukprn.Value, command.Vacancy.EmployerAccountId, command.Vacancy.AccountLegalEntityPublicHashedId, OperationType.RecruitmentRequiresReview)) .ReturnsAsync(false); var actual = await handler.Handle(command, CancellationToken.None); actual.ResultCode.Should().Be(ResponseCode.Created); actual.Data.Should().Be(vacancy.VacancyReference); providerVacancyClient.Verify(x => x.CreateProviderApiVacancy(command.Vacancy.Id, command.Vacancy.Title, command.Vacancy.EmployerAccountId, command.VacancyUserDetails), Times.Once); vacancyRepository.Verify(x => x.UpdateAsync(It.Is <Vacancy>(c => c.Id.Equals(command.Vacancy.Id) && c.Status == VacancyStatus.Submitted && c.VacancyReference == vacancy.VacancyReference && c.CreatedByUser == vacancy.CreatedByUser && c.Title == command.Vacancy.Title && c.CreatedByUser == vacancy.CreatedByUser && c.CreatedDate == vacancy.CreatedDate && c.OwnerType == vacancy.OwnerType && c.SourceOrigin == vacancy.SourceOrigin && c.SourceType == vacancy.SourceType && c.ProgrammeId == command.Vacancy.ProgrammeId && c.SubmittedByUser == command.VacancyUserDetails && c.LastUpdatedByUser == command.VacancyUserDetails && c.SubmittedDate == timeNow && c.LastUpdatedDate == timeNow && c.TrainingProvider == provider )), Times.Once); }
public async Task Then_The_Provider_Is_Looked_Up_And_Error_Returned_If_Not_Exists( CreateVacancyCommand command, [Frozen] Mock <IRecruitVacancyClient> recruitVacancyClient, [Frozen] Mock <ITrainingProviderService> trainingProviderService, CreateVacancyCommandHandler handler) { command.ValidateOnly = false; trainingProviderService.Setup(x => x.GetProviderAsync(command.VacancyUserDetails.Ukprn.Value)) .ReturnsAsync((TrainingProvider)null); var actual = await handler.Handle(command, CancellationToken.None); actual.ResultCode.Should().Be(ResponseCode.InvalidRequest); actual.ValidationErrors.Should().Contain(error => ((DetailedValidationError)error).Field.Equals(nameof(command.VacancyUserDetails.Ukprn), StringComparison.InvariantCultureIgnoreCase) && ((DetailedValidationError)error).Message.Equals("Training Provider UKPRN not valid")); }
public async Task Then_If_The_Employer_Vacancy_Has_Already_Been_Created_For_The_Given_Id_Then_Error_Returned( Exception mongoWriteException, CreateVacancyCommand command, [Frozen] Mock <IEmployerVacancyClient> recruitVacancyClient, [Frozen] Mock <IRecruitVacancyClient> vacancyClient, CreateVacancyCommandHandler handler) { command.ValidateOnly = false; vacancyClient.Setup(x => x.Validate(It.IsAny <Vacancy>(), VacancyRuleSet.All)) .Returns(new EntityValidationResult()); recruitVacancyClient.Setup(x => x.CreateEmployerApiVacancy(It.IsAny <Guid>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <VacancyUser>(), It.IsAny <TrainingProvider>(), It.IsAny <string>())) .ThrowsAsync(mongoWriteException); var actual = await handler.Handle(command, CancellationToken.None); actual.ValidationErrors.Should().Contain(error => ((DetailedValidationError)error).Field.Equals(nameof(command.Vacancy.Id), StringComparison.InvariantCultureIgnoreCase) && ((DetailedValidationError)error).Message.Equals("Unable to create Vacancy. Vacancy already submitted")); actual.ResultCode.Should().Be(ResponseCode.InvalidRequest); }
public async Task Then_If_The_Legal_Entity_Does_Not_Belong_To_The_Employer_Account_Exception_Thrown( string responseValue, CreateVacancyCommand command, AccountDetail accountDetailApiResponse, GetEmployerAccountLegalEntityItem leaglEntityResponse, [Frozen] Mock <IAccountLegalEntityPermissionService> accountLegalEntityPermissionService, [Frozen] Mock <IRecruitApiClient <RecruitApiConfiguration> > recruitApiClient, CreateVacancyCommandHandler handler) { command.PostVacancyRequestData.OwnerType = OwnerType.Employer; accountLegalEntityPermissionService .Setup(x => x.GetAccountLegalEntity(It.IsAny <AccountIdentifier>(), It.IsAny <string>())) .ReturnsAsync((AccountLegalEntityItem)null); //Act Assert.ThrowsAsync <SecurityException>(() => handler.Handle(command, CancellationToken.None)); recruitApiClient.Verify(x => x.PostWithResponseCode <string>( It.IsAny <PostVacancyRequest>()), Times.Never); }
public async Task Then_If_The_Command_Is_Valid_A_Vacancy_Created_Event_Is_Submitted( Vacancy vacancy, CreateVacancyCommand command, TrainingProvider provider, [Frozen] Mock <IEmployerVacancyClient> employerVacancyClient, [Frozen] Mock <IRecruitVacancyClient> recruitVacancyClient, [Frozen] Mock <IMessaging> messaging, [Frozen] Mock <ITrainingProviderService> trainingProviderService, CreateVacancyCommandHandler handler) { command.ValidateOnly = false; trainingProviderService.Setup(x => x.GetProviderAsync(command.VacancyUserDetails.Ukprn.Value)) .ReturnsAsync(provider); recruitVacancyClient.Setup(x => x.Validate(It.IsAny <Vacancy>(), VacancyRuleSet.All)) .Returns(new EntityValidationResult()); recruitVacancyClient.Setup(x => x.GetVacancyAsync(command.Vacancy.Id)).ReturnsAsync(vacancy); await handler.Handle(command, CancellationToken.None); messaging.Verify(x => x.PublishEvent(It.Is <VacancySubmittedEvent>(c => c.VacancyId.Equals(command.Vacancy.Id) && c.VacancyReference.Equals(vacancy.VacancyReference) ))); }
public async Task Then_The_Command_Is_Handled_With_Account_Info_looked_Up_For_Provider_And_Api_Called_With_Response( int accountIdentifierId, string responseValue, CreateVacancyCommand command, AccountLegalEntityItem accountLegalEntityItem, [Frozen] Mock <IAccountLegalEntityPermissionService> accountLegalEntityPermissionService, [Frozen] Mock <IRecruitApiClient <RecruitApiConfiguration> > mockRecruitApiClient, CreateVacancyCommandHandler handler) { //Arrange command.AccountIdentifier = new AccountIdentifier($"Provider-{accountIdentifierId}-Product"); command.IsSandbox = false; var apiResponse = new ApiResponse <string>(responseValue, HttpStatusCode.Created, ""); mockRecruitApiClient.Setup(x => x.PostWithResponseCode <string>( It.Is <PostVacancyRequest>(c => c.PostUrl.Contains($"{command.Id.ToString()}?ukprn={command.PostVacancyRequestData.User.Ukprn}&userEmail=") && ((PostVacancyRequestData)c.Data).Title.Equals(command.PostVacancyRequestData.Title) && ((PostVacancyRequestData)c.Data).LegalEntityName.Equals(accountLegalEntityItem.Name) && ((PostVacancyRequestData)c.Data).EmployerAccountId.Equals(accountLegalEntityItem.AccountHashedId) ))) .ReturnsAsync(apiResponse); accountLegalEntityPermissionService .Setup(x => x.GetAccountLegalEntity(It.Is <AccountIdentifier>(c => c.Equals(command.AccountIdentifier)), command.PostVacancyRequestData.AccountLegalEntityPublicHashedId)) .ReturnsAsync(accountLegalEntityItem); //Act var result = await handler.Handle(command, CancellationToken.None); //Assert result.VacancyReference.Should().Be(apiResponse.Body); mockRecruitApiClient.Verify(client => client.PostWithResponseCode <string>(It.IsAny <PostValidateVacancyRequest>()), Times.Never); }