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 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 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 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 UpdateTest() { Dictionary <string, string> target = new Dictionary <string, string>() { { "test1", "test1" }, { "test2", "test2" }, { "test3", "test3" } }; Dictionary <string, string> append = new Dictionary <string, string>() { { "test4", "test4" }, { "test5", "test5" }, { "test2", "test6" } }; Dictionary <string, string> result = new Dictionary <string, string>() { { "test1", "test1" }, { "test2", "test2" }, { "test3", "test3" }, { "test4", "test4" }, { "test5", "test5" } }; target.Update(append); AssertExtras.DictionaryIsEqual(result, target); target.Update(null); AssertExtras.DictionaryIsEqual(result, target); }
public void GetEnumeratorTest() { Tuple target = new Tuple("123", "321", 42); AssertExtras.AreEqual(new object[3] { "123", "321", 42 }, target.AsWeakEnumerable()); }
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 CleanTest() { var target = new UrlField(); // OK values target.Clean("http://www.example.com/"); // Bad values AssertExtras.Raises <ValidationException>(delegate() { target.Clean("blah"); }); }
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 GetEnumeratorTest1() { IEnumerable target = new FilePathCollection(); AssertExtras.Raises <ArgumentException>(delegate() { foreach (var choice in target) { } }); }
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 GetValueFromDataCollectionTest() { BaseMultiWidget target = CreateBaseMultiWidget(); // TODO: Initialize to an appropriate value var data = new NameValueCollection { { "Test10", "Test1" }, { "Test11", bool.TrueString }, }; AssertExtras.AreEqual(new object[] { "Test1", bool.TrueString }, target.GetValueFromDataCollection(data, null, "Test1") as IEnumerable); }
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 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 GetValueFromDataCollectionTest() { var data = new NameValueCollection(); var target = new SelectMultiple(); Assert.AreEqual(null, target.GetValueFromDataCollection(data, null, "test")); data["test"] = ""; Assert.AreEqual(null, target.GetValueFromDataCollection(data, null, "test")); data["test"] = "1,2,3,4,5"; AssertExtras.AreEqual(new string[] { "1", "2", "3", "4", "5" }, target.GetValueFromDataCollection(data, null, "test") as IEnumerable); }
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 RadioInputConstructorTest() { string name = "Test1"; string value = "TestVal"; ElementAttributesDictionary attributes = new ElementAttributesDictionary(); IChoice choice = new Choice("test"); int index = 4; RadioInput target = new RadioInput(name, value, attributes, choice, index); Assert.AreEqual(name, target.Name); Assert.AreEqual(value, target.Value); Assert.AreEqual(index, target.Index); Assert.AreSame(choice, target.Choice); AssertExtras.DictionaryIsEqual(attributes, target.Attributes); }
public void SplitStringTest() { List <object> empty = new List <object>(); List <object> single = new List <object>() { "test1" }; List <object> multiple = new List <object>() { "test1", "test2", "test3" }; AssertExtras.ListIsEqual(empty, ConversionHelper.SplitString(null)); AssertExtras.ListIsEqual(empty, ConversionHelper.SplitString(string.Empty)); AssertExtras.ListIsEqual(single, ConversionHelper.SplitString("test1")); AssertExtras.ListIsEqual(multiple, ConversionHelper.SplitString("test1,test2,test3")); }
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 ObjectListTest() { Collection <object> empty = new Collection <object>(); string[] stringArray = new string[] { "a", "b", "c" }; List <object> stringList = new List <object>() { "a", "b", "c" }; List <object> single = new List <object>() { "test1" }; Assert.IsNull(ConversionHelper.ObjectList(null)); Assert.AreSame(empty, ConversionHelper.ObjectList(empty)); AssertExtras.ListIsEqual(stringList, ConversionHelper.ObjectList(stringArray)); AssertExtras.ListIsEqual(single, ConversionHelper.ObjectList("test1")); }