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: 'title is omitted from the map constructor, so it is null'
        Book b = new Book(isbn: '9780547928227', pageCount: 310)

        then: 'the nullable constraint - not blank - is what fires for a null value'
        !b.validate()
        b.errors.getFieldError('title').code == 'nullable'
    }

    void "rejects a blank title"() {
        when: 'a blank string is assigned directly (the map constructor would convert it to null)'
        Book b = new Book(isbn: '9780547928227', pageCount: 310)
        b.title = ''

        then: 'now the blank constraint fires'
        !b.validate()
        b.errors.getFieldError('title').code == 'blank'
    }

    void "rejects a title longer than maxSize"() {
        when:
        Book b = new Book(title: 'x' * 256, isbn: '9780547928227', pageCount: 310)

        then:
        !b.validate()
        b.errors.getFieldError('title').code == 'maxSize.exceeded'
    }

    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.getFieldError('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() {
        // flush: true forces the in-memory datastore to persist before the
        // GORM finders below query it - without it the finders see zero rows.
        new Book(title: 'Short Story',  isbn: '9780000000001', pageCount: 50 ).save(flush: true, failOnError: true)
        new Book(title: 'Novella',      isbn: '9780000000002', pageCount: 150).save(flush: true, failOnError: true)
        new Book(title: 'Novel',        isbn: '9780000000003', pageCount: 400).save(flush: true, failOnError: true)
        new Book(title: 'Doorstopper',  isbn: '9780000000004', pageCount: 900).save(flush: true, 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
    }

    void "get returns the book when it exists"() {
        given: 'the isbn from the setup fixture'
        Book b = Book.findByIsbn('9780000000001')

        expect:
        service.get(b.id)?.title == 'Short Story'
    }

    void "get returns null when the id does not exist"() {
        expect:
        service.get(99999L) == null
    }

    void "save persists a book and returns it with an id"() {
        when:
        Book saved = service.save(new Book(
            title: 'New Book', isbn: '9780000000005', pageCount: 200))

        then:
        saved.id != null
        saved.title == 'New Book'

        and: 'it is visible to a subsequent query'
        service.countByPageCountGreaterThanEquals(0) == 5
    }

    void "save rejects a duplicate isbn with ValidationException"() {
        given:
        service.save(new Book(title: 'Original', isbn: '9780000000005', pageCount: 100))
        Book.withSession { it.flush() }

        when:
        service.save(new Book(title: 'Duplicate', isbn: '9780000000005', pageCount: 200))

        then:
        def ex = thrown(grails.validation.ValidationException)
        ex.message.contains('unique')
    }

    void "list returns all books when called without constraints"() {
        expect:
        service.list([:]).size() == 4
    }

    void "list respects the max parameter"() {
        expect:
        service.list([max: 2]).size() == 2
    }
}

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: 'RestfulController.show() reads params.id - it takes no argument'
        request.method = 'GET'
        params.id = b.id
        controller.show()

        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'
        params.id = 99999L
        controller.show()

        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()
    }

    void "index returns the persisted books in its model"() {
        given:
        new Book(title: 'First', isbn: '9780547928227', pageCount: 100)
            .save(flush: true, failOnError: true)
        new Book(title: 'Second', isbn: '9780547928228', pageCount: 200)
            .save(flush: true, failOnError: true)

        when: 'the index action builds its model (HTML format returns the model map)'
        request.method = 'GET'
        Map model = controller.index(10)

        then:
        model.bookCount == 2
        model.bookList*.title.containsAll(['First', 'Second'])
    }

    void "POST /books with valid data saves and returns 201"() {
        given:
        request.method = 'POST'
        request.json = [title: 'Valid Book', isbn: '9780547928228', pageCount: 150]

        when:
        controller.save()

        then:
        response.status == HttpStatus.CREATED.value()
        response.json.title == 'Valid Book'
        response.json.isbn  == '9780547928228'
    }

    void "GET /books/create returns a new transient instance"() {
        when:
        request.method = 'GET'
        request.format = 'json'
        controller.create()

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

    void "GET /books/{id}/edit returns the book for editing"() {
        given:
        Book b = new Book(title: 'Editable', isbn: '9780547928228', pageCount: 100)
            .save(flush: true, failOnError: true)

        when:
        request.method = 'GET'
        request.format = 'json'
        params.id = b.id
        controller.edit()

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

    void "PUT /books/{id} updates the book"() {
        given:
        Book b = new Book(title: 'Original', isbn: '9780547928228', pageCount: 100)
            .save(flush: true, failOnError: true)

        when:
        request.method = 'PUT'
        request.json = [title: 'Updated']
        params.id = b.id
        controller.update()

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

    void "PUT /books/{id} with invalid data returns 422"() {
        given:
        Book b = new Book(title: 'Original', isbn: '9780547928229', pageCount: 100)
            .save(flush: true, failOnError: true)

        when:
        request.method = 'PUT'
        request.json = [title: '']
        params.id = b.id
        controller.update()

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

    void "DELETE /books/{id} deletes the book"() {
        given:
        Book b = new Book(title: 'Deletable', isbn: '9780547928228', pageCount: 100)
            .save(flush: true, failOnError: true)

        when:
        request.method = 'DELETE'
        params.id = b.id
        controller.delete()

        then:
        response.status == HttpStatus.NO_CONTENT.value()
        Book.get(b.id) == null
    }
}

package example

import grails.gorm.transactions.Rollback
import grails.testing.mixin.integration.Integration
import grails.validation.ValidationException
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 is rejected"() {
        given: 'a persisted book, flushed so the unique validator can see it'
        bookService.save(new Book(title: 'First',  isbn: '9780547928227', pageCount: 100))
        Book.withSession { it.flush() }

        when: 'a second book reuses the isbn'
        bookService.save(new Book(title: 'Second', isbn: '9780547928227', pageCount: 200))

        then: 'the @Service save throws a ValidationException (failOnError is implicit) carrying the unique error'
        ValidationException ex = thrown()
        ex.message.contains('unique')
    }
}

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. The fixture is therefore seeded inside its own
 * withNewTransaction block; a bare GORM call would fail because an
 * @Integration spec without @Rollback has no ambient Hibernate session.
 */
@Integration
class BookFunctionalSpec extends ContainerGebSpec {

    void setup() {
        Book.withNewTransaction {
            if (!Book.findByIsbn('9780261103344')) {
                new Book(title: 'The Hobbit', isbn: '9780261103344', pageCount: 310).save(failOnError: true)
            }
        }
    }

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

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

}

@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(layout.buildDirectory.get().asFile).include('jacoco/*.exec')
    reports {
        xml.required = true       // for Codecov upload
        html.required = true      // for human inspection
    }
}