Question

假设我有一个具有类似属性的类：

public string First { get; set; }
public string Second { get; set; }
public string Third { get; set; }

我想在测试中以相同的方式测试它们......所以我写道：

[Test]
public void TestFirst()
{
    // Asserting strings here
}

有没有办法避免创建三个测试（一个用于第一个，一个用于第二个，一个用于第三个）？

我正在寻找像[Values(First, Second, Third)]这样的东西，所以我可以编写一个将遍历属性的测试。

干杯，并提前感谢：）

Answer 1

这个怎么样：

[TestFixture]
public class Tests
{
    [Test]
    public void Test()
    {
        var obj = new MyClass();

        obj.First = "some value";
        obj.Second = "some value";
        obj.Third = "some value";

        AssertPropertyValues(obj, "some value", x => x.First, x => x.Second, x => x.Third);
    }

    private void AssertPropertyValues<T, TProp>(T obj, TProp expectedValue, params Func<T, TProp>[] properties)
    {
        foreach (var property in properties)
        {
            TProp actualValue = property(obj);
            Assert.AreEqual(expectedValue, actualValue);
        }
    }
}

Answer 2

您应该可以将expression trees用于此目的。使用Expression.Property方法的MSDN文档，我创建了以下帮助方法，用于从任意对象T获取名为propertyName的类型obj属性：

public T InvokePropertyExpression<T>(object obj, string propertyName)
{
    return Expression.Lambda<Func<T>>(Expression.Property(
               Expression.Constant(obj), propertyName)).Compile()();
}

在我的单元测试中使用这个帮助器方法，我现在可以根据其名称访问相关属性，例如：

[Test, Sequential]
public void Tests([Values("First", "Second", "Third")] string propertyName,
                  [Values("hello", "again", "you")] string expected)
{
    var obj = new SomeClass 
        { First = "hello", Second = "again", Third = "you" };
    var actual = InvokePropertyExpression<string>(obj, propertyName);
    Assert.AreEqual(expected, actual);
}

Answer 3

使用NUnit.Framework.Constraints.Constraint表达这种断言有很多可能性。此外，您可以使用ValuesAttribute或TestCaseAttribute

为测试描述更多输入，而不是使用ValuesSoueceAttribute或TestCaseSourceAttribute

描述测试输入

让我们使用TestCaseSourceAttribute

定义预期的属性名称及其值

public IEnumerable TestCasesSourcesAllProperties
{
    get
    {
        yield return new TestCaseData(
            new Tuple<string, string>[] { 
                Tuple.Create("First", "foo"), 
                Tuple.Create("Second", "bar"), 
                Tuple.Create("Third", "boo") } as object)
                    .SetDescription("Test all properties using Constraint expression");
    }
}

在单个测试中构建约束

现在我们可以在单个测试中为所有三个属性构建约束

// get test parameters from TestCasesSourcesAllProperties
[TestCaseSource("TestCasesSourcesAllProperties")]
public void ClassUnderTest_CheckAllProperty_ExpectValues(Tuple<string, string>[] propertiesNamesWithValues)
{
    // Arrange
    ClassUnderTest cut = null;

    // Act: perform actual test, here is only assignment
    cut = new ClassUnderTest { First =  "foo", Second = "bar",  Third  = "boo" };

    // Assert
    // check that class-under-test is not null
    NUnit.Framework.Constraints.Constraint expression = Is.Not.Null;

    foreach(var property in propertiesNamesWithValues)
    {
        // add constraint for every property one by one
        expression = expression.And.Property(property.Item1).EqualTo(property.Item2);
    }

    Assert.That(cut, expression);
}

这是a full example

缺点

内部测试逻辑中的协调逻辑，即foreach

Answer 4

这样做很容易，但我怀疑它是否值得。

如何 - 上面的许多答案都有效，但这似乎最简单，假设你正在测试一个新创建的对象......

[TestCase("First", "foo"]
[TestCase("Second", 42]
[TestCase("Third", 3.14]
public void MyTest(string name, object expected)
{
    Assert.That(new MyClass(), Has.Property(name).EqualTo(expected));
}

然而，在测试中放置三个单独的断言似乎更容易阅读......

[Test]
public void MyTest()
{
    var testObject = new MyClass();
    Assert.That(testObject, Has.Property("First").EqualTo("foo"));
    Assert.That(testObject, Has.Property("Second").EqualTo(42));
    Assert.That(testObject, Has.Property("Third").EqualTo(3.14));
}

当然，这假设三个断言都是测试一件事的一部分，比如DefaultConstructorInitializesMyClassCorrectly。如果那不是你正在测试的，那么三个测试更有意义，即使它需要更多的输入。一种方法是确定您是否能够为测试找到合理的名称。

查理

Answer 5

您可以对参数使用Values属性来测试方法：

[Test]
public void MyTest([Values("A","B")] string s)
{
    ...
}

但是，这只适用于字符串常量（即不是属性值）。

我猜你可以使用反射从给定的值中获取属性的值，例如

[Test]
public void MyTest([Values("A","B")] string propName)
{
    var myClass = new MyClass();
    var value = myClass.GetType().GetProperty(propName).GetValue(myClass, null);

    // test value
}

但这并不是最干净的解决方案。也许你可以编写一个调用方法来测试每个属性的测试。

[Test]
public void MyTest()
{
    var myClass = new MyClass();
    MyPropertyTest(myClass.First);
    MyPropertyTest(myClass.Second);
    MyPropertyTest(myClass.Third);
}

public void MyPropertyTest(string value)
{
    // Assert on string
}

但是，最好避免使用这种测试方式，因为单元测试应该这样做 - 测试一个代码单元。如果每个测试都被正确命名，它可以用来记录您期望的内容，并且可以在将来轻松添加。

Answer 6

您可以编写参数化测试并将属性访问器作为参数传递：

参见示例：假设您的班级有3个属性：

public class MyClass
{
    public string First { get; set; }
    public string Second { get; set; }
    public string Third { get; set; }
}

然后测试可能看起来：

[TestFixture]
public class MyTest
{
    private TestCaseData[] propertyCases = new[]
        {
            new TestCaseData(
                "First",
                (Func<MyClass, string>) (obj => obj.First),
                (Action<MyClass, string>) ((obj, newVal) => obj.First = newVal)),

            new TestCaseData(
                "Second",
                (Func<MyClass, string>) (obj => obj.Second),
                (Action<MyClass, string>) ((obj, newVal) => obj.Second = newVal)),

            new TestCaseData(
                "Third",
                (Func<MyClass, string>) (obj => obj.Third),
                (Action<MyClass, string>) ((obj, newVal) => obj.Third = newVal))
        };

    [Test]
    [TestCaseSource("propertyCases")]
    public void Test(string description, Func<MyClass, string> getter, Action<MyClass, string> setter)
    {
        var obj = new MyClass();
        setter(obj, "42");

        var actual = getter(obj);

        Assert.That(actual, Is.EqualTo("42"));
    }
}

几句注意事项：
1.未使用的字符串描述作为第一个参数传递，以区分通过NUnit测试运行器UI或Resharper运行的测试用例。
2. Tet案例是独立的，即使First属性的测试失败，也会运行其他2个测试 3.可以通过NUnit测试运行器UI或Resharper单独运行一个测试用例。

所以，你的测试是干净的，干的：）

Answer 7

感谢大家的回答和帮助。学到了很多东西。

这就是我最终做的事情。我使用了反射来获取所有的字符串属性，然后设置为一个值，设置检查值，设置为null，检查它是否返回一个空字符串（属性的getter中的逻辑）。

[Test]
public void Test_AllStringProperties()
{
    // Linq query to get a list containing all string properties
    var string_props= (from prop in bkvm.GetType()
                            .GetProperties(BindingFlags.Public | BindingFlags.Instance)
                      where
                        prop.PropertyType == typeof(string) &&
                        prop.CanWrite && prop.CanRead
                      select prop).ToList();

    string_props.ForEach(p =>{
                                 // Set value of property to a different string
                                 string set_val = string.Format("Setting [{0}] to: \"Testing string\".", p.Name);
                                 p.SetValue(bkvm, "Testing string", null);
                                 Debug.WriteLine(set_val);
                                 // Assert it was set correctly
                                 Assert.AreEqual("Testing string", p.GetValue(bkvm, null));

                                 // Set property to null
                                 p.SetValue(bkvm,null,null);
                                 set_val = string.Format("Setting [{0}] to null. Should yield an empty string.", p.Name);
                                 Debug.WriteLine(set_val);
                                 // Assert it returns an empty string.
                                 Assert.AreEqual(string.Empty,p.GetValue(bkvm, null));
                             }
        );
}

这样我就不需要担心是否有人添加了属性，因为它会自动检查，而不需要更新测试代码（正如您可能猜到的那样，并非所有人都更新或编写测试：）< / p>

欢迎对此解决方案发表任何评论。

有没有办法测试类似的属性？

7 个答案:

描述测试输入

在单个测试中构建约束

缺点