Question

我要测试两个类。它们都有两个功能（outer和inner）。

我想查看已将什么参数传递给inner。因此，我使用inner（MockFor）和另一个mock.demand.inner来模拟Closure。

第一类返回一个Closure，它将调用inner。然后Closure由测试执行。它可以工作，原始inner不会被调用。

第二个类直接执行inner。它失败，原始的inner被调用。

我尝试通过覆盖（Can Groovy dynamically add or override a method on a POJO?）来模拟它，并且仍然调用原始的inner。

问题是，我必须在第二堂课的inner中调用outer。我不能延迟或委托它。

所以，我想知道那里正在发生什么？我该如何运作？

以下是从1500多行代码减少到66行代码的代码，它们隔离并突出了实际行为。

要知道inner是否未正确模拟，它将引发异常。仅当它未被嘲笑时才会抛出。

package org.aroundmedia.tools

import groovy.mock.interceptor.MockFor
import org.junit.Test
import sun.reflect.generics.reflectiveObjects.NotImplementedException

class ClassWithClosure {
    def outer() {
        return { this.inner('foo') }
    }

    private def inner(arg) {
        throw new NotImplementedException()
    }
}
class ClassWithoutClosure {
    def outer() {
        this.inner('foo')
    }

    private def inner(arg) {
        throw new NotImplementedException()
    }
}

class ParameterizedTestsForPostAlways extends GroovyTestCase {
    @Test
    void testWithClosure() {
        def mock = new MockFor(ClassWithClosure)
        mock.ignore('outer')
        def res = []
        mock.demand.inner {a -> res.add(a)}

        mock.use {
            def instance = new ClassWithClosure()

            def closure = instance.outer()
            closure()
        }
        assert res == ["foo"]
    }
    @Test
    void testWithoutClosure() {

        def mock = new MockFor(ClassWithoutClosure)
        mock.ignore('outer')
        def res = []
        mock.demand.inner {a -> res.add(a)}

        mock.use {
            def instance = new ClassWithoutClosure()

            instance.outer()
        }
        assert res == ["foo"]
    }

    @Test
    void testOverrideWithoutClosure() {
        ClassWithoutClosure inst = new ClassWithoutClosure()
        def res = []
        inst.metaClass.inner = {a -> res.add(a)}
        inst.outer()
        assert res == ['foo']
    }
}

带和不带闭包的Groovy嘲讽：行为似乎很奇怪

0 个答案: