protected void AddErrors(ValidationResult result)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.ErrorMessage);
}
}
private void Validate(object sender, PropertyChangedEventArgs e)
{
//var propertyChain = new PropertyChain();
//propertyChain.Add(e.PropertyName);
//validationResult = validator.Validate(new ValidationContext(target, propertyChain, new DefaultValidatorSelector()));
validationResult = validator.Validate(target);
}
public ValidatorError(String errorTitle, HttpStatusCode statusCode, ValidationResult result, HttpRequestMessage request)
{
_errorTitle = errorTitle;
_result = result;
_request = request;
_statusCode = statusCode;
}
public void Setup()
{
_riskAssessmentService = new Mock<IFireRiskAssessmentService>();
_fireRiskAssessmentChecklistService = new Mock<IFireRiskAssessmentChecklistService>();
_target = new FireRiskAssessmentChecklistViewModelFactory(_riskAssessmentService.Object, _fireRiskAssessmentChecklistService.Object);
_riskAssessmentId = 123L;
_companyId = 456L;
var validationResult = new ValidationResult
(
new List<ValidationFailure>
{
new ValidationFailure
(
"10",
"error 10"
),
new ValidationFailure
(
"20",
"error 20"
),
new ValidationFailure
(
"30",
"error 30"
)
}
);
_fireRiskAssessmentChecklistService
.Setup(x => x.ValidateFireRiskAssessmentChecklist(It.IsAny<ValidateCompleteFireRiskAssessmentChecklistRequest>()))
.Returns(validationResult);
}
protected virtual IEnumerable<ModelValidationResult> ConvertValidationResultToModelValidationResults(ValidationResult result) {
return result.Errors.Select(x => new ModelValidationResult
{
MemberName = x.PropertyName,
Message = x.ErrorMessage
});
}
public ValidationResultExtensionTests()
{
result = new ValidationResult(new[] {
new ValidationFailure("foo", "A foo error occurred", "x"),
new ValidationFailure("bar", "A bar error occurred", "y"),
});
}
private void Validate(object sender, PropertyChangedEventArgs e)
{
if (validator != null)
{
validationResult = validator.Validate(target);
}
}
public ValidationTemplate(INotifyPropertyChanged target)
{
this.target = target;
validator = GetValidator(target.GetType());
validationResult = validator.Validate(target);
target.PropertyChanged += Validate;
}
public ValidationResult ValidateFireRiskAssessmentChecklist(ValidateCompleteFireRiskAssessmentChecklistRequest request)
{
var result = new ValidationResult();
var correspondingAnswers = _fireAnswerRepository.GetByChecklistIdAndQuestionIds(request.ChecklistId, request.QuestionIds);
foreach (var questionId in request.QuestionIds)
{
var answer = correspondingAnswers.SingleOrDefault(x => x.Question != null && x.Question.Id == questionId);
if(answer == null)
{
result.Errors.Add(new ValidationFailure(questionId.ToString(), "Please select a response"));
}else if(!answer.IsValidateForCompleteChecklist())
{
string errorMessage = string.Empty;
switch(answer.YesNoNotApplicableResponse)
{
case YesNoNotApplicableEnum.No:
errorMessage = "Please add a Further Control Measure Task";
break;
case YesNoNotApplicableEnum.Yes:
errorMessage = "Please enter a comment";
break;
}
result.Errors.Add(new ValidationFailure(questionId.ToString(), errorMessage));
}
}
return result;
}
public ValidatorError(String errorTitle, ValidationResult result, HttpRequestMessage request)
{
_errorTitle = errorTitle;
_result = result;
_request = request;
_statusCode = HttpStatusCode.InternalServerError;
}
protected override void Context()
{
_createCustomerRequestValidator = new CreateCustomerRequestValidator();
_expectedResult = new ValidationResult(new List<ValidationFailure>
{
new ValidationFailure("Name", "'Name' cannot be empty."),
});
}
public void ResultIndicatesValidWhenNoValidationErrorsFound()
{
var innerResult = new ValidationResult();
validationResult = new FluentValidationResult(innerResult);
bool isModelValid = validationResult.IsModelValid();
Assert.True(isModelValid);
}
public void OnPropertyChanged(string propertyName)
{
validationResult = validator.Validate(this);
var handler = PropertyChanged;
if (handler != null)
{
handler(this, new PropertyChangedEventArgs(propertyName));
}
}
protected override bool PreValidate(ValidationContext <Rate> context, FluentValidation.Results.ValidationResult result)
{
if (context.InstanceToValidate == null)
{
result.Errors.Add(new ValidationFailure("", "Object null"));
return(false);
}
return(true);
}
public void ResultShowNoErrorsForValidProperty()
{
var innerResult = new ValidationResult();
validationResult = new FluentValidationResult(innerResult);
var errorsForProperty = validationResult.GetErrorsForProperty("NewProperty");
Assert.That(errorsForProperty.Count() == 0);
}
static FluentValidation.Results.ValidationResult BuildResult(FluentValidation.Results.ValidationResult rawResult)
{
var cleanedErrors = rawResult.Errors.Select(error => new ValidationFailure(CleanPropertyName(error.PropertyName), error.ErrorMessage, error.AttemptedValue)
{
CustomState = error.CustomState
}).ToList();
return(new FluentValidation.Results.ValidationResult(cleanedErrors));
}
private static string GetErrors(ValidationResult results)
{
if (results != null && results.Errors.Any())
{
var errors = string.Join(Environment.NewLine, results.Errors.Select(x => x.ErrorMessage).ToArray());
return errors;
}
return string.Empty;
}
public void ResultShowsNoErrorsWhenNoneWereFound()
{
var innerResult = new ValidationResult();
validationResult = new FluentValidationResult(innerResult);
int totalErrorCount = validationResult.GetErrorCount();
Assert.That(totalErrorCount == 0);
}
public void It_should_map_error_message()
{
var fluentValidationResult = new FluentValidation.Results.ValidationResult();
fluentValidationResult.Errors.Add(new ValidationFailure("property", "error"));
var validationErrors = FluentConverter.ToProjectValidationResult(fluentValidationResult);
Assert.AreEqual(fluentValidationResult.Errors.Single().ErrorMessage, validationErrors.ValidationErrors.Single().ErrorMessage);
}
/// <summary>
/// return http message 400 Bad Request, with the content of the validation
/// </summary>
/// <param name="_results"></param>
/// <returns></returns>
public static HttpResponseMessage FailedValidationMessage(ValidationResult _results)
{
var validationErrors = _results.Errors.Select(error => error.ErrorMessage).ToList();
var errors = JsonConvert.SerializeObject(validationErrors);
return new HttpResponseMessage
{
Content = new StringContent(errors),
StatusCode = HttpStatusCode.BadRequest
};
}
private bool ValidateDataService()
{
ServiceValidator serviceValidator = new ServiceValidator();
FluentValidation.Results.ValidationResult dataValidationResult = serviceValidator.Validate(Service);
IList <ValidationFailure> validationFailures = dataValidationResult.Errors;
UserFeedback userFeedback = new UserFeedback(FormGrid, validationFailures);
userFeedback.ShowFeedback();
return(dataValidationResult.IsValid && ValidateCity() && ValidateState());
}
private bool ValidateDataReport()
{
ReportValidator reportValidator = new ReportValidator();
FluentValidation.Results.ValidationResult dataValidationResult = reportValidator.Validate(report);
IList <ValidationFailure> validationFailures = dataValidationResult.Errors;
UserFeedback userFeedback = new UserFeedback(FormGrid, validationFailures);
userFeedback.ShowFeedback();
return(dataValidationResult.IsValid);
}
private bool ValidateDataAccount()
{
MemberATEValidator memberATEValidator = new MemberATEValidator(PasswordBoxConfirmPassword.Password);
FluentValidation.Results.ValidationResult dataValidationResult = memberATEValidator.Validate(memberATE);
IList <ValidationFailure> validationFailures = dataValidationResult.Errors;
UserFeedback userFeedback = new UserFeedback(FormGrid, validationFailures);
userFeedback.ShowFeedback();
return(dataValidationResult.IsValid && ValidateCity() && ValidateState());
}
private bool IsValidData()
{
CoordinatorValidator coordinatorDataValidator = new CoordinatorValidator();
FluentValidation.Results.ValidationResult dataValidationResult = coordinatorDataValidator.Validate(Coordinator);
IList <ValidationFailure> validationFailures = dataValidationResult.Errors;
UserFeedback userFeedback = new UserFeedback(FormGrid, validationFailures);
userFeedback.ShowFeedback();
return(dataValidationResult.IsValid);
}
/// <inheritdoc />
public async ValueTask <ValidationResult> ValidateAsync(object model, CancellationToken cancellationToken)
{
FV.Results.ValidationResult result = await _validator.ValidateAsync(model, cancellationToken);
if (!result.IsValid)
{
return(new ValidationResult(result.Errors.Select(CreateValidationError)));
}
return(ValidationResult.Success);
}
private bool IsValidData()
{
TeacherValidator teacherDataValidator = new TeacherValidator();
FluentValidation.Results.ValidationResult dataValidationResult = teacherDataValidator.Validate(_teacher);
IList <ValidationFailure> validationFailures = dataValidationResult.Errors;
UserFeedback userFeedback = new UserFeedback(FormGrid, validationFailures);
userFeedback.ShowFeedback();
return(dataValidationResult.IsValid);
}
public bool Validate <TModel, TValidator>(TModel model, TValidator validator, ModelStateDictionary modelState)
where TValidator : AbstractValidator <TModel>
{
FluentValidation.Results.ValidationResult result = validator.Validate(model);
foreach (var error in result.Errors)
{
modelState.AddModelError(error.PropertyName, error.ErrorMessage);
}
return(result.IsValid);
}
public ActionResult CreateForGame([Bind(Include = "ProductInGameID,ProductID, ReferencePrice, PriceInGame,GameID,Quantity,CurrencyID,DateInserted,DateUpdated,USR")] ProductInGame productInGame)
{
ProductInGameValidator validator = new ProductInGameValidator();
if (ModelState.IsValid)
{
//Deduct quantity from Product table if stock available
//@Patrick 6) Depletes the product Quantity from the "Available Stock" amount on the Product record.
//Available Stock must not go negative (Validator checks for this)
//Get Product
var product = db.Products.Where(x => x.ProductID == productInGame.ProductID).First();
//Deplete available stock on hand
product.AvailableSOH -= productInGame.Quantity;
//Save
if (product.AvailableSOH >= 0)
{
db.Entry(product).State = EntityState.Modified;
db.SaveChanges();
}
else
{
ModelState.AddModelError("QuantityError", "Not enough stock on hand for this product");
ViewBag.CurrencyID = new SelectList(db.Currencies, "CurrencyID", "CurrencyCode", productInGame.CurrencyID);
ViewBag.GameID = new SelectList(db.Games, "GameID", "GameCode", productInGame.GameID);
ViewBag.ProductID = new SelectList(db.Products, "ProductID", "ProductSKUCode", productInGame.ProductID);
return(View(productInGame));
}
db.ProductInGames.Add(productInGame);
db.SaveChanges();
return(RedirectToAction("EditMakeGame", "Games", new { id = productInGame.GameID }));
}
FluentValidation.Results.ValidationResult results = validator.Validate(productInGame);
IList <ValidationFailure> failures = results.Errors;
StringBuilder sb = new StringBuilder();
foreach (var e in results.Errors)
{
ModelState.AddModelError(e.PropertyName + "Error", e.ErrorMessage);
sb.AppendLine(e.ErrorMessage);
}
ViewBag.CurrencyID = new SelectList(db.Currencies, "CurrencyID", "CurrencyCode", productInGame.CurrencyID);
ViewBag.GameID = new SelectList(db.Games, "GameID", "GameCode", productInGame.GameID);
ViewBag.ProductID = new SelectList(db.Products, "ProductID", "ProductSKUCode", productInGame.ProductID);
return(View(productInGame));
}
private void InsertUpdateAccount()
{
dhAccount objInsert = new dhAccount();
objInsert = (dhAccount)this.AccountDt.DataContext;
dhAccountValidator validator = new dhAccountValidator();
FluentValidation.Results.ValidationResult results = validator.Validate(objInsert);
bool validationSucceeded = results.IsValid;
IList <ValidationFailure> failures = results.Errors;
if (validationSucceeded)
{
if (this.vAccountType.SelectedValue != null)
{
objInsert.IFinaceType = Convert.ToInt32(this.vAccountType.SelectedValue.ToString());
}
else
{
throw new ApplicationException("Please Select Account Type.");
}
DataSet ds = iFacede.InsertUpdateAccount(Globalized.ObjDbName, objInsert);
if (ds.Tables[0].Rows.Count > 0)
{
if (objInsert.IUpdate == 1)
{
string msg = "Account '" + objInsert.AccountName + "' information is updated successfully.";
Globalized.setException(msg, lblErrorMsg, DataHolders.MsgType.Info);
//Globalized.SetMsg(msg, DataHolders.MsgType.Info);
//Globalized.ShowMsg(lblErrorMsg);
}
else
{
System.Media.SystemSounds.Beep.Play();
lblErrorMsg.Visibility = Visibility.Hidden;
Globalized.SetMsg("New Acount '" + objInsert.AccountName + "' is added successfully.", DataHolders.MsgType.Info);
objTodisplay.IUpdate = 1;
this.DataContext = objTodisplay;
Globalized.ShowMsg(lblErrorMsg);
}
}
Globalized.AccountListOptimizated();
}
else
{
throw new ApplicationException(failures.First().ErrorMessage);
}
}
public void ResultShowErrorsForInvalidProperty()
{
var innerResult = new ValidationResult();
string propertyName = "AnyProperty";
string errorMessage = "Just some error message, doesnt matter";
innerResult.Errors.Add(new ValidationFailure(propertyName, errorMessage));
validationResult = new FluentValidationResult(innerResult);
var errorsForProperty = validationResult.GetErrorsForProperty(propertyName);
Assert.That(errorsForProperty.Count() == 1);
Assert.That(errorsForProperty.First() == errorMessage);
}
private void AssertInvalidResult(
FluentValidation.Results.ValidationResult validationResult,
string propertyName,
string message = null)
{
validationResult.IsValid.Should().BeFalse();
validationResult.Errors
.Should()
.ContainSingle(
error => error.PropertyName.Equals(propertyName) &&
error.ErrorMessage.Equals(message)
);
}
protected override void OnValidated(FluentValidation.Results.ValidationResult res)
{
if (this is ITreeConfigNode)
{
var cfg = this.GetConfig();
if (cfg == null)
{
return;
}
bool isValid = true;
foreach (var ts in cfg.GroupAppSolutions.ListAppSolutions)
{
foreach (var tp in ts.ListAppProjects)
{
foreach (var tg in tp.ListAppProjectGenerators)
{
if (tg.PluginGenerator != null)
{
var lst = tg.PluginGenerator.ValidateNode(this as ITreeConfigNode, tg.Guid);
foreach (var t in lst)
{
Debug.Assert(!string.IsNullOrWhiteSpace(t.PropertyName));
Debug.Assert(!string.IsNullOrWhiteSpace(t.Message));
var r = new ValidationFailure(t.PropertyName, t.Message);
switch (t.Level)
{
case ValidationPluginMessage.EnumValidationMessage.Error:
r.Severity = Severity.Error;
isValid = false;
break;
case ValidationPluginMessage.EnumValidationMessage.Warning:
r.Severity = Severity.Warning;
break;
case ValidationPluginMessage.EnumValidationMessage.Info:
r.Severity = Severity.Info;
break;
default:
throw new Exception();
}
res.Errors.Add(r);
}
}
}
}
}
Debug.Assert(isValid || (!isValid && !res.IsValid));
}
}
protected override void Context()
{
base.Context();
_expectedResult = new ValidationResult(new List<ValidationFailure>
{
new ValidationFailure("FirstName", "First Name cannot be empty."),
new ValidationFailure("LastName", "Last Name cannot be empty."),
new ValidationFailure("EmailAddress", "Email Address cannot be empty."),
new ValidationFailure("Username", "Username cannot be empty."),
new ValidationFailure("Role", "Role cannot be empty.", Role.Undefined),
});
}
private void ModifyButtonClicked(object sender, RoutedEventArgs e)
{
LinkedOrganizationValidator linkedOrganizationValidator = new LinkedOrganizationValidator();
FluentValidation.Results.ValidationResult dataValidationResult = linkedOrganizationValidator.Validate(LinkedOrganizationToBeModified);
IList <ValidationFailure> validationFailures = dataValidationResult.Errors;
UserFeedback userFeedback = new UserFeedback(FormGrid, validationFailures);
userFeedback.ShowFeedback();
if (dataValidationResult.IsValid)
{
ModifyLinkedOrganization();
}
}
/// <summary>
/// Validates any object
/// </summary>
/// <typeparam name="TObject">The type of the object.</typeparam>
/// <param name="validate">The validate.</param>
/// <returns></returns>
public ValidationResult Validate <TObject>(TObject validate)
{
FluentValidation.Results.ValidationResult validationResult;
if (validate == null)
{
validationResult = new FluentValidation.Results.ValidationResult();
validationResult.Errors.Add(new ValidationFailure("ActionObject", "Please provide some input"));
}
else
{
var validator = GetValidator <TObject>();
validationResult = validator.Validate(validate);
}
return(FluentConverter.ToProjectValidationResult(validationResult));
}
protected override void Context()
{
base.Context();
_createAccountRequest = new CreateAccountRequest
{
EmailAddress = "someinvalidemailaddress",
Username = "******",
};
_expectedResult = new ValidationResult(new List<ValidationFailure>
{
new ValidationFailure("EmailAddress", "Email address is not valid."),
new ValidationFailure("Username", "Username has some invalid characters."),
});
}
public void Handle_InvokesDecoratedHandle_WhenValidationPasses()
{
var query = new FakeQueryWithoutValidator();
var decorated = new Mock<IHandleQuery<FakeQueryWithoutValidator, string>>(MockBehavior.Strict);
var validator = new Mock<IValidator<FakeQueryWithoutValidator>>(MockBehavior.Strict);
var expectedResult = new ValidationResult();
validator.Setup(x => x.Validate(query)).Returns(expectedResult);
decorated.Setup(x => x.Handle(query)).Returns("faked");
var decorator = new ValidateQueryDecorator<FakeQueryWithoutValidator, string>(decorated.Object, validator.Object);
var result = decorator.Handle(query);
Assert.Equal("faked", result);
validator.Verify(x => x.Validate(query), Times.Once);
decorated.Verify(x => x.Handle(query), Times.Once);
}
public void Handle_InvokesDecoratedHandle_WhenValidationPasses()
{
var command = new FakeCommandWithValidator();
var decorated = new Mock<IHandleCommand<FakeCommandWithValidator>>(MockBehavior.Strict);
var validator = new Mock<IValidator<FakeCommandWithValidator>>(MockBehavior.Strict);
Expression<Func<FakeCommandWithValidator, bool>> expectedCommand = x => ReferenceEquals(x, command);
var expectedResult = new ValidationResult();
validator.Setup(x => x.Validate(It.Is(expectedCommand))).Returns(expectedResult);
decorated.Setup(x => x.Handle(It.Is(expectedCommand))).Returns(Task.FromResult(0));
var decorator = new ValidateCommandDecorator<FakeCommandWithValidator>(decorated.Object, validator.Object);
decorator.Handle(command).Wait();
validator.Verify(x => x.Validate(It.Is(expectedCommand)), Times.Once);
decorated.Verify(x => x.Handle(It.Is(expectedCommand)), Times.Once);
}
public void Handle_ThrowsValidationException_AndDoesNotInvokeDecoratedHandle_WhenValidationFails()
{
var command = new FakeCommandWithValidator();
var decorated = new Mock<IHandleCommand<FakeCommandWithValidator>>(MockBehavior.Strict);
var validator = new Mock<IValidator<FakeCommandWithValidator>>(MockBehavior.Strict);
Expression<Func<FakeCommandWithValidator, bool>> expectedCommand = x => ReferenceEquals(x, command);
var expectedResult = new ValidationResult(new[] { new ValidationFailure("Name", "Invalid.", command.ReturnValue), });
validator.Setup(x => x.Validate(It.Is(expectedCommand))).Returns(expectedResult);
var decorator = new ValidateCommandDecorator<FakeCommandWithValidator>(decorated.Object, validator.Object);
var exception = Assert.Throws<ValidationException>(() => decorator.Handle(command));
exception.ShouldNotBeNull();
validator.Verify(x => x.Validate(It.Is(expectedCommand)), Times.Once);
decorated.Verify(x => x.Handle(It.IsAny<FakeCommandWithValidator>()), Times.Never);
}
public ActionResult EditFromProductInGame(ProductLocationViewModel plvm)
{
StringBuilder sb = new StringBuilder();
if (ModelState.IsValid)
{
db.Entry(plvm.ProductLocation).State = EntityState.Modified;
foreach (var s in plvm.ProductLocation.SerialNumbers)
{
SerialNumberValidator validator = new SerialNumberValidator();
FluentValidation.Results.ValidationResult results = validator.Validate(s);
IList <ValidationFailure> failures = results.Errors;
foreach (var e in results.Errors)
{
ModelState.AddModelError(e.PropertyName + "Error", e.ErrorMessage);
sb.AppendLine(e.ErrorMessage);
}
db.Entry(s).State = EntityState.Modified;
}
foreach (var v in plvm.ProductLocation.Vouchers)
{
db.Entry(v).State = EntityState.Modified;
}
if (ModelState.IsValid)
{
db.SaveChanges();
return(RedirectToAction("Edit", "ProductInGames", new { id = plvm.ProductLocation.ProductInGameID }));
}
else
{
ViewBag.ProductInGameID = plvm.ProductLocation.ProductInGameID;
ViewBag.ErrorMessage = sb.ToString();
plvm.ProductLocation.ProductInGame = db.ProductInGames.Find(plvm.ProductLocation.ProductInGameID);
return(View(plvm));
}
}
ViewBag.ErrorMessage = sb.ToString();
ViewBag.ProductInGameID = plvm.ProductLocation.ProductInGameID;
plvm.ProductLocation.ProductInGame = db.ProductInGames.Find(plvm.ProductLocation.ProductInGameID);
return(View(plvm));
}
public void Handle_ThrowsValidationException_AndDoesNotInvokeDecoratedHandle_WhenValidationFails()
{
var query = new FakeQueryWithoutValidator();
var decorated = new Mock<IHandleQuery<FakeQueryWithoutValidator, string>>(MockBehavior.Strict);
var validator = new Mock<IValidator<FakeQueryWithoutValidator>>(MockBehavior.Strict);
Expression<Func<FakeQueryWithoutValidator, bool>> expectedQuery = x => ReferenceEquals(x, query);
var expectedResult = new ValidationResult(new[] { new ValidationFailure("Name", "Invalid."), });
validator.Setup(x => x.Validate(It.Is(expectedQuery))).Returns(expectedResult);
var decorator = new ValidateQueryDecorator<FakeQueryWithoutValidator, string>(decorated.Object, validator.Object);
var exception = Assert.Throws<ValidationException>(() => decorator.Handle(query));
Assert.NotNull(exception);
validator.Verify(x => x.Validate(It.Is(expectedQuery)), Times.Once);
decorated.Verify(x => x.Handle(It.IsAny<FakeQueryWithoutValidator>()), Times.Never);
}
public override async Task <FluentValidation.Results.ValidationResult> ValidateAsync(ValidationContext <ModificarEmailCommand> context, CancellationToken cancellation = default)
{
var result = new FluentValidation.Results.ValidationResult();
var entity = context.InstanceToValidate;
string normalizedEmail = entity.NuevoEmail.ToUpper();
bool oldUser = await db
.Usuario
.AnyAsync(el => el.NormalizedEmail == normalizedEmail, cancellation);
if (oldUser)
{
result.Errors.Add(new ValidationFailure(nameof(entity.NuevoEmail), "El email ya se encuentra registrado"));
}
return(result);
}
public void given_an_exception_thrown_check_that_the_controller_throws_correct_exception_and_500_status_code()
{
var expectedStatusCode = 500;
var request = new PostProcessImageRequest(); //an empty request will be invalid
var fakeValidationResult = new FV.ValidationResult(); //Need to create ValidationResult so that I could setup Validator mock to return it upon '.Validate()' call. Also this is the only place where it's possible to manipulate the validation result - You can only make the validation result invalid by inserting a list of validation errors as a parameter through a constructor. The boolean '.IsValid' comes from expression 'IsValid => Errors.Count == 0;', so it can't be set manually.
_mockPostValidator.Setup(v => v.Validate(It.IsAny <PostProcessImageRequest>())).Returns(fakeValidationResult);
_mockUsecase.Setup(x => x.ExecutePost(request)).Throws <ImageNotInsertedToS3>();
//act
var controllerResponse = _processImageController.PostProcessImage(request);
var result = controllerResponse as ObjectResult;
//assert
Assert.NotNull(controllerResponse);
Assert.NotNull(result);
Assert.AreEqual(expectedStatusCode, result.StatusCode);
}
public override async Task <FluentValidation.Results.ValidationResult> ValidateAsync(ValidationContext <CreateUserCommand> context, CancellationToken cancellation = default)
{
var result = new FluentValidation.Results.ValidationResult();
var entity = context.InstanceToValidate;
string normalizedUser = entity.UserName.ToUpper();
bool nombreUsuarioRegistrado = await db
.User
.AnyAsync(el => el.NormalizedUserName == normalizedUser, cancellation);
if (nombreUsuarioRegistrado)
{
result.Errors.Add(new ValidationFailure(nameof(entity.UserName), "El nombre de usuario ya se encuentra registrado"));
}
return(result);
}
private void SendMessageButtonClicked(object sender, RoutedEventArgs routedEvent)
{
messagesSend = new Models.Message();
messagesSend.message = TextBoxMessage.Text;
messagesSend.idChat = ChatSelect.idChat;
messagesSend.memberType = Login.tokenAccount.memberATEType;
MessageValidator messageValidator = new MessageValidator();
FluentValidation.Results.ValidationResult dataValidationResult = messageValidator.Validate(messagesSend);
IList <ValidationFailure> validationFailures = dataValidationResult.Errors;
if (dataValidationResult.IsValid)
{
RegisterMessage();
}
else
{
MessageBox.Show("Por favor ingrese un mensaje correcto", "Mensaje invalido", MessageBoxButton.OK, MessageBoxImage.Warning);
}
}
public async Task <IActionResult> UserRegister([Required][FromBody] CustomerDetails userDetails)
{
CustomerValidator customerValidator = new CustomerValidator();
FluentValidation.Results.ValidationResult validationResult = customerValidator.Validate(userDetails);
if (!validationResult.IsValid)
{
return(BadRequest(validationResult.ToString("; ")));
}
var result = await Task <int> .Run(() => _customerBusiness.UserRegisteration(userDetails));
if (result > 0)
{
return(Ok("User Added Successfully"));
}
else
{
return(BadRequest("User is not added"));
}
}
public void Builder_Create_WhenContextIsValid()
{
var result = new FluentValidation.Results.ValidationResult();
var context = Substitute.For <IContext>();
context.ValidateConfiguration(Arg.Any <IGeneratorConfiguration>())
.Returns(result);
var codeGenerator = Substitute.For <ICodeGenerator>();
var output = Substitute.For <IOutputStrategy>();
var logger = Substitute.For <ILogger <Builder> >();
var configuration = Substitute.For <IGeneratorConfiguration>();
var sut = new Builder(context, codeGenerator, output, logger);
sut.Create(configuration);
logger.ReceivedCalls().Should().HaveCount(2);
codeGenerator.ReceivedCalls().Should().HaveCount(1);
}
public void Assign_NullOrWhitespace_to_SongTitleAlbumComposer_ReturnsError(string whitespace)
{
Song fakeSong = new Song()
{
Title = whitespace,
Album = whitespace,
Composer = whitespace
};
SongValidator validator = new SongValidator();
ValidationResult results = validator.Validate(fakeSong);
bool isValid = results.IsValid;
IList <ValidationFailure> failures = results.Errors;
Assert.False(isValid);
foreach (var failure in failures)
{
_output.WriteLine(failure.ErrorMessage);
}
}
public static Dictionary<string, object> GetErrors(ValidationResult r)
{
Dictionary<string, object> dic = null;
Dictionary<string, List<string>> m = new Dictionary<string, List<string>>();
if (!r.IsValid)
{
foreach (ValidationFailure e in r.Errors)
{
SetError(e.PropertyName, e.ErrorMessage, m);
}
dic = new Dictionary<string, object>
{
{ "error", 1 },
{ "errors", m }
};
}
return dic;
}
public async Task <IActionResult> UpdateCustomerDetails([Required][FromBody] CustomerDetails customerDetails)
{
//_msgObj.RegisterOnMessageHandlerAndReceiveMessages();
CustomerValidator customerValidator = new CustomerValidator();
FluentValidation.Results.ValidationResult validationResult = customerValidator.Validate(customerDetails);
if (!validationResult.IsValid)
{
return(BadRequest(validationResult.ToString("; ")));
}
var result = await Task <int> .Run(() => _customerBusiness.UpdateCustomerDetails(customerDetails));
if (result > 0)
{
return(Ok("Customer data updated successfully"));
}
else
{
return(BadRequest("Customer data cannot be updated.Please try again later"));
}
}
private void BtnUpdatePerson_Click(object sender, RoutedEventArgs e)
{
SelectedPersonne.Nom = txtbUpdatePersonName.Text;
PersonneValidator validator = new PersonneValidator();
FluentValidation.Results.ValidationResult results = validator.Validate(SelectedPersonne);
if (results.IsValid == false)
{
foreach (ValidationFailure failure in results.Errors)
{
MessageBox.Show($"{failure.ErrorMessage}", "Erreur", MessageBoxButton.OK, MessageBoxImage.Error);
}
return;
}
DAL.UpdatePerson(SelectedPersonne);
this.Close();
}
protected override void Context()
{
base.Context();
_createAccountRequest = new CreateAccountRequest();
AuthorizationService.Stub(
x => x.CanExecute(Arg<string>.Is.Equal(Username), Arg<Type>.Is.Equal(typeof (CreateAccountRequest)))).
Return(true);
_validationResultReturnedFromValidator = new ValidationResult(new List<ValidationFailure>
{
new ValidationFailure("FirstName",
"First Name cannot be empty."),
new ValidationFailure("LastName",
"Last Name cannot be empty."),
new ValidationFailure("EmailAddress",
"Email Address cannot be empty."),
new ValidationFailure("Username",
"Username cannot be empty."),
new ValidationFailure("Role",
"Role cannot be empty."),
});
_createAccountRequestValidator = MockRepository.GenerateStub<CreateAccountRequestValidator>();
_createAccountRequestValidator.Stub(
x => x.Validate(Arg<CreateAccountRequest>.Is.Equal(_createAccountRequest)))
.Return(_validationResultReturnedFromValidator);
ValidatorFactory.Stub(
x => x.GetValidator<CreateAccountRequest>())
.Return(_createAccountRequestValidator);
_expectedCreateAccountResponse = new CreateAccountResponse
{
Success = false,
Errors = _validationResultReturnedFromValidator.Errors.Select(x=>x.ErrorMessage),
};
}
protected override void Context()
{
base.Context();
_document = Builder<Document>.CreateNew().Build();
AuthorizationService.Stub(
x => x.CanExecute(Arg<string>.Is.Equal(Username), Arg<string>.Is.Equal("CreateDocument")))
.Return(true);
_validationResultReturnedFromValidator = new ValidationResult();
Validator.Stub(x => x.Validate(Arg<Document>.Is.Equal(_document)))
.Return(_validationResultReturnedFromValidator);
_documentReturnedFromRepository = new Document
{
Body = _document.Body,
CreatedByUsername = Username,
CreatedDate = new DateTime(2011, 1, 1),
CustomerId = 7,
CustomerName = "some customer name",
DocumentId = 123,
Title = _document.Title,
};
DocumentRepository.Stub(x => x.Save(Arg<string>.Is.Equal(Username), Arg<Document>.Is.Anything))
.Return(_documentReturnedFromRepository);
_expectedDocument = new Document
{
Body = _documentReturnedFromRepository.Body,
CreatedByUsername = _documentReturnedFromRepository.CreatedByUsername,
CreatedDate = _documentReturnedFromRepository.CreatedDate,
CustomerId = _documentReturnedFromRepository.CustomerId,
CustomerName = _documentReturnedFromRepository.CustomerName,
DocumentId = _documentReturnedFromRepository.DocumentId,
Title = _documentReturnedFromRepository.Title,
};
}
public static Contracts.Domain.BusinessRules.ValidationResult Map(this FluentValidation.Results.ValidationResult validationResult)
{
if (validationResult.IsValid)
{
return(Contracts.Domain.BusinessRules.ValidationResult.Success);
}
var result = new Contracts.Domain.BusinessRules.ValidationResult();
foreach (var validationFailure in validationResult.Errors)
{
var error =
new BusinessError(
validationFailure.ErrorCode,
validationFailure.ErrorMessage,
_severtyMapper[validationFailure.Severity]);
result.AddError(error);
}
return(result);
}
private void RegisterButtonClicked(object sender, RoutedEventArgs e)
{
CreateLinkedOrganizationFromUserInput();
LinkedOrganizationValidator linkedOrganizationValidator = new LinkedOrganizationValidator();
FluentValidation.Results.ValidationResult dataValidationResult = linkedOrganizationValidator.Validate(LinkedOrganization);
IList <ValidationFailure> validationFailures = dataValidationResult.Errors;
UserFeedback userFeedback = new UserFeedback(FormGrid, validationFailures);
userFeedback.ShowFeedback();
if (dataValidationResult.IsValid)
{
ProfessionalPracticesContext professionalPracticesContext = new ProfessionalPracticesContext();
UnitOfWork unitOfWork = new UnitOfWork(professionalPracticesContext);
try
{
if (ThereIsAnotherLinkedOrganizationWithSameData(unitOfWork))
{
MessageBox.Show("Existe una organización vinculada con el mismo nombre, correo o teléfono registrado");
}
else
{
unitOfWork.LinkedOrganizations.Add(LinkedOrganization);
MessageBox.Show("La organización vinculada se registró exitosamente");
GoBackToCoordinatorMenu();
}
}
catch (SqlException)
{
MessageBox.Show("No se pudo obtener la información de la base de datos");
this.Close();
}
finally
{
unitOfWork.Complete();
unitOfWork.Dispose();
}
}
}
public BaseResponse <TransferResponse> Transfer(string userId, TransferRequest transferRequest)
{
var response = new BaseResponse <TransferResponse>();
try
{
transferRequest.UserId = userId;
TransferValidator transferValidator = new TransferValidator(_checkingAccountService);
FluentValidation.Results.ValidationResult validationResult = transferValidator.Validate(transferRequest);
if (!validationResult.IsValid)
{
response.AddErrors(validationResult.Errors);
return(response);
}
var from = _checkingAccountService.UpdateBalance(transferRequest.NumberFrom, transferRequest.Amount * -1);
var to = _checkingAccountService.UpdateBalance(transferRequest.NumberTo, transferRequest.Amount);
_transactionService.Add(new Transaction
{
Amount = transferRequest.Amount,
FromCheckingAccountId = from.Id,
ToCheckingAccountId = to.Id
});
_checkingAccountService.Commit();
response.Data = new TransferResponse {
Balance = from.Balance
};
}
catch (Exception ex)
{
_checkingAccountService.Rollback();
response.AddError(1, "Erro inesperado");
}
return(response);
}
public void given_an_invalid_request_object_controller_should_return_bad_request()
{
var requestObject = new MatProcessData();
var request = new UpdateProcessDataRequest()
{
processDataToUpdate = new MatUpdateProcessData()
};
var validationErrorList = new List <ValidationFailure>();
validationErrorList.Add(new ValidationFailure(faker.Random.Word(), faker.Random.Word()));
var fakeValidationResult = new FV.ValidationResult(validationErrorList); //Need to create ValidationResult so that I could setup Validator mock to return it upon '.Validate()' call. Also this is the only place where it's possible to manipulate the validation result - You can only make the validation result invalid by inserting a list of validation errors as a parameter through a constructor. The boolean '.IsValid' comes from expression 'IsValid => Errors.Count == 0;', so it can't be set manually.
_mockValidatorUpdate.Setup(x => x.Validate(request)).Returns(fakeValidationResult);
var response = _processDataController.UpdateExistingProcessDocument(request);
var okResult = (ObjectResult)response;
var resultContent = okResult.Value;
Assert.NotNull(response);
Assert.NotNull(okResult);
Assert.NotNull(resultContent);
Assert.AreEqual(400, okResult.StatusCode);
}
public void GiveAIdWhichUserHasNoPermission_ShouldThrowException()
{
const int aValidId = 1;
var genres = new List<Genre>
{
new Genre
{
Id = aValidId
}
};
var dbSet = new FakeDbSet<Genre>();
foreach (Genre genre in genres)
{
dbSet.Add(genre);
}
var entitiesContext = A.Fake<IEntitiesContext>();
A.CallTo(() => entitiesContext.Set<Genre>()).Returns(dbSet);
var fakeValidator = A.Fake<IValidator<Genre>>();
var validationFailure = new List<ValidationFailure> { new ValidationFailure("Id", "fake error") };
var validationResult = new ValidationResult(validationFailure);
A.CallTo(() => fakeValidator.Validate(A<Genre>.Ignored)).Returns(validationResult);
var repo = new EntityRepository<Genre>(entitiesContext);
IValidatorFactory factory = A.Fake<IValidatorFactory>();
var fakeMapping = A.Fake<IMappingEngine>();
var genreService = new GenreService(repo, factory, fakeMapping);
//Genre result = genreService.GetGenre(aValidId);
Action act = () => genreService.GetGenre(aValidId);
act.ShouldThrow<ValidationException>();
}
protected override void Context()
{
base.Context();
_createCustomerRequest = Builder<CreateCustomerRequest>.CreateNew().Build();
AuthorizationService.Stub(
x => x.CanExecute(Arg<string>.Is.Equal(Username), Arg<Type>.Is.Equal(typeof (CreateCustomerRequest)))).
Return(true);
_validationResponse = new ValidationResult(new List<ValidationFailure>
{
new ValidationFailure("some property", "some error")
});
CreateCustomerRequestValidator.Stub(
x => x.Validate(Arg<CreateCustomerRequest>.Is.Equal(_createCustomerRequest)))
.Return(_validationResponse);
_expectedResponse = new CreateCustomerResponse(_validationResponse.Errors.Select(x => x.ErrorMessage))
{
Success = false,
};
}
void Validate(object sender, PropertyChangedEventArgs e)
{
validationResult = validator.Validate(target);
foreach (var error in validationResult.Errors)
{
RaiseErrorsChanged(error.PropertyName);
}
}
