public void TrainingProvidedRequired(string trainingProvided, bool expectValid)
{
var viewModel = new TrainingDetailsViewModel
{
TrainingProvided = trainingProvided,
VacancySource = VacancySource.Raa
};
var vacancyViewModel = new VacancyViewModelBuilder().With(_furtherDetailsViewModel).With(viewModel).Build();
_validator.Validate(viewModel);
_aggregateValidator.Validate(vacancyViewModel);
_aggregateValidator.Validate(vacancyViewModel, ruleSet: RuleSets.Errors);
_aggregateValidator.Validate(vacancyViewModel, ruleSet: RuleSets.Warnings);
_aggregateValidator.Validate(vacancyViewModel, ruleSet: RuleSets.ErrorsAndWarnings);
if (expectValid)
{
_validator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingProvided, viewModel);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.TrainingProvided, vacancyViewModel);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.TrainingProvided, vacancyViewModel, RuleSets.Errors);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.TrainingProvided, vacancyViewModel, RuleSets.Warnings);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.TrainingProvided, vacancyViewModel, RuleSets.ErrorsAndWarnings);
}
else
{
_validator.ShouldHaveValidationErrorFor(vm => vm.TrainingProvided, viewModel);
_aggregateValidator.ShouldHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.TrainingProvided, vacancyViewModel);
_aggregateValidator.ShouldHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.TrainingProvided, vacancyViewModel, RuleSets.Errors);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.TrainingProvided, vacancyViewModel, RuleSets.Warnings);
_aggregateValidator.ShouldHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.TrainingProvided, vacancyViewModel, RuleSets.ErrorsAndWarnings);
}
}
public ActionResult TrainingDetails(TrainingDetailsViewModel viewModel)
{
var response = _vacancyMediator.UpdateVacancy(viewModel);
ModelState.Clear();
switch (response.Code)
{
case VacancyMediatorCodes.UpdateVacancy.FailedValidation:
response.ValidationResult.AddToModelState(ModelState, string.Empty);
return(View(response.ViewModel));
case VacancyMediatorCodes.UpdateVacancy.Ok:
return(RedirectToRoute(ManagementRouteNames.ReviewVacancy,
new
{
vacancyReferenceNumber = response.ViewModel.VacancyReferenceNumber
}));
case VacancyMediatorCodes.UpdateVacancy.InvalidVacancy:
SetUserMessage(response.Message);
return(RedirectToRoute(ManagementRouteNames.Dashboard));
default:
throw new InvalidMediatorCodeException(response.Code);
}
}
public void ShouldRequireApprenticeshipLevel(ApprenticeshipLevel apprenticeshipLevel, TrainingType trainingType, bool expectValid)
{
// Arrange.
var viewModel = new TrainingDetailsViewModel
{
TrainingType = trainingType,
ApprenticeshipLevel = apprenticeshipLevel
};
var vacancyViewModel = new VacancyViewModelBuilder().With(viewModel).With(_furtherDetailsViewModel).Build();
// Act.
_validator.Validate(viewModel);
_aggregateValidator.Validate(vacancyViewModel);
_aggregateValidator.Validate(vacancyViewModel, ruleSet: RuleSets.Errors);
_aggregateValidator.Validate(vacancyViewModel, ruleSet: RuleSets.Warnings);
_aggregateValidator.Validate(vacancyViewModel, ruleSet: RuleSets.ErrorsAndWarnings);
// Assert.
if (expectValid)
{
_validator.ShouldNotHaveValidationErrorFor(m => m.ApprenticeshipLevel, viewModel);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.ApprenticeshipLevel, vacancyViewModel);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.ApprenticeshipLevel, vacancyViewModel, RuleSets.Errors);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.ApprenticeshipLevel, vacancyViewModel, RuleSets.Warnings);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.ApprenticeshipLevel, vacancyViewModel, RuleSets.ErrorsAndWarnings);
}
else
{
_validator.ShouldHaveValidationErrorFor(m => m.ApprenticeshipLevel, viewModel);
_aggregateValidator.ShouldHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.ApprenticeshipLevel, vacancyViewModel);
_aggregateValidator.ShouldHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.ApprenticeshipLevel, vacancyViewModel, RuleSets.Errors);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.ApprenticeshipLevel, vacancyViewModel, RuleSets.Warnings);
_aggregateValidator.ShouldHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.ApprenticeshipLevel, vacancyViewModel, RuleSets.ErrorsAndWarnings);
}
}
public async Task <IActionResult> Edit(int id, TrainingDetailsViewModel trainingDetails)
{
if (id != trainingDetails.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(trainingDetails.GetModel());
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TrainingDetailsExists(trainingDetails.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index), new { id = trainingDetails.TrainingId }));
}
ViewBag.TrainingId = trainingDetails.TrainingId;
return(View(trainingDetails));
}
public void ShouldFillApprenticeshipLevelIfTrainingTypeIsStandardAndApprenticeshipLevelIsUnknown()
{
// Arrange.
var trainingDetailsViewModel = new TrainingDetailsViewModel
{
VacancyReferenceNumber = VacancyReferenceNumber,
ApprenticeshipLevel = ApprenticeshipLevel.Unknown,
TrainingType = TrainingType.Standards,
StandardId = 1
};
MockVacancyPostingService.Setup(s => s.UpdateVacancy(It.IsAny <Vacancy>())).Returns <Vacancy>(v => v);
MockMapper.Setup(m => m.Map <Vacancy, TrainingDetailsViewModel>(It.IsAny <Vacancy>()))
.Returns((Vacancy av) => new TrainingDetailsViewModel()
{
FrameworkCodeName = av.FrameworkCodeName, ApprenticeshipLevel = av.ApprenticeshipLevel
});
var provider = GetVacancyPostingProvider();
// Act.
var viewModel = provider.UpdateVacancy(trainingDetailsViewModel);
// Assert.
viewModel.ApprenticeshipLevel.Should().NotBe(ApprenticeshipLevel.Unknown);
}
public void ShouldCreateNullFrameworkCodeIfTrainingTypeStandard()
{
// Arrange.
var trainingDetailsViewModel = new TrainingDetailsViewModel
{
VacancyReferenceNumber = VacancyReferenceNumber,
ApprenticeshipLevel = ApprenticeshipLevel.Unknown,
TrainingType = TrainingType.Standards,
StandardId = 1,
FrameworkCodeName = "ShouldBeNulled"
};
MockVacancyPostingService.Setup(s => s.UpdateVacancy(It.IsAny <Vacancy>())).Returns <Vacancy>(v => v);
MockMapper.Setup(m => m.Map <Vacancy, TrainingDetailsViewModel>(It.IsAny <Vacancy>()))
.Returns((Vacancy av) => new TrainingDetailsViewModel()
{
FrameworkCodeName = av.FrameworkCodeName
});
var provider = GetVacancyPostingProvider();
// Act.
var viewModel = provider.UpdateVacancy(trainingDetailsViewModel);
// Assert.
viewModel.FrameworkCodeName.Should().BeNullOrEmpty();
}
public void ShouldCreateApprenticeshipLevelIfTrainingTypeStandard(int standardId, ApprenticeshipLevel expectedApprenticeshipLevel)
{
// Arrange.
var trainingDetailsViewModel = new TrainingDetailsViewModel
{
VacancyReferenceNumber = VacancyReferenceNumber,
ApprenticeshipLevel = expectedApprenticeshipLevel,
TrainingType = TrainingType.Standards,
StandardId = standardId
};
MockVacancyPostingService.Setup(s => s.UpdateVacancy(It.IsAny <Vacancy>())).Returns <Vacancy>(v => v);
MockMapper.Setup(m => m.Map <Vacancy, TrainingDetailsViewModel>(It.IsAny <Vacancy>()))
.Returns((Vacancy av) => new TrainingDetailsViewModel()
{
ApprenticeshipLevel = av.ApprenticeshipLevel
});
var provider = GetVacancyPostingProvider();
// Act.
var viewModel = provider.UpdateVacancy(trainingDetailsViewModel);
// Assert.
viewModel.ApprenticeshipLevel.Should().Be(expectedApprenticeshipLevel);
}
public void ContactDetailsShouldPassValidation(string fullName, string email, string phoneNumber)
{
// Arrange.
var viewModel = new TrainingDetailsViewModel
{
ContactName = fullName,
ContactEmail = email,
ContactNumber = phoneNumber,
VacancySource = VacancySource.Raa
};
var vacancyViewModel = new VacancyViewModelBuilder().With(_furtherDetailsViewModel).With(viewModel).Build();
// Act.
_validator.Validate(viewModel);
_aggregateValidator.Validate(vacancyViewModel);
_aggregateValidator.Validate(vacancyViewModel, ruleSet: RuleSets.Errors);
_aggregateValidator.Validate(vacancyViewModel, ruleSet: RuleSets.Warnings);
_aggregateValidator.Validate(vacancyViewModel, ruleSet: RuleSets.ErrorsAndWarnings);
// Assert.
_validator.ShouldNotHaveValidationErrorFor(m => m.ContactName, viewModel);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.ContactName, vacancyViewModel);
_validator.ShouldNotHaveValidationErrorFor(m => m.ContactNumber, viewModel);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.ContactNumber, vacancyViewModel);
_validator.ShouldNotHaveValidationErrorFor(m => m.ContactEmail, viewModel);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.ContactEmail, vacancyViewModel);
}
public void ShouldRequireSectorCodeName(string sectorCodeName, VacancyType vacancyType, bool expectValid)
{
// Arrange.
var viewModel = new TrainingDetailsViewModel
{
VacancyType = vacancyType,
SectorCodeName = sectorCodeName
};
var vacancyViewModel = new VacancyViewModelBuilder().With(_furtherDetailsViewModel).With(viewModel).Build();
// Act.
_validator.Validate(viewModel);
_aggregateValidator.Validate(vacancyViewModel);
_aggregateValidator.Validate(vacancyViewModel, ruleSet: RuleSets.Errors);
_aggregateValidator.Validate(vacancyViewModel, ruleSet: RuleSets.Warnings);
_aggregateValidator.Validate(vacancyViewModel, ruleSet: RuleSets.ErrorsAndWarnings);
// Assert.
if (expectValid)
{
_validator.ShouldNotHaveValidationErrorFor(m => m.SectorCodeName, viewModel);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.SectorCodeName, vacancyViewModel);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.SectorCodeName, vacancyViewModel, RuleSets.Errors);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.SectorCodeName, vacancyViewModel, RuleSets.Warnings);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.SectorCodeName, vacancyViewModel, RuleSets.ErrorsAndWarnings);
}
else
{
_validator.ShouldHaveValidationErrorFor(m => m.SectorCodeName, viewModel);
_aggregateValidator.ShouldHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.SectorCodeName, vacancyViewModel);
_aggregateValidator.ShouldHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.SectorCodeName, vacancyViewModel, RuleSets.Errors);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.SectorCodeName, vacancyViewModel, RuleSets.Warnings);
_aggregateValidator.ShouldHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.SectorCodeName, vacancyViewModel, RuleSets.ErrorsAndWarnings);
}
}
public ActionResult SelectStandard(TrainingDetailsViewModel viewModel)
{
var response = _vacancyMediator.SelectStandardAsTrainingType(viewModel);
ModelState.Clear();
return(View("TrainingDetails", response.ViewModel));
}
public void DefaultShouldNotHaveAnyValidationErrors()
{
var viewModel = new TrainingDetailsViewModel();
var result = _validator.Validate(viewModel);
result.IsValid.Should().BeTrue();
}
// GET: TrainingDetails/Create
/// <summary>
///
/// </summary>
/// <returns></returns>
public IActionResult Create(int id)
{
TrainingDetailsViewModel vm;
vm = new TrainingDetailsViewModel(_context);
vm.TrainingId = id;
ViewBag.TrainingId = id;
return(View(vm));
}
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Training training = db.Trainings.Find(id);
//ユーザー名を取得
string userName = "";
var userId = training.ApplicationUserId;
var user = db.Users.FirstOrDefault(u => u.Id == userId);
if (user != null)
{
userName = user.UserName;
}
//お気に入り追加済みか判定
var favorite = db.Favorites.FirstOrDefault(f => f.ApplicationUserId == userId && f.TrainingID == id);
bool isFavorite = true;
if (favorite == null)
{
isFavorite = false;
}
//View用モデル生成
var trainingDetailsViewModel = new TrainingDetailsViewModel()
{
ID = training.ID,
AddDateTime = training.AddDateTime.ToShortDateString(),
Purpose = training.Purpose,
Title = training.Title,
UpdateDateTime = training.UpdateDateTime,
YoutubeURL = training.YoutubeURL,
Tags = training.Tags.Select(t => t.Name).ToList(),
IsFavorite = isFavorite,
RecommendPersonNumber = training.RecommendPersonNumber,
RequiredPersonNumber = training.RequiredPersonNumber,
TimeDuration = training.TimeDuration,
UserName = userName
};
if (trainingDetailsViewModel == null)
{
return(HttpNotFound());
}
return(View(trainingDetailsViewModel));
}
public async Task <IActionResult> Create(int id, TrainingDetailsViewModel trainingDetails)
{
if (ModelState.IsValid)
{
ViewBag.TrainingId = id;
trainingDetails.Id = 0;
trainingDetails.TrainingId = id;
_context.Add(trainingDetails.GetModel());
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index), new { id = trainingDetails.TrainingId }));
}
return(View(trainingDetails));
}
public void EmptyContactDetailsShouldBeValid()
{
var viewModel = new TrainingDetailsViewModel();
var vacancyViewModel = new VacancyViewModelBuilder().With(_furtherDetailsViewModel).With(viewModel).Build();
_validator.Validate(viewModel);
_aggregateValidator.Validate(vacancyViewModel);
_aggregateValidator.Validate(vacancyViewModel, ruleSet: RuleSets.Errors);
_aggregateValidator.Validate(vacancyViewModel, ruleSet: RuleSets.Warnings);
_aggregateValidator.Validate(vacancyViewModel, ruleSet: RuleSets.ErrorsAndWarnings);
_validator.ShouldNotHaveValidationErrorFor(m => m.ContactName, viewModel);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.ContactName, vacancyViewModel);
_validator.ShouldNotHaveValidationErrorFor(m => m.ContactNumber, viewModel);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.ContactNumber, vacancyViewModel);
_validator.ShouldNotHaveValidationErrorFor(m => m.ContactEmail, viewModel);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.ContactEmail, vacancyViewModel);
}
public void ContactNumberInvalidCharacters(string contactNumber, bool expectValid)
{
var viewModel = new TrainingDetailsViewModel
{
ContactNumber = contactNumber,
VacancySource = VacancySource.Raa
};
_validator.Validate(viewModel);
if (expectValid)
{
_validator.ShouldNotHaveValidationErrorFor(vm => vm.ContactNumber, viewModel);
}
else
{
_validator.ShouldHaveValidationErrorFor(vm => vm.ContactNumber, viewModel);
}
}
public void TrainingProvidedInvalidCharacters(string trainingProvided, bool expectValid)
{
var viewModel = new TrainingDetailsViewModel
{
TrainingProvided = trainingProvided,
VacancySource = VacancySource.Raa
};
_validator.Validate(viewModel);
if (expectValid)
{
_validator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingProvided, viewModel);
}
else
{
_validator.ShouldHaveValidationErrorFor(vm => vm.TrainingProvided, viewModel);
}
}
public void ShouldRequireStandardId(string standardIdString, TrainingType trainingType, bool expectValid)
{
// Arrange.
int?standardId = null;
int parsedStandardId;
if (int.TryParse(standardIdString, out parsedStandardId))
{
standardId = parsedStandardId;
}
var viewModel = new TrainingDetailsViewModel
{
TrainingType = trainingType,
StandardId = standardId
};
var vacancyViewModel = new VacancyViewModelBuilder().With(_furtherDetailsViewModel).With(viewModel).Build();
// Act.
_validator.Validate(viewModel);
_aggregateValidator.Validate(vacancyViewModel);
_aggregateValidator.Validate(vacancyViewModel, ruleSet: RuleSets.Errors);
_aggregateValidator.Validate(vacancyViewModel, ruleSet: RuleSets.Warnings);
_aggregateValidator.Validate(vacancyViewModel, ruleSet: RuleSets.ErrorsAndWarnings);
// Assert.
if (expectValid)
{
_validator.ShouldNotHaveValidationErrorFor(m => m.StandardId, viewModel);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.StandardId, vacancyViewModel);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.StandardId, vacancyViewModel, RuleSets.Errors);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.StandardId, vacancyViewModel, RuleSets.Warnings);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.StandardId, vacancyViewModel, RuleSets.ErrorsAndWarnings);
}
else
{
_validator.ShouldHaveValidationErrorFor(m => m.StandardId, viewModel);
_aggregateValidator.ShouldHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.StandardId, vacancyViewModel);
_aggregateValidator.ShouldHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.StandardId, vacancyViewModel, RuleSets.Errors);
_aggregateValidator.ShouldNotHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.StandardId, vacancyViewModel, RuleSets.Warnings);
_aggregateValidator.ShouldHaveValidationErrorFor(vm => vm.TrainingDetailsViewModel, vm => vm.TrainingDetailsViewModel.StandardId, vacancyViewModel, RuleSets.ErrorsAndWarnings);
}
}
public MediatorResponse <TrainingDetailsViewModel> UpdateVacancy(TrainingDetailsViewModel viewModel)
{
var validationResult = _trainingDetailsViewModelServerValidator.Validate(viewModel);
if (!validationResult.IsValid)
{
var sectorsAndFrameworks = _vacancyQaProvider.GetSectorsAndFrameworks();
var standards = _vacancyQaProvider.GetStandards();
var sectors = _vacancyQaProvider.GetSectors();
viewModel.SectorsAndFrameworks = sectorsAndFrameworks;
viewModel.Standards = standards;
viewModel.Sectors = sectors;
return(GetMediatorResponse(VacancyMediatorCodes.UpdateVacancy.FailedValidation, viewModel, validationResult));
}
var updatedViewModel = _vacancyQaProvider.UpdateVacancyWithComments(viewModel);
return(ReturnResult(updatedViewModel));
}
// GET: TrainingDetails/Edit/5
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task <IActionResult> Edit(int?id)
{
TrainingDetailsViewModel vm;
if (id == 0)
{
vm = new TrainingDetailsViewModel(_context);
}
else
{
var trainingDetails = await _context.TrainingDetails.FindAsync(id);
if (trainingDetails == null)
{
return(NotFound());
}
vm = new TrainingDetailsViewModel(_context, trainingDetails);
ViewBag.TrainingId = trainingDetails.TrainingId;
}
return(View(vm));
}
public void ShouldReturnOKIfTheUserCanLockTheVacancy()
{
//Arrange
const string ukprn = "ukprn";
//const int QAVacancyTimeout = 10;
const string userName = "******";
var utcNow = DateTime.UtcNow;
const int vacancyReferenceNumber = 1;
const string aString = "aString";
const int autoSaveTimeoutInSeconds = 60;
var sectorList = new List <Sector>
{
new Fixture().Build <Sector>().Create()
};
var viewModel = new TrainingDetailsViewModel()
{
TrainingProvided = aString,
TrainingProvidedComment = aString,
VacancyReferenceNumber = vacancyReferenceNumber,
AutoSaveTimeoutInSeconds = autoSaveTimeoutInSeconds
};
var vacancy = new Fixture().Build <Vacancy>()
.With(av => av.VacancyReferenceNumber, vacancyReferenceNumber)
.With(av => av.TrainingProvided, aString)
.With(av => av.TrainingProvidedComment, aString)
.Create();
var configurationService = new Mock <IConfigurationService>();
configurationService.Setup(x => x.Get <CommonWebConfiguration>())
.Returns(new CommonWebConfiguration {
BlacklistedCategoryCodes = ""
});
configurationService.Setup(x => x.Get <RecruitWebConfiguration>())
.Returns(new RecruitWebConfiguration {
AutoSaveTimeoutInSeconds = autoSaveTimeoutInSeconds
});
var referenceDataService = new Mock <IReferenceDataService>();
referenceDataService.Setup(m => m.GetSectors()).Returns(sectorList);
var providerService = new Mock <IProviderService>();
providerService.Setup(ps => ps.GetProvider(ukprn, true)).Returns(new Provider());
var vacancyPostingService = new Mock <IVacancyPostingService>();
var currentUserService = new Mock <ICurrentUserService>();
currentUserService.Setup(cus => cus.CurrentUserName).Returns(userName);
var dateTimeService = new Mock <IDateTimeService>();
dateTimeService.Setup(dts => dts.UtcNow).Returns(utcNow);
var vacancylockingService = new Mock <IVacancyLockingService>();
vacancylockingService.Setup(vls => vls.IsVacancyAvailableToQABy(userName, vacancy)).Returns(true);
//Arrange: get AV, update retrieved AV with NVVM, save modified AV returning same modified AV, map AV to new NVVM with same properties as input
vacancyPostingService.Setup(
vps => vps.GetVacancyByReferenceNumber(vacancyReferenceNumber)).Returns(vacancy);
vacancyPostingService.Setup(vps => vps.UpdateVacancy(It.IsAny <Vacancy>())).Returns((Vacancy av) => av);
var mapper = new Mock <IMapper>();
mapper.Setup(m => m.Map <Vacancy, TrainingDetailsViewModel>(It.IsAny <Vacancy>()))
.Returns((Vacancy av) => viewModel);
var vacancyProvider =
new VacancyProviderBuilder().With(vacancyPostingService)
.With(providerService)
.With(configurationService)
.With(referenceDataService)
.With(mapper)
.With(currentUserService)
.With(dateTimeService)
.With(vacancylockingService)
.Build();
var expectedResult = new QAActionResult <TrainingDetailsViewModel>(QAActionResultCode.Ok, viewModel);
//Act
var result = vacancyProvider.UpdateVacancyWithComments(viewModel);
//Assert
vacancyPostingService.Verify(
vps => vps.GetVacancyByReferenceNumber(viewModel.VacancyReferenceNumber.Value), Times.Once);
vacancyPostingService.Verify(
vps =>
vps.UpdateVacancy(
It.Is <Vacancy>(av => av.VacancyReferenceNumber == viewModel.VacancyReferenceNumber &&
av.QAUserName == userName && av.DateStartedToQA == utcNow)));
result.ShouldBeEquivalentTo(expectedResult);
}
public VacancyViewModelBuilder With(TrainingDetailsViewModel trainingDetailsViewModel)
{
_trainingDetailsViewModel = trainingDetailsViewModel;
return(this);
}
public MediatorResponse <TrainingDetailsViewModel> SelectStandardAsTrainingType(TrainingDetailsViewModel viewModel)
{
viewModel.TrainingType = TrainingType.Standards;
viewModel.StandardId = null;
viewModel.SectorCodeName = null;
viewModel.ApprenticeshipLevel = ApprenticeshipLevel.Unknown;
viewModel.Standards = _vacancyQaProvider.GetStandards();
viewModel.SectorsAndFrameworks = _vacancyQaProvider.GetSectorsAndFrameworks();
viewModel.Sectors = _vacancyQaProvider.GetSectors();
return(GetMediatorResponse(VacancyMediatorCodes.SelectStandardAsTrainingType.Ok, viewModel));
}
