private void _postValidate()
{
Extensions.WriteColoredLine("Post-validation: ", ConsoleColor.DarkCyan);
var validator = new PostValidator(new List <IPostValidationStep>
{
new GlobalIdentifiersAreUnique(),
new ObjectIdentifiersAreUnique(),
new UtilityIdentifiersAreUnique()
});
var postValidationResult = validator.Validate(_tree);
if (Verbose)
{
foreach (var validationStepResult in validator.Results)
{
Extensions.WriteColoredLine(" - " + validationStepResult.Output, validationStepResult.Valid ? ConsoleColor.DarkGreen : ConsoleColor.Red);
}
}
Console.WriteLine();
Console.WriteLine(postValidationResult ? $"Post-validation for `{_name}` successful" : $"Post-validation for {_name} failed!");
Console.WriteLine();
if (postValidationResult == false)
{
throw new PostValidationException("EInterpreter stopped before execution because of failing Post-validation");
}
}
public void ValidationShouldFail_UtilityIdentifiersAreUnique()
{
// arrange
var validator = new PostValidator(new List <IPostValidationStep> {
new UtilityIdentifiersAreUnique()
});
// act
var result = validator.Validate(new ETree
{
Utilities = new List <EUtility>
{
new EUtility("Test")
{
Functions = new List <EFunction>
{
new EFunction("void", "Test1", null),
new EFunction("void", "Test1", null)
}
}
}
});
// assert
Assert.IsFalse(result);
}
protected void ValidateResource(TResource resource, bool skipValidate = false, bool skipSharedValidate = false)
{
if (resource == null)
{
throw new BadRequestException("Request body can't be empty");
}
var errors = new List <ValidationFailure>();
if (!skipSharedValidate)
{
errors.AddRange(SharedValidator.Validate(resource).Errors);
}
if (Request.Method.Equals("POST", StringComparison.InvariantCultureIgnoreCase) && !skipValidate && !Request.Path.ToString().EndsWith("/test", StringComparison.InvariantCultureIgnoreCase))
{
errors.AddRange(PostValidator.Validate(resource).Errors);
}
else if (Request.Method.Equals("PUT", StringComparison.InvariantCultureIgnoreCase))
{
errors.AddRange(PutValidator.Validate(resource).Errors);
}
if (errors.Any())
{
throw new ValidationException(errors);
}
}
protected TResource ReadResourceFromRequest()
{
//TODO: handle when request is null
var resource = Request.Body.FromJson <TResource>();
if (resource == null)
{
throw new BadRequestException("Request body can't be empty");
}
var errors = SharedValidator.Validate(resource).Errors.ToList();
if (Request.Method.Equals("POST", StringComparison.InvariantCultureIgnoreCase))
{
errors.AddRange(PostValidator.Validate(resource).Errors);
}
else if (Request.Method.Equals("PUT", StringComparison.InvariantCultureIgnoreCase))
{
errors.AddRange(PutValidator.Validate(resource).Errors);
}
if (errors.Any())
{
throw new ValidationException(errors);
}
return(resource);
}
public void ValidationShouldFail_ObjectIdentifiersAreUnique()
{
// arrange
var validator = new PostValidator(new List <IPostValidationStep> {
new ObjectIdentifiersAreUnique()
});
// act
var result = validator.Validate(new ETree
{
Objects = new List <EObject>
{
new EObject("Test")
{
Properties = new List <EProperty>
{
new EProperty("test", "Test1"),
new EProperty("test", "Test1")
}
}
}
});
// assert
Assert.IsFalse(result);
}
public PostResource AddPost(PostDto postDto)
{
#region Checks
if (postDto == null)
{
throw new PostCannotBeNullException();
}
var postValidator = new PostValidator();
var validationResult = postValidator.Validate(postDto);
if (!validationResult.IsValid)
{
throw new PostIsNotValidException(validationResult.Errors.First().ErrorMessage);
}
#endregion
var newPost = _mapper.Map <Post>(postDto);
_context.Posts.Add(newPost);
_context.SaveChanges();
var postResource = _mapper.Map <PostResource>(newPost);
return(postResource);
}
public async Task <IActionResult> PostAsync([FromBody] SavePostResource resPost)
{
var Post = _mapper.Map <SavePostResource, Post>(resPost);
var validator = new PostValidator();
var results = validator.Validate(Post);
results.AddToModelState(ModelState, null);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _PostService.SaveAsync(Post);
if (!result.Success)
{
return(BadRequest(new ErrorResource(result.Message)));
}
var PostResource = _mapper.Map <Post, PostResource>(result.Resource);
return(Ok(PostResource));
}
public void ValidationShouldSucceed_Empty()
{
// arrange
var validator = new PostValidator(new List <IPostValidationStep>());
// act
var result = validator.Validate(new ETree());
// assert
Assert.IsTrue(result, "Validation should succeed if no steps are specified");
}
public void GivenAPostObject_WithUrlWithoutScheme_IsValidReturnsFalse(string url)
{
//Arrange
var post = GetPostObject(url: url);
//Act
var result = PostValidator.Validate(post);
//Assert
result.Should().BeFalse();
}
public void GivenAPostObject_WithAllValidData_IsValidReturnsTrue()
{
//Arrange
var post = GetPostObject();
//Act
var result = PostValidator.Validate(post);
//Assert
result.Should().BeTrue();
}
public void GivenAPostObject_WithDescendantsSetToZero_IsValidReturnsTrue()
{
//Arrange
var descendants = 0;
var post = GetPostObject(descendants: descendants);
//Act
var result = PostValidator.Validate(post);
//Assert
result.Should().BeTrue();
}
public void GivenAPostObject_WithDescendantsSetToNegativeInteger_IsValidReturnsFalse()
{
//Arrange
var descendants = -12;
var post = GetPostObject(descendants: descendants);
//Act
var result = PostValidator.Validate(post);
//Assert
result.Should().BeFalse();
}
public void GivenAPostObject_WithTypeSetToJob_IsValidReturnsFalse()
{
//Arrange
var type = "job";
var post = GetPostObject(type: type);
//Act
var result = PostValidator.Validate(post);
//Assert
result.Should().BeFalse();
}
public void GivenAPostObject_WithScoreSetToZero_IsValidReturnsTrue()
{
//Arrange
var score = 0;
var post = GetPostObject(score: score);
//Act
var result = PostValidator.Validate(post);
//Assert
result.Should().BeTrue();
}
public void GivenAPostObject_WithScoreSetToNegativeInteger_IsValidReturnsFalse()
{
//Arrange
var score = -12;
var post = GetPostObject(score: score);
//Act
var result = PostValidator.Validate(post);
//Assert
result.Should().BeFalse();
}
public void GivenAPostObject_WithByGreaterThan256Chars_IsValidReturnsFalse()
{
//Arrange
var longName = $"{new string('a', 135)} {new string('b', 135)}";
var post = GetPostObject(by: longName);
//Act
var result = PostValidator.Validate(post);
//Assert
result.Should().BeFalse();
}
public void GivenAPostObject_WithTitleGreaterThan256Chars_IsValidReturnsFalse()
{
//Arrange
var longTitle = new string('a', 257);
var post = GetPostObject(title: longTitle);
//Act
var result = PostValidator.Validate(post);
//Assert
result.Should().BeFalse();
}
public void ValidationShouldFail_GlobalIdentifiersAreUnique()
{
// arrange
var validator = new PostValidator(new List <IPostValidationStep> {
new GlobalIdentifiersAreUnique()
});
// act
var result = validator.Validate(new ETree {
Constants = new List <EConstant> {
new EConstant("test", "Test1", "")
}, Utilities = new List <EUtility> {
new EUtility("Test1")
}
});
// assert
Assert.IsFalse(result);
}
protected TResource ReadResourceFromRequest(bool skipValidate = false, bool skipSharedValidate = false)
{
var resource = new TResource();
try
{
resource = Request.Body.FromJson <TResource>();
}
catch (JsonReaderException ex)
{
throw new BadRequestException(ex.Message);
}
if (resource == null)
{
throw new BadRequestException("Request body can't be empty");
}
var errors = new List <ValidationFailure>();
if (!skipSharedValidate)
{
errors.AddRange(SharedValidator.Validate(resource).Errors);
}
if (Request.Method.Equals("POST", StringComparison.InvariantCultureIgnoreCase) && !skipValidate && !Request.Url.Path.EndsWith("/test", StringComparison.InvariantCultureIgnoreCase))
{
errors.AddRange(PostValidator.Validate(resource).Errors);
}
else if (Request.Method.Equals("PUT", StringComparison.InvariantCultureIgnoreCase))
{
errors.AddRange(PutValidator.Validate(resource).Errors);
}
if (errors.Any())
{
throw new ValidationException(errors);
}
return(resource);
}
protected void Page_Load(object sender, EventArgs e)
{
if (Page.IsPostBack)
{
PostValidator validator = new PostValidator();
Post entity = new Post()
{
// Map form fields to entity properties
Id = Convert.ToInt32(PostId.Value),
Title = PostTitle.Text.Trim(),
Body = PostBody.Text.Trim()
};
ValidationResult results = validator.Validate(entity);
if (results.IsValid)
{
// Save to the database and continue to the next page
}
else
{
BulletedList summary = (BulletedList)FindControl("ErrorSummary");
// Display errors to the user
foreach (var failure in results.Errors)
{
Label errorMessage = FindControl(failure.PropertyName + "Error") as Label;
if (errorMessage == null)
{
summary.Items.Add(new ListItem(failure.ErrorMessage));
}
else
{
errorMessage.Text = failure.ErrorMessage;
}
}
}
}
else
{
// Display form
}
}
public IActionResult AddWithCustomeValidationResponse()
{
PostValidator validator = new PostValidator();
List <string> ValidationMessages = new List <string>();
var tester = new Post
{
Title = "Ok",
Description = "",
CreatedBy = "1",
};
var validationResult = validator.Validate(tester);
var response = new ResponseModel();
if (!validationResult.IsValid)
{
response.IsValid = false;
foreach (ValidationFailure failure in validationResult.Errors)
{
ValidationMessages.Add(failure.ErrorMessage);
}
response.ValidationMessages = ValidationMessages;
}
return(Ok(response));
}
public override ValidationResult Validate()
{
var validation = new PostValidator();
return(validation.Validate(this));
}
public async Task<GenericOperationResult<bool>> AddPost(PostDto postDto, string host)
{
//Validate model
var result = new GenericOperationResult<bool>();
var postValidator = new PostValidator();
var res = postValidator.Validate(postDto);
if (res.IsValid)
{
try
{
int userId = int.Parse(httpContext.HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier));
if (postDto.Image != null)
{
var path = await uploadFile.UploadImage(postDto.Image, host);
if (path != null)
{
postDto.ImageUrl = path;
}
else
{
result.Messages.Add("Invalid image type");
result.Status = OperationResultStatusEnum.Exception;
return result;
}
}
Post createPost = MapPost(postDto);
createPost.UserId = userId;
unitOfWork.PostRepository.Create(createPost);
if (unitOfWork.SaveChanges())
{
result.Data = true;
result.Messages.Add("your post has been added ");
result.Status = OperationResultStatusEnum.Succeeded;
return result;
}
else
{
result.Data = false;
result.Messages.Add("Sorry your post couldn't be uploaded try again!!");
result.Status = OperationResultStatusEnum.Failed;
return result;
}
}
catch (NullReferenceException nullEx)
{
throw new BusinessException("Null Refrence exception", nullEx);
}
catch (IndexOutOfRangeException outOfRangeEx)
{
throw new BusinessException("Out of range exception exception", outOfRangeEx);
}
catch (SqlException sqlEx)
{
throw new BusinessException("Sql Exception exception", sqlEx);
}
catch (Exception e)
{
throw new BusinessException("error Occured ", e);
}
}
result.Data = false;
result.Messages = res.Errors.Select(e => e.ErrorMessage).ToList();
result.Status = OperationResultStatusEnum.Failed;
return result;
}
/// <summary>
/// Method to validate model
/// </summary>
/// <returns>Returns the result of validation</returns>
protected override FluentValidation.Results.ValidationResult Validate()
{
var validator = new PostValidator();
return(validator.Validate(this));
}
