public void Ensure_Context_Is_Validated()
{
var context = Tuple.Create("Name here", "Value here");
var contextDictionary = new Dictionary <object, object>();
contextDictionary.Add(context.Item1, context.Item2);
var testContext = new TestContext();
testContext.KeyName = context.Item1;
testContext.RunTimeType = typeof(string);
testContext.Value = "Different Value";
var result = ValidationHandler.Validate(testContext, contextDictionary);
Assert.IsNotNull(result);
Assert.AreEqual(1, result.Count);
testContext.RunTimeType = typeof(object);
testContext.Value = context.Item2; //set back to original
result = ValidationHandler.Validate(testContext, contextDictionary);
Assert.IsNotNull(result);
Assert.AreEqual(1, result.Count);
contextDictionary.Remove(context.Item1);
result = ValidationHandler.Validate(testContext, contextDictionary);
Assert.IsNotNull(result);
Assert.AreEqual(1, result.Count);
}
public void Ensure_Context_Handles_Nulls()
{
var testContext = new TestContext();
testContext.KeyName = "Name here";
testContext.RunTimeType = typeof(string);
testContext.Value = "Value here";
var result = ValidationHandler.Validate(testContext, null);
}
public void Validate_BasicObject_Valid()
{
var obj = new BasicValidationObject()
{
StringProperty = "Some String", EmailProperty = "*****@*****.**", IntegerProperty = 3
};
var result = ValidationHandler.Validate(obj);
Assert.IsTrue(result == null);
}
public void DataAttribute_Valid()
{
var obj = new UnitTestModel()
{
Name = "F#"
};
var result = ValidationHandler.Validate(obj);
Assert.IsNull(result);
}
public void Parent_Child_Validators_Error()
{
var metalGizmo = new MetalGizmo();
var expectedErrorCount = 2;
var result = ValidationHandler.Validate(metalGizmo);
Assert.IsNotNull(result);
Assert.AreEqual(expectedErrorCount, result.Count());
}
public void ValidationLoader_AttributeTest_Invalid()
{
var obj = new DomainObject17();
obj.ID = -5;
var result = ValidationHandler.Validate(obj);
Assert.IsNotNull(result);
Assert.IsNotNull(result.FirstOrDefault(x => x.MemberNames.Any(y => y == "ID")));
}
public void Parent_Child_Validator_No_Error()
{
var metalGizmo = new MetalGizmo()
{
ID = "1", Alloy = "iron"
};
var result = ValidationHandler.Validate(metalGizmo);
Assert.IsNull(result, "Validation have errors");
}
public void ValidationLoader_AttributeTest_Valid()
{
var obj = new DomainObject17();
obj.ID = 5;
var r = ValidationHandler.Validate(obj);
var sum = ValidationSummary.Map(r);
Assert.IsNull(r, "Validation Object returned not null for model with validation attributes");
Assert.IsNotNull(sum.Errors.Count == 0);
}
public void Validate_BasicObject_Invalid()
{
var obj = new BasicValidationObject();
var result = ValidationHandler.Validate(obj);
Assert.IsTrue(result.Count() > 0);
Assert.AreEqual(3, result.Count());
Assert.AreEqual("Required", ((ValidationPathResult)result[0]).Type);
Assert.AreEqual("Range", ((ValidationPathResult)result[1]).Type);
Assert.AreEqual("Required", ((ValidationPathResult)result[2]).Type);
}
public void Validate_NestedObject_Invalid()
{
var obj = new NestedValidationObject();
obj.NestedObject = new BasicValidationObject();
//n.NestedObject.SubNest = null;
var r = ValidationHandler.Validate(obj);
Assert.IsTrue(r.Count() > 0);
Assert.AreEqual(4, r.Count());
}
public void Validate_NestedDictionaryObject_Invalid2()
{
var obj = new NestedDictionaryValidationObject <string>();
obj.GuidID = Guid.NewGuid().ToString();
obj.NestedDictionary.Add("1", BasicValidationObject.Valid);
obj.NestedDictionary.Add("13", BasicValidationObject.Invalid);
var r = ValidationHandler.Validate(obj);
Assert.IsNotNull(r);
Assert.IsNotNull(r.FirstOrDefault(x => x.MemberNames.Any(y => y == "NestedDictionary[\"13\"].EmailProperty")));
}
public void DataAttribute_Invalid()
{
var obj = new UnitTestModel()
{
Name = "<forbidden phrase>"
};
var result = ValidationHandler.Validate(obj);
Assert.IsNotNull(result);
Assert.IsTrue(result.Any(x => x.ErrorMessage.Contains("<forbidden phrase>")));
Assert.IsTrue(result.Any(x => x.MemberNames.Any(n => n == "Name")));
}
public void Validate_NestedObject_Valid()
{
var obj = new NestedValidationObject();
obj.GuidID = Guid.NewGuid().ToString();
obj.NestedObject = new BasicValidationObject()
{
StringProperty = "Some String", EmailProperty = "*****@*****.**", IntegerProperty = 3
};
var r = ValidationHandler.Validate(obj);
Assert.IsTrue(r == null);
}
public bool Validate(string password)
{
bool hasPassedValidation = _handler.Validate(password);
if (IsEndOfChain)
{
return(hasPassedValidation);
}
if (hasPassedValidation)
{
return(Successor.Validate(password));
}
return(false);
}
public void Validate_NestedListObject_Invalid()
{
var obj = new NestedListValidationObject();
obj.NestedObject = new List <BasicValidationObject>();
obj.NestedObject.Add(BasicValidationObject.Valid);
obj.NestedObject.Add(BasicValidationObject.Invalid);
obj.NestedObject.Add(BasicValidationObject.Valid);
var r = ValidationHandler.Validate(obj);
Assert.IsTrue(r.Count() > 0);
Assert.AreEqual(4, r.Count());
Assert.IsNotNull(r.FirstOrDefault(x => x.MemberNames.Any(y => y == "NestedObject[1].EmailProperty")));
}
protected override async Task <CommandResponse <Submission> > ExecuteStage(CommandStage stage, CommandResponse <Submission> previous)
{
switch (stage)
{
case CommandStage.OnValidation:
var results = ValidationHandler.Validate(_userSubmission);
if (!results.IsNullOrEmpty())
{
return(CommandResponse.Invalid <Submission>(results));
}
break;
}
return(await base.ExecuteStage(stage, previous));
}
public void Parent_Validators_Error()
{
var metalGizmo = new MetalGizmo()
{
Alloy = "iron"
};
var expectedErrorCount = 1;
var expectedErrorMssg = "ID is empty";
var result = ValidationHandler.Validate(metalGizmo);
Assert.IsNotNull(result, "Validation for {0} fail", metalGizmo.ID);
Assert.AreEqual(expectedErrorCount, result.Count());
Assert.AreEqual(expectedErrorMssg, result.FirstOrDefault().ErrorMessage);
}
public VoatValidationTests()
: base(new Func <object, ValidationContext, List <ValidationResult>, bool, bool>((o, v, l, b) =>
{
var result = ValidationHandler.Validate(o);
if (result != null)
{
result.ToList().ForEach(x => l.Add(new ValidationResult(x.ErrorMessage, new List <string> {
x.MemberNames.First()
})));
}
return(l.Count() == 0);
}))
{ }
public override ValidationResult Validate(Entity target, object fieldValue)
{
if (handler.Validate(fieldValue))
{
return(Success());
}
if (Min == null)
{
return(Error(string.Format(Strings.ValueShouldNotBeGreaterThanMax, Max), fieldValue));
}
if (Max == null)
{
return(Error(string.Format(Strings.ValueShouldNotBeLessThanMin, Min), fieldValue));
}
return(Error(string.Format(Strings.ValueShouldNotBeLessThanMinOrGreaterThanMax, Min, Max), fieldValue));
}
public void Ensure_Context_Is_Persisted()
{
var context = Tuple.Create("Name here", "Value here");
var contextDictionary = new Dictionary <object, object>();
contextDictionary.Add(context.Item1, context.Item2);
var testContext = new TestContext();
testContext.KeyName = context.Item1;
testContext.RunTimeType = typeof(string);
testContext.Value = context.Item2;
var result = ValidationHandler.Validate(testContext, contextDictionary);
Assert.IsNull(result);
}
public void Validation_Nested_List_Cast_To_BaseType()
{
var input = "This is a long string that should not pass validation so we are going to continue rambling on and on for a while meow";
var obj = new NestedListValidationObject();
obj.NestedObject.Add(new BasicValidationObject()
{
StringProperty = input, EmailProperty = "invalid email", IntegerProperty = 45
});
obj.NestedObject.Add(new ExtendedBasicValidationObject()
{
StringProperty = input, EmailProperty = "invalid email", IntegerProperty = 45
});
obj.GuidID = "Not A Guid";
var results = ValidationHandler.Validate(obj);
Assert.AreEqual("NestedObject[1].ExtendedProperty", results[4].MemberNames.First());
}
public void ValidationLoader_AttributeTest_BadTypeName()
{
var obj = new DomainObjectError();
var result = ValidationHandler.Validate(obj);
}
public void Pathing_Tests_IValidatableObject()
{
Nested <NestedSubType> n;
n = new Nested <NestedSubType>();
n.Options = new List <NestedSubType> {
new NestedSubType()
{
ReturnValidationError = false
},
new NestedSubType()
{
ReturnValidationError = false
}
};
var result = ValidationHandler.Validate(n, new Dictionary <object, object>(), false);
Assert.IsNull(result);
n = new Nested <NestedSubType>();
n.Options = new List <NestedSubType> {
new NestedSubType()
{
ReturnValidationError = true, UseValidationPathResult = true
},
new NestedSubType()
{
ReturnValidationError = true, UseValidationPathResult = true
}
};
result = ValidationHandler.Validate(n, new Dictionary <object, object>(), false);
Assert.IsNotNull(result);
for (int i = 0; i < result.Count; i++)
{
Assert.AreEqual($"Options[{i}].UserName", result[i].MemberNames.FirstOrDefault());
}
n = new Nested <NestedSubType>();
n.Options = new List <NestedSubType> {
new NestedSubType()
{
ReturnValidationError = true, UseValidationPathResult = false
},
new NestedSubType()
{
ReturnValidationError = true, UseValidationPathResult = false
}
};
result = ValidationHandler.Validate(n, new Dictionary <object, object>(), false);
Assert.IsNotNull(result);
for (int i = 0; i < result.Count; i++)
{
Assert.AreEqual($"Options[{i}].UserName", result[i].MemberNames.FirstOrDefault());
}
n = new Nested <NestedSubType>();
n.Options = new List <NestedSubType> {
new NestedSubType()
{
ReturnValidationError = false
},
};
n.Options[0].EndlessNesting.Add(new NestedSubType()
{
ReturnValidationError = true, UseValidationPathResult = true
});
n.Options[0].EndlessNesting.Add(new NestedSubType()
{
ReturnValidationError = false, UseValidationPathResult = true
});
n.Options[0].EndlessNesting.Add(new NestedSubType()
{
ReturnValidationError = true, UseValidationPathResult = true
});
result = ValidationHandler.Validate(n, new Dictionary <object, object>(), false);
Assert.IsNotNull(result);
Assert.AreEqual(2, result.Count);
Assert.AreEqual($"Options[0].EndlessNesting[0].UserName", result[0].MemberNames.FirstOrDefault());
Assert.AreEqual($"Options[0].EndlessNesting[2].UserName", result[1].MemberNames.FirstOrDefault());
}
public void Pathing_Tests_IValidatableObject_BaseType()
{
Nested <NestedSubTypeBase> n;
//var t = AttributeFinder.FindValidatableProperties(typeof(NestedSubType));
//t.First().Item1.GetCustomAttributes(
n = new Nested <NestedSubTypeBase>();
n.Options = new List <NestedSubTypeBase> {
new NestedSubType()
{
ReturnValidationError = false
},
new NestedSubType()
{
ReturnValidationError = false
}
};
var result = ValidationHandler.Validate(n, new Dictionary <object, object>(), false);
Assert.IsNull(result);
n = new Nested <NestedSubTypeBase>();
n.Options = new List <NestedSubTypeBase> {
new NestedSubType()
{
ReturnValidationError = true, UseValidationPathResult = true
},
new NestedSubType()
{
ReturnValidationError = true, UseValidationPathResult = true
}
};
result = ValidationHandler.Validate(n, new Dictionary <object, object>(), false);
Assert.IsNotNull(result);
for (int i = 0; i < result.Count; i++)
{
Assert.AreEqual($"Options[{i}].UserName", result[i].MemberNames.FirstOrDefault());
}
n = new Nested <NestedSubTypeBase>();
n.Options = new List <NestedSubTypeBase> {
new NestedSubType()
{
ReturnValidationError = true, UseValidationPathResult = false
},
new NestedSubType()
{
ReturnValidationError = true, UseValidationPathResult = false
}
};
result = ValidationHandler.Validate(n, new Dictionary <object, object>(), false);
Assert.IsNotNull(result);
for (int i = 0; i < result.Count; i++)
{
Assert.AreEqual($"Options[{i}].UserName", result[i].MemberNames.FirstOrDefault());
}
//n = new Nested<NestedSubTypeBase>();
//n.Options = new List<NestedSubTypeBase> {
// new NestedSubType() { ReturnValidationError = false},
//};
//n.Options[0].EndlessNesting.Add(new NestedSubType() { ReturnValidationError = true, UseValidationPathResult = true });
//n.Options[0].EndlessNesting.Add(new NestedSubType() { ReturnValidationError = false, UseValidationPathResult = true });
//n.Options[0].EndlessNesting.Add(new NestedSubType() { ReturnValidationError = true, UseValidationPathResult = true });
//result = ValidationHandler.Validate(n, new Dictionary<object, object>(), false);
//Assert.IsNotNull(result);
//Assert.AreEqual(2, result.Count);
//Assert.AreEqual($"Options[0].EndlessNesting[0].UserName", result[0].MemberNames.FirstOrDefault());
//Assert.AreEqual($"Options[0].EndlessNesting[2].UserName", result[1].MemberNames.FirstOrDefault());
}
/// <summary>
/// Run validation event to perform custom validations
/// </summary>
/// <param name="validationResults">Object to contain any validation errors/warnings</param>
/// <returns>Value indicating if the form is valid or not</returns>
public override async Task RunValidation(object data, ModelStateDictionary validationResults)
{
await _validationHandler.Validate(data, validationResults);
}
