如何监视Spock/Groovy中的闭包或代理？

Question

如何监视Spock/Groovy中的闭包或代理？

Spock有一个限制，您不能使用以下样式的交互测试模式：

setup:
subscriber.receive("message1") >> "ok"

when:
publisher.send("message1")

then:
1 * subscriber.receive("message1")

1 * subscriber.receive("message1") >> "ok"

#!groovy
import spock.lang.Specification

class C {
    def c
    C (Closure c) { this.c = c }

    def call (Map args = null) { args? c?.call (args) : c?.call() }
    def call (Map args = null, one) { args? c?.call (args, one) : c?.call (one) }
    def call (Map args = null, one, two) { args? c?.call (args, one, two) : c?.call (one, two) }
    // etc.
}

class spyTest extends Specification {

    void "should accept 0 args" () {
        given:
            def foo = Spy (C, constructorArgs:[{return "foo"}])
        when:
            def result = foo ()
        then:
            1 * foo()
            result == "foo"
    }

    void "should accept 1 positional args, 0 named args" () {
        given:
            def foo = Spy (C, constructorArgs:[{ one -> ["foo", one]}])
        when:
            def result = foo (1)
        then:
            1 * foo(1)
            result == ["foo", 1]
    }

    void "should accept 1 args, + 1 named args" () {
        given:
            def foo = Spy (C , constructorArgs:[{ args, one -> return ["foo", args, one]}])
        when:
            def result = foo (1, a:'a')
        then:
            1 * foo(1, a:'a')
            result == ["foo", [a:'a'], 1]
    }

    void "should accept 2 args, + 0 named args" () {
        given:
            def foo = Spy (C , constructorArgs:[{ one, two -> return ["foo", one, two]}])
        when:
            def result = foo (1,2)
        then:
            1 * foo(1,2)
            result == ["foo", 1, 2]
    }

    void "should accept 2 args, + 2 named args" () {
        given:
            def foo = Spy (C , constructorArgs:[{ args, one, two -> return ["foo", args, one, two]}])
        when:
            def result = foo (1,2, a:'a', b:'b')
        then:
            1 * foo(1,2,a:'a', b:'b')
            result == ["foo", [a:'a', b:'b'], 1, 2]
    }

}

这是可行的，如果有点笨拙，但显然有一个更动态的“闭包”类比一个我必须添加所有潜在数量的参数的类更好。

那么，是否可能有一个更动态的解决方案（如何？），或者使用spy或groovyspy这一事实是否禁止了一个更动态的监视类？

Answer 1

你能再详细说明一下吗？你所展示的一切都可以很容易地用模拟来完成，不需要间谍。

class MockTest extends Specification {

  void "should accept 0 args" () {
    given:
    def foo = Mock (C)
    when:
    def result = foo ()
    then:
    1 * foo() >> 'foo'
    result == "foo"
  }

  void "should accept 1 positional args, 0 named args" () {
    given:
    def foo = Mock (C)
    when:
    def result = foo (1)
    then:
    1 * foo(1) >> { args -> ["foo", args[0]]}
    result == ["foo", 1]
  }

  void "should accept 1 args, + 1 named args" () {
    given:
    def foo = Mock (C)
    when:
    def result = foo (1, a:'a')
    then:
    1 * foo(1, a:'a') >> { args, one -> ["foo", args, one]}
    result == ["foo", [a:'a'], 1]
  }

  void "should accept 2 args, + 0 named args" () {
    given:
    def foo =  Mock (C)
    when:
    def result = foo (1,2)
    then:
    1 * foo(1,2) >> { one, two -> ["foo", one, two]}
    result == ["foo", 1, 2]
  }

  void "should accept 2 args, + 2 named args" () {
    given:
    def foo = Mock (C)
    when:
    def result = foo (1,2, a:'a', b:'b')
    then:
    1 * foo(1,2,a:'a', b:'b') >> { args, one, two -> ["foo", args, one, two]}
    result == ["foo", [a:'a', b:'b'], 1, 2]
  }

}