837 lines
35 KiB
C#
837 lines
35 KiB
C#
// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
|
|
|
|
using System.Collections.Specialized;
|
|
using System.ComponentModel.DataAnnotations;
|
|
using System.Linq;
|
|
using System.Web.Mvc;
|
|
using System.Web.WebPages.Html;
|
|
using System.Web.WebPages.Scope;
|
|
using Moq;
|
|
using Xunit;
|
|
using Assert = Microsoft.TestCommon.AssertEx;
|
|
|
|
namespace System.Web.WebPages.Validation.Test
|
|
{
|
|
public class ValidationHelperTest
|
|
{
|
|
[Fact]
|
|
public void FormFieldKeyIsCommonToModelStateAndValidationHelper()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
string key = "_FORM";
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext());
|
|
|
|
// Act and Assert
|
|
Assert.Equal(key, ModelStateDictionary.FormFieldKey);
|
|
Assert.Equal(key, validationHelper.FormField);
|
|
}
|
|
|
|
[Fact]
|
|
public void AddThrowsIfFieldIsEmpty()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext());
|
|
|
|
// Act and Assert
|
|
Assert.ThrowsArgumentNullOrEmptyString(() => validationHelper.Add(field: null), "field");
|
|
Assert.ThrowsArgumentNullOrEmptyString(() => validationHelper.Add(field: String.Empty), "field");
|
|
}
|
|
|
|
[Fact]
|
|
public void AddThrowsIfValidatorsParamsArrayIsNull()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext());
|
|
|
|
// Act and Assert
|
|
Assert.ThrowsArgumentNull(() => validationHelper.Add("foo", null), "validators");
|
|
}
|
|
|
|
[Fact]
|
|
public void AddThrowsIfValidatorsAreNull()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext());
|
|
|
|
// Act and Assert
|
|
Assert.ThrowsArgumentNull(() => validationHelper.Add("foo", Validator.Required(), null, Validator.Range(0, 10)), "validators");
|
|
}
|
|
|
|
[Fact]
|
|
public void RequiredReturnsErrorMessageIfFieldIsNotPresentInForm()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
string message = "Foo is required.";
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext());
|
|
|
|
// Act
|
|
validationHelper.RequireField("foo", message);
|
|
var results = validationHelper.Validate();
|
|
|
|
// Assert
|
|
Assert.Equal(1, results.Count());
|
|
Assert.Equal(message, results.First().ErrorMessage);
|
|
}
|
|
|
|
[Fact]
|
|
public void RequiredReturnsErrorMessageIfFieldIsEmpty()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
string message = "Foo is required.";
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext(new { foo = "" }));
|
|
|
|
// Act
|
|
validationHelper.RequireField("foo", message);
|
|
var results = validationHelper.Validate();
|
|
|
|
// Assert
|
|
Assert.Equal(1, results.Count());
|
|
Assert.Equal(message, results.First().ErrorMessage);
|
|
}
|
|
|
|
[Fact]
|
|
public void RequiredReturnsNoValidationResultsIfFieldIsPresent()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
string message = "Foo is required.";
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext(new { foo = "some value" }));
|
|
|
|
// Act
|
|
validationHelper.RequireField("foo", message);
|
|
var results = validationHelper.Validate();
|
|
|
|
// Assert
|
|
Assert.Equal(0, results.Count());
|
|
}
|
|
|
|
[Fact]
|
|
public void RequiredUsesDefaultErrorMessageIfNoValueIsProvided()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext());
|
|
|
|
// Act
|
|
validationHelper.RequireField("foo");
|
|
var results = validationHelper.Validate();
|
|
|
|
// Assert
|
|
Assert.Equal(1, results.Count());
|
|
Assert.Equal("This field is required.", results.First().ErrorMessage);
|
|
}
|
|
|
|
[Fact]
|
|
public void RequiredReturnsValidationResultForEachFieldThatFailed()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
string message = "This field is required.";
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext());
|
|
|
|
// Act
|
|
validationHelper.RequireFields("foo", "bar");
|
|
var results = validationHelper.Validate();
|
|
|
|
// Assert
|
|
Assert.Equal(2, results.Count());
|
|
Assert.Equal(message, results.First().ErrorMessage);
|
|
Assert.Equal("foo", results.First().MemberNames.Single());
|
|
|
|
Assert.Equal(message, results.Last().ErrorMessage);
|
|
Assert.Equal("bar", results.Last().MemberNames.Single());
|
|
}
|
|
|
|
[Fact]
|
|
public void RequiredReturnsValidationResultForEachFieldThatFailedWhenFieldsIsEmpty()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
string message = "This field is required.";
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext());
|
|
|
|
// Act
|
|
validationHelper.RequireFields("foo", "bar");
|
|
var results = validationHelper.Validate(fields: null);
|
|
|
|
// Assert
|
|
Assert.Equal(2, results.Count());
|
|
Assert.Equal(message, results.First().ErrorMessage);
|
|
Assert.Equal("foo", results.First().MemberNames.Single());
|
|
|
|
Assert.Equal(message, results.Last().ErrorMessage);
|
|
Assert.Equal("bar", results.Last().MemberNames.Single());
|
|
}
|
|
|
|
[Fact]
|
|
public void GetValidationHtmlThrowsIfArgumentIsNullOrEmpty()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext());
|
|
|
|
// Act and Assert
|
|
Assert.ThrowsArgumentNullOrEmptyString(() => validationHelper.For(field: null), "field");
|
|
Assert.ThrowsArgumentNullOrEmptyString(() => validationHelper.For(field: String.Empty), "field");
|
|
}
|
|
|
|
[Fact]
|
|
public void RequireFieldThrowsIfValueIsNullOrEmpty()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext());
|
|
|
|
// Act and Assert
|
|
Assert.ThrowsArgumentNullOrEmptyString(() => validationHelper.RequireField(field: null), "field");
|
|
Assert.ThrowsArgumentNullOrEmptyString(() => validationHelper.RequireField(field: String.Empty), "field");
|
|
Assert.ThrowsArgumentNullOrEmptyString(() => validationHelper.RequireField(field: null, errorMessage: "baz"), "field");
|
|
Assert.ThrowsArgumentNullOrEmptyString(() => validationHelper.RequireField(field: String.Empty, errorMessage: null), "field");
|
|
}
|
|
|
|
[Fact]
|
|
public void RequireFieldsThrowsIfFieldsAreNullOrHasEmptyValues()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext());
|
|
|
|
// Act and Assert
|
|
Assert.ThrowsArgumentNull(() => validationHelper.RequireFields(fields: null), "fields");
|
|
Assert.ThrowsArgumentNullOrEmptyString(() => validationHelper.RequireFields(fields: new[] { "foo", null }), "field");
|
|
Assert.ThrowsArgumentNullOrEmptyString(() => validationHelper.RequireFields(fields: new[] { "foo", "" }), "field");
|
|
}
|
|
|
|
[Fact]
|
|
public void AddThrowsIfFieldIsNullOrEmpty()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext());
|
|
|
|
// Act and Assert
|
|
Assert.ThrowsArgumentNullOrEmptyString(() => validationHelper.Add(field: null), "field");
|
|
Assert.ThrowsArgumentNullOrEmptyString(() => validationHelper.Add(field: String.Empty), "field");
|
|
}
|
|
|
|
[Fact]
|
|
public void AddThrowsIfValidatorsIsNullOrAnyValidatorIsNull()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext());
|
|
|
|
// Act and Assert
|
|
Assert.ThrowsArgumentNull(() => validationHelper.Add(field: "foo", validators: null), "validators");
|
|
Assert.ThrowsArgumentNull(() => validationHelper.Add(field: "foo", validators: new[] { Validator.DateTime(), null }), "validators");
|
|
}
|
|
|
|
[Fact]
|
|
public void AddFormErrorCallsMethodInUnderlyingModelStateDictionary()
|
|
{
|
|
// Arrange
|
|
var message = "This is a form error.";
|
|
var dictionary = new ModelStateDictionary();
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext(), dictionary);
|
|
|
|
// Act
|
|
validationHelper.AddFormError(message);
|
|
|
|
// Assert
|
|
Assert.Equal(message, dictionary["_FORM"].Errors.Single());
|
|
}
|
|
|
|
[Fact]
|
|
public void GetValidationHtmlForRequired()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
string message = "Foo is required.";
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext());
|
|
|
|
// Act
|
|
validationHelper.RequireField("foo", message);
|
|
var validationHtml = validationHelper.For("foo");
|
|
|
|
// Assert
|
|
Assert.Equal(@"data-val-required=""Foo is required."" data-val=""true""", validationHtml.ToString());
|
|
}
|
|
|
|
[Fact]
|
|
public void ValidateReturnsAnEmptySequenceIfNoValidationsAreRegistered()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext());
|
|
|
|
// Act
|
|
var results = validationHelper.Validate();
|
|
|
|
// Assert
|
|
Assert.False(results.Any());
|
|
}
|
|
|
|
[Fact]
|
|
public void ValidatePopulatesModelStateDictionary()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
var modelStateDictionary = new ModelStateDictionary();
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext(), modelStateDictionary);
|
|
|
|
// Act
|
|
validationHelper.RequireFields(new[] { "foo", "bar" });
|
|
validationHelper.Validate();
|
|
|
|
// Assert
|
|
Assert.False(modelStateDictionary.IsValid);
|
|
Assert.False(modelStateDictionary.IsValidField("foo"));
|
|
Assert.False(modelStateDictionary.IsValidField("bar"));
|
|
Assert.Equal("This field is required.", modelStateDictionary["foo"].Errors.Single());
|
|
Assert.Equal("This field is required.", modelStateDictionary["bar"].Errors.Single());
|
|
}
|
|
|
|
[Fact]
|
|
public void IsValidPopulatesModelStateDictionary()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
var modelStateDictionary = new ModelStateDictionary();
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext(), modelStateDictionary);
|
|
|
|
// Act
|
|
validationHelper.RequireFields("foo", "bar");
|
|
validationHelper.IsValid();
|
|
|
|
// Assert
|
|
Assert.False(modelStateDictionary.IsValid);
|
|
Assert.False(modelStateDictionary.IsValidField("foo"));
|
|
Assert.False(modelStateDictionary.IsValidField("bar"));
|
|
Assert.Equal("This field is required.", modelStateDictionary["foo"].Errors.Single());
|
|
Assert.Equal("This field is required.", modelStateDictionary["bar"].Errors.Single());
|
|
}
|
|
|
|
[Fact]
|
|
public void GetErrorsPopulatesModelStateDictionary()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
var modelStateDictionary = new ModelStateDictionary();
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext(), modelStateDictionary);
|
|
|
|
// Act
|
|
validationHelper.RequireFields("foo", "bar");
|
|
validationHelper.GetErrors();
|
|
|
|
// Assert
|
|
Assert.False(modelStateDictionary.IsValid);
|
|
Assert.False(modelStateDictionary.IsValidField("foo"));
|
|
Assert.False(modelStateDictionary.IsValidField("bar"));
|
|
Assert.Equal("This field is required.", modelStateDictionary["foo"].Errors.Single());
|
|
Assert.Equal("This field is required.", modelStateDictionary["bar"].Errors.Single());
|
|
}
|
|
|
|
[Fact]
|
|
public void GetErrorsReturnsAnEmptySequenceIfNoValidationsAreRegistered()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext());
|
|
|
|
// Act
|
|
var results = validationHelper.GetErrors();
|
|
|
|
// Assert
|
|
Assert.False(results.Any());
|
|
}
|
|
|
|
[Fact]
|
|
public void GetErrorsReturnsErrorsAddedViaAddError()
|
|
{
|
|
// Arrange
|
|
var modelStateDictionary = new ModelStateDictionary();
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext(), modelStateDictionary);
|
|
|
|
// Act
|
|
modelStateDictionary.AddError("foo", "Foo error");
|
|
var errors = validationHelper.GetErrors("foo");
|
|
|
|
// Assert
|
|
Assert.Equal(new[] { "Foo error" }, errors);
|
|
}
|
|
|
|
[Fact]
|
|
public void GetErrorsReturnsFormErrors()
|
|
{
|
|
// Arrange
|
|
string error = "Unable to connect to remote servers.";
|
|
var modelStateDictionary = new ModelStateDictionary();
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext(), modelStateDictionary);
|
|
|
|
// Act
|
|
validationHelper.AddFormError(error);
|
|
var errors = validationHelper.GetErrors();
|
|
|
|
// Assert
|
|
Assert.Equal(error, errors.Single());
|
|
}
|
|
|
|
[Fact]
|
|
public void InvokingValidateMultipleTimesDoesNotCauseErrorMessagesToBeDuplicated()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
var modelStateDictionary = new ModelStateDictionary();
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext(), modelStateDictionary);
|
|
|
|
// Act
|
|
validationHelper.RequireField("foo", "Foo is required.");
|
|
validationHelper.RequireField("bar", "Bar is required.");
|
|
validationHelper.Validate();
|
|
Assert.False(validationHelper.IsValid());
|
|
validationHelper.Validate();
|
|
validationHelper.Validate();
|
|
|
|
// Assert
|
|
Assert.False(modelStateDictionary.IsValid);
|
|
Assert.False(modelStateDictionary.IsValidField("foo"));
|
|
Assert.False(modelStateDictionary.IsValidField("bar"));
|
|
Assert.Equal("Foo is required.", modelStateDictionary["foo"].Errors.Single());
|
|
Assert.Equal("Bar is required.", modelStateDictionary["bar"].Errors.Single());
|
|
}
|
|
|
|
[Fact]
|
|
public void AddWorksForCustomValidator()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
string message = "Foo is not an odd number.";
|
|
var oddValidator = new Mock<IValidator>();
|
|
oddValidator.Setup(c => c.Validate(It.IsAny<ValidationContext>())).Returns<ValidationContext>(v =>
|
|
{
|
|
Assert.IsAssignableFrom<HttpContextBase>(v.ObjectInstance);
|
|
var context = (HttpContextBase)v.ObjectInstance;
|
|
var value = Int32.Parse(context.Request.Form["foo"]);
|
|
|
|
if (value % 2 != 0)
|
|
{
|
|
return ValidationResult.Success;
|
|
}
|
|
return new ValidationResult(message);
|
|
}).Verifiable();
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext(new { foo = "6" }));
|
|
|
|
// Act
|
|
validationHelper.Add("foo", oddValidator.Object);
|
|
var result = validationHelper.Validate();
|
|
|
|
// Assert
|
|
Assert.Equal(1, result.Count());
|
|
Assert.Equal(message, result.First().ErrorMessage);
|
|
oddValidator.Verify();
|
|
}
|
|
|
|
[Fact]
|
|
public void ValidateRunsForSpecifiedFields()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
string message = "Foo is not an odd number.";
|
|
var oddValidator = new Mock<IValidator>();
|
|
oddValidator.Setup(c => c.Validate(It.IsAny<ValidationContext>())).Returns<ValidationContext>(v =>
|
|
{
|
|
Assert.IsAssignableFrom<HttpContextBase>(v.ObjectInstance);
|
|
var context = (HttpContextBase)v.ObjectInstance;
|
|
if (context.Request.Form["foo"].IsEmpty())
|
|
{
|
|
return ValidationResult.Success;
|
|
}
|
|
int value = context.Request.Form["foo"].AsInt();
|
|
if (value % 2 != 0)
|
|
{
|
|
return ValidationResult.Success;
|
|
}
|
|
return new ValidationResult(message);
|
|
}).Verifiable();
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext(new { foo = "", bar = "" }));
|
|
|
|
// Act
|
|
validationHelper.Add(new[] { "foo", "bar" }, oddValidator.Object);
|
|
validationHelper.RequireField("foo");
|
|
var result = validationHelper.Validate("foo");
|
|
|
|
// Assert
|
|
Assert.Equal(1, result.Count());
|
|
Assert.Equal("This field is required.", result.First().ErrorMessage);
|
|
}
|
|
|
|
[Fact]
|
|
public void GetErrorsReturnsAllErrorsIfNoParametersAreSpecified()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
string message = "Foo is not an odd number.";
|
|
var oddValidator = new Mock<IValidator>();
|
|
oddValidator.Setup(c => c.Validate(It.IsAny<ValidationContext>())).Returns<ValidationContext>(v =>
|
|
{
|
|
Assert.IsAssignableFrom<HttpContextBase>(v.ObjectInstance);
|
|
var context = (HttpContextBase)v.ObjectInstance;
|
|
if (context.Request.Form["foo"].IsEmpty())
|
|
{
|
|
return ValidationResult.Success;
|
|
}
|
|
int value = context.Request.Form["foo"].AsInt();
|
|
if (value % 2 != 0)
|
|
{
|
|
return ValidationResult.Success;
|
|
}
|
|
return new ValidationResult(message);
|
|
}).Verifiable();
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext(new { foo = "4", bar = "" }));
|
|
|
|
// Act
|
|
validationHelper.Add("foo", oddValidator.Object);
|
|
validationHelper.RequireFields(new[] { "bar", "foo" });
|
|
var result = validationHelper.GetErrors();
|
|
|
|
// Assert
|
|
Assert.Equal(2, result.Count());
|
|
Assert.Equal("Foo is not an odd number.", result.First());
|
|
Assert.Equal("This field is required.", result.Last());
|
|
}
|
|
|
|
[Fact]
|
|
public void IsValidReturnsTrueIfAllValuesPassValidation()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
string message = "Foo is not an odd number.";
|
|
var oddValidator = new Mock<IValidator>();
|
|
oddValidator.Setup(c => c.Validate(It.IsAny<ValidationContext>())).Returns<ValidationContext>(v =>
|
|
{
|
|
Assert.IsAssignableFrom<HttpContextBase>(v.ObjectInstance);
|
|
var context = (HttpContextBase)v.ObjectInstance;
|
|
if (context.Request.Form["foo"].IsEmpty())
|
|
{
|
|
return ValidationResult.Success;
|
|
}
|
|
int value = context.Request.Form["foo"].AsInt();
|
|
if (value % 2 != 0)
|
|
{
|
|
return ValidationResult.Success;
|
|
}
|
|
return new ValidationResult(message);
|
|
}).Verifiable();
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext(new { foo = "5", bar = "2" }));
|
|
|
|
// Act
|
|
validationHelper.Add(new[] { "foo", "bar" }, oddValidator.Object);
|
|
validationHelper.RequireField("foo");
|
|
var result = validationHelper.IsValid();
|
|
|
|
// Assert
|
|
Assert.True(result);
|
|
}
|
|
|
|
[Fact]
|
|
public void IsValidValidatesSpecifiedFields()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
string message = "Foo is not an odd number.";
|
|
var oddValidator = new Mock<IValidator>();
|
|
oddValidator.Setup(c => c.Validate(It.IsAny<ValidationContext>())).Returns<ValidationContext>(v =>
|
|
{
|
|
Assert.IsAssignableFrom<HttpContextBase>(v.ObjectInstance);
|
|
var context = (HttpContextBase)v.ObjectInstance;
|
|
int value;
|
|
if (!Int32.TryParse(context.Request.Form["foo"], out value))
|
|
{
|
|
return ValidationResult.Success;
|
|
}
|
|
if (value % 2 != 0)
|
|
{
|
|
return ValidationResult.Success;
|
|
}
|
|
return new ValidationResult(message);
|
|
}).Verifiable();
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext(new { foo = "3", bar = "" }));
|
|
|
|
// Act
|
|
validationHelper.Add(new[] { "foo", "bar" }, oddValidator.Object);
|
|
validationHelper.RequireFields(new[] { "foo", "bar" });
|
|
var result = validationHelper.IsValid("foo");
|
|
|
|
// Assert
|
|
Assert.True(result);
|
|
}
|
|
|
|
[Fact]
|
|
public void GetValidationHtmlReturnsNullIfNoRulesAreRegistered()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext());
|
|
|
|
// Assert
|
|
var validationAttributes = validationHelper.For("bar");
|
|
|
|
// Assert
|
|
Assert.Null(validationAttributes);
|
|
}
|
|
|
|
[Fact]
|
|
public void GetValidationHtmlReturnsAttributesForRegisteredValidators()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
var validator = new Mock<IValidator>();
|
|
var clientRules = new ModelClientValidationRule { ValidationType = "foo", ErrorMessage = "Foo error." };
|
|
clientRules.ValidationParameters["qux"] = "some data";
|
|
validator.Setup(c => c.ClientValidationRule).Returns(clientRules).Verifiable();
|
|
var expected = @"data-val-required=""This field is required."" data-val-foo=""Foo error."" data-val-foo-qux=""some data"" data-val=""true""";
|
|
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext());
|
|
|
|
// Act
|
|
validationHelper.RequireField("foo");
|
|
validationHelper.Add("foo", validator.Object);
|
|
var validationAttributes = validationHelper.For("foo");
|
|
|
|
// Assert
|
|
Assert.Equal(expected, validationAttributes.ToString());
|
|
}
|
|
|
|
[Fact]
|
|
public void GetValidationHtmlHtmlEncodesAttributeValues()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
var validator = new Mock<IValidator>();
|
|
var clientRules = new ModelClientValidationRule { ValidationType = "biz", ErrorMessage = "<Biz error.>" };
|
|
clientRules.ValidationParameters["qux"] = "<some ' data>";
|
|
validator.Setup(c => c.ClientValidationRule).Returns(clientRules).Verifiable();
|
|
var expected = @"data-val-required=""This field is required."" data-val-biz=""<Biz error.>"" data-val-biz-qux=""<some ' data>"" data-val=""true""";
|
|
|
|
// Act
|
|
ValidationHelper validationHelper = GetValidationHelper(GetContext());
|
|
|
|
// Assert
|
|
validationHelper.RequireField("foo");
|
|
validationHelper.Add("foo", validator.Object);
|
|
var validationAttributes = validationHelper.For("foo");
|
|
|
|
// Assert
|
|
Assert.Equal(expected, validationAttributes.ToString());
|
|
}
|
|
|
|
[Fact]
|
|
public void GetValidationFromClientValidationRulesThrowsIfValidationTypeIsNullOrEmpty()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
var clientRule = new ModelClientValidationRule { ValidationType = null };
|
|
|
|
// Act and Assert
|
|
Assert.Throws<InvalidOperationException>(() => ValidationHelper.GenerateHtmlFromClientValidationRules(new[] { clientRule }),
|
|
"Validation type names in unobtrusive client validation rules cannot be empty. Client rule type: System.Web.Mvc.ModelClientValidationRule");
|
|
|
|
clientRule.ValidationType = String.Empty;
|
|
Assert.Throws<InvalidOperationException>(() => ValidationHelper.GenerateHtmlFromClientValidationRules(new[] { clientRule }),
|
|
"Validation type names in unobtrusive client validation rules cannot be empty. Client rule type: System.Web.Mvc.ModelClientValidationRule");
|
|
}
|
|
|
|
[Fact]
|
|
public void GetValidationFromClientValidationRulesThrowsIfSameValidationTypeIsSpecifiedMultipleTimes()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
var clientRule1 = new ModelClientValidationRule { ValidationType = "foo" };
|
|
var clientRule2 = new ModelClientValidationRule { ValidationType = "foo" };
|
|
|
|
// Act and Assert
|
|
Assert.Throws<InvalidOperationException>(() => ValidationHelper.GenerateHtmlFromClientValidationRules(new[] { clientRule1, clientRule2 }),
|
|
"Validation type names in unobtrusive client validation rules must be unique. The following validation type was seen more than once: foo");
|
|
}
|
|
|
|
[Fact]
|
|
public void GetValidationFromClientValidationRulesThrowsIfValidationTypeDoesNotContainAllLowerCaseCharacters()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
var clientRule = new ModelClientValidationRule { ValidationType = "Foo" };
|
|
|
|
// Act and Assert
|
|
Assert.Throws<InvalidOperationException>(() => ValidationHelper.GenerateHtmlFromClientValidationRules(new[] { clientRule }),
|
|
"Validation type names in unobtrusive client validation rules must consist of only lowercase letters. Invalid name: \"Foo\", client rule type: System.Web.Mvc.ModelClientValidationRule");
|
|
|
|
clientRule.ValidationType = "bAr";
|
|
Assert.Throws<InvalidOperationException>(() => ValidationHelper.GenerateHtmlFromClientValidationRules(new[] { clientRule }),
|
|
"Validation type names in unobtrusive client validation rules must consist of only lowercase letters. Invalid name: \"bAr\", client rule type: System.Web.Mvc.ModelClientValidationRule");
|
|
|
|
clientRule.ValidationType = "bar123";
|
|
Assert.Throws<InvalidOperationException>(() => ValidationHelper.GenerateHtmlFromClientValidationRules(new[] { clientRule }),
|
|
"Validation type names in unobtrusive client validation rules must consist of only lowercase letters. Invalid name: \"bar123\", client rule type: System.Web.Mvc.ModelClientValidationRule");
|
|
}
|
|
|
|
[Fact]
|
|
public void GetValidationFromClientValidationRulesThrowsIfValidationParamaterContainsNonAlphaNumericCharacters()
|
|
{
|
|
// Arrange
|
|
RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
|
|
var clientRule = new ModelClientValidationRule { ValidationType = "required" };
|
|
clientRule.ValidationParameters["min^"] = "some-val";
|
|
|
|
// Act and Assert
|
|
Assert.Throws<InvalidOperationException>(() => ValidationHelper.GenerateHtmlFromClientValidationRules(new[] { clientRule }),
|
|
"Validation parameter names in unobtrusive client validation rules must start with a lowercase letter and consist of only lowercase letters or digits. Validation parameter name: min^, client rule type: System.Web.Mvc.ModelClientValidationRule");
|
|
|
|
clientRule.ValidationParameters.Clear();
|
|
clientRule.ValidationParameters["Min"] = "some-val";
|
|
|
|
Assert.Throws<InvalidOperationException>(() => ValidationHelper.GenerateHtmlFromClientValidationRules(new[] { clientRule }),
|
|
"Validation parameter names in unobtrusive client validation rules must start with a lowercase letter and consist of only lowercase letters or digits. Validation parameter name: Min, client rule type: System.Web.Mvc.ModelClientValidationRule");
|
|
}
|
|
|
|
[Fact]
|
|
public void DefaultValidCssClassIsNull()
|
|
{
|
|
Assert.Null(ValidationHelper.ValidCssClass);
|
|
}
|
|
|
|
[Fact]
|
|
public void DefaultInvalidCssClassIsSameAsHtmlHelper()
|
|
{
|
|
Assert.Equal(HtmlHelper.DefaultValidationInputErrorCssClass, ValidationHelper.InvalidCssClass);
|
|
}
|
|
|
|
[Fact]
|
|
public void InvalidCssClassIsNullIfExplicitlySetToNull()
|
|
{
|
|
using (ValidationHelper.OverrideScope())
|
|
{
|
|
ValidationHelper.InvalidCssClass = null;
|
|
Assert.Null(ValidationHelper.InvalidCssClass);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void ValidCssClassIsScopeBacked()
|
|
{
|
|
// Set a value
|
|
string old = ValidationHelper.ValidCssClass;
|
|
ValidationHelper.ValidCssClass = "outer";
|
|
using (ScopeStorage.CreateTransientScope())
|
|
{
|
|
ValidationHelper.ValidCssClass = "inner";
|
|
Assert.Equal("inner", ValidationHelper.ValidCssClass);
|
|
}
|
|
Assert.Equal("outer", ValidationHelper.ValidCssClass);
|
|
ValidationHelper.ValidCssClass = old;
|
|
}
|
|
|
|
[Fact]
|
|
public void InvalidCssClassIsScopeBacked()
|
|
{
|
|
// Set a value
|
|
string old = ValidationHelper.InvalidCssClass;
|
|
ValidationHelper.InvalidCssClass = "outer";
|
|
using (ScopeStorage.CreateTransientScope())
|
|
{
|
|
ValidationHelper.InvalidCssClass = "inner";
|
|
Assert.Equal("inner", ValidationHelper.InvalidCssClass);
|
|
}
|
|
Assert.Equal("outer", ValidationHelper.InvalidCssClass);
|
|
ValidationHelper.InvalidCssClass = old;
|
|
}
|
|
|
|
[Fact]
|
|
public void ClassForReturnsNullIfNotPost()
|
|
{
|
|
// Arrange
|
|
ValidationHelper helper = GetValidationHelper();
|
|
|
|
// Act/Assert
|
|
Assert.Null(helper.ClassFor("foo"));
|
|
}
|
|
|
|
[Fact]
|
|
public void ClassForReturnsValidClassNameIfNoErrorsAddedForField()
|
|
{
|
|
// Arrange
|
|
ValidationHelper helper = GetPostValidationHelper();
|
|
|
|
// Act/Assert
|
|
HtmlString html = helper.ClassFor("foo");
|
|
string str = html == null ? null : html.ToHtmlString();
|
|
Assert.Equal(ValidationHelper.ValidCssClass, str);
|
|
}
|
|
|
|
[Fact]
|
|
public void ClassForReturnsInvalidClassNameIfFieldHasErrors()
|
|
{
|
|
// Arrange
|
|
ValidationHelper helper = GetPostValidationHelper();
|
|
helper.Add("foo", new AutoFailValidator());
|
|
|
|
// Act/Assert
|
|
Assert.Equal(ValidationHelper.InvalidCssClass, helper.ClassFor("foo").ToHtmlString());
|
|
}
|
|
|
|
private static ValidationHelper GetPostValidationHelper()
|
|
{
|
|
HttpContextBase context = GetContext();
|
|
Mock.Get(context.Request).SetupGet(c => c.HttpMethod).Returns("POST");
|
|
ValidationHelper helper = GetValidationHelper(httpContext: context);
|
|
return helper;
|
|
}
|
|
|
|
private static HttpContextBase GetContext(object formValues = null)
|
|
{
|
|
var context = new Mock<HttpContextBase>();
|
|
var request = new Mock<HttpRequestBase>();
|
|
|
|
var nameValueCollection = new NameValueCollection();
|
|
if (formValues != null)
|
|
{
|
|
foreach (var prop in formValues.GetType().GetProperties())
|
|
{
|
|
nameValueCollection.Add(prop.Name, prop.GetValue(formValues, null).ToString());
|
|
}
|
|
}
|
|
request.SetupGet(c => c.Form).Returns(nameValueCollection);
|
|
context.SetupGet(c => c.Request).Returns(request.Object);
|
|
|
|
return context.Object;
|
|
}
|
|
|
|
private static ValidationHelper GetValidationHelper(HttpContextBase httpContext = null, ModelStateDictionary modelStateDictionary = null)
|
|
{
|
|
httpContext = httpContext ?? GetContext();
|
|
modelStateDictionary = modelStateDictionary ?? new ModelStateDictionary();
|
|
|
|
return new ValidationHelper(httpContext, modelStateDictionary);
|
|
}
|
|
|
|
private class AutoFailValidator : IValidator
|
|
{
|
|
|
|
public ValidationResult Validate(ValidationContext validationContext)
|
|
{
|
|
return new ValidationResult("Failed!");
|
|
}
|
|
|
|
public ModelClientValidationRule ClientValidationRule
|
|
{
|
|
get { throw new NotImplementedException(); }
|
|
}
|
|
}
|
|
}
|
|
}
|