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"));
}
