public void CleanTest()
{
var target = new StringField();
AssertExtras.Raises <ValidationException>(delegate
{
target.Clean(null);
}).WithMessage("This field is required.");
target.Required = false;
Assert.AreEqual(null, target.Clean(null));
target = new StringField
{
MinLength = 10,
MaxLength = 15
};
AssertExtras.Raises <ValidationException>(delegate
{
target.Clean("Too Short");
}).WithMessage("Ensure this value has at least 10 characters (it has 9).");
AssertExtras.Raises <ValidationException>(delegate
{
target.Clean("This is too Long");
}).WithMessage("Ensure this value has at most 15 characters (it has 16).");
Assert.AreEqual("This is ok.", target.Clean("This is ok."));
}
public void CleanTest()
{
DateField target = new DateField();
var expected = new DateTime(2006, 10, 25);
// Required
AssertExtras.Raises <ValidationException>(delegate
{
target.Clean(null);
}).WithMessage("This field is required.");
target.Required = false;
Assert.IsNull(target.Clean(null));
Assert.AreEqual(expected, target.Clean(new DateTime?(expected)));
Assert.AreEqual(expected, target.Clean("2006-10-25"));
Assert.AreEqual(expected, target.Clean("06-10-25"));
Assert.AreEqual(expected, target.Clean("10/25/2006"));
Assert.AreEqual(expected, target.Clean("10/25/06"));
Assert.AreEqual(expected, target.Clean("Oct 25 2006"));
Assert.AreEqual(expected, target.Clean("Oct 25, 2006"));
Assert.AreEqual(expected, target.Clean("25 Oct 2006"));
Assert.AreEqual(expected, target.Clean("25 Oct, 2006"));
Assert.AreEqual(expected, target.Clean("October 25 2006"));
Assert.AreEqual(expected, target.Clean("October 25, 2006"));
Assert.AreEqual(expected, target.Clean("25 October 2006"));
Assert.AreEqual(expected, target.Clean("25 October, 2006"));
AssertExtras.Raises <ValidationException>(delegate
{
target.Clean("25 Octc, 2006");
}).WithMessage("Enter a valid date.");
}
public void CleanTest()
{
IntegerField target = new IntegerField();
// Default test
Assert.AreEqual(5, (int?)target.Clean("5"));
Assert.AreEqual(-5, (int?)target.Clean("-5"));
AssertExtras.Raises <ValidationException>(delegate {
target.Clean(null);
}).WithMessage("This field is required.");
AssertExtras.Raises <ValidationException>(delegate {
target.Clean("abc");
}).WithMessage("Enter a whole number.");
AssertExtras.Raises <ValidationException>(delegate {
target.Clean("4.1");
}).WithMessage("Enter a whole number.");
target.MinValue = (int?)5;
AssertExtras.Raises <ValidationException>(delegate {
target.Clean("3");
}).WithMessage("Ensure this value is greater than or equal to 5.");
Assert.AreEqual(6, (int?)target.Clean("6"));
target.MaxValue = (int?)24;
AssertExtras.Raises <ValidationException>(delegate {
target.Clean("27");
}).WithMessage("Ensure this value is less than or equal to 24.");
Assert.AreEqual(23, (int?)target.Clean("23"));
target.Required = false;
Assert.IsNull(target.Clean(null));
Assert.IsNull(target.Clean(""));
Assert.IsNull(target.Clean(" "));
}
public void CleanTest()
{
BooleanField target = new BooleanField(); // TODO: Initialize to an appropriate value
// Required
AssertExtras.Raises <ValidationException>(
() => target.Clean(null)
).WithMessage("This field is required.");
Assert.IsTrue((bool)target.Clean(true));
Assert.IsTrue((bool)target.Clean(bool.TrueString));
Assert.IsTrue((bool)target.Clean("1"));
Assert.IsTrue((bool)target.Clean(1));
Assert.IsTrue((bool)target.Clean("on"));
Assert.IsTrue((bool)target.Clean("asdfakjsdfaksjdhf"));
target.Required = false;
Assert.IsFalse((bool)target.Clean(null));
Assert.IsFalse((bool)target.Clean(false));
Assert.IsFalse((bool)target.Clean(string.Empty));
Assert.IsFalse((bool)target.Clean(bool.FalseString));
Assert.IsFalse((bool)target.Clean("0"));
Assert.IsFalse((bool)target.Clean(0));
Assert.IsFalse((bool)target.Clean(" "));
Assert.IsFalse((bool)target.Clean("off"));
}
public void CleanFileTest()
{
using (var file = File.Open(testFileValid, FileMode.Open, FileAccess.Read))
{
var postedFile = new Mock <HttpPostedFileBase>();
postedFile.Setup(foo => foo.FileName).Returns(Path.GetFileName(file.Name));
postedFile.Setup(foo => foo.ContentType).Returns("image/png");
postedFile.Setup(foo => foo.ContentLength).Returns((int)file.Length);
postedFile.Setup(foo => foo.InputStream).Returns(file);
var target = new ImageField();
Assert.AreSame(postedFile.Object, target.Clean(postedFile.Object));
// Test MaxWidth
target.MaxWidth = 600;
AssertExtras.Raises <ValidationException>(delegate()
{
target.Clean(postedFile.Object);
}).WithMessage("Ensure this image is no more than 600px wide (it is 640px).");
target.MaxWidth = 640;
Assert.AreSame(postedFile.Object, target.Clean(postedFile.Object));
// Test MaxHeight
target.MaxHeight = 400;
AssertExtras.Raises <ValidationException>(delegate()
{
target.Clean(postedFile.Object);
}).WithMessage("Ensure this image is no more than 400px high (it is 480px).");
target.MaxHeight = 480;
Assert.AreSame(postedFile.Object, target.Clean(postedFile.Object));
}
}
public void CleanTest()
{
FloatField target = new FloatField();
// Default test
Assert.AreEqual((float?)12.2, (float?)target.Clean("12.2"));
AssertExtras.Raises <ValidationException>(delegate {
target.Clean(null);
}).WithMessage("This field is required.");
AssertExtras.Raises <ValidationException>(delegate {
target.Clean("abc");
}).WithMessage("Enter a number.");
target.MinValue = (float?)5;
AssertExtras.Raises <ValidationException>(delegate {
target.Clean("4.65");
}).WithMessage("Ensure this value is greater than or equal to 5.");
Assert.AreEqual((float?)5.5, (float?)target.Clean("5.5"));
target.MaxValue = (float?)10.3;
AssertExtras.Raises <ValidationException>(delegate {
target.Clean("15");
}).WithMessage("Ensure this value is less than or equal to 10.3.");
Assert.AreEqual((float?)10.2, (float?)target.Clean("10.2"));
target.Required = false;
Assert.IsNull(target.Clean(null));
}
public void CleanTest()
{
TimeField target = new TimeField();
// Required
AssertExtras.Raises <ValidationException>(delegate
{
target.Clean(null);
}).WithMessage("This field is required.");
target.Required = false;
Assert.IsNull(target.Clean(null));
var expected = new TimeSpan(14, 30, 59);
Assert.AreEqual(expected, target.Clean(new DateTime?(new DateTime(2006, 10, 25, 14, 30, 59))));
Assert.AreEqual(expected, target.Clean("14:30:59"));
Assert.AreEqual(new TimeSpan(14, 30, 00), target.Clean("14:30"));
AssertExtras.Raises <ValidationException>(delegate
{
target.Clean("14:65:59");
}).WithMessage("Enter a valid time.");
}
public void CleanTest()
{
using (var file = File.Open(testFile, FileMode.Open, FileAccess.Read))
{
var fileOK = new Mock<HttpPostedFileBase>();
fileOK.Setup(foo => foo.FileName).Returns(Path.GetFileName(file.Name));
fileOK.Setup(foo => foo.ContentType).Returns("text/plain");
fileOK.Setup(foo => foo.ContentLength).Returns((int)file.Length);
fileOK.Setup(foo => foo.InputStream).Returns(file);
FileField target = new FileField();
Assert.AreSame(fileOK.Object, target.Clean(fileOK.Object));
// Test MaxSize property
target.MaxSize = 20;
AssertExtras.Raises<ValidationException>(delegate()
{
target.Clean(fileOK.Object);
}).WithMessage("Ensure this file is at most 20 bytes (submitted file is 37 bytes).");
target.MaxSize = 40;
Assert.AreSame(fileOK.Object, target.Clean(fileOK.Object));
// Test MaxLength property
target.MaxLength = 5;
AssertExtras.Raises<ValidationException>(delegate()
{
target.Clean(fileOK.Object);
}).WithMessage("Ensure this file name has at most 5 characters (it has 9).");
target.MaxLength = 10;
Assert.AreSame(fileOK.Object, target.Clean(fileOK.Object));
}
}
public void AddTest2()
{
ICollection <KeyValuePair <string, string> > target = new ReadOnlyDictionary <string, string>(testDictionary);
AssertExtras.Raises <NotSupportedException>(delegate() {
target.Add(new KeyValuePair <string, string>("123", "abc"));
});
}
public void ClearTest1()
{
ICollection <KeyValuePair <string, string> > target = new ReadOnlyDictionary <string, string>(testDictionary);
AssertExtras.Raises <NotSupportedException>(delegate() {
target.Clear();
});
}
public void RemoveTest()
{
IDictionary target = new ReadOnlyDictionary <string, string>(testDictionary);
AssertExtras.Raises <NotSupportedException>(delegate() {
target.Remove("sdf");
});
}
public void AddTest1()
{
IDictionary <string, string> target = new ReadOnlyDictionary <string, string>(testDictionary);
AssertExtras.Raises <NotSupportedException>(delegate()
{
target.Add("123", "abc");
});
}
public void ItemTest()
{
Tuple target = new Tuple("123", "321", 42);
Assert.AreEqual("123", target[0]);
Assert.AreEqual("321", target[1]);
Assert.AreEqual(42, target[2]);
AssertExtras.Raises <ArgumentOutOfRangeException>(delegate { var test = target[4]; });
}
public void IndexorTest()
{
var target = new ReadOnlyDictionary <string, string>(testDictionary);
Assert.AreEqual(testDictionary["Item1"], target["Item1"]);
AssertExtras.Raises <NotSupportedException>(delegate() {
target["sdf"] = "123";
});
}
public void ReadOnlyDictionaryConstructorTest()
{
IDictionary target = new ReadOnlyDictionary <string, string>(testDictionary);
// Pass
AssertExtras.Raises <ArgumentNullException>(delegate() {
target = new ReadOnlyDictionary <string, string>(null);
});
}
public void CleanTest()
{
var target = new UrlField();
// OK values
target.Clean("http://www.example.com/");
// Bad values
AssertExtras.Raises <ValidationException>(delegate() { target.Clean("blah"); });
}
public void CleanTest()
{
var target = new SlugField();
// OK values
target.Clean("this-is-slug");
target.Clean("thisisok");
// Bad values
AssertExtras.Raises <ValidationException>(delegate() { target.Clean("this is not"); });
}
public void CleanTest()
{
var target = new IPAddressField();
// OK values
target.Clean("127.0.0.1");
target.Clean("192.168.11.1");
// Bad values
AssertExtras.Raises <ValidationException>(delegate() { target.Clean("blah"); });
}
public void GetEnumeratorTest()
{
FilePathCollection target = new FilePathCollection();
AssertExtras.Raises <ArgumentException>(delegate()
{
foreach (var choice in target)
{
}
});
// Test path
target.Path = testFolderPath;
var expected = new List <string> {
testFolderPath + "item1.txt",
testFolderPath + "item2.txt",
testFolderPath + "item3.log",
testFolderPath + "item5.png",
};
var actual = new List <string>();
foreach (var choice in target)
{
actual.Add(choice.Value.ToString());
}
AssertExtras.ListIsEqual(expected, actual);
// Test pattern
target.SearchPattern = "*.txt";
expected = new List <string> {
testFolderPath + "item1.txt",
testFolderPath + "item2.txt"
};
actual = new List <string>();
foreach (var choice in target)
{
actual.Add(choice.Value.ToString());
}
AssertExtras.ListIsEqual(expected, actual);
// Test recursive
target.Recursive = true;
expected = new List <string> {
testFolderPath + "item1.txt",
testFolderPath + "item2.txt",
testFolderPath + "SubFolder\\item4.txt"
};
actual = new List <string>();
foreach (var choice in target)
{
actual.Add(choice.Value.ToString());
}
AssertExtras.ListIsEqual(expected, actual);
}
public void GetEnumeratorTest1()
{
IEnumerable target = new FilePathCollection();
AssertExtras.Raises <ArgumentException>(delegate()
{
foreach (var choice in target)
{
}
});
}
public void ValidationExceptionConstructorTest1()
{
// Check for a null argument exception
AssertExtras.Raises <ArgumentNullException>(delegate()
{
var test = new ValidationException(null as ErrorCollection);
});
ErrorCollection el = new ErrorCollection();
var test2 = new ValidationException(el);
Assert.AreSame(el, test2.Messages);
}
public void CleanTest()
{
var target = new EmailField();
// OK values
target.Clean("*****@*****.**");
target.Clean("*****@*****.**");
target.Clean("*****@*****.**");
target.Clean("*****@*****.**");
// Bad values
AssertExtras.Raises <ValidationException>(delegate() { target.Clean("test+person"); });
AssertExtras.Raises <ValidationException>(delegate() { target.Clean("test+person@"); });
AssertExtras.Raises <ValidationException>(delegate() { target.Clean("test+person@example"); });
}
public void CleanTest()
{
ChoiceField target = new ChoiceField
{
Choices = MvcForms.Widgets.Choices.AustralianStates.Abbreviated
};
AssertExtras.Raises <ValidationException>(delegate() {
target.Clean(null);
}).WithMessage("This field is required.");
target.Required = false;
Assert.IsNull(target.Clean(null));
Assert.AreEqual("QLD", target.Clean("QLD"));
AssertExtras.Raises <ValidationException>(delegate()
{
target.Clean("CA");
});
}
public void CleanFileTest1()
{
using (var file = File.Open(testFileInvalid, FileMode.Open, FileAccess.Read))
{
var postedFile = new Mock <HttpPostedFileBase>();
postedFile.Setup(foo => foo.FileName).Returns(Path.GetFileName(file.Name));
postedFile.Setup(foo => foo.ContentType).Returns("text/plain");
postedFile.Setup(foo => foo.ContentLength).Returns((int)file.Length);
postedFile.Setup(foo => foo.InputStream).Returns(file);
var target = new ImageField();
// Test MaxSize property
AssertExtras.Raises <ValidationException>(delegate()
{
target.Clean(postedFile.Object);
}).WithMessage("Upload a valid image. The file you uploaded was either not an image or a corrupted image.");
}
}
public void CleanTest()
{
var target = new RegexField(TestRegex);
// Default test
Assert.AreEqual("test", target.Clean("test"));
Assert.AreEqual("test-one", target.Clean("test-one"));
AssertExtras.Raises<ValidationException>(delegate
{
target.Clean(null);
}).WithMessage("This field is required.");
target.Required = false;
Assert.AreEqual(null, target.Clean(null));
AssertExtras.Raises<ValidationException>(delegate
{
target.Clean("Bad Value");
}).WithMessage("Enter a valid value.");
}
public void CleanTest1()
{
var fileEmpty = new Mock<HttpPostedFileBase>();
fileEmpty.Setup(foo => foo.FileName).Returns(string.Empty);
fileEmpty.Setup(foo => foo.ContentType).Returns(string.Empty);
fileEmpty.Setup(foo => foo.ContentLength).Returns(0);
fileEmpty.Setup(foo => foo.InputStream).Returns((Stream)null);
FileField target = new FileField();
// Test required empty file
AssertExtras.Raises<ValidationException>(delegate() {
target.Clean(fileEmpty.Object);
}).WithMessage("This field is required.");
// Test non required empty file
target.Required = false;
AssertExtras.Raises<ValidationException>(delegate() {
target.Clean(fileEmpty.Object);
}).WithMessage("The submitted file is empty.");
}
public void CleanTest()
{
DateTimeField target = new DateTimeField();
var expectedDate = new DateTime(2006, 10, 25);
var expectedTime = new DateTime(2006, 10, 25, 14, 30, 00);
var expectedTime2 = new DateTime(2006, 10, 25, 14, 30, 59);
// Required
AssertExtras.Raises <ValidationException>(delegate
{
target.Clean(null);
}).WithMessage("This field is required.");
target.Required = false;
Assert.IsNull(target.Clean(null));
Assert.AreEqual(expectedTime2, target.Clean(new DateTime?(expectedTime2)));
Assert.AreEqual(expectedTime2, target.Clean("2006-10-25 14:30:59"));
Assert.AreEqual(expectedTime, target.Clean("2006-10-25 14:30"));
Assert.AreEqual(expectedDate, target.Clean("2006-10-25"));
Assert.AreEqual(expectedTime2, target.Clean("10/25/2006 14:30:59"));
Assert.AreEqual(expectedTime, target.Clean("10/25/2006 14:30"));
Assert.AreEqual(expectedDate, target.Clean("10/25/2006"));
Assert.AreEqual(expectedTime2, target.Clean("10/25/06 14:30:59"));
Assert.AreEqual(expectedTime, target.Clean("10/25/06 14:30"));
Assert.AreEqual(expectedDate, target.Clean("10/25/06"));
AssertExtras.Raises <ValidationException>(delegate
{
target.Clean("2006-10-25 14:30:61");
}).WithMessage("Enter a valid date.");
Assert.AreEqual(expectedTime2, target.Clean(new Tuple("2006-10-25", "14:30:59")));
AssertExtras.Raises <ValidationException>(delegate
{
target.Clean(new Tuple("2006-10-25", "14:30:59", "abc"));
}).WithMessage("Enter a valid date.");
}
public void CleanTest()
{
var target = new MultipleChoiceField()
{
Choices = Widgets.Choices.AustralianStates.Abbreviated
};
AssertExtras.Raises <ValidationException>(delegate() {
target.Clean(null);
}).WithMessage("This field is required.");
target.Required = false;
var result = target.Clean(null) as Collection <object>;
Assert.IsInstanceOfType(result, typeof(Collection <object>));
Assert.AreEqual(0, result.Count);
var validCollection = new Collection <object> {
"QLD", "SA"
};
var invalidCollection = new Collection <object> {
"QLD", "SA", "CA"
};
AssertExtras.Raises <ValidationException>(delegate()
{
target.Clean("123");
}).WithMessage("Select a valid choice. \"123\" is not one of the available choices.");
AssertExtras.ListIsEqual(validCollection, target.Clean(validCollection) as IList);
AssertExtras.Raises <ValidationException>(delegate()
{
target.Clean(invalidCollection);
}).WithMessage("Select a valid choice. \"CA\" is not one of the available choices.");
}