public void _08_SaveCustomerButton_Click_ShouldShowAnErrorWhenTheSelectedCustomerIsInvalid()
{
//Arrange
var existingCustomer = new CustomerBuilder().WithId().Build();
AddCustomerToTheGridAndSelectIt(existingCustomer);
_errorTextBlock.Text = "";
var expectedErrorMessage = Guid.NewGuid().ToString();
_customerValidatorMock.Setup(validator => validator.IsValid(It.IsAny <Customer>()))
.Returns(ValidatorResult.Fail(expectedErrorMessage));
//Act
_saveCustomerButton.FireClickEvent();
//Assert
_customerValidatorMock.Verify(validator => validator.IsValid(existingCustomer), Times.Once,
"The validator is not used correctly to check if the customer is valid.");
_customerRepositoryMock.Verify(repo => repo.Update(It.IsAny <Customer>()), Times.Never,
"The 'Update' method of the repository should not have been called.");
_customerRepositoryMock.Verify(repo => repo.Add(It.IsAny <Customer>()), Times.Never,
"The 'Add' method of the repository should not have been called.");
Assert.That(_errorTextBlock.Text, Is.EqualTo(expectedErrorMessage),
"The ErrorTextBlock should contain the error message in de failed ValidatorResult.");
}
public async Task <ValidatorResult> Validate(CreateVisitRequest request)
{
var validationResult = new ValidatorResult();
if (request == null)
{
validationResult.Exception = new ArgumentNullException(nameof(request));
return(validationResult);
}
var restaurant = await restaurantRepository.FindById(request.RestaurantId);
if (restaurant == null)
{
validationResult.Exception = new EntityNotFoundException(typeof(Restaurant), request.RestaurantId);
return(validationResult);
}
var user = await userRepository.FindById(request.UserId);
if (user == null)
{
validationResult.Exception = new EntityNotFoundException(typeof(User), request.UserId);
return(validationResult);
}
return(validationResult);
}
public static ValidatorResult CreateInvalid(string error)
{
ValidatorResult x = new ValidatorResult();
x.Error = error;
return(x);
}
public static MessageModel FromKafkaMessage(KafkaMessageModel kafkaMessage, ValidatorResult result) => new MessageModel()
{
KafkaMessage = kafkaMessage,
FoundInKafka = kafkaMessage != null,
Result = result,
Event = new EventModel(kafkaMessage)
};
public ValidatorResult Validate(string name, object value)
{
var result = new ValidatorResult();
if (value == null)
{
return(result);
}
var script = value.ToString();
if (script == string.Empty)
{
return(result);
}
try {
var program = _jint.Parse(script, _options);
if (program != null && program.Errors != null && program.Errors.Any())
{
result.Valid = false;
foreach (var e in program.Errors)
{
result.Error("{0}, script: {1}...", e.Message, script.Left(30));
}
}
} catch (ParserException ex) {
result.Valid = false;
result.Error("{0}, script: {1}...", ex.Message, script.Left(30));
}
return(result);
}
public Task <ValidatorResult> Validate(UpdateVisitRequest request)
{
return(Task.Factory.StartNew(() =>
{
var validationResult = new ValidatorResult();
if (request == null)
{
validationResult.Exception = new ArgumentNullException(nameof(request));
return validationResult;
}
var visit = visitRepository.FindById(request.Id);
if (visit == null)
{
validationResult.Exception = new EntityNotFoundException(typeof(Visit), request.Id);
return validationResult;
}
var restaurant = restaurantRepository.FindById(request.RestaurantId);
if (restaurant == null)
{
validationResult.Exception = new EntityNotFoundException(typeof(Restaurant), request.RestaurantId);
return validationResult;
}
var user = userRepository.FindById(request.UserId);
if (user == null)
{
validationResult.Exception = new EntityNotFoundException(typeof(User), request.UserId);
return validationResult;
}
return validationResult;
}));
}
public async Task <ValidatorResult> IsSatisfiedAsync(OptionDto option)
{
var result = new ValidatorResult {
IsSatisfied = true
};
if (_option == null)
{
return(result);
}
var allOptions = await _option.FindAsync(new OptionByNameSpecification(option.Name, option.OptionId));
if (allOptions == null ||
!allOptions.Any())
{
return(result);
}
result.IsSatisfied = false;
result.Errors = new List <ValidatorError> {
new ValidatorError {
Code = ErrorCode.DuplicateName,
Detail = new ValidatorErrorDetail {
JsonData = "", Messages = new List <string> {
$"Option duplicate: {option.Name}"
}
},
Type = ValidatorType.Rules,
GeneratorClass = GetType().FullName
}
};
return(result);
}
public async Task <ValidatorResult> Validate(UpdateUserRequest updateUserRequest)
{
var validationResult = new ValidatorResult();
if (updateUserRequest == null)
{
validationResult.Exception = new ArgumentNullException(nameof(updateUserRequest));
return(validationResult);
}
var user = await repository.FindById(updateUserRequest.Id);
if (user == null)
{
validationResult.Exception = new EntityNotFoundException(typeof(User), updateUserRequest.Id);
return(validationResult);
}
var userFoundByEmail = await repository.FindByEmail(updateUserRequest.Email);
var userWithEmailExists = userFoundByEmail != null;
var isUserOwnerOfEmail = userFoundByEmail?.Id == updateUserRequest.Id;
if (userWithEmailExists && !isUserOwnerOfEmail)
{
validationResult.Exception = new EntityAlreadyExistsException(typeof(User), nameof(User.Email), updateUserRequest.Email);
return(validationResult);
}
return(validationResult);
}
public string Post([FromBody] CourseDTO courseDTO)
{
ValidatorResult validatorResult = CourseValidator.IsValidCourse(courseDTO);
if (!validatorResult.IsValid)
{
HttpContext.Response.StatusCode = 422;
return(JsonConvert.SerializeObject(validatorResult.ValidationMessage));
}
Course course = new Course()
{
Name = courseDTO.Name,
Description = courseDTO.Description,
Length = courseDTO.Length,
StartDate = courseDTO.StartDate,
EndDate = courseDTO.EndDate
};
//Add to DB
try
{
northwindContext.Add(course);
northwindContext.SaveChanges();
HttpContext.Response.StatusCode = 200;
return(JsonConvert.SerializeObject("The course is successfully saved."));
}
catch (Exception e)
{
HttpContext.Response.StatusCode = 520;
return(JsonConvert.SerializeObject(e.Message));
}
}
public ValidatorResult Validate()
{
ValidatorResult resultModel = new ValidatorResult();
switch (this._ruleset)
{
case CategoryRuleset.Insert:
resultModel = ValidateInsertRuleset(resultModel);
break;
case CategoryRuleset.Update:
resultModel = ValidateEditRuleset(resultModel);
break;
case CategoryRuleset.Delete:
resultModel = ValidateDeleteRuleset(resultModel);
break;
case CategoryRuleset.Recover:
resultModel = ValidateRecoverRuleset(resultModel);
break;
}
return(resultModel);
}
public ValidatorResult Validate(T validatingObject)
{
var result = new ValidatorResult();
AddErrors(result.Errors, validatingObject);
return(result);
}
protected override ValidatorResult Evaluate()
{
ValidatorResult returnVal = base.Evaluate();
if (returnVal != ValidatorResult.Valid)
{
Item obj = base.GetItem();
ItemLink[] brokenLinks = obj.Links.GetBrokenLinks(false);
//are all the broken links basically because they are contextual?
if (brokenLinks.All(a => a.TargetPath.Contains("$development")))
{
foreach (ItemLink brokenLink in brokenLinks)
{
Database database = Sitecore.Configuration.Factory.GetDatabase("master");
//try again but replacing the varible with a context
var secondTryPath = brokenLink.TargetPath.Replace(
"$development", obj.Paths.Path);
Item secondTryItem = database.GetItem(secondTryPath);
if (secondTryItem == null)
{
return(returnVal);
}
}
//if we've got here then all the links are valid when adding the context
return(ValidatorResult.Valid);
}
}
return(returnVal);
}
public async Task <ValidatorResult> IsSatisfiedAsync(CategoryDto category)
{
var result = new ValidatorResult {
IsSatisfied = true
};
if (_category == null)
{
return(result);
}
var allCategories = await _category.FindAsync(new CategoryByNameSpecification(category.Name, category.CategoryId));
if (allCategories == null ||
!allCategories.Any())
{
return(result);
}
result.IsSatisfied = false;
result.Errors = new List <ValidatorError> {
new ValidatorError {
Code = ErrorCode.DuplicateName,
Detail = new ValidatorErrorDetail {
JsonData = "", Messages = new List <string> {
$"Category duplicate: {category.Name}"
}
},
Type = ValidatorType.Rules,
GeneratorClass = GetType().FullName
}
};
return(result);
}
public async Task <ValidatorResult> Validate(CreateRestaurantRequest request)
{
var validationResult = new ValidatorResult();
if (request == null)
{
validationResult.Exception = new ArgumentNullException(nameof(request));
return(validationResult);
}
var restaurant = await repository.FindRestaurantByNameAndAddress(request.Name, request.Address);
if (restaurant != null)
{
var restaurantValuePairs = new[]
{
new EntityValuePair(nameof(Restaurant.Name), request.Name),
new EntityValuePair(nameof(Restaurant.Address), request.Address)
};
validationResult.Exception = new EntityAlreadyExistsException(typeof(Restaurant), restaurantValuePairs);
return(validationResult);
}
return(validationResult);
}
public async Task <ValidatorResult> IsSatisfiedAsync(ProductDto product)
{
var result = new ValidatorResult {
IsSatisfied = true
};
if (!string.IsNullOrWhiteSpace(product.Name) &&
product.Name.Trim().Length <= 50)
{
return(result);
}
result.IsSatisfied = false;
result.Errors = new List <ValidatorError> {
new ValidatorError {
Code = ErrorCode.LenghtName50,
Detail = new ValidatorErrorDetail {
JsonData = "", Messages = new List <string> {
$"Name lenght min 1 max 50, actual is: {product?.Name?.Length ?? 0}"
}
},
Type = ValidatorType.Rules,
GeneratorClass = GetType().FullName
}
};
return(result);
}
private ValidatorResult ValidateBase(ValidatorResult resultModel)
{
if (CurrentCategorySchema == null)
{
resultModel.Errors.Add(CATEGORY_SCHEMA_NULL_ERROR_MESSAGE);
}
if (this._categoryToValidate.Parent != null)
{
if (this._categoryToValidate.Parent.StartDate > this._categoryToValidate.StartDate)
{
resultModel.Errors.Add(START_DATE_PARENT_ERROR_MESSAGE);
}
if (this._categoryToValidate.Parent.EndDate <= this._categoryToValidate.StartDate)
{
resultModel.Errors.Add(END_DATE_PARENT_ERROR_MESSAGE);
}
if (CurrentCategorySchema != null)
{
CategorySchema parentCategorySchema = FacadeFactory.Instance.CategorySchemaFacade.GetActiveCategorySchema(this._categoryToValidate.Parent.StartDate);
if (parentCategorySchema.Id != CurrentCategorySchema.Id)
{
resultModel.Errors.Add(ANOTHER_SCHEMA_PARENT_ERROR_MESSAGE);
}
}
}
return(resultModel);
}
public static ValidatorResult ValidarTamanhos(this object objeto)
{
var result = new ValidatorResult();
var properties = objeto.GetType().GetProperties();
var erros = new List <ValidatorModel>();
foreach (var csvColumnDef in properties.Where(p => p.CustomAttributes.Any()).Select(propertie => (ValidarAttribute)propertie.GetCustomAttributes(typeof(ValidarAttribute), false).First()))
{
try
{
var val = objeto.GetPropertyValue <string>(csvColumnDef.Nome);
if (val != null && val.Length > csvColumnDef.TamanhoMaximo)
{
erros.Add(new ValidatorModel()
{
Campo = csvColumnDef.Nome,
TamanhoMaximo = csvColumnDef.TamanhoMaximo,
TamanhoReal = val.Length,
Valor = val
});
}
}
catch (Exception)
{
result.IsValid = false;
}
}
if (!erros.Any())
{
return(result);
}
result.IsValid = false;
result.Erros = erros;
return(result);
}
public async Task <ValidatorResult> IsSatisfiedAsync(ProductDto product)
{
var result = new ValidatorResult {
IsSatisfied = true
};
if (_product == null)
{
return(result);
}
var allProducts = await _product.FindAsync(new ProductByNameSpecification(product.Name, product.ProductId));
if (allProducts == null ||
!allProducts.Any())
{
return(result);
}
result.IsSatisfied = false;
result.Errors = new List <ValidatorError> {
new ValidatorError {
Code = ErrorCode.DuplicateName,
Detail = new ValidatorErrorDetail {
JsonData = "", Messages = new List <string> {
$"Name duplicate: {product.Name}"
}
},
Type = ValidatorType.Rules,
GeneratorClass = GetType().FullName
}
};
return(result);
}
public async Task <CoapMessage> ObserveAsync(CoapMessage message)
{
if (!message.Observe.HasValue)
{
//RST because GET needs to be observe/unobserve
await logger?.LogWarningAsync($"CoAP observe received without Observe flag and will return RST for {session.Identity}");
await logger?.LogDebugAsync($"Returning RST because GET needs to be observe/unobserve for {session.Identity}");
return(new CoapResponse(message.MessageId, ResponseMessageType.Reset, ResponseCodeType.EmptyMessage));
}
CoapUri uri = new CoapUri(message.ResourceUri.ToString());
ResponseMessageType rmt = message.MessageType == CoapMessageType.Confirmable ? ResponseMessageType.Acknowledgement : ResponseMessageType.NonConfirmable;
ValidatorResult result = EventValidator.Validate(false, uri.Resource, channel, graphManager);
if (!result.Validated)
{
await logger?.LogErrorAsync($"{result.ErrorMessage} for {session.Identity}");
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Unauthorized, message.Token));
}
if (!message.Observe.Value)
{
//unsubscribe
await logger?.LogInformationAsync($"CoAP unobserve '{message.ResourceUri.ToString()}' for {session.Identity}.");
await adapter.UnsubscribeAsync(uri.Resource);
await logger?.LogDebugAsync($"CoAP unsubscribed '{message.ResourceUri.ToString()} for {session.Identity}'.");
coapObserved.Remove(uri.Resource);
}
else
{
//subscribe
SubscriptionMetadata metadata = new SubscriptionMetadata()
{
IsEphemeral = true,
Identity = session.Identity,
Indexes = session.Indexes
};
await logger?.LogInformationAsync($"CoAP subscribed '{message.ResourceUri.ToString()}' for {session.Identity}");
string subscriptionUriString = await adapter.SubscribeAsync(uri.Resource, metadata);
if (!coapObserved.ContainsKey(uri.Resource)) //add resource to observed list
{
coapObserved.Add(uri.Resource, message.Token);
await logger?.LogDebugAsync("Key added to observable resource.");
}
}
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Valid, message.Token));
}
public override ValidatorResult Validate(MessageModel message)
{
ValidatorResult toReturn = base.Validate(message);
toReturn.Concat(message.RunValidation(new List <(Func <MessageModel, bool> validation, Func <MessageModel, string> message)>()
{
{ Rules.RequiredStringPropertyRule(m => m.OpCo, "OPCO") },
{ Rules.RequiredStringPropertyRule(m => m.Role, "Role") },
public override ValidatorResult Validate(MessageModel message)
{
ValidatorResult toReturn = base.Validate(message);
toReturn.Concat(message.RunValidation(new List <(Func <MessageModel, bool> validation, Func <MessageModel, string> message)>()
{
{ Rules.CategoryValueRule("PDP") },
{ Rules.ActionValueRule("Ad Impression") },
public static ValidatorResult CreateValid(T result)
{
ValidatorResult x = new ValidatorResult();
x.Error = string.Empty;
x.ValidResult = result;
return(x);
}
protected override ValidatorResult Validate()
{
if (!File.Exists(Input))
{
return(ValidatorResult.CreateInvalid(Global.GetStringResource("StringFileNotExists")));
}
return(ValidatorResult.CreateValid(Input));
}
static public DrawOptionsResult GetResult(ValidatorResult result)
{
return(new DrawOptionsResult()
{
backgroundItem = GetColorItemBackground(result.isItemValid, result.isItemAllError),
BackgroundKey = GetColorPartBackground(result.isKeyValid, result.isItemValid, result.isItemAllError),
BackgroundValue = GetColorPartBackground(result.isValueValid, result.isItemValid, result.isItemAllError)
});
}
public void Validator_CheckValues_Pass()
{
var validator = new Validator();
var expected = new ValidatorResult() { IsValid = true, Error = null };
var result = validator.CheckValues("12", "1", "10", "20");
Assert.AreEqual(expected.IsValid, result.IsValid);
}
public override ValidatorResult Validate(MessageModel message)
{
ValidatorResult toReturn = base.Validate(message);
toReturn.Concat(message.RunValidation(new List <(Func <MessageModel, bool> validation, Func <MessageModel, string> message)>()
{
{ Rules.CategoryValueRule("Cart") },
{ Rules.ActionValueRule("Quantity Change") }
}));
public override ValidatorResult Validate(MessageModel message)
{
ValidatorResult toReturn = base.Validate(message);
toReturn.Concat(message.RunValidation(new List <(Func <MessageModel, bool> validation, Func <MessageModel, string> message)>()
{
}));
return(toReturn);
}
public override ValidatorResult Validate(MessageModel message)
{
ValidatorResult toReturn = base.Validate(message);
toReturn.Concat(message.RunValidation(new List <(Func <MessageModel, bool> validation, Func <MessageModel, string> message)>()
{
//{ ( validation: m => m.EventId > 0 , message: "Event Id is not set" ) }
}));
return(toReturn);
}
public void Validator_CheckValues_Fail_Aphanumeric()
{
var validator = new Validator();
var expected = new ValidatorResult() { IsValid = false, Error = "The following values are invalid: Height" };
var result = validator.CheckValues("12", "A1", "10", "20");
Assert.AreEqual(expected.IsValid, result.IsValid);
Assert.AreEqual(expected.Error, result.Error);
}
public void Validator_CheckValues_Fail_NegativeValues()
{
var validator = new Validator();
var expected = new ValidatorResult() { IsValid = false, Error = "The following values are invalid: Width" };
var result = validator.CheckValues("12", "1", "-10", "20");
Assert.AreEqual(expected.IsValid, result.IsValid);
Assert.IsNotNull(expected.Error, result.Error);
}
public bool Equals(ValidatorResult other)
{
if (ReferenceEquals(null, other)) return false;
if (ReferenceEquals(this, other)) return true;
return other.successful.Equals(successful) && Equals(other.failure_message, failure_message);
}
