git clone -b grails8 https://github.com/grails-guides/grails-spock-test-tour.git
cd grails-spock-test-tour/complete
./gradlew test integrationTest

package example

import grails.testing.gorm.DomainUnitTest
import spock.lang.Specification
import spock.lang.Unroll

/**
 * DomainUnitTest<Book> exercises just the constraint logic.
 *
 * Loads in milliseconds because no Spring context boots; the
 * @AutoCleanup datastore is in-memory and per-spec. Use this layer for
 * every constraint regression: blank, nullable, maxSize, unique,
 * matches, min, max, range.
 */
class BookSpec extends Specification implements DomainUnitTest<Book> {

    void "rejects a book with no title"() {
        when:
        Book b = new Book(isbn: '9780547928227', pageCount: 310)

        then:
        !b.validate()
        b.errors.fieldError('title').code == 'blank'
    }

    void "rejects a book with a malformed ISBN"() {
        when:
        Book b = new Book(title: 'Test', isbn: 'not-an-isbn', pageCount: 100)

        then:
        !b.validate()
        b.errors.fieldError('isbn').code == 'matches.invalid'
    }

    void "accepts a book with a valid ISBN-13"() {
        when:
        Book b = new Book(title: 'The Hobbit', isbn: '9780547928227', pageCount: 310)

        then:
        b.validate()
    }

    @Unroll
    void "pageCount #pageCount is #expectedValid"() {
        when:
        Book b = new Book(title: 'X', isbn: '9780547928227', pageCount: pageCount)

        then:
        b.validate() == expectedValid

        where:
        pageCount || expectedValid
        null      || true
        1         || true
        100       || true
        0         || false
        -1        || false
    }
}

package example

import grails.testing.gorm.DataTest
import grails.testing.services.ServiceUnitTest
import spock.lang.Specification

/**
 * DataTest + ServiceUnitTest exercises the @Service(Book) interface
 * against the in-memory datastore. Real GORM finders run; no Spring
 * context, no real database. Best fit for testing query logic
 * (criteria, where queries, finder method names).
 */
class BookServiceSpec extends Specification
        implements ServiceUnitTest<BookService>, DataTest {

    Class[] getDomainClassesToMock() { [Book] }

    void setup() {
        new Book(title: 'Short Story',  isbn: '9780000000001', pageCount: 50 ).save(failOnError: true)
        new Book(title: 'Novella',      isbn: '9780000000002', pageCount: 150).save(failOnError: true)
        new Book(title: 'Novel',        isbn: '9780000000003', pageCount: 400).save(failOnError: true)
        new Book(title: 'Doorstopper',  isbn: '9780000000004', pageCount: 900).save(failOnError: true)
    }

    void "countByPageCountGreaterThanEquals returns the right count"() {
        expect:
        service.countByPageCountGreaterThanEquals(200) == 2
        service.countByPageCountGreaterThanEquals(0)   == 4
        service.countByPageCountGreaterThanEquals(901) == 0
    }

    void "findByIsbn returns the matching book"() {
        when:
        Book b = service.findByIsbn('9780000000003')

        then:
        b.title == 'Novel'
    }

    void "findByIsbn returns null when no match"() {
        expect:
        service.findByIsbn('9999999999999') == null
    }
}

package example

import grails.testing.gorm.DataTest
import grails.testing.web.controllers.ControllerUnitTest
import org.springframework.http.HttpStatus
import spock.lang.Specification

/**
 * ControllerUnitTest<BookController> wires up just enough of the web
 * layer to exercise action routing, model preparation, and response
 * status codes. Adding DataTest (with the right domain mocked) lets
 * the RestfulController's auto-generated CRUD actions actually find
 * persisted entities through GORM.
 */
class BookControllerSpec extends Specification
        implements ControllerUnitTest<BookController>, DataTest {

    Class[] getDomainClassesToMock() { [Book] }

    void "GET /books/{id} returns the book as JSON"() {
        given:
        Book b = new Book(title: 'The Hobbit', isbn: '9780547928227', pageCount: 310)
                  .save(failOnError: true, flush: true)

        when:
        request.method = 'GET'
        controller.show(b.id)

        then:
        response.status == HttpStatus.OK.value()
        response.json.title == 'The Hobbit'
    }

    void "GET /books/{id} for a missing id returns 404"() {
        when:
        request.method = 'GET'
        controller.show(99999L)

        then:
        response.status == HttpStatus.NOT_FOUND.value()
    }

    void "POST /books with a malformed ISBN returns 422"() {
        given:
        request.method = 'POST'
        request.json = [title: 'X', isbn: 'not-an-isbn']

        when:
        controller.save()

        then:
        response.status == HttpStatus.UNPROCESSABLE_ENTITY.value()
    }
}

package example

import grails.gorm.transactions.Rollback
import grails.testing.mixin.integration.Integration
import spock.lang.Specification

/**
 * @Integration boots the full Spring context against a real datasource
 * (whatever the `test` environment in application.yml configures - H2
 * by default). @Rollback ensures every test method's database changes
 * are rolled back at the end so specs stay isolated.
 *
 * Use this layer for cross-layer concerns: domain + service + transaction
 * boundary together. Avoid it for what unit tests can answer faster.
 */
@Integration
@Rollback
class BookIntegrationSpec extends Specification {

    BookService bookService

    void "a saved book round-trips through GORM"() {
        given:
        Book draft = new Book(title: 'Round Trip', isbn: '9780547928227', pageCount: 200)

        when:
        Book saved = bookService.save(draft)

        then:
        saved.id != null

        when:
        Book reloaded = bookService.get(saved.id)

        then:
        reloaded.title == 'Round Trip'
        reloaded.isbn  == '9780547928227'
    }

    void "saving a book with a duplicate isbn fails validation"() {
        given:
        bookService.save(new Book(title: 'First',  isbn: '9780547928227', pageCount: 100))

        when:
        Book second = bookService.save(new Book(title: 'Second', isbn: '9780547928227', pageCount: 200))

        then:
        second == null || second.hasErrors()
    }
}

package example

import grails.plugin.geb.ContainerGebSpec
import grails.testing.mixin.integration.Integration

/**
 * Functional test driven by Geb 8 against a real booted application.
 *
 * ContainerGebSpec (from `testFixtures("org.apache.grails:grails-geb")`)
 * starts a Selenium-Chrome container via Testcontainers and points the
 * browser at the host-side Grails app. No local WebDriver binaries are
 * installed; the only host requirement is a running Docker daemon.
 *
 * @Integration is mandatory: GrailsContainerGebExtension throws at
 * runtime if the annotation is missing. @Rollback is NOT used here -
 * functional tests exercise the full HTTP stack and need committed
 * data.
 */
@Integration
class BookFunctionalSpec extends ContainerGebSpec {

    void "the book index page renders the seeded books"() {
        when:
        go '/books'

        then:
        title.contains('Book')
        $('table tbody tr').size() > 0
    }
}

@Unroll
void "pageCount #pageCount is #expectedValid"() {
    when:
    Book b = new Book(title: 'X', isbn: '9780547928227', pageCount: pageCount)

    then:
    b.validate() == expectedValid

    where:
    pageCount || expectedValid
    null      || true
    1         || true
    100       || true
    0         || false
    -1        || false
}

tasks.withType(Test).configureEach {
    useJUnitPlatform()
}

plugins {
    id 'jacoco'
}

jacocoTestReport {
    dependsOn test, integrationTest
    executionData fileTree(buildDir).include('jacoco/*.exec')
    reports {
        xml.required = true       // for Codecov upload
        html.required = true      // for human inspection
    }
}