1235 lines
40 KiB
C#
1235 lines
40 KiB
C#
//
|
|
// Authors:
|
|
// Marek Habersack <grendel@twistedcode.net>
|
|
//
|
|
// Copyright (C) 2011 Novell, Inc. (http://novell.com/)
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining
|
|
// a copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel.DataAnnotations;
|
|
using System.Text;
|
|
|
|
using NUnit.Framework;
|
|
|
|
namespace MonoTests.System.ComponentModel.DataAnnotations
|
|
{
|
|
[TestFixture]
|
|
public class ValidatorTest
|
|
{
|
|
[Test]
|
|
public void TryValidateObject_Object_ValidationContext_ICollection_01 ()
|
|
{
|
|
var dummy = new DummyNoAttributes ();
|
|
var ctx = new ValidationContext (dummy, null, null);
|
|
var results = new List<ValidationResult> ();
|
|
|
|
Assert.Throws<ArgumentNullException> (() => {
|
|
Validator.TryValidateObject (null, ctx, results);
|
|
}, "#A1-1");
|
|
|
|
Assert.Throws<ArgumentNullException> (() => {
|
|
Validator.TryValidateObject (dummy, null, results);
|
|
}, "#A1-2");
|
|
|
|
bool valid = Validator.TryValidateObject (dummy, ctx, null);
|
|
Assert.IsTrue (valid, "#A2-1");
|
|
Assert.IsTrue (results.Count == 0, "#A2-2");
|
|
}
|
|
|
|
[Test]
|
|
public void TryValidateObject_Object_ValidationContext_ICollection_02 ()
|
|
{
|
|
var dummy = new Dummy ();
|
|
var ctx = new ValidationContext (dummy, null, null);
|
|
var results = new List<ValidationResult> ();
|
|
|
|
bool valid = Validator.TryValidateObject (dummy, ctx, results);
|
|
Assert.IsTrue (valid, "#A1-1");
|
|
Assert.AreEqual (0, results.Count, "#A1-2");
|
|
|
|
dummy = new Dummy {
|
|
NameField = null
|
|
};
|
|
Assert.Throws<ArgumentException> (() => {
|
|
// The instance provided must match the ObjectInstance on the ValidationContext supplied.
|
|
valid = Validator.TryValidateObject (dummy, ctx, results);
|
|
}, "#A2");
|
|
|
|
// Fields are ignored
|
|
ctx = new ValidationContext (dummy, null, null);
|
|
valid = Validator.TryValidateObject (dummy, ctx, results);
|
|
Assert.IsTrue (valid, "#A3-1");
|
|
Assert.AreEqual (0, results.Count, "#A3-2");
|
|
|
|
// Required properties existence is validated
|
|
dummy = new Dummy {
|
|
RequiredDummyField = null
|
|
};
|
|
ctx = new ValidationContext (dummy, null, null);
|
|
valid = Validator.TryValidateObject (dummy, ctx, results);
|
|
Assert.IsTrue (valid, "#A4-1");
|
|
Assert.AreEqual (0, results.Count, "#A4-2");
|
|
|
|
dummy = new Dummy {
|
|
RequiredDummyProperty = null
|
|
};
|
|
ctx = new ValidationContext (dummy, null, null);
|
|
valid = Validator.TryValidateObject (dummy, ctx, results);
|
|
Assert.IsFalse (valid, "#A5-1");
|
|
Assert.AreEqual (1, results.Count, "#A5-2");
|
|
|
|
results.Clear ();
|
|
|
|
// validation attributes other than Required are ignored
|
|
dummy = new Dummy {
|
|
NameProperty = null
|
|
};
|
|
ctx = new ValidationContext (dummy, null, null);
|
|
valid = Validator.TryValidateObject (dummy, ctx, results);
|
|
Assert.IsTrue (valid, "#A6-1");
|
|
Assert.AreEqual (0, results.Count, "#A6-2");
|
|
|
|
dummy = new Dummy {
|
|
MinMaxProperty = 0
|
|
};
|
|
ctx = new ValidationContext (dummy, null, null);
|
|
valid = Validator.TryValidateObject (dummy, ctx, results);
|
|
Assert.IsTrue (valid, "#A7-1");
|
|
Assert.AreEqual (0, results.Count, "#A7-2");
|
|
|
|
dummy = new Dummy {
|
|
FailValidation = true
|
|
};
|
|
ctx = new ValidationContext (dummy, null, null);
|
|
valid = Validator.TryValidateObject (dummy, ctx, results);
|
|
Assert.IsFalse (valid, "#A8-1");
|
|
Assert.AreEqual (1, results.Count, "#A8-2");
|
|
}
|
|
|
|
[Test]
|
|
public void TryValidateObject_Object_ValidationContext_ICollection_Bool_01 ()
|
|
{
|
|
var dummy = new DummyNoAttributes ();
|
|
var ctx = new ValidationContext (dummy, null, null);
|
|
var results = new List<ValidationResult> ();
|
|
|
|
Assert.Throws<ArgumentNullException> (() => {
|
|
Validator.TryValidateObject (null, ctx, results, false);
|
|
}, "#A1-1");
|
|
|
|
Assert.Throws<ArgumentNullException> (() => {
|
|
Validator.TryValidateObject (dummy, null, results, false);
|
|
}, "#A1-2");
|
|
|
|
bool valid = Validator.TryValidateObject (dummy, ctx, null, false);
|
|
Assert.IsTrue (valid, "#A2-1");
|
|
Assert.IsTrue (results.Count == 0, "#A2-2");
|
|
|
|
valid = Validator.TryValidateObject (dummy, ctx, null, true);
|
|
Assert.IsTrue (valid, "#A3-1");
|
|
Assert.IsTrue (results.Count == 0, "#A3-2");
|
|
}
|
|
|
|
[Test]
|
|
public void TryValidateObject_Object_ValidationContext_ICollection_Bool_02 ()
|
|
{
|
|
var dummy = new Dummy ();
|
|
var ctx = new ValidationContext (dummy, null, null);
|
|
var results = new List<ValidationResult> ();
|
|
|
|
bool valid = Validator.TryValidateObject (dummy, ctx, results, false);
|
|
Assert.IsTrue (valid, "#A1-1");
|
|
Assert.AreEqual (0, results.Count, "#A1-2");
|
|
|
|
valid = Validator.TryValidateObject (dummy, ctx, results, true);
|
|
Assert.IsTrue (valid, "#A1-3");
|
|
Assert.AreEqual (0, results.Count, "#A1-4");
|
|
|
|
dummy = new Dummy {
|
|
NameField = null
|
|
};
|
|
Assert.Throws<ArgumentException> (() => {
|
|
// The instance provided must match the ObjectInstance on the ValidationContext supplied.
|
|
valid = Validator.TryValidateObject (dummy, ctx, results, false);
|
|
}, "#A2-1");
|
|
|
|
Assert.Throws<ArgumentException> (() => {
|
|
// The instance provided must match the ObjectInstance on the ValidationContext supplied.
|
|
valid = Validator.TryValidateObject (dummy, ctx, results, true);
|
|
}, "#A2-2");
|
|
|
|
// Fields are ignored
|
|
ctx = new ValidationContext (dummy, null, null);
|
|
valid = Validator.TryValidateObject (dummy, ctx, results, false);
|
|
Assert.IsTrue (valid, "#A3-1");
|
|
Assert.AreEqual (0, results.Count, "#A3-2");
|
|
|
|
valid = Validator.TryValidateObject (dummy, ctx, results, true);
|
|
Assert.IsTrue (valid, "#A3-3");
|
|
Assert.AreEqual (0, results.Count, "#A3-4");
|
|
|
|
dummy = new Dummy {
|
|
RequiredDummyField = null
|
|
};
|
|
ctx = new ValidationContext (dummy, null, null);
|
|
valid = Validator.TryValidateObject (dummy, ctx, results, false);
|
|
Assert.IsTrue (valid, "#A4-1");
|
|
Assert.AreEqual (0, results.Count, "#A4-2");
|
|
|
|
valid = Validator.TryValidateObject (dummy, ctx, results, true);
|
|
Assert.IsTrue (valid, "#A4-3");
|
|
Assert.AreEqual (0, results.Count, "#A4-4");
|
|
|
|
// Required properties existence is validated
|
|
dummy = new Dummy {
|
|
RequiredDummyProperty = null
|
|
};
|
|
ctx = new ValidationContext (dummy, null, null);
|
|
valid = Validator.TryValidateObject (dummy, ctx, results, false);
|
|
Assert.IsFalse (valid, "#A5-1");
|
|
Assert.AreEqual (1, results.Count, "#A5-2");
|
|
results.Clear ();
|
|
|
|
valid = Validator.TryValidateObject (dummy, ctx, results, true);
|
|
Assert.IsFalse (valid, "#A5-3");
|
|
Assert.AreEqual (1, results.Count, "#A5-4");
|
|
results.Clear ();
|
|
|
|
dummy = new Dummy {
|
|
NameProperty = null
|
|
};
|
|
ctx = new ValidationContext (dummy, null, null);
|
|
valid = Validator.TryValidateObject (dummy, ctx, results, false);
|
|
Assert.IsTrue (valid, "#A6-1");
|
|
Assert.AreEqual (0, results.Count, "#A6-2");
|
|
|
|
// NameProperty is null, that causes the StringLength validator to skip its tests
|
|
valid = Validator.TryValidateObject (dummy, ctx, results, true);
|
|
Assert.IsTrue (valid, "#A6-3");
|
|
Assert.AreEqual (0, results.Count, "#A6-4");
|
|
|
|
dummy.NameProperty = "0";
|
|
valid = Validator.TryValidateObject (dummy, ctx, results, true);
|
|
Assert.IsFalse (valid, "#A6-5");
|
|
Assert.AreEqual (1, results.Count, "#A6-6");
|
|
results.Clear ();
|
|
|
|
dummy.NameProperty = "name too long (invalid value)";
|
|
valid = Validator.TryValidateObject (dummy, ctx, results, true);
|
|
Assert.IsFalse (valid, "#A6-7");
|
|
Assert.AreEqual (1, results.Count, "#A6-8");
|
|
results.Clear ();
|
|
|
|
dummy = new Dummy {
|
|
MinMaxProperty = 0
|
|
};
|
|
ctx = new ValidationContext (dummy, null, null);
|
|
valid = Validator.TryValidateObject (dummy, ctx, results, false);
|
|
Assert.IsTrue (valid, "#A7-1");
|
|
Assert.AreEqual (0, results.Count, "#A7-2");
|
|
|
|
valid = Validator.TryValidateObject (dummy, ctx, results, true);
|
|
Assert.IsFalse (valid, "#A7-3");
|
|
Assert.AreEqual (1, results.Count, "#A7-4");
|
|
results.Clear ();
|
|
|
|
dummy = new Dummy {
|
|
FailValidation = true
|
|
};
|
|
ctx = new ValidationContext (dummy, null, null);
|
|
valid = Validator.TryValidateObject (dummy, ctx, results, false);
|
|
Assert.IsFalse (valid, "#A8-1");
|
|
Assert.AreEqual (1, results.Count, "#A8-2");
|
|
results.Clear ();
|
|
|
|
valid = Validator.TryValidateObject (dummy, ctx, results, true);
|
|
Assert.IsFalse (valid, "#A8-3");
|
|
Assert.AreEqual (1, results.Count, "#A8-4");
|
|
results.Clear ();
|
|
|
|
var dummy2 = new DummyWithException ();
|
|
ctx = new ValidationContext (dummy2, null, null);
|
|
Assert.Throws<ApplicationException> (() => {
|
|
Validator.TryValidateObject (dummy2, ctx, results, true);
|
|
}, "#A9");
|
|
}
|
|
|
|
[Test]
|
|
public void TryValidateProperty ()
|
|
{
|
|
var dummy = new DummyNoAttributes ();
|
|
var ctx = new ValidationContext (dummy, null, null) {
|
|
MemberName = "NameProperty"
|
|
};
|
|
var results = new List<ValidationResult> ();
|
|
|
|
Assert.Throws<ArgumentException> (() => {
|
|
// MonoTests.System.ComponentModel.DataAnnotations.ValidatorTest.TryValidateProperty:
|
|
// System.ArgumentException : The type 'DummyNoAttributes' does not contain a public property named 'NameProperty'.
|
|
// Parameter name: propertyName
|
|
//
|
|
// at System.ComponentModel.DataAnnotations.ValidationAttributeStore.TypeStoreItem.GetPropertyStoreItem(String propertyName)
|
|
// at System.ComponentModel.DataAnnotations.ValidationAttributeStore.GetPropertyType(ValidationContext validationContext)
|
|
// at System.ComponentModel.DataAnnotations.Validator.TryValidateProperty(Object value, ValidationContext validationContext, ICollection`1 validationResults)
|
|
// at MonoTests.System.ComponentModel.DataAnnotations.ValidatorTest.TryValidateProperty() in C:\Users\grendel\Documents\Visual Studio 2010\Projects\System.Web.Test\System.Web.Test\System.ComponentModel.DataAnnotations\ValidatorTest.cs:line 283
|
|
|
|
Validator.TryValidateProperty ("dummy", ctx, results);
|
|
}, "#A1-1");
|
|
Assert.AreEqual (0, results.Count, "#A1-2");
|
|
|
|
Assert.Throws<ArgumentNullException> (() => {
|
|
Validator.TryValidateProperty ("dummy", null, results);
|
|
}, "#A1-2");
|
|
|
|
var dummy2 = new Dummy ();
|
|
ctx = new ValidationContext (dummy2, null, null) {
|
|
MemberName = "NameProperty"
|
|
};
|
|
|
|
bool valid = Validator.TryValidateProperty (null, ctx, results);
|
|
Assert.IsTrue (valid, "#A1-3");
|
|
Assert.AreEqual (0, results.Count, "#A1-4");
|
|
|
|
ctx = new ValidationContext (dummy2, null, null) {
|
|
MemberName = "MinMaxProperty"
|
|
};
|
|
|
|
Assert.Throws<ArgumentException> (() => {
|
|
Validator.TryValidateProperty (null, ctx, results);
|
|
}, "#A1-5");
|
|
|
|
ctx = new ValidationContext (dummy2, null, null);
|
|
Assert.Throws<ArgumentNullException> (() => {
|
|
// MonoTests.System.ComponentModel.DataAnnotations.ValidatorTest.TryValidateProperty:
|
|
// System.ArgumentNullException : Value cannot be null.
|
|
// Parameter name: propertyName
|
|
//
|
|
// at System.ComponentModel.DataAnnotations.ValidationAttributeStore.TypeStoreItem.TryGetPropertyStoreItem(String propertyName, PropertyStoreItem& item)
|
|
// at System.ComponentModel.DataAnnotations.ValidationAttributeStore.TypeStoreItem.GetPropertyStoreItem(String propertyName)
|
|
// at System.ComponentModel.DataAnnotations.ValidationAttributeStore.GetPropertyType(ValidationContext validationContext)
|
|
// at System.ComponentModel.DataAnnotations.Validator.TryValidateProperty(Object value, ValidationContext validationContext, ICollection`1 validationResults)
|
|
// at MonoTests.System.ComponentModel.DataAnnotations.ValidatorTest.TryValidateProperty() in C:\Users\grendel\Documents\Visual Studio 2010\Projects\System.Web.Test\System.Web.Test\System.ComponentModel.DataAnnotations\ValidatorTest.cs:line 289
|
|
|
|
Validator.TryValidateProperty ("dummy", ctx, results);
|
|
}, "#A2-1");
|
|
Assert.AreEqual (0, results.Count, "#A2-2");
|
|
|
|
ctx = new ValidationContext (dummy2, null, null) {
|
|
MemberName = String.Empty
|
|
};
|
|
|
|
Assert.Throws<ArgumentNullException> (() => {
|
|
// MonoTests.System.ComponentModel.DataAnnotations.ValidatorTest.TryValidateProperty:
|
|
// System.ArgumentNullException : Value cannot be null.
|
|
// Parameter name: propertyName
|
|
//
|
|
// at System.ComponentModel.DataAnnotations.ValidationAttributeStore.TypeStoreItem.TryGetPropertyStoreItem(String propertyName, PropertyStoreItem& item)
|
|
// at System.ComponentModel.DataAnnotations.ValidationAttributeStore.TypeStoreItem.GetPropertyStoreItem(String propertyName)
|
|
// at System.ComponentModel.DataAnnotations.ValidationAttributeStore.GetPropertyType(ValidationContext validationContext)
|
|
// at System.ComponentModel.DataAnnotations.Validator.TryValidateProperty(Object value, ValidationContext validationContext, ICollection`1 validationResults)
|
|
// at MonoTests.System.ComponentModel.DataAnnotations.ValidatorTest.TryValidateProperty() in C:\Users\grendel\Documents\Visual Studio 2010\Projects\System.Web.Test\System.Web.Test\System.ComponentModel.DataAnnotations\ValidatorTest.cs:line 289
|
|
|
|
Validator.TryValidateProperty ("dummy", ctx, results);
|
|
}, "#A2-2");
|
|
Assert.AreEqual (0, results.Count, "#A2-2");
|
|
|
|
dummy2 = new Dummy ();
|
|
ctx = new ValidationContext (dummy2, null, null) {
|
|
MemberName = "NameProperty"
|
|
};
|
|
|
|
Assert.Throws<ArgumentException> (() => {
|
|
// MonoTests.System.ComponentModel.DataAnnotations.ValidatorTest.TryValidateProperty:
|
|
// System.ArgumentException : The value for property 'NameProperty' must be of type 'System.String'.
|
|
// Parameter name: value
|
|
//
|
|
// at System.ComponentModel.DataAnnotations.Validator.EnsureValidPropertyType(String propertyName, Type propertyType, Object value)
|
|
// at System.ComponentModel.DataAnnotations.Validator.TryValidateProperty(Object value, ValidationContext validationContext, ICollection`1 validationResults)
|
|
// at MonoTests.System.ComponentModel.DataAnnotations.ValidatorTest.TryValidateProperty() in C:\Users\grendel\Documents\Visual Studio 2010\Projects\System.Web.Test\System.Web.Test\System.ComponentModel.DataAnnotations\ValidatorTest.cs:line 315
|
|
|
|
Validator.TryValidateProperty (1234, ctx, results);
|
|
}, "#A3-1");
|
|
Assert.AreEqual (0, results.Count, "#A3-2");
|
|
|
|
dummy2 = new Dummy ();
|
|
ctx = new ValidationContext (dummy2, null, null) {
|
|
MemberName = "NameProperty"
|
|
};
|
|
|
|
valid = Validator.TryValidateProperty (String.Empty, ctx, results);
|
|
Assert.IsFalse (valid, "#A4-1");
|
|
Assert.AreEqual (1, results.Count, "#A4-2");
|
|
results.Clear ();
|
|
|
|
valid = Validator.TryValidateProperty ("this value is way too long", ctx, results);
|
|
Assert.IsFalse (valid, "#A4-3");
|
|
Assert.AreEqual (1, results.Count, "#A4-4");
|
|
results.Clear ();
|
|
|
|
valid = Validator.TryValidateProperty ("good value", ctx, results);
|
|
Assert.IsTrue (valid, "#A4-5");
|
|
Assert.AreEqual (0, results.Count, "#A4-6");
|
|
|
|
dummy2 = new Dummy ();
|
|
ctx = new ValidationContext (dummy2, null, null) {
|
|
MemberName = "CustomValidatedProperty"
|
|
};
|
|
|
|
valid = Validator.TryValidateProperty (String.Empty, ctx, results);
|
|
Assert.IsFalse (valid, "#A5-1");
|
|
Assert.AreEqual (1, results.Count, "#A5-2");
|
|
results.Clear ();
|
|
|
|
valid = Validator.TryValidateProperty ("fail", ctx, results);
|
|
Assert.IsFalse (valid, "#A5-3");
|
|
Assert.AreEqual (1, results.Count, "#A5-4");
|
|
results.Clear ();
|
|
|
|
valid = Validator.TryValidateProperty ("f", ctx, results);
|
|
Assert.IsFalse (valid, "#A5-5");
|
|
Assert.AreEqual (2, results.Count, "#A5-6");
|
|
results.Clear ();
|
|
|
|
valid = Validator.TryValidateProperty ("good value", ctx, results);
|
|
Assert.IsTrue (valid, "#A5-7");
|
|
Assert.AreEqual (0, results.Count, "#A5-8");
|
|
}
|
|
|
|
[Test]
|
|
public void TryValidateValue_01 ()
|
|
{
|
|
var dummy = new DummyNoAttributes ();
|
|
var ctx = new ValidationContext (dummy, null, null) {
|
|
MemberName = "NameProperty"
|
|
};
|
|
var results = new List<ValidationResult> ();
|
|
var attributes = new List <ValidationAttribute> ();
|
|
|
|
bool valid = Validator.TryValidateValue (null, ctx, results, attributes);
|
|
Assert.IsTrue (valid, "#A1-1");
|
|
Assert.AreEqual (0, results.Count, "#A1-2");
|
|
|
|
Assert.Throws<ArgumentNullException> (() => {
|
|
Validator.TryValidateValue ("dummy", null, results, attributes);
|
|
}, "#A2");
|
|
|
|
valid = Validator.TryValidateValue ("dummy", ctx, null, attributes);
|
|
Assert.IsTrue (valid, "#A3-1");
|
|
Assert.AreEqual (0, results.Count, "#A3-2");
|
|
|
|
Assert.Throws<ArgumentNullException> (() => {
|
|
Validator.TryValidateValue ("dummy", ctx, results, null);
|
|
}, "#A4");
|
|
}
|
|
|
|
[Test]
|
|
public void TryValidateValue_02 ()
|
|
{
|
|
var dummy = new DummyNoAttributes ();
|
|
var ctx = new ValidationContext (dummy, null, null);
|
|
var results = new List<ValidationResult> ();
|
|
var log = new List<string> ();
|
|
var attributes = new List<ValidationAttribute> () {
|
|
new StringLengthAttributePoker (10, log) {
|
|
MinimumLength = 2
|
|
},
|
|
new RequiredAttributePoker (log)
|
|
};
|
|
|
|
bool valid = Validator.TryValidateValue (null, ctx, results, attributes);
|
|
Assert.IsFalse (valid, "#A1-1");
|
|
Assert.AreEqual (1, results.Count, "#A1-2");
|
|
Assert.AreEqual (1, log.Count, "#A1-3");
|
|
Assert.IsTrue (log [0].StartsWith ("RequiredAttributePoker.IsValid (object)"), "#A1-4");
|
|
results.Clear ();
|
|
log.Clear ();
|
|
|
|
Assert.Throws<InvalidCastException> (() => {
|
|
// Thrown by StringValidatorAttribute
|
|
Validator.TryValidateValue (1234, ctx, results, attributes);
|
|
}, "#A2-1");
|
|
Assert.AreEqual (0, results.Count, "#A2-2");
|
|
Assert.AreEqual (2, log.Count, "#A2-3");
|
|
Assert.IsTrue (log[0].StartsWith ("RequiredAttributePoker.IsValid (object)"), "#A2-4");
|
|
Assert.IsTrue (log[1].StartsWith ("StringLengthAttributePoker.IsValid (object)"), "#A2-5");
|
|
results.Clear ();
|
|
log.Clear ();
|
|
|
|
attributes.Add (new CustomValidationAttribute (typeof (ValidatorTest), "ValueValidationMethod"));
|
|
attributes.Add (new CustomValidationAttribute (typeof (ValidatorTest), "ValueValidationMethod"));
|
|
valid = Validator.TryValidateValue ("test", ctx, results, attributes);
|
|
Assert.IsFalse (valid, "#A3-1");
|
|
Assert.AreEqual (2, results.Count, "#A3-2");
|
|
Assert.AreEqual (2, log.Count, "#A3-3");
|
|
Assert.IsTrue (log[0].StartsWith ("RequiredAttributePoker.IsValid (object)"), "#A3-4");
|
|
Assert.IsTrue (log[1].StartsWith ("StringLengthAttributePoker.IsValid (object)"), "#A3-5");
|
|
Assert.AreEqual ("ValueValidationMethod", results[0].ErrorMessage, "#A3-6");
|
|
Assert.AreEqual ("ValueValidationMethod", results[1].ErrorMessage, "#A3-7");
|
|
results.Clear ();
|
|
log.Clear ();
|
|
attributes.RemoveAt (2);
|
|
attributes.RemoveAt (2);
|
|
|
|
Assert.Throws<ArgumentNullException> (() => {
|
|
Validator.TryValidateValue ("dummy", null, results, attributes);
|
|
}, "#B1");
|
|
|
|
valid = Validator.TryValidateValue ("dummy", ctx, null, attributes);
|
|
Assert.IsTrue (valid, "#B2-1");
|
|
Assert.AreEqual (0, results.Count, "#B2-2");
|
|
|
|
Assert.Throws<ArgumentNullException> (() => {
|
|
Validator.TryValidateValue ("dummy", ctx, results, null);
|
|
}, "#B3");
|
|
}
|
|
|
|
[Test]
|
|
public void ValidateObject_Object_ValidationContext_01 ()
|
|
{
|
|
var dummy = new DummyNoAttributes ();
|
|
var ctx = new ValidationContext (dummy, null, null);
|
|
|
|
Assert.Throws<ArgumentNullException> (() => {
|
|
Validator.ValidateObject (null, ctx);
|
|
}, "#A1-1");
|
|
|
|
Assert.Throws<ArgumentNullException> (() => {
|
|
Validator.ValidateObject (dummy, null);
|
|
}, "#A1-2");
|
|
|
|
try {
|
|
Validator.ValidateObject (dummy, ctx);
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#A2 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void ValidateObject_Object_ValidationContext_02 ()
|
|
{
|
|
var dummy = new Dummy ();
|
|
var ctx = new ValidationContext (dummy, null, null);
|
|
|
|
try {
|
|
Validator.ValidateObject (dummy, ctx);
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#A1 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
|
|
dummy = new Dummy {
|
|
NameField = null
|
|
};
|
|
Assert.Throws<ArgumentException> (() => {
|
|
// The instance provided must match the ObjectInstance on the ValidationContext supplied.
|
|
Validator.ValidateObject (dummy, ctx);
|
|
}, "#A2");
|
|
|
|
// Fields are ignored
|
|
ctx = new ValidationContext (dummy, null, null);
|
|
try {
|
|
Validator.ValidateObject (dummy, ctx);
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#A3 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
|
|
dummy = new Dummy {
|
|
RequiredDummyField = null
|
|
};
|
|
ctx = new ValidationContext (dummy, null, null);
|
|
try {
|
|
Validator.ValidateObject (dummy, ctx);
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#A4 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
|
|
dummy = new Dummy {
|
|
RequiredDummyProperty = null
|
|
};
|
|
ctx = new ValidationContext (dummy, null, null);
|
|
Assert.Throws<ValidationException> (() => {
|
|
Validator.ValidateObject (dummy, ctx);
|
|
}, "#A5");
|
|
|
|
// validation attributes other than Required are ignored
|
|
dummy = new Dummy {
|
|
NameProperty = null
|
|
};
|
|
ctx = new ValidationContext (dummy, null, null);
|
|
try {
|
|
Validator.ValidateObject (dummy, ctx);
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#A6 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
|
|
dummy = new Dummy {
|
|
MinMaxProperty = 0
|
|
};
|
|
ctx = new ValidationContext (dummy, null, null);
|
|
try {
|
|
Validator.ValidateObject (dummy, ctx);
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#A7 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
|
|
dummy = new Dummy {
|
|
FailValidation = true
|
|
};
|
|
ctx = new ValidationContext (dummy, null, null);
|
|
Assert.Throws<ValidationException> (() => {
|
|
Validator.ValidateObject (dummy, ctx);
|
|
}, "#A8");
|
|
|
|
var dummy2 = new DummyMultipleCustomValidators ();
|
|
ctx = new ValidationContext (dummy2, null, null);
|
|
try {
|
|
Validator.ValidateObject (dummy2, ctx);
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#A9 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void ValidateObject_Object_ValidationContext_Bool_01 ()
|
|
{
|
|
var dummy = new DummyNoAttributes ();
|
|
var ctx = new ValidationContext (dummy, null, null);
|
|
|
|
Assert.Throws<ArgumentNullException> (() => {
|
|
Validator.ValidateObject (null, ctx, false);
|
|
}, "#A1-1");
|
|
|
|
Assert.Throws<ArgumentNullException> (() => {
|
|
Validator.ValidateObject (dummy, null, false);
|
|
}, "#A1-2");
|
|
|
|
try {
|
|
Validator.ValidateObject (dummy, ctx, false);
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#A2 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
|
|
try {
|
|
Validator.ValidateObject (dummy, ctx, true);
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#A3 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void ValidateObject_Object_ValidationContext_Bool_02 ()
|
|
{
|
|
var dummy = new Dummy ();
|
|
var ctx = new ValidationContext (dummy, null, null);
|
|
|
|
try {
|
|
Validator.ValidateObject (dummy, ctx, false);
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#A1 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
|
|
try {
|
|
Validator.ValidateObject (dummy, ctx, true);
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#A2 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
|
|
dummy = new Dummy {
|
|
NameField = null
|
|
};
|
|
Assert.Throws<ArgumentException> (() => {
|
|
// The instance provided must match the ObjectInstance on the ValidationContext supplied.
|
|
Validator.ValidateObject (dummy, ctx, false);
|
|
}, "#A3-1");
|
|
|
|
Assert.Throws<ArgumentException> (() => {
|
|
// The instance provided must match the ObjectInstance on the ValidationContext supplied.
|
|
Validator.ValidateObject (dummy, ctx, true);
|
|
}, "#A3-2");
|
|
|
|
// Fields are ignored
|
|
ctx = new ValidationContext (dummy, null, null);
|
|
try {
|
|
Validator.ValidateObject (dummy, ctx, false);
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#A4-1 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
|
|
try {
|
|
Validator.ValidateObject (dummy, ctx, true);
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#A4-2 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
|
|
dummy = new Dummy {
|
|
RequiredDummyField = null
|
|
};
|
|
ctx = new ValidationContext (dummy, null, null);
|
|
try {
|
|
Validator.ValidateObject (dummy, ctx, false);
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#A5-1 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
|
|
try {
|
|
Validator.ValidateObject (dummy, ctx, true);
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#A5-2 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
|
|
// Required properties existence is validated
|
|
dummy = new Dummy {
|
|
RequiredDummyProperty = null
|
|
};
|
|
ctx = new ValidationContext (dummy, null, null);
|
|
Assert.Throws<ValidationException> (() => {
|
|
Validator.ValidateObject (dummy, ctx, false);
|
|
}, "#A6-1");
|
|
|
|
Assert.Throws<ValidationException> (() => {
|
|
Validator.ValidateObject (dummy, ctx, true);
|
|
}, "#A6-2");
|
|
|
|
dummy = new Dummy {
|
|
NameProperty = null
|
|
};
|
|
ctx = new ValidationContext (dummy, null, null);
|
|
try {
|
|
Validator.ValidateObject (dummy, ctx, false);
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#A7 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
|
|
// NameProperty is null, that causes the StringLength validator to skip its tests
|
|
try {
|
|
Validator.ValidateObject (dummy, ctx, true);
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#A8 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
|
|
dummy.NameProperty = "0";
|
|
Assert.Throws<ValidationException> (() => {
|
|
Validator.ValidateObject (dummy, ctx, true);
|
|
}, "#A9");
|
|
|
|
dummy.NameProperty = "name too long (invalid value)";
|
|
Assert.Throws<ValidationException> (() => {
|
|
Validator.ValidateObject (dummy, ctx, true);
|
|
}, "#A10");
|
|
|
|
dummy = new Dummy {
|
|
MinMaxProperty = 0
|
|
};
|
|
ctx = new ValidationContext (dummy, null, null);
|
|
try {
|
|
Validator.ValidateObject (dummy, ctx, false);
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#A11 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
|
|
Assert.Throws<ValidationException> (() => {
|
|
Validator.ValidateObject (dummy, ctx, true);
|
|
}, "#A12");
|
|
|
|
dummy = new Dummy {
|
|
FailValidation = true
|
|
};
|
|
ctx = new ValidationContext (dummy, null, null);
|
|
Assert.Throws<ValidationException> (() => {
|
|
Validator.ValidateObject (dummy, ctx, false);
|
|
}, "#A13-1");
|
|
|
|
Assert.Throws<ValidationException> (() => {
|
|
Validator.ValidateObject (dummy, ctx, true);
|
|
}, "#A13-2");
|
|
|
|
var dummy2 = new DummyWithException ();
|
|
ctx = new ValidationContext (dummy2, null, null);
|
|
Assert.Throws<ApplicationException> (() => {
|
|
Validator.ValidateObject (dummy2, ctx, true);
|
|
}, "#A14");
|
|
|
|
var dummy3 = new DummyMultipleCustomValidators ();
|
|
ctx = new ValidationContext (dummy3, null, null);
|
|
try {
|
|
Validator.ValidateObject (dummy3, ctx, false);
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#A9 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
|
|
try {
|
|
Validator.ValidateObject (dummy3, ctx, true);
|
|
} catch (ValidationException ex) {
|
|
Assert.AreEqual ("FirstPropertyValidationMethod", ex.Message, "#A10");
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#A10 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void ValidateProperty ()
|
|
{
|
|
var dummy = new DummyNoAttributes ();
|
|
var ctx = new ValidationContext (dummy, null, null) {
|
|
MemberName = "NameProperty"
|
|
};
|
|
|
|
Assert.Throws<ArgumentException> (() => {
|
|
Validator.ValidateProperty ("dummy", ctx);
|
|
}, "#A1-1");
|
|
|
|
Assert.Throws<ArgumentNullException> (() => {
|
|
Validator.ValidateProperty ("dummy", null);
|
|
}, "#A1-2");
|
|
|
|
var dummy2 = new Dummy ();
|
|
ctx = new ValidationContext (dummy2, null, null) {
|
|
MemberName = "NameProperty"
|
|
};
|
|
|
|
try {
|
|
Validator.ValidateProperty (null, ctx);
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#A2 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
|
|
ctx = new ValidationContext (dummy2, null, null) {
|
|
MemberName = "MinMaxProperty"
|
|
};
|
|
|
|
Assert.Throws<ArgumentException> (() => {
|
|
Validator.ValidateProperty (null, ctx);
|
|
}, "#A3");
|
|
|
|
ctx = new ValidationContext (dummy2, null, null);
|
|
Assert.Throws<ArgumentNullException> (() => {
|
|
Validator.ValidateProperty ("dummy", ctx);
|
|
}, "#A4");
|
|
|
|
ctx = new ValidationContext (dummy2, null, null) {
|
|
MemberName = String.Empty
|
|
};
|
|
|
|
Assert.Throws<ArgumentNullException> (() => {
|
|
Validator.ValidateProperty ("dummy", ctx);
|
|
}, "#A5");
|
|
|
|
dummy2 = new Dummy ();
|
|
ctx = new ValidationContext (dummy2, null, null) {
|
|
MemberName = "NameProperty"
|
|
};
|
|
|
|
Assert.Throws<ArgumentException> (() => {
|
|
Validator.ValidateProperty (1234, ctx);
|
|
}, "#A6");
|
|
|
|
dummy2 = new Dummy ();
|
|
ctx = new ValidationContext (dummy2, null, null) {
|
|
MemberName = "NameProperty"
|
|
};
|
|
|
|
Assert.Throws<ValidationException> (() => {
|
|
Validator.ValidateProperty (String.Empty, ctx);
|
|
}, "#A7");
|
|
|
|
Assert.Throws<ValidationException> (() => {
|
|
Validator.ValidateProperty ("this value is way too long", ctx);
|
|
}, "#A8");
|
|
|
|
try {
|
|
Validator.ValidateProperty ("good value", ctx);
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#A9 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
|
|
dummy2 = new Dummy ();
|
|
ctx = new ValidationContext (dummy2, null, null) {
|
|
MemberName = "CustomValidatedProperty"
|
|
};
|
|
|
|
Assert.Throws<ValidationException> (() => {
|
|
Validator.ValidateProperty (String.Empty, ctx);
|
|
}, "#A10");
|
|
|
|
Assert.Throws<ValidationException> (() => {
|
|
Validator.ValidateProperty ("fail", ctx);
|
|
}, "#A11");
|
|
|
|
Assert.Throws<ValidationException> (() => {
|
|
Validator.ValidateProperty ("f", ctx);
|
|
}, "#A12");
|
|
|
|
try {
|
|
Validator.ValidateProperty ("good value", ctx);
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#A13 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void ValidateValue_01 ()
|
|
{
|
|
var dummy = new DummyNoAttributes ();
|
|
var ctx = new ValidationContext (dummy, null, null) {
|
|
MemberName = "NameProperty"
|
|
};
|
|
var attributes = new List<ValidationAttribute> ();
|
|
|
|
try {
|
|
Validator.ValidateValue (null, ctx, attributes);
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#A1 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
|
|
Assert.Throws<ArgumentNullException> (() => {
|
|
Validator.ValidateValue ("dummy", null, attributes);
|
|
}, "#A2");
|
|
|
|
try {
|
|
Validator.ValidateValue ("dummy", ctx, attributes);
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#A3 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
|
|
Assert.Throws<ArgumentNullException> (() => {
|
|
Validator.ValidateValue ("dummy", ctx, null);
|
|
}, "#A4");
|
|
}
|
|
|
|
[Test]
|
|
public void ValidateValue_02 ()
|
|
{
|
|
var dummy = new DummyNoAttributes ();
|
|
var ctx = new ValidationContext (dummy, null, null);
|
|
var log = new List<string> ();
|
|
var attributes = new List<ValidationAttribute> () {
|
|
new StringLengthAttributePoker (10, log) {
|
|
MinimumLength = 2
|
|
},
|
|
new RequiredAttributePoker (log)
|
|
};
|
|
|
|
Assert.Throws<ValidationException> (() => {
|
|
Validator.ValidateValue (null, ctx, attributes);
|
|
}, "#A1-1");
|
|
Assert.AreEqual (1, log.Count, "#A1-2");
|
|
Assert.IsTrue (log[0].StartsWith ("RequiredAttributePoker.IsValid (object)"), "#A1-3");
|
|
log.Clear ();
|
|
|
|
Assert.Throws<InvalidCastException> (() => {
|
|
// Thrown by StringValidatorAttribute
|
|
Validator.ValidateValue (1234, ctx, attributes);
|
|
}, "#A2-1");;
|
|
Assert.AreEqual (2, log.Count, "#A2-2");
|
|
Assert.IsTrue (log[0].StartsWith ("RequiredAttributePoker.IsValid (object)"), "#A2-3");
|
|
Assert.IsTrue (log[1].StartsWith ("StringLengthAttributePoker.IsValid (object)"), "#A2-4");
|
|
log.Clear ();
|
|
|
|
attributes.Add (new CustomValidationAttribute (typeof (ValidatorTest), "ValueValidationMethod"));
|
|
attributes.Add (new CustomValidationAttribute (typeof (ValidatorTest), "ValueValidationMethod"));
|
|
Assert.Throws<ValidationException> (() => {
|
|
Validator.ValidateValue ("test", ctx, attributes);
|
|
}, "#A3-1");
|
|
Assert.AreEqual (2, log.Count, "#A3-2");
|
|
Assert.IsTrue (log[0].StartsWith ("RequiredAttributePoker.IsValid (object)"), "#A3-3");
|
|
Assert.IsTrue (log[1].StartsWith ("StringLengthAttributePoker.IsValid (object)"), "#A3-4");
|
|
log.Clear ();
|
|
attributes.RemoveAt (2);
|
|
attributes.RemoveAt (2);
|
|
|
|
Assert.Throws<ArgumentNullException> (() => {
|
|
Validator.ValidateValue ("dummy", null, attributes);
|
|
}, "#B1");
|
|
|
|
try {
|
|
Validator.ValidateValue ("dummy", ctx, attributes);
|
|
} catch (Exception ex) {
|
|
Assert.Fail ("#B2 (exception {0} thrown: {1})", ex.GetType (), ex.Message);
|
|
}
|
|
|
|
Assert.Throws<ArgumentNullException> (() => {
|
|
Validator.ValidateValue ("dummy", ctx, null);
|
|
}, "#B3");
|
|
}
|
|
|
|
[Test]
|
|
public void TryValidateValue_Throws_ValidationException_When_Property_Is_NullableAndRequired_And_Value_Is_Null ()
|
|
{
|
|
EntityMock entity = new EntityMock ();
|
|
ICollection<ValidationResult> result = new List<ValidationResult>();
|
|
|
|
ICollection<ValidationAttribute> attributes = new List<ValidationAttribute> ();
|
|
attributes.Add (new RequiredAttribute ());
|
|
|
|
// Year = null
|
|
bool isValid = Validator.TryValidateValue (null, new ValidationContext (entity, null, null) { MemberName = "Year" }, result, attributes);
|
|
|
|
Assert.IsFalse (isValid, "#A1-1");
|
|
Assert.AreEqual (1, result.Count, "#A1-2");
|
|
|
|
// Name = null, string
|
|
result.Clear ();
|
|
|
|
isValid = Validator.TryValidateValue (null, new ValidationContext (entity, null, null) { MemberName = "Name" }, result, attributes);
|
|
|
|
Assert.IsFalse (isValid, "#A2-1");
|
|
Assert.AreEqual (1, result.Count, "#A2-2");
|
|
|
|
// Name = string.Empty, string
|
|
result.Clear ();
|
|
|
|
isValid = Validator.TryValidateValue (String.Empty, new ValidationContext (entity, null, null) { MemberName = "Name" }, result, attributes);
|
|
|
|
Assert.IsFalse (isValid, "#A3-1");
|
|
Assert.AreEqual (1, result.Count, "#A3-2");
|
|
}
|
|
|
|
[Test]
|
|
public void TryValidateProperty_Throws_ValidationException_When_Property_Is_NullableAndRequired_And_Value_Is_Null ()
|
|
{
|
|
EntityMock entity = new EntityMock ();
|
|
ICollection<ValidationResult> result = new List<ValidationResult> ();
|
|
|
|
// Year = null
|
|
bool isValid = Validator.TryValidateProperty (null, new ValidationContext (entity, null, null) { MemberName = "Year" }, result);
|
|
|
|
Assert.IsFalse (isValid, "#A1-1");
|
|
Assert.AreEqual (1, result.Count, "#A1-2");
|
|
|
|
// Name = null, string
|
|
result.Clear ();
|
|
|
|
isValid = Validator.TryValidateProperty (null, new ValidationContext (entity, null, null) { MemberName = "Name" }, result);
|
|
|
|
Assert.IsFalse (isValid, "#A2-1");
|
|
Assert.AreEqual (1, result.Count, "#A2-2");
|
|
|
|
// Name = string.Empty, string
|
|
result.Clear ();
|
|
|
|
isValid = Validator.TryValidateProperty (String.Empty, new ValidationContext (entity, null, null) { MemberName = "Name" }, result);
|
|
|
|
Assert.IsFalse (isValid, "#A3-1");
|
|
Assert.AreEqual (1, result.Count, "#A3-2");
|
|
}
|
|
|
|
[Test]
|
|
public void TryValidateObject_Throws_ValidationException_When_Property_Is_NullableAndRequired_And_Value_Is_Null ()
|
|
{
|
|
EntityMock entity = new EntityMock ();
|
|
ICollection<ValidationResult> result = new List<ValidationResult> ();
|
|
|
|
// Year = null
|
|
bool isValid = Validator.TryValidateObject (entity, new ValidationContext (entity, null, null), result);
|
|
|
|
Assert.IsFalse (isValid, "#A1-1");
|
|
Assert.AreEqual (2, result.Count, "#A1-2");
|
|
|
|
// Name = null, string
|
|
result.Clear ();
|
|
|
|
isValid = Validator.TryValidateObject (entity, new ValidationContext (entity, null, null), result);
|
|
|
|
Assert.IsFalse (isValid, "#A2-1");
|
|
Assert.AreEqual (2, result.Count, "#A2-2");
|
|
|
|
// Name = string.Empty, string
|
|
result.Clear ();
|
|
|
|
entity.Name = String.Empty;
|
|
isValid = Validator.TryValidateObject (entity, new ValidationContext (entity, null, null), result);
|
|
|
|
Assert.IsFalse (isValid, "#A3-1");
|
|
Assert.AreEqual (2, result.Count, "#A3-2");
|
|
}
|
|
|
|
public static ValidationResult DummyValidationMethod (object o)
|
|
{
|
|
var dummy = o as Dummy;
|
|
if (dummy == null)
|
|
return new ValidationResult ("Invalid DummyValidationMethod input - broken test?");
|
|
|
|
if (dummy.FailValidation)
|
|
return new ValidationResult ("Dummy validation failed.");
|
|
return ValidationResult.Success;
|
|
}
|
|
|
|
public static ValidationResult CustomValidatedPropertyValidationMethod (object o)
|
|
{
|
|
var dummy = o as string;
|
|
if (dummy != null && (dummy == "f" || dummy == "fail"))
|
|
return new ValidationResult ("Dummy.CustomValidatedProperty validation failed.");
|
|
return ValidationResult.Success;
|
|
}
|
|
|
|
public static ValidationResult ValidationMethodException (object o)
|
|
{
|
|
throw new ApplicationException ("SNAFU");
|
|
}
|
|
|
|
public static ValidationResult ValueValidationMethod (object o, ValidationContext validationContext)
|
|
{
|
|
return new ValidationResult ("ValueValidationMethod");
|
|
}
|
|
|
|
public static ValidationResult FirstPropertyValidationMethod (object o, ValidationContext validationContext)
|
|
{
|
|
return new ValidationResult ("FirstPropertyValidationMethod");
|
|
}
|
|
|
|
public static ValidationResult SecondPropertyValidationMethod (object o, ValidationContext validationContext)
|
|
{
|
|
return new ValidationResult ("SecondPropertyValidationMethod");
|
|
}
|
|
|
|
public class RequiredAttributePoker : RequiredAttribute
|
|
{
|
|
List <string> log;
|
|
|
|
public RequiredAttributePoker (List<string> log)
|
|
{
|
|
if (log == null)
|
|
throw new ArgumentNullException ("log");
|
|
this.log = log;
|
|
}
|
|
|
|
public override bool IsValid (object value)
|
|
{
|
|
log.Add ("RequiredAttributePoker.IsValid (object)");
|
|
return base.IsValid (value);
|
|
}
|
|
}
|
|
|
|
public class StringLengthAttributePoker : StringLengthAttribute
|
|
{
|
|
List <string> log;
|
|
|
|
public StringLengthAttributePoker (int maximumLength, List<string> log)
|
|
: base (maximumLength)
|
|
{
|
|
if (log == null)
|
|
throw new ArgumentNullException ("log");
|
|
this.log = log;
|
|
}
|
|
|
|
public override bool IsValid (object value)
|
|
{
|
|
log.Add ("StringLengthAttributePoker.IsValid (object)");
|
|
return base.IsValid (value);
|
|
}
|
|
}
|
|
|
|
class DummyNoAttributes
|
|
{ }
|
|
|
|
[CustomValidation (typeof (ValidatorTest), "DummyValidationMethod")]
|
|
class Dummy
|
|
{
|
|
[StringLength (10, MinimumLength=2)]
|
|
public string NameField;
|
|
|
|
[Required]
|
|
public DummyNoAttributes RequiredDummyField;
|
|
|
|
[StringLength (10, MinimumLength = 2)]
|
|
public string NameProperty { get; set; }
|
|
|
|
[Required]
|
|
public DummyNoAttributes RequiredDummyProperty { get; set; }
|
|
|
|
[global::System.ComponentModel.DataAnnotations.RangeAttribute ((int)1, (int)10)]
|
|
public int MinMaxProperty { get; set; }
|
|
|
|
[StringLength (10, MinimumLength = 2)]
|
|
[CustomValidation (typeof (ValidatorTest), "CustomValidatedPropertyValidationMethod")]
|
|
public string CustomValidatedProperty { get; set; }
|
|
|
|
[CustomValidation (typeof (ValidatorTest), "CustomValidatedPropertyValidationMethod")]
|
|
[StringLength (10, MinimumLength = 2)]
|
|
public string AnotherCustomValidatedProperty { get; set; }
|
|
|
|
public bool FailValidation { get; set; }
|
|
|
|
public Dummy ()
|
|
{
|
|
NameField = "name";
|
|
NameProperty = "name";
|
|
RequiredDummyField = new DummyNoAttributes ();
|
|
RequiredDummyProperty = new DummyNoAttributes ();
|
|
MinMaxProperty = 5;
|
|
AnotherCustomValidatedProperty = "I'm valid";
|
|
}
|
|
}
|
|
|
|
class DummyWithException
|
|
{
|
|
[CustomValidation (typeof (ValidatorTest), "ValidationMethodException")]
|
|
public string AnotherCustomValidatedProperty { get; set; }
|
|
}
|
|
|
|
class DummyForValueValidation
|
|
{
|
|
public string DummyNoAttributes;
|
|
|
|
public DummyForValueValidation ()
|
|
{
|
|
this.DummyNoAttributes = "I am valid";
|
|
}
|
|
}
|
|
|
|
class DummyMultipleCustomValidators
|
|
{
|
|
[CustomValidation (typeof (ValidatorTest), "FirstPropertyValidationMethod")]
|
|
public string FirstProperty { get; set; }
|
|
|
|
[CustomValidation (typeof (ValidatorTest), "SecondPropertyValidationMethod")]
|
|
public string SecondProperty { get; set; }
|
|
}
|
|
|
|
class EntityMock
|
|
{
|
|
private int? _year;
|
|
|
|
[Required]
|
|
public int? Year
|
|
{
|
|
get { return _year; }
|
|
set
|
|
{
|
|
_year = value;
|
|
}
|
|
}
|
|
|
|
private string _name;
|
|
|
|
[Required]
|
|
public string Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
_name = value;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|