public static void AssertValidationResult(this MediatorResponse response, string code, bool parametersShouldNotBeNull = false)
{
response.Code.Should().Be(code);
response.Message.Should().BeNull();
response.AssertParameters(parametersShouldNotBeNull);
response.ValidationResult.Should().NotBeNull();
}
private ActionResult HandleBasicDetails(MediatorResponse <NewVacancyViewModel> response)
{
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 SendContactMessageTest_WithUserName()
{
//Arrange
const string username = "******";
var contactMessageViewModel = new ContactMessageViewModel
{
Details = "Can you please guide me to the right job?",
Email = "*****@*****.**",
Enquiry = "How to apply for a apprenticeship",
Name = "Jane Doe"
};
//Act
_contactMessageServerViewModelValidator.Setup(validator => validator.Validate(It.IsAny <ContactMessageViewModel>()))
.Returns(new ValidationResult());
_providerUserMediator.Setup(mediator => mediator.SendContactMessage(contactMessageViewModel)).Returns(true);
MediatorResponse <ContactMessageViewModel> response = _homeMediator.SendContactMessage(username,
contactMessageViewModel);
//Assert
response.Code.Should().NotBeNullOrWhiteSpace();
response.Message.Should().NotBeNull();
response.Message.Level.ShouldBeEquivalentTo(UserMessageLevel.Success);
response.Message.Text.Should().Be("Your question has been successfully sent. Thank you.");
}
public static void AssertMessage(this MediatorResponse response, string code, string message, UserMessageLevel messageLevel, bool parametersShouldNotBeNull = false)
{
response.Code.Should().Be(code);
response.Message.Text.Should().Be(message);
response.Message.Level.Should().Be(messageLevel);
response.AssertParameters(parametersShouldNotBeNull);
response.ValidationResult.Should().BeNull();
}
private static void AssertParameters(this MediatorResponse response, bool parametersShouldNotBeNull)
{
if (parametersShouldNotBeNull)
{
response.Parameters.Should().NotBeNull();
}
else
{
response.Parameters.Should().BeNull();
}
}
private static void AssertViewModel <T>(this MediatorResponse <T> response, bool viewModelShouldNotBeNull)
{
if (viewModelShouldNotBeNull)
{
response.ViewModel.Should().NotBeNull();
}
else
{
response.ViewModel.Should().BeNull();
}
}
private static JsonResult SavedVacancyResultFromViewModel(MediatorResponse <SavedVacancyViewModel> response)
{
return(new JsonResult
{
Data = new
{
applicationStatus = response.ViewModel.ApplicationStatus.HasValue
? response.ViewModel.ApplicationStatus.ToString()
: "Unsaved"
}
});
}
public MediatorResponse <T> GetMediatorResponse <T>(string code, T viewModel = default(T),
ValidationResult validationResult = null, object parameters = null, string message = null)
{
MediatorResponse <T> response = new MediatorResponse <T> {
Code = code,
ViewModel = viewModel,
ValidationResult = validationResult,
Parameters = parameters,
Message = message
};
return(response);
}
private ActionResult GetDetailsResult(MediatorResponse <ApprenticeshipVacancyDetailViewModel> response)
{
switch (response.Code)
{
case ApprenticeshipSearchMediatorCodes.Details.VacancyNotFound:
return(new ApprenticeshipNotFoundResult());
case ApprenticeshipSearchMediatorCodes.Details.VacancyHasError:
ModelState.Clear();
SetUserMessage(response.Message.Text, response.Message.Level);
return(View("Details", response.ViewModel));
case ApprenticeshipSearchMediatorCodes.Details.Ok:
return(View("Details", response.ViewModel));
}
throw new InvalidMediatorCodeException(response.Code);
}
public async Task Invoke <TAction>(TAction action, MediatorResponse response, MiddlewareDelegate next, CancellationToken cancellationToken)
{
using (_logger.BeginMethod(action, action?.GetType()?.FullName ?? ""))
{
var stopwatch = Stopwatch.StartNew();
try
{
await next();
}
catch (Exception e)
{
_logger.LogError(e, "Pipeline exception");
throw;
}
finally
{
stopwatch.Stop();
_logger.LogInformation($"Execution time = {stopwatch.ElapsedMilliseconds}ms");
}
}
}
public async Task Invoke <TAction>(TAction action, MediatorResponse response, MiddlewareDelegate next, CancellationToken cancellationToken)
{
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
var typeValidator = _validatorFactory.GetValidator(action.GetType());
if (typeValidator != null)
{
var result = await typeValidator.ValidateAsync(new ValidationContext <object>(action), cancellationToken);
if (result.Errors.Any())
{
_logger.LogWarning("Model validation failed", result.Errors);
throw new ValidationException(result.Errors);
}
}
await next();
}
public void GetContactMessageViewModelTest_WithUserName()
{
//// Arrange.
const string username = "******";
var providerUser = new ProviderUser
{
Fullname = "fullname",
Email = "*****@*****.**"
};
//Act
_userProfileService.Setup(pup => pup.GetProviderUser(username))
.Returns(providerUser);
MediatorResponse <ContactMessageViewModel> response = _homeMediator.GetContactMessageViewModel(username);
//Assert
response.ViewModel.Name.Should().NotBeNullOrWhiteSpace();
response.ViewModel.Email.Should().NotBeNullOrWhiteSpace();
}
public async Task Invoke <TAction>(TAction action, MediatorResponse response, MiddlewareDelegate next, CancellationToken cancellationToken)
{
_logger.LogInformation("Hello from " + nameof(CommandSpecificMiddleware));
await next();
}
