Spock：Mock/Stub最终类的void方法失败问题排查

Let me break down what's likely happening here and how to fix it, based on your description:

First, Understand the Core Observations #

You're mocking org.apache.lucene.document.TextField (a non-final subclass of Field), and seeing two key behaviors:

• When you explicitly mock getClass() to return Object.class, your logs confirm the mock is active, but the test still fails at the setStringValue call.
• Removing that getClass() mock changes your test output, but the setStringValue failure persists.

Why This Is Happening #

1. Mocking getClass() Is a Red Herring (But Reveals a Constraint) #

getClass() is a final method on Object, which default mocking frameworks (including Spock's built-in mocks or vanilla Mockito) can't handle without special configuration. When you force it to return Object.class, you're bypassing that final method restriction (likely via a library like Mockito-inline or PowerMock), but this doesn't fix the root issue with setStringValue.

Worse, altering getClass() breaks Java's type semantics—your test code might be relying on instanceof checks or type comparisons that now behave unpredictably, which explains the output changes when you remove the mock.

2. The setStringValue Failure Has a Few Likely Causes #

Even though Field is non-final, here's why your mock's setStringValue isn't behaving as expected:

• Incorrect Mock Initialization: You might not be explicitly defining behavior for the void setStringValue method in your Spock spec. By default, Spock mocks will throw an exception if you call a method without defining its behavior.
• Unintended Real Method Execution: If your mock setup is incomplete, Spock might be falling back to executing the real setStringValue method (which could throw exceptions if the mock isn't properly initialized).
• Injection Failure: Your mocked TextField instance isn't actually being used by the code under test—instead, the code is creating a new real TextField instance somewhere.

Fixes to Try #

1. Explicitly Define Behavior for setStringValue #

In Spock, you need to tell the mock what to do when setStringValue is called. For void methods, you can either:

• Do nothing (the most common case):

  def textFieldMock = Mock(TextField)
  // Define that any call to setStringValue should be a no-op
  textFieldMock.setStringValue(_) >> {}
  

• Verify the method is called with specific arguments (if that's part of your test assertion):

  then:
  1 * textFieldMock.setStringValue("expected-value")
  

2. Stop Mocking getClass() (Unless Absolutely Necessary) #

Mocking final methods like getClass() is a code smell and leads to fragile tests. If your production code uses getClass() for type checks, refactor it to use instanceof instead (which works with mocks) or define an interface for TextField and mock that interface instead.

If you must mock getClass() (e.g., legacy code you can't change), return the correct type instead of Object.class:

textFieldMock.getClass() >> TextField.class

3. Ensure Your Mock Is Properly Injected #

Double-check that the mocked TextField is being passed into the code under test. If your production code creates a new TextField instance directly (instead of accepting one via dependency injection), your mock will never be used. You'll need to refactor the production code to accept a TextField (or an interface) as a parameter, or use a test spy to replace the instance creation.

4. Verify Mock Framework Configuration #

If you're using Mockito alongside Spock, make sure you've added the mockito-inline dependency to your build (this enables mocking of final methods/classes if you need it):

testImplementation 'org.mockito:mockito-inline:5.6.0'

Example Working Spock Spec #

class TextFieldMockSpec extends Specification {
    def "test setStringValue is called correctly"() {
        given:
        // Create the mock and define void method behavior
        def textFieldMock = Mock(TextField)
        textFieldMock.setStringValue(_) >> {}

        // Inject the mock into your service under test
        def myService = new DocumentProcessingService(textFieldMock)

        when:
        myService.populateTextField("test-content")

        then:
        // Verify the method was called once with the expected value
        1 * textFieldMock.setStringValue("test-content")
    }
}

内容的提问来源于stack exchange，提问作者mike rodent