如何调用验证属性进行测试？

Question

我正在使用 DataAnnotations 中的 RegularExpressionAttribute 进行验证，并想测试我的正则表达式。有没有办法在单元测试中直接调用该属性？

我希望能够做类似的事情：

public class Person
{
    [RegularExpression(@"^[0-9]{3}-[0-9]{3}-[0-9]{4}$")]
    public string PhoneNumber { get; set; }
}

然后在单元测试中：

[TestMethod]
public void PhoneNumberIsValid
{
    var dude = new Person();
    dude.PhoneNumber = "555-867-5309";

    Assert.IsTrue(dude.IsValid);
}

或者甚至

Assert.IsTrue(dude.PhoneNumber.IsValid);

Answer 1

我最终使用了 DataAnnotations 命名空间中的静态 Validator 类。我的测试现在看起来像这样：

[TestMethod]
public void PhoneNumberIsValid()
{
    var dude = new Person();
    dude.PhoneNumber = "666-978-6410";

    var result = Validator.TryValidateObject(dude, new ValidationContext(dude, null, null), null, true);

    Assert.IsTrue(result);
}

Answer 2

只需新建一个 RegularExpressionAttribute 对象即可。

var regularExpressionAttribute = new RegularExpressionAttribute("pattern");

Assert.IsTrue(regularExpressionAttribute.IsValid(objToTest));

Answer 3

抱歉回复晚了。

我是新来的。如果您想测试隔离中的每个 ValidationAttribute，您可以继续执行下一种方式，例如：

    [Test]
    public void Test_the_State_value_IsRequired()
    {
        string value = "Finished";
        var propertyInfo = typeof(TimeoffTemporalIncapacityEntry).GetProperty("State");
        var attribute = propertyInfo.GetCustomAttributes(typeof(RequiredAttribute), true).Cast<RequiredAttribute>().FirstOrDefault();
        Assert.IsTrue(attribute.IsValid(value));
    }

Answer 4

我使用了 @Martin 的建议以及静态常量文件，这使我可以避免在本地指定正则表达式字符串

[TestMethod]
public void Test_Regex_NationalinsuranceNumber()
{
    var regularExpressionAttribute = new RegularExpressionAttribute(Constants.Regex_NationalInsuranceNumber_Validate);

    List<string> validNINumbers = new List<string>() { "TN311258F", "QQ123456A" };
    List<string> invalidNINumbers = new List<string>() { "cake", "1234", "TS184LZ" };
    validNINumbers.ForEach(p => Assert.IsTrue(regularExpressionAttribute.IsValid(p)));
    invalidNINumbers.ForEach(p => Assert.IsFalse(regularExpressionAttribute.IsValid(p)));
}

Answer 5

您可以使用此类来验证隔离中的任何 ValidationAttribute 类型：
T = 包含属性的类类型，
A = 类型 ValidationAttribute

示例：

string stateValue = "Pendiente";
ValidationAttributeValidator<ConfirmationTemporalIncapacityEntry, RequiredAttribute> validator =
    new ValidationAttributeValidator<ConfirmationTemporalIncapacityEntry, RequiredAttribute>();
Assert.IsTrue(validator.ValidateValidationAttribute("State", stateValue));


public class ValidationAttributeValidator<T,A>
{
    public ValidationAttributeValidator() { }

    public bool ValidateValidationAttribute(string property, object value)
    {
        var propertyInfo = typeof(T).GetProperty(property);
        var validationAttributes = propertyInfo.GetCustomAttributes(true);

        if (validationAttributes == null)
        {
            return false; 
        }
        List<ValidationAttribute> validationAttributeList = new List<ValidationAttribute>();
        foreach (object attribute in validationAttributes)
        {
            if (attribute.GetType() == typeof(A))
            {
                validationAttributeList.Add((ValidationAttribute)attribute);
            }
        }
        return(validationAttributeList.Exists(x => x.IsValid(value)));
    }
}

Answer 6

在 @Evelio 的答案的基础上，我将提供一个关于如何对自定义验证器进行单元测试的答案，因为这似乎在互联网上的任何地方都没有阐明，并且这是在搜索如何做时出现的热门点击之一它。

@Evelio 的答案非常接近，但还需要更多的解释。

要测试验证，您需要一个将验证属性附加到其成员数据的类。在这里，我使用了一个新的自定义验证器，它对我的​​项目有意义，称为 FeeTimeUnitValidator。该验证器采用一个范围和另一个属性作为输入。如果其他属性为零，则验证器附加到的属性并不重要。但如果另一个属性不为零，则该属性需要在范围内。
这是我用于测试的 MockClass：

    class MockClass
    {
        public decimal Fee { get; set; }

        [FeeTimeUnitValidator(otherPropertyName:"Fee", minValue:1, maxValue:12)]
        public int attributeUnderTest { get; set; }

        public int badOtherProperty { get; set; }
        [FeeTimeUnitValidator(otherPropertyName: "badOtherProperty", minValue: 1, maxValue: 12)]
        public int badAttributeUnderTest { get; set; }

        [FeeTimeUnitValidator(otherPropertyName: "NotFoundAttribute", minValue: 1, maxValue: 12)]
        public int nameNotFoundAttribute { get; set; }
    }

注意属性验证：

[FeeTimeUnitValidator(otherPropertyName:"Fee", minValue:1, maxValue:12)]

这表示检查属性“Fee”作为 Fee 属性（即，它必须非零），然后范围为 1 - 12。

我实例化类在单元测试类中并使用设置方法进行设置。由于此类上有三个具有验证器的属性，因此我将属性的名称传递到设置类中。

    private MockClass classUnderTest;
    private ValidationContext context;

    FeeTimeUnitValidator setup(string attributeUnderTest)
    {
        classUnderTest = new MockClass();
        classUnderTest.Fee = 0;
        var propertyInfo = typeof(MockClass).GetProperty(attributeUnderTest);
        var validatorArray = propertyInfo.GetCustomAttributes(typeof(FeeTimeUnitValidator), true);

        Assert.AreEqual(1, validatorArray.Length);
        var validator = validatorArray[0];
        Assert.IsTrue(validator.GetType().Equals(typeof(FeeTimeUnitValidator)));

        context = new ValidationContext(classUnderTest, null, null);

        return (FeeTimeUnitValidator)validator;
    }

有一些有趣的事情。我正在使用 @Evelio 的方法从属性中提取验证器。这是设置例程的第 3 行和第 4 行中的内容。然后，由于这是一个单元测试方法，我做了一些断言以确保我得到了我所期望的结果。当我将此模式转移到另一个验证器的另一个单元测试类时，这实际上遇到了一个问题。

然后另一个关键是我创建 ValidationContext （因为更复杂的验证器需要一个上下文来查找它们引用的其他属性 - 在我的例子中，我使用它来查找 Fee 属性）。当我研究如何对这些自定义验证器进行单元测试时，让我困惑的是 ValidationContext。我找不到任何有关如何创建它们的信息。我相信属性验证的“上下文”是属性所在的类。这就是为什么我使用类实例作为第一个参数创建验证上下文。然后，这为验证器提供了对类上其他属性的访问权限，以便您可以进行跨属性验证。

现在我已经创建了上下文和指向验证器的指针，我可以跳入单元测试本身以确保验证器正确完成其工作：

    [TestMethod]
    public void TestInRangeIsValidWhenFeeNonZero()
    {
        // Arrange
        var validator = setup("attributeUnderTest");
        classUnderTest.Fee = 10;

        // Act
        ValidationResult value12 = validator.GetValidationResult(12, context);
        ValidationResult value1 = validator.GetValidationResult(1, context);
        ValidationResult value5 = validator.GetValidationResult(5, context);

        // Assert
        Assert.AreEqual(ValidationResult.Success, value12);
        Assert.AreEqual(ValidationResult.Success, value1);
        Assert.AreEqual(ValidationResult.Success, value5);
    }

如果我的验证器不需要上下文（即，它可以验证属性）不引用其他属性），那么我可以使用更简单的 IsValid() 接口，但如果验证器需要非空上下文，则必须使用 GetValidationResult() 方法，就像我在这里所做的那样。

我希望这对那些可能正在编写验证器并且像我一样热衷于单元测试的人有所帮助。 :)

这是一篇关于创建自定义验证器的好文章。

Answer 7

扩展@CobraGeek的答案和@Erik的评论，您可以使用Validator.TryValidateProperty来仅验证一个字段而不是整个对象，如下所示

var results = new List<ValidationResult>();

Person dude = new Person();

System.ComponentModel.TypeDescriptor.AddProviderTransparent
(new AssociatedMetadataTypeTypeDescriptionProvider(dude.GetType()), dude.GetType());

dude.PhoneNumber = "555-867-5309";

var vc = new ValidationContext(dude, null, null);

vc.MemberName = "PhoneNumber";   

bool result = Validator.TryValidateProperty(dude.PhoneNumber, vc, results);

： >result 是表示验证成功的布尔值，如果为 false，results 包含抛出的错误的详细信息列表。

Answer 8

// You can do something like this.
[TestMethod]
public void PhoneNumberIsValid
{
    var propInfo = typeof(Person).GetProperty("PhoneNumber");
    var attr = propInfo.GetCustomAttributes(typeof(RegularExpressionAttribute), true);

    // Act Assert Positives
        Assert.IsTrue(((RegularExpressionAttribute)attr [0]).IsValid("555-55-5555"));

        // Act Assert Negative
      Assert.IsFalse(((RegularExpressionAttribute)attr[0]).IsValid("123654654654"));

        }