What is the correct Spock syntax for Grails?

Question

I have a Grails 2.5.0 app running and this test:

package moduleextractor

import grails.test.mixin.TestFor
import spock.lang.Specification

/**
 * See the API for {@link grails.test.mixin.web.ControllerUnitTestMixin} for usage instructions
 */
@TestFor(ExtractorController)
class ExtractorControllerSpec extends Specification {

    def moduleDataService
    def mockFile

    def setup() {
        moduleDataService = Mock(ModuleDataService)
        mockFile = Mock(File)
    }

    def cleanup() {
    }

    void "calls the moduleDataService"() {
        given: 'a term is passed'
            params.termCode = termCode
        when: 'the getModuleData action is called'
            controller.getModuleData()
        then: 'the service is called 1 time'
            1 * moduleDataService.getDataFile(termCode, 'json') >> mockFile
        where:
            termCode = "201415"
    }
}

If I run grails test-app unit:spock I get this:

| Tests PASSED - view reports in /home/foo/Projects/moduleExtractor/target/test-reports

I don't understand why it sees 2 tests. I have not included spock in my BuildConfig file as it is already included in Grails 2.5.0. Also the test is not supposed to pass, as I do not have a service yet. Why does it pass?

Also when I run this grails test-app ExtractorController I get another result:

| Running 2 unit tests...
| Running 2 unit tests... 1 of 2
| Failure:  calls the moduleDataService(moduleextractor.ExtractorControllerSpec)
|  Too few invocations for:
1 * moduleDataService.getDataFile(termCode, 'json') >> mockFile   (0 invocations)
Unmatched invocations (ordered by similarity):
None
    at org.spockframework.mock.runtime.InteractionScope.verifyInteractions(InteractionScope.java:78)
    at org.spockframework.mock.runtime.MockController.leaveScope(MockController.java:76)
    at moduleextractor.ExtractorControllerSpec.calls the moduleDataService(ExtractorControllerSpec.groovy:27)
| Completed 1 unit test, 1 failed in 0m 3s
| Tests FAILED  - view reports in /home/foo/Projects/moduleExtractor/target/test-reports
| Error Forked Grails VM exited with error

If I run grails test-app unit: I get:

| Running 4 unit tests...
| Running 4 unit tests... 1 of 4
| Failure:  calls the moduleDataService(moduleextractor.ExtractorControllerSpec)
|  Too few invocations for:
1 * moduleDataService.getDataFile(termCode, 'json') >> mockFile   (0 invocations)
Unmatched invocations (ordered by similarity):
None
    at org.spockframework.mock.runtime.InteractionScope.verifyInteractions(InteractionScope.java:78)
    at org.spockframework.mock.runtime.MockController.leaveScope(MockController.java:76)
    at moduleextractor.ExtractorControllerSpec.calls the moduleDataService(ExtractorControllerSpec.groovy:27)
| Completed 1 unit test, 1 failed in 0m 3s
| Tests FAILED  - view reports in /home/foo/Projects/moduleExtractor/target/test-reports
| Error Forked Grails VM exited with error

First of all could somebody tell me what is the correct syntax to run spock tests?

Also what is the difference between having unit and unit: and unit:spock in the command?

(Since Spock comes with Grails 2.5.0, it will run spocks tests anyway.)

What is the correct syntax and why does it sees 2 tests instead of 1 ?

Answer 1

First question: for the 'grails test-app unit:spock', have you looked at the results to see the tests it says passed? The test count at the CLI can be wrong, check your results to see what actually ran (if no tests actually ran, then there were no failures).

Your test method doesn't start with 'test', nor does it have a @Test annotation, so the 'void "calls the moduleDataService"' isn't being seen as a spock test case (I believe that is the reason).

When you run 'grails test-app ExtractorController', you aren't specifying that it has to be a spock test, so grails testing finds and executes the 'calls the moduleDataService' test method.

Since spock is the de facto testing framework, you can just use: grails test-app -unit

Second question:

@TestFor creates your controller, but if you're running a unit test, then the usual grails magic isn't happening. Your controller code is executing in isolation. If your ExtractorController usually has the moduleDataService injected, you'll have to take care of that.

I work in grails 2.4.3, and here would be my interpretation of your test (assuredly in need of tweaking since I'm inferring a lot in this example):

import grails.test.mixin.TestFor
import grails.test.mixin.Mock
import spock.lang.specification
import some.pkg.ModuleDataService // if necessary
import some.pkg.File // if necessary

@TestFor(ExtractorController)
@Mock([ModuleDataService, File])
class ExtractorControllerSpec extends Specification

    def "test callsModuleDataService once for a termCode"() {

        setup:
        def mockFile = mockFor(File)
        def mockService = mockFor(ModuleDataService, true) // loose mock
        // in this mockService, we expect getDataFile to be called
        // just once, with two parameters, and it'll return a mocked
        // file
        mockService.demand.getDataFile(1) { String termCode, String fmt ->
            return mockFile.createMock()
        }
        controller.moduleDataService = mockService.createMock()

        when:
        controller.params.termCode = "201415"
        controller.getModuleData()

        then:
        response.status == 200 // all good?
    }
}

Last question: is that a Banner term code? (just curious)

Answer 2

Don't be concerned with the number of tests. It's never been a problem for me. You can always check the report HTML file to see exactly what ran.

I always run my tests with either

grails test-app

or

grails test-app ExtractorController

The error you're getting means you coded the test to expect moduleDataService.getDataFile() to get called with parameters null and 'json' when controller.getModuleData() is called. However, moduleDataService.getDataFile() never got called, so the test failed.

Spock takes some getting used to. I recommend looking at examples in the Grails documentation and reading the Spock Framework Reference.