java - 如何在 spock 或 hamcrest 中创建自定义域特定断言/匹配器

Question

我正在尝试在 spock 或 hamcrest 中编写与自定义域相关的断言/匹配器，但我不确定如何继续。

我尝试在 hamcrest 中编写自定义匹配器，但到目前为止，这仅使我得到了部分解决方案。

我正在寻找一些指导，了解在这种情况下正确的做法是什么。

域对象:

• ResultMap 有一个对象 Map < ILine, IResult > - 有一个INodeResult 与每个 ILine 关联。
• IResult 有 4 个 (Google Guava) 多 map 对象需要验证。

我想在我的 spock 测试中做的是这样的:

expect:
  that actualResultMap, matchesInAnyOrder(expectedResultMap)
  or
  that actualResultMap, matches(expectedResultMap) // Will only match if everything is in the same order.

然后内部代码将评估每个条目并对内部对象进行适当的测试。

到目前为止，我设法编写了评估一组多重映射的代码的一部分，但我不确定如何链接我的测试。

自定义匹配器:

package com.ps.DE.Test.CustomMatcher

import org.hamcrest.BaseMatcher

class MultimapMatcher {

    /**
     * Checks all the entries in a Multimap with another
     * @param expected
     * @return Shows the failure only if the entries do not match or are not in the same order
     */
    static hasAllInOrder(final com.google.common.collect.Multimap expected){
        [
                matches: { actual ->
                    for(key in actual.keySet()){
                        if (actual.get(key) != expected.get(key)){
                            return false
                        }
                    }
                    return true
                },
                describeTo: { description ->
                    description.appendText("MultiMap entries to be ${expected}")
                },
                describeMismatch: { actual, description ->
                    description.appendText("were ${actual}")
                }
        ]   as BaseMatcher
    }

    /**
     * Checks all the entries in a Multimap with another
     * @param expected
     * @return Shows the failure only if the entries do not match
     */
    static hasAllInAnyOrder(final com.google.common.collect.Multimap expected){
        [
                matches: { actual ->
                    for(key in actual.keySet()){
                        if (!actual.get(key).containsAll(expected.get(key))) {
                            return false
                        }
                    }
                    return true
                },
                describeTo: { description ->
                    description.appendText("MultiMap entries to be ${expected}")
                },
                describeMismatch: { actual, description ->
                    description.appendText("were ${actual}")
                }
        ]   as BaseMatcher
    }
}

测试自定义匹配器:

package com.ps.DE.Test.CustomMatcher

import com.google.common.collect.ArrayListMultimap
import com.google.common.collect.Multimap
import spock.lang.Specification

import static com.ps.DE.Test.CustomMatcher.MultimapMatcher.hasAllInAnyOrder
import static com.ps.DE.Test.CustomMatcher.MultimapMatcher.hasAllInOrder
import static org.hamcrest.Matchers.not
import static spock.util.matcher.HamcrestSupport.that


class MultimapMatcherSpec extends Specification {

    def "Test hasAllInOrder"() {
        def actual = ArrayListMultimap.create();

        // Adding some key/value
        actual.put "Fruits", "Apple"
        actual.put "Fruits", "Banana"
        actual.put "Fruits", "Pear"
        actual.put "Vegetables", "Carrot"

        Multimap<String, String> expected = ArrayListMultimap.create();

        // Adding some key/value
        expected.put("Fruits", "Apple");
        expected.put("Fruits", "Banana");
        expected.put("Fruits", "Pear");
        expected.put("Vegetables", "Carrot");

        expect:

        that actual, hasAllInAnyOrder(expected)
        that actual, hasAllInOrder(expected)
    }

    def "Test hasAllInAnyOrder"() {
        Multimap<String, String> actual = ArrayListMultimap.create();

        // Adding some key/value
        actual.put("Fruits", "Apple");
        actual.put("Fruits", "Banana");
        actual.put("Fruits", "Pear");
        actual.put("Vegetables", "Carrot");

        Multimap<String, String> expected = ArrayListMultimap.create();

        // Adding some key/value
        expected.put("Fruits", "Banana");
        expected.put("Fruits", "Apple");
        expected.put("Fruits", "Pear");
        expected.put("Vegetables", "Carrot");

        expect:
        that actual, hasAllInAnyOrder(expected)
        that actual, not(hasAllInOrder(expected))
    }
}

任何帮助或指导将不胜感激。

Answer 1

为什么你需要自定义匹配器？也许，Spock 和 Groovy 足够强大，无需自定义匹配器即可满足您的需求。

要匹配两个具有相同内容且顺序相同的 Multimap 对象，只需执行以下操作:

expected:
actual == expected

向同一个断言添加更多代码有什么好处吗？

对于任何顺序的匹配，这有点棘手，但添加排序方法就足够了(可以在其他测试类中提取和重用)。这可能看起来像:

expected:
sortValues(actual) == sortValues(expected)

以及方法本身:

static Map<String, Collection<String>> sortValues(Multimap<String, String> multimap) {
    multimap.asMap().collectEntries {
        [it.key, it.value.sort(false)]
    }
}

也许为了更好的规范可读性 sortValues() 可能具有名称 anyOrder() 这将使断言看起来像:

expect:
anyOrder(actual) == anyOrder(expected)

The internal code will then evaluate each entry and do the appropriate tests on the inner objects as well.

这部分可以通过比较每个对象类型的equals方法来实现。