Question

我正在和我的朋友争论，我想知道你的意见。

在测试中，您认为是逐个字段进行比较还是创建一个 expectedResultObject 并进行比较更好。

例如：

Assert.That(obj.Foo).isEqualTo(FOO);
Assert.That(obj.Test).isEqualTo(TEST);

对比

Foo expected = new Foo(FOO, TEST);
assertThat(obj).usingRecursiveComparison().isEqualTo(expected);

在这个例子中，我们只有两个字段，但我们可以分配更多。

谢谢

Answer 1

如果您可以有多个字段，那么预期的方法会更好，因为您将在构造函数的参数中添加其他字段。想象一下，如果您有 100 个字段，按照您在第一个示例中的建议逐行添加它们会很头疼，而添加参数会更简单一些。

Answer 2

在这两种可能性之间，我更喜欢没有 usingRecursiveComparison() 的一种。

我想添加一些细项：

对象不是数据工具箱，因此添加 getter/setter 来测试对象的创建并不是一件好事。最好测试一种行为，一种可以测试回报的方法。
一般来说，我不喜欢在测试中编写多个断言。

有一种技术可以使断言更加可靠（使用 AssertJ，但我认为您可以使用 Hamcrest 实现这种功能）。

初始类：

public class Amount {
    private int value;

    public Integer add(int amountToAdd) {
        value += amountToAdd;
        
        return value;
    }
}

创建断言者：

public class IntegerAsserter extends org.assertj.core.api.AbstractAssert<IntegerAsserter, Integer> {
    IntegerAsserter(Integer actual) {
        super(IntegerAsserter.class, actual);
    }

    public IntegerAsserter isBetweenOneOrTwo() {
        Assert.assertTrue(actual < 2);
        Assert.assertTrue(actual > 1);

        return this;
    }
}

创建一个新的断言：

public class Assertions extends org.fest.assertions.Assertions {
    public static IntegerAsserter assertThat(Integer actual) {
        return new IntegerAsserter(actual);
    }
}

然后使用它：

public void should_be_between_one_or_two {
    Amount amount = new Amount(0);
    
    Integer newAmount = amount.add(1);

    Assertions.assertThat(obj).isBetweenOneOrTwo();
}

按字段或比较对象断言该字段

2 个答案: