public async Task IfInvalidVacancyStatus_ShouldThrowError(VacancyStatus invalidCloneStatus)
{
var newVacancyId = Guid.NewGuid();
var existingVacancy = _autoFixture.Build <Vacancy>().With(c => c.Status, invalidCloneStatus).Create();
var currentTime = DateTime.UtcNow;
var startDate = DateTime.Now.AddDays(20);
var closingDate = DateTime.Now.AddDays(10);
var user = new VacancyUser {
Name = "Test", Email = "*****@*****.**", UserId = "123"
};
var command = new CloneVacancyCommand(
cloneVacancyId: existingVacancy.Id,
newVacancyId: newVacancyId,
user: user,
sourceOrigin: SourceOrigin.EmployerWeb,
startDate: startDate,
closingDate: closingDate);
var mockRepository = new Mock <IVacancyRepository>();
var mockTimeProvider = new Mock <ITimeProvider>();
mockTimeProvider.Setup(x => x.Now).Returns(currentTime);
mockRepository.Setup(x => x.GetVacancyAsync(existingVacancy.Id)).ReturnsAsync(existingVacancy);
var handler = new CloneVacancyCommandHandler(
Mock.Of <ILogger <CloneVacancyCommandHandler> >(),
mockRepository.Object,
Mock.Of <IMessaging>(),
mockTimeProvider.Object
);
await Assert.ThrowsAsync <InvalidStateException>(() => handler.Handle(command, new CancellationToken()));
}
public async Task GetEmployerNameAsync_ShouldReturnTradingName(VacancyStatus status)
{
var employerName = "Employer Name";
var legalEntityName = "Legal Entity Name";
var tradingName = "Trading Name";
var vacancy = new Vacancy()
{
Status = status,
EmployerName = employerName,
LegalEntityName = legalEntityName,
EmployerNameOption = EmployerNameOption.TradingName
};
var profile = new EmployerProfile
{
TradingName = tradingName
};
_mockEmployerProfileRepository.Setup(pr => pr.GetAsync(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(profile);
var sut = GetSut();
var result = await sut.GetEmployerNameAsync(vacancy);
result.Should().Be(tradingName);
}
public IHttpActionResult PutVacancyStatus(int id, VacancyStatus vacancyStatus)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != vacancyStatus.ID)
{
return(BadRequest());
}
db.Entry(vacancyStatus).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!VacancyStatusExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public static bool IsStateReadOnly(this VacancyStatus status)
{
return(status == VacancyStatus.Submitted || status == VacancyStatus.Live ||
status == VacancyStatus.ReservedForQA || status == VacancyStatus.Closed ||
status == VacancyStatus.Withdrawn || status == VacancyStatus.Completed ||
status == VacancyStatus.PostedInError);
}
public void CanHaveApplications_NoApplicationsRouteTest(VacancyStatus status, bool shouldHaveArchiveMessage)
{
//Arrange
var vacancyViewModel = new VacancyViewModelBuilder().BuildValid(status, VacancyType.Apprenticeship);
vacancyViewModel.ApplicationCount = 0;
VacancyPostingProvider.Setup(p => p.GetVacancy(It.IsAny <int>())).Returns(vacancyViewModel);
var mediator = GetMediator();
//Act
var result = mediator.GetPreviewVacancyViewModel(0);
//Assert
if (shouldHaveArchiveMessage)
{
result.AssertMessage(VacancyPostingMediatorCodes.GetPreviewVacancyViewModel.Ok, VacancyViewModelMessages.VacancyHasBeenArchived + "<br/>" + VacancyViewModelMessages.NoApplications, UserMessageLevel.Info);
}
else
{
result.AssertMessage(VacancyPostingMediatorCodes.GetPreviewVacancyViewModel.Ok,
status == VacancyStatus.Closed
? VacancyViewModelMessages.Closed
: VacancyViewModelMessages.NoApplications, UserMessageLevel.Info);
}
}
public EditLinkViewModel(VacancyStatus status, string anchorName, string editUrl, string comment)
{
Status = status;
AnchorName = anchorName;
EditUrl = editUrl;
CommentViewModel = new CommentViewModel(status, anchorName, comment, editUrl, string.Empty);
}
public void ShouldMapVacancyStatus(VacancyStatus fromVacancyStatus, VacancyStatuses expectedVacancyStatus)
{
// Act.
var actualVacancyStatus = fromVacancyStatus.GetVacancyStatuses();
// Assert.
actualVacancyStatus.Should().Be(expectedVacancyStatus);
}
public async Task WhenVacancyInInvalidState_ShouldThrowInvalidStateException(VacancyStatus status)
{
var vacancy = SourceVacancy;
vacancy.Status = status;
var sut = GetSut(vacancy);
await Assert.ThrowsAsync <InvalidStateException>(() => sut.GetCloneableAuthorisedVacancyAsync(VRM));
}
private static Course MakeCourse(VacancyStatus partTimeVacancyStatus, VacancyStatus fullTimeVacancyStatus)
{
return(new Course
{
PartTime = partTimeVacancyStatus,
FullTime = fullTimeVacancyStatus
});
}
public async Task <IEnumerable <Vacancy> > GetVacanciesByStatusAsync(VacancyStatus status)
{
var filter = Builders <Vacancy> .Filter.Eq(v => v.Status, status);
var collection = GetCollection <Vacancy>();
var result = await RetryPolicy.ExecuteAsync(context => collection.FindAsync(filter), new Context(nameof(GetVacanciesByStatusAsync)));
return(await result.ToListAsync());
}
public VacancyLinksViewModel(int vacancyReferenceNumber,
VacancyStatus status, int totalNumberOfApplications, VacancyType vacancyType, int totalNumberOfApplicationsWithPendingDecision)
{
VacancyReferenceNumber = vacancyReferenceNumber;
Status = status;
TotalNumberOfApplications = totalNumberOfApplications;
VacancyType = vacancyType;
TotalNumberOfApplicationsWithPendingDecision = totalNumberOfApplicationsWithPendingDecision;
}
public AddVacancyCommand(Guid id, Guid projectId, string name, string description, VacancyStatus status, DateTime expirationDate)
{
Id = id;
ProjectId = projectId;
Name = name;
Description = description;
Status = status;
ExpirationDate = expirationDate;
}
public void ChangeStatus(VacancyStatus status)
{
if (Status == status)
{
return;
}
Status = status;
AddEvent(new PlaceholderDomainEvent(Guid.NewGuid(), DateTime.UtcNow, "Vacancy status has been changed"));
}
public void ShouldThrowIfUnhandledVacancyStatus()
{
const VacancyStatus unhandledVacancyStatus = (VacancyStatus)11;
// Act.
Action action = () => unhandledVacancyStatus.GetVacancyStatuses();
// Assert.
action.ShouldThrow <ArgumentException>();
}
public void Publish()
{
if (status != VacancyStatus.Draft)
{
throw new Exception("Неправильный статус вакансии");
}
status = VacancyStatus.Active;
// webSite.AddVacancy();
}
private Vacancy GetTestProviderOwnedVacancy(VacancyStatus status)
{
return(_autoFixture
.Build <Vacancy>()
.Without(v => v.TransferInfo)
.Without(v => v.EmployerContact)
.With(v => v.OwnerType, OwnerType.Provider)
.With(v => v.Status, status)
.With(v => v.ProviderContact, _autoFixture.Create <ContactDetail>())
.Create());
}
public void ShouldBeAbleToReserveForQAIfTheVacancyIsReservedByMe(VacancyStatus currentVacancyStatus, bool expectedCanBeReserved)
{
var vacancySummary = new VacancySummary {
Status = currentVacancyStatus, QAUserName = UserName
};
var canBeReserved = new VacancyLockingServiceBuilder().Build()
.IsVacancyAvailableToQABy(UserName, vacancySummary);
canBeReserved.Should().Be(expectedCanBeReserved);
}
public ValidationResultViewModel(VacancyStatus status, string anchorName, bool hasError, string error, bool hasWarning, string warning, string viewValidationResultUrl, string comment)
{
Status = status;
HasError = hasError;
Error = error;
HasWarning = hasWarning;
Warning = warning;
ViewValidationResultUrl = viewValidationResultUrl;
AnchorName = anchorName;
CommentViewModel = new CommentViewModel(status, anchorName, comment, viewValidationResultUrl, string.Empty);
}
public IHttpActionResult GetVacancyStatus(int id)
{
VacancyStatus vacancyStatus = db.VacancyStatus.Find(id);
if (vacancyStatus == null)
{
return(NotFound());
}
return(Ok(vacancyStatus));
}
//public int NumberOfSpots { get; private set; } //TODO
public Vacancy(Guid id, string name, string description, VacancyStatus status, DateTime expirationDate)
{
Guard.AgainstEmptyIdentity(id);
Guard.AgainstEmptyString(name, nameof(name));
Guard.AgainstEmptyString(description, nameof(description));
Id = new VacancyId(id);
Name = name;
Description = description;
Status = status;
ExpirationDate = expirationDate;
}
public IHttpActionResult PostVacancyStatus(VacancyStatus vacancyStatus)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.VacancyStatus.Add(vacancyStatus);
db.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { id = vacancyStatus.ID }, vacancyStatus));
}
public async Task WhenVacancyIsNotInValidState_ShouldNotSetVacancyDeleted(VacancyStatus status)
{
var fixture = new Fixture();
var vacancy = fixture.Build <Vacancy>().With(v => v.Status, status).Create();
_mockVacancyRepository.Setup(r => r.GetVacancyAsync(It.IsAny <Guid>())).ReturnsAsync(vacancy);
var sut = GetSut();
await sut.Handle(fixture.Create <DeleteVacancyCommand>(), new CancellationToken());
_mockVacancyRepository.Verify(m => m.UpdateAsync(It.IsAny <Vacancy>()), Times.Never);
_mockMessaging.Verify(m => m.PublishEvent(It.IsAny <VacancyDeletedEvent>()), Times.Never);
}
public void ClosingDateCanBeTodayIfLive(VacancyStatus vacancyStatus, bool expectValid)
{
var today = DateTime.Today;
var viewModel = new FurtherVacancyDetailsViewModel
{
VacancyDatesViewModel = new VacancyDatesViewModel
{
ClosingDate = new DateViewModel(today),
VacancyStatus = vacancyStatus
},
Wage = new WageViewModel()
};
var vacancyViewModel = new VacancyViewModelBuilder().With(viewModel).Build();
var response = _validator.Validate(viewModel, ruleSet: RuleSet);
_aggregateValidator.Validate(vacancyViewModel);
var aggregateResponse = _aggregateValidator.Validate(vacancyViewModel, ruleSet: RuleSet);
if (expectValid)
{
_validator.ShouldNotHaveValidationErrorFor(vm => vm.VacancyDatesViewModel,
vm => vm.VacancyDatesViewModel.ClosingDate, viewModel, RuleSet);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.FurtherVacancyDetailsViewModel,
vm => vm.FurtherVacancyDetailsViewModel.VacancyDatesViewModel,
vm => vm.FurtherVacancyDetailsViewModel.VacancyDatesViewModel.ClosingDate, vacancyViewModel);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.FurtherVacancyDetailsViewModel,
vm => vm.FurtherVacancyDetailsViewModel.VacancyDatesViewModel,
vm => vm.FurtherVacancyDetailsViewModel.VacancyDatesViewModel.ClosingDate, vacancyViewModel, RuleSet);
}
else
{
_validator.ShouldHaveValidationErrorFor(vm => vm.VacancyDatesViewModel,
vm => vm.VacancyDatesViewModel.ClosingDate, viewModel, RuleSet);
_aggregateValidator.ShouldHaveValidationErrorFor(vm => vm.FurtherVacancyDetailsViewModel,
vm => vm.FurtherVacancyDetailsViewModel.VacancyDatesViewModel,
vm => vm.FurtherVacancyDetailsViewModel.VacancyDatesViewModel.ClosingDate, vacancyViewModel);
_aggregateValidator.ShouldHaveValidationErrorFor(vm => vm.FurtherVacancyDetailsViewModel,
vm => vm.FurtherVacancyDetailsViewModel.VacancyDatesViewModel,
vm => vm.FurtherVacancyDetailsViewModel.VacancyDatesViewModel.ClosingDate, vacancyViewModel, RuleSet);
var error = response.Errors.SingleOrDefault(e => e.PropertyName == "VacancyDatesViewModel.ClosingDate");
error.Should().NotBeNull();
error?.ErrorMessage.Should().Be(VacancyViewModelMessages.ClosingDate.AfterTodayErrorText);
var aggregateError = aggregateResponse.Errors.SingleOrDefault(e => e.PropertyName == "FurtherVacancyDetailsViewModel.VacancyDatesViewModel.ClosingDate");
aggregateError.Should().NotBeNull();
aggregateError?.ErrorMessage.Should().Be(VacancyViewModelMessages.ClosingDate.AfterTodayErrorText);
}
}
public void CannotHaveApplications(VacancyStatus status)
{
//Arrange
var vacancyViewModel = new VacancyViewModelBuilder().BuildValid(status, VacancyType.Apprenticeship);
VacancyPostingProvider.Setup(p => p.GetVacancy(It.IsAny <int>())).Returns(vacancyViewModel);
var mediator = GetMediator();
//Act
var result = mediator.GetPreviewVacancyViewModel(0);
//Assert
result.AssertCodeAndMessage(VacancyPostingMediatorCodes.GetPreviewVacancyViewModel.Ok);
}
public IHttpActionResult DeleteVacancyStatus(int id)
{
VacancyStatus vacancyStatus = db.VacancyStatus.Find(id);
if (vacancyStatus == null)
{
return(NotFound());
}
db.VacancyStatus.Remove(vacancyStatus);
db.SaveChanges();
return(Ok(vacancyStatus));
}
public async Task <IEnumerable <T> > GetVacanciesByStatusAsync <T>(VacancyStatus status)
{
var filter = Builders <T> .Filter.Eq(VacancyStatusFieldName, status.ToString());
var collection = GetCollection <T>();
var result = await RetryPolicy.Execute(_ =>
collection.Find(filter)
.Project <T>(GetProjection <T>())
.ToListAsync(),
new Context(nameof(GetVacanciesByStatusAsync)));
return(result);
}
public static VacancyStatusEntity CreateDomain(this VacancyStatus status)
{
switch (status)
{
case VacancyStatus.Draft: return(VacancyStatusEntity.Draft);
case VacancyStatus.Opened: return(VacancyStatusEntity.Opened);
case VacancyStatus.Closed: return(VacancyStatusEntity.Closed);
default:
throw new ArgumentOutOfRangeException(nameof(status), status, null);
}
}
public async Task GetEmployerNameAsync_ShouldReturnVacancyEmployerName(VacancyStatus status)
{
var employerName = "Employer Name";
var vacancy = new Vacancy()
{
Status = status,
EmployerName = employerName
};
var sut = GetSut();
var result = await sut.GetEmployerNameAsync(vacancy);
result.Should().Be(employerName);
}
public void ShouldNotBeAbleToReserveForQAIfAnotherUserHasLockedTheVacancy(VacancyStatus currentVacancyStatus)
{
// Arrange
var vacancySummary = new VacancySummary
{
QAUserName = AnotherUserName,
Status = currentVacancyStatus,
DateStartedToQA = _utcNow.AddMinutes(-SmallerTimeout)
};
var canBeReserved = new VacancyLockingServiceBuilder().Build()
.IsVacancyAvailableToQABy(UserName, vacancySummary);
canBeReserved.Should().BeFalse();
}
public void CanHaveApplications_OneApplicationRouteTest(VacancyStatus status, bool messageShouldBeNull)
{
//Arrange
var vacancyViewModel = new VacancyViewModelBuilder().BuildValid(status, VacancyType.Apprenticeship);
vacancyViewModel.ApplicationCount = 1;
VacancyPostingProvider.Setup(p => p.GetVacancy(It.IsAny <int>())).Returns(vacancyViewModel);
var mediator = GetMediator();
//Act
var result = mediator.GetPreviewVacancyViewModel(0);
//Assert
result.AssertCodeAndMessage(VacancyPostingMediatorCodes.GetPreviewVacancyViewModel.Ok, false, messageShouldBeNull);
}
