在 Spock 中使用 GroovyMock 或类似方法模拟静态方法

Question

第一次来到这里，如果我错过了什么，请道歉。 我希望使用 Spock 绕过对静态方法的调用。反馈会很棒

使用 groovy 模拟，我认为我可以通过静态调用，但没有找到它。 作为背景，我正在改造遗留 Java 中的测试。禁止重构。我正在使用 spock-0.7 和 groovy-1.8。

对静态方法的调用以这种形式与实例调用链接在一起：

public class ClassUnderTest{

public void methodUnderTest(Parameter param){
  //everything else commented out
Thing someThing = ClassWithStatic.staticMethodThatReturnsAnInstance().instanceMethod(param);
   }

}

staticMethod 返回一个 ClassWithStatic 的实例 instanceMethod 返回方法其余部分所需的事物

如果我直接执行全局mock，它返回mocked实例ok：

def exerciseTheStaticMock(){
    given:
    def globalMock = GroovyMock(ClassWithStatic,global: true)
    def instanceMock = Mock(ClassWithStatic)

    when:
    println(ClassWithStatic.staticMethodThatReturnsAnInstance().instanceMethod(testParam))

    then:
    interaction{
        1 * ClassWithStatic.staticMethodThatReturnsAnInstance() >> instanceMock
        1 * instanceMock.instanceMethod(_) >> returnThing
    }
}

但是如果我从 ClassUnderTest 运行 methodUnderTest：

def failingAttemptToGetPastStatic(){
    given:
    def globalMock = GroovyMock(ClassWithStatic,global: true)
    def instanceMock = Mock(ClassWithStatic)
    ClassUnderTest myClassUnderTest = new ClassUnderTest()

    when:
    myClassUnderTest.methodUnderTest(testParam)

    then:
    interaction{
        1 * ClassWithStatic.staticMethodThatReturnsAnInstance() >> instanceMock
        1 * instanceMock.instanceMethod(_) >> returnThing
    }
}

它抛出一个 ClassWithStatic 的真实实例，该实例在其 instanceMethod 中继续失败。

Answer 1

Spock 只能模拟在 Groovy 中实现的静态方法。要模拟在 Java 中实现的静态方法，您需要使用像 GroovyMock、PowerMock 或 JMockit 这样的工具。

PS：鉴于这些工具为了实现其目标而采用了一些深奥的技巧，我很想知道它们是否以及如何与在 Groovy/Spock（而不是 Java/JUnit）中实现的测试一起工作。

Answer 2

这是我使用 Spock (v1.0) 和 PowerMock (v1.6.4) 解决类似问题的方法（模拟从另一个静态类调用的静态方法调用）

import org.junit.Rule
import org.powermock.core.classloader.annotations.PowerMockIgnore
import org.powermock.core.classloader.annotations.PrepareForTest
import org.powermock.modules.junit4.rule.PowerMockRule
import spock.lang.Specification
import static org.powermock.api.mockito.PowerMockito.mockStatic
import static org.powermock.api.mockito.PowerMockito.when

@PrepareForTest([YourStaticClass.class])
@PowerMockIgnore(["javax.xml.*", "ch.qos.logback.*", "org.slf4j.*"])
class YourSpockSpec extends Specification {

@Rule
Powermocked powermocked = new Powermocked();

def "something something something something"() {
    mockStatic(YourStaticClass.class)

    when: 'something something'
    def mocked = Mock(YourClass)
    mocked.someMethod(_) >> "return me"

    when(YourStaticClass.someStaticMethod(xyz)).thenReturn(mocked)

    then: 'expect something'
    YourStaticClass.someStaticMethod(xyz).someMethod(abc) == "return me"

   }
}

@PowerMockIgnore 注解是可选的，只有在与现有库有冲突时才使用它

Answer 3

我在 Groovy/Spock 中处理静态方法的方法是创建在实际代码中替换的代理类。这些代理类只返回您需要的静态方法。您只需将代理类传递给您正在测试的类的构造函数。

因此，当您编写测试时，您会接触到代理类（然后将返回静态方法）并且您应该能够以这种方式进行测试。

Answer 4

解决方法是将静态方法调用包装到实例方法中。

class BeingTested {
    public void methodA() {
        ...

        // was:
        // OtherClass.staticMethod();

        // replaced with:
        wrapperMethod();

        ...
    }

    // add a wrapper method for testing purpose
    void wrapperMethod() {
        OtherClass.staticMethod();
    }
}

现在您可以使用 Spy 来模拟静态方法。

class BeingTestedSpec extends Specification {

    @Subject BeingTested object = new BeingTested()

    def "test static method"() {
        given: "a spy into the object"
        def spyObject = Spy(object)

        when: "methodA is called"
        spyObject.methodA()

        then: "the static method wrapper is called"
        1 * spyObject.wrapperMethod() >> {}
    }
}

如果包装方法应该返回一个值，您也可以为包装方法存根罐头响应。此解决方案仅使用 Spock 内置函数，并适用于 Java 和 Groovy 类，而不依赖于 PowerMock 或 GroovyMock。