如何在spock / groovy中监视闭包或代理？

Question

How to Spy on a Closure or Proxy in spock/groovy?

Spock has a limitation that you can't use the following style interaction testing pattern:

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

when:
publisher.send("message1")

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

Because the 1 * interaction line overrides the stubbed return of the "ok". You have to instead put them both on the same line:

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

Mostly this is ok, but for some cases with the need to stub just a bit more complicated behaviour it'd be really nice to be able to separate stubbed behaviour and interaction like that.

All the things I'm mocking/stubbing can be represented by a Closure , but I can't get a Spy to a Closure to work (or a Spy to a Proxy to a Closure ). So I have the following Closure-lite class:

#!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.
}

That lets the following tests pass despite their separation of stubbed behaviour and interaction:

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]
    }

}

This is workable, if a little clunky, but obviously it'd be nicer to have a more dynamic "Closure" class than one where I have to add every potential number of parameters.

So is a more dynamic solution possible (how?), or does the fact of using Spy or GroovySpy prohibit a more dynamic spied-upon class?

Answer 1

Could you elaborate a bit more, everything you have shown can be easily done with mocks no need for a spy.

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]
  }

}