grails create-controller com.acme.app.simple

grails test-app

-------------------------------------------------------
Running Unit Tests…
Running test FooTests...FAILURE
Unit Tests Completed in 464ms …
-------------------------------------------------------
Tests failed: 0 errors, 1 failures

open test-report

grails test-app SimpleController

grails test-app *Controller

grails test-app some.org.*Controller

grails test-app some.org.*

grails test-app some.org.**.*

grails test-app SimpleController.testLogin

grails test-app some.org.* SimpleController.testLogin BookController

grails test-app integration:integration

grails test-app unit:

grails test-app :spock

grails test-app functional:spock

grails test-app unit:spock integration:spock

grails test-app integration: unit: some.org.**.*

@TestFor(BookController)
@Mock([Book, Author, BookService])

void testSearch() {
      def control = mockFor(SearchService)
      control.demand.searchWeb { String q -> ['mock results'] }
      control.demand.static.logResults { List results ->  }
      controller.searchService = control.createMock()
      controller.search()
      assert controller.response.text.contains "Found 1 results"
}

import grails.test.mixin.TestFor
@TestFor(SimpleController)
class SimpleControllerTests {
    void testSomething() {
    }
}

// Test class
class SimpleController {
    def hello() {
        render "hello"
    }
}

void testHello() {
    controller.hello()
    assert response.text == 'hello'
}

// Test class
class SimpleController {
    def index() {
        redirect action: 'hello'
    }
    …
}

void testIndex() {
    controller.index()
    assert response.redirectedUrl == '/simple/hello'
}

void testList() {
    params.sort = "name"
    params.max = 20
    params.offset = 0
    controller.list()
    …
}

void testSave() {
    request.method = "POST"
    controller.save()
    …
}

void testGetPage() {
    request.method = "POST"
    request.makeAjaxRequest()
    controller.getPage()
    …
}

// Test class
class SimpleController {
    def home() {
        render view: "homePage", model: [title: "Hello World"]
    }
    …
}

void testIndex() {
    controller.home()
    assert view == "/simple/homePage"
    assert model.title == "Hello World"
}

class SimpleController {
    def display() {
        render template:"snippet"
    }
}

void testDisplay() {
    controller.display()
    assert response.text == 'contents of template'
}

void testDisplay() {
    views['/simple/_snippet.gsp'] = 'mock contents'
    controller.display()
    assert response.text == 'mock contents'
}

class SimpleController {
    def showBookDetails() {
        [title: 'The Nature Of Necessity', author: 'Alvin Plantinga']
    }
}

import grails.test.mixin.*
@TestFor(SimpleController)
class SimpleControllerTests {
    void testShowBookDetails() {
        def model = controller.showBookDetails()
        assert model.author == 'Alvin Plantinga'
    }
}

def renderXml() {
    render(contentType:"text/xml") {
        book(title:"Great")
    }
}

void testRenderXml() {
    controller.renderXml()
    assert "<book title='Great'/>" == response.text
    assert "Great" == response.xml.@title.text()
}

// controller action
def renderJson() {
    render(contentType:"application/json") {
        book = "Great"
    }
}

// test
void testRenderJson() {
    controller.renderJson()
    assert '{"book":"Great"}' == response.text
    assert "Great" == response.json.book
}

def consumeBook() {
    def b = new Book(params['book'])
    render b.title
}

void testConsumeBookXml() {
    request.xml = '<book><title>The Shining</title></book>'
    controller.consumeBook()
    assert response.text == 'The Shining'
}

void testConsumeBookXml() {
    request.xml = new Book(title:"The Shining")
    controller.consumeBook()
    assert response.text == 'The Shining'
}

void testConsumeBookJson() {
    request.json = new Book(title:"The Shining")
    controller.consumeBook()
    assert response.text == 'The Shining'
}

def consume() {
    request.withFormat {
        xml {
            render request.XML.@title
        }
        json {
            render request.JSON.title
        }
    }
}

void testConsumeXml() {
    request.xml = '<book title="The Stand" />'
    controller.consume()
    assert response.text == 'The Stand'
}

void testConsumeJson() {
    request.json = '{title:"The Stand"}'
    controller.consume()
    assert response.text == 'The Stand'
}

class SimpleController {
    SimpleService simpleService
    def hello() {
        render simpleService.sayHello()
    }
}

void testBeanWiring() {
    defineBeans {
        simpleService(SimpleService)
    }
    controller.hello()
    assert response.text == "Hello World"
}

void testAutowiringViaNew() {
    defineBeans {
        simpleService(SimpleService)
    }
    def controller1 = new SimpleController()
    def controller2 = new SimpleController()
    assert controller1.simpleService != null
    assert controller2.simpleService != null
}

// controller action
def sayHello() {
    def data = [Hello:"World"]
    withFormat {
        xml { render data as XML }
        html data
    }
}

// test
void testSayHello() {
    response.format = 'xml'
    controller.sayHello()
    String expected = '<?xml version="1.0" encoding="UTF-8"?>' +
                      '<map><entry key="Hello">World</entry></map>'
    assert expected == response.text
}

def handleForm() {
    withForm {
        render "Good"
    }.invalidToken {
        render "Bad"
    }
}

void testDuplicateFormSubmission() {
    controller.handleForm()
    assert "Bad" == response.text
}

import org.codehaus.groovy.grails.web.servlet.mvc.SynchronizerToken
...
void testValidFormSubmission() {
    def tokenHolder = SynchronizerTokensHolder.store(session)
    params[SynchronizerTokensHolder.TOKEN_URI] = '/controller/handleForm'
    params[SynchronizerTokensHolder.TOKEN_KEY] = tokenHolder.generateToken(params[SynchronizerTokensHolder.TOKEN_URI])
    controller.handleForm()
    assert "Good" == response.text
}

controller.handleForm() // first execution
…
response.reset()
…
controller.handleForm() // second execution

def uploadFile() {
    MultipartFile file = request.getFile("myFile")
    file.transferTo(new File("/local/disk/myFile"))
}

void testFileUpload() {
    final file = new GrailsMockMultipartFile("myFile", "foo".bytes)
    request.addFile(file)
    controller.uploadFile()
    assert file.targetFileLocation.path == "/local/disk/myFile"
}

def handleCommand(SimpleCommand simple) {
    if (simple.hasErrors()) {
        render "Bad"
    }
    else {
        render "Good"
    }
}

void testInvalidCommand() {
    def cmd = mockCommandObject(SimpleCommand)
    cmd.name = '' // doesn't allow blank names
    cmd.validate()
    controller.handleCommand(cmd)
    assert response.text == 'Bad'
}

def showMessage() {
    render g.message(code: "foo.bar")
}

void testRenderBasicTemplateWithTags() {
    messageSource.addMessage("foo.bar", request.locale, "Hello World")
    controller.showMessage()
    assert response.text == "Hello World"
}

@TestFor(SimpleTagLib)
class SimpleTagLibTests {
}

@TestFor(SimpleController)
@Mock(SimpleTagLib)
class GroovyPageUnitTestMixinTests {
}

class SimpleTagLib {
    static namespace = 's'
    def hello = { attrs, body ->
        out << "Hello ${attrs.name ?: 'World'}"
    }
    def bye = { attrs, body ->
        out << "Bye ${attrs.author.name ?: 'World'}"
    }
}

@TestFor(SimpleTagLib)
class SimpleTagLibTests {
    void testHelloTag() {
        assert applyTemplate('<s:hello />') == 'Hello World'
        assert applyTemplate('<s:hello name="Fred" />') == 'Hello Fred'
        assert applyTemplate('<s:bye author="${author}" />', [author: new Author(name: 'Fred')]) == 'Bye Fred'
    }
}

@grails.test.mixin.TestMixin(GroovyPageUnitTestMixin)
class MultipleTagLibraryTests {
    @Test
    void testMuliple() {
        mockTagLib(FirstTagLib)
        mockTagLib(SecondTagLib)
        …
    }
}

@grails.test.mixin.TestMixin(GroovyPageUnitTestMixin)
class MultipleTagLibraryTests {
    @Test
    void testMuliple() {
        mockTagLib(FirstTagLib)
        mockTagLib(SecondTagLib)
        assertOutputEquals ('Hello World', '<s:hello />')
        assertOutputMatches (/.*Fred.*/, '<s:hello name="Fred" />')
    }
}

def result = render(template: "/simple/hello")
assert result == "Hello World"

import grails.test.mixin.*
@TestFor(SimpleController)
@Mock(Simple)
class SimpleControllerTests {
}

class BookController {
    def save() {
        def book = new Book(params)
        if (book.save(flush: true)) {
            flash.message = message(
                    code: 'default.created.message',
                    args: [message(code: 'book.label',
                                   default: 'Book'), book.id])}"
            redirect(action: "show", id: book.id)
        }
        else {
            render(view: "create", model: [bookInstance: book])
        }
    }
}

import grails.test.mixin.*
@TestFor(BookController)
@Mock(Book)
class BookControllerTests {
    void testSaveInvalidBook() {
        controller.save()
        assert model.bookInstance != null
        assert view == '/book/create'
    }
    void testSaveValidBook() {
        params.title = "The Stand"
        params.pages = "500"
        controller.save()
        assert response.redirectedUrl == '/book/show/1'
        assert flash.message != null
        assert Book.count() == 1
    }
}

@TestFor(BookController)
@Mock([Book, Author])
class BookControllerTests {
   …
}

import grails.test.mixin.domain.DomainClassUnitTestMixin
@TestFor(BookController)
@TestMixin(DomainClassUnitTestMixin)
class BookControllerTests {
   …
}

void testSave() {
    mockDomain(Author)
    mockDomain(Book)
}

void testSave() {
    mockDomain(Book, [
            [title: "The Stand", pages: 1000],
            [title: "The Shining", pages: 400],
            [title: "Along Came a Spider", pages: 300] ])
}

// src/groovy/com/demo/MyValidateable.groovy
package com.demo
@grails.validation.Validateable
class MyValidateable {
    String name
    Integer age
    static constraints = {
        name matches: /[A-Z].*/
        age range: 1..99
    }
}

// grails-app/domain/com/demo/Person.groovy
package com.demo
class Person {
    String name
    static constraints = {
        name matches: /[A-Z].*/
    }
}

// grails-app/controllers/com/demo/DemoController.groovy
package com.demo
class DemoController {
    def addItems(MyCommandObject co) {
        if(co.hasErrors()) {
            render 'something went wrong'
        } else {
            render 'items have been added'
        }
    }
}
class MyCommandObject {
    Integer numberOfItems
    static constraints = {
        numberOfItems range: 1..10
    }
}

// test/unit/com/demo/PersonSpec.groovy
package com.demo
import grails.test.mixin.TestFor
import spock.lang.Specification
@TestFor(Person)
class PersonSpec extends Specification {
    void "Test that name must begin with an upper case letter"() {
        when: 'the name begins with a lower letter'
        def p = new Person(name: 'jeff')
        then: 'validation should fail'
        !p.validate()
        when: 'the name begins with an upper case letter'
        p = new Person(name: 'Jeff')
        then: 'validation should pass'
        p.validate()
    }
}

// test/unit/com/demo/DemoControllerSpec.groovy
package com.demo
import grails.test.mixin.TestFor
import spock.lang.Specification
@TestFor(DemoController)
class DemoControllerSpec extends Specification {
    void 'Test an invalid number of items'() {
        when:
        params.numberOfItems = 42
        controller.addItems()
        then:
        response.text == 'something went wrong'
    }
    void 'Test a valid number of items'() {
        when:
        params.numberOfItems = 8
        controller.addItems()
        then:
        response.text == 'items have been added'
    }
}

// test/unit/com/demo/MyValidateableSpec.groovy
package com.demo
import grails.test.mixin.TestMixin
import grails.test.mixin.support.GrailsUnitTestMixin
import spock.lang.Specification

@TestMixin(GrailsUnitTestMixin)
class MyValidateableSpec extends Specification {
    void 'Test validate can be invoked in a unit test with no special configuration'() {
        when: 'an object is valid'
        def validateable = new MyValidateable(name: 'Kirk', age: 47)
        then: 'validate() returns true and there are no errors'
        validateable.validate()
        !validateable.hasErrors()
        validateable.errors.errorCount == 0
        when: 'an object is invalid'
        validateable.name = 'kirk'
        then: 'validate() returns false and the appropriate error is created'
        !validateable.validate()
        validateable.hasErrors()
        validateable.errors.errorCount == 1
        validateable.errors['name'].code == 'matches.invalid'
        when: 'the clearErrors() is called'
        validateable.clearErrors()
        then: 'the errors are gone'
        !validateable.hasErrors()
        validateable.errors.errorCount == 0
        when: 'the object is put back in a valid state'
        validateable.name = 'Kirk'
        then: 'validate() returns true and there are no errors'
        validateable.validate()
        !validateable.hasErrors()
        validateable.errors.errorCount == 0
    }
}

// test/unit/com/demo/MyCommandObjectSpec.groovy
package com.demo
import grails.test.mixin.TestMixin
import grails.test.mixin.support.GrailsUnitTestMixin
import spock.lang.Specification
@TestMixin(GrailsUnitTestMixin)
class MyCommandObjectSpec extends Specification {
    void 'Test that numberOfItems must be between 1 and 10'() {
        when: 'numberOfItems is less than 1'
        def co = new MyCommandObject()
        co.numberOfItems = 0
        then: 'validation fails'
        !co.validate()
        co.hasErrors()
        co.errors['numberOfItems'].code == 'range.toosmall'
        when: 'numberOfItems is greater than 10'
        co.numberOfItems = 11
        then: 'validation fails'
        !co.validate()
        co.hasErrors()
        co.errors['numberOfItems'].code == 'range.toobig'
        when: 'numberOfItems is greater than 1'
        co.numberOfItems = 1
        then: 'validation succeeds'
        co.validate()
        !co.hasErrors()
        when: 'numberOfItems is greater than 10'
        co.numberOfItems = 10
        then: 'validation succeeds'
        co.validate()
        !co.hasErrors()
    }
}

// src/groovy/com/demo/Book.groovy
package com.demo
class Book {
    String title
    String author
    static constraints = {
        author minSize: 5
    }
}

// grails-app/conf/Config.groovy
grails.validateable.classes = [com.demo.Book]
// ...

// test/unit/com/demo/BookSpec.groovy
package com.demo
import grails.test.mixin.TestMixin
import grails.test.mixin.support.GrailsUnitTestMixin
import spock.lang.Specification
@TestMixin(GrailsUnitTestMixin)
class BookSpec extends Specification {
    void 'Test validation'() {
        given:
        mockForConstraintsTests Book
        when: 'the author name has only 4 characters'
        def book = new Book()
        book.author = 'Jeff'
        then: 'validation should fail'
        !book.validate()
        book.hasErrors()
        book.errors['author'] == 'minSize'
        when: 'the author name has 5 characters'
        book.author = 'Jacob'
        then: 'validation should pass'
        book.validate()
        !book.hasErrors()
    }
}

class CancellingFilters {
    def filters = {
        all(controller:"simple", action:"list") {
            before = {
                redirect(controller:"book")
                return false
            }
        }
    }
}

@TestFor(SimpleController)
@Mock(CancellingFilters)
class SimpleControllerTests {
}

void testInvocationOfListActionIsFiltered() {
    withFilters(action:"list") {
        controller.list()
    }
    assert response.redirectedUrl == '/book'
}

withFilters(controller:"book",action:"list") {
    controller.list()
}

import org.example.AuthorController
import org.example.SimpleController
@TestFor(UrlMappings)
@Mock([AuthorController, SimpleController])
class UrlMappingsTests {
    …
}

static mappings = {
    "/action1"(controller: "simple", action: "action1")
    "/action2"(controller: "simple", action: "action2")
}

void testUrlMappings() {
    assertForwardUrlMapping("/action1", controller: 'simple',
                                        action: "action1")
    assertForwardUrlMapping("/action2", controller: 'simple',
                                        action: "action2")
    shouldFail {
        assertForwardUrlMapping("/action2", controller: 'simple',
                                            action: "action1")
    }
}

@TestFor(SimpleController)
@Mock(UrlMappings)
class SimpleControllerTests {
    void testControllerMapping() {
        SimpleController controller = mapURI('/simple/list')
        assert controller != null
        def model = controller.list()
        assert model != null
    }
}

mockFor(class, loose = false)

def strictControl = mockFor(MyService)
strictControl.demand.someMethod(0..2) { String arg1, int arg2 -> … }
strictControl.demand.static.aStaticMethod {-> … }

class MyService {
    def someMethod(String s) { … }
}

def strictControl = mockFor(MyService)
//Works just like the demand method since method signature exists on the class
strictControl.demandExplicit.someMethod(1) { String arg1  }

def strictControl = mockFor(MyService)
//Throws ExplicitDemandException because method signature doesn't exist
strictControl.demandExplicit.someMethod(1) { String arg1, String arg2  }

def looseControl = mockFor(MyService, true)

mockCodec(MyCustomCodec)

class MyServiceTests extends GroovyTestCase {
    void testSomething() {
        log.info "Starting tests"
        …
    }
}

class MyServiceTests extends GroovyTestCase {
    static transactional = false
    void testMyTransactionalServiceMethod() {
        …
    }
}

class FooController {
    def text() {
        render "bar"
    }
    def someRedirect() {
        redirect(action:"bar")
    }
}

class FooControllerTests extends GroovyTestCase {
    void testText() {
        def fc = new FooController()
        fc.text()
        assertEquals "bar", fc.response.contentAsString
    }
    void testSomeRedirect() {
        def fc = new FooController()
        fc.someRedirect()
        assertEquals "/foo/bar", fc.response.redirectedUrl
    }
}

class FilmStarsController {
    def popularityService
    def update() {
        // do something with popularityService
    }
}

class FilmStarsTests extends GroovyTestCase {
    def popularityService
    void testInjectedServiceInController () {
        def fsc = new FilmStarsController()
        fsc.popularityService = popularityService
        fsc.update()
    }
}

class AuthenticationController {
    def signup(SignupForm form) {
        …
    }
}

def controller = new AuthenticationController()
controller.params.login = "marcpalmer"
controller.params.password = "secret"
controller.params.passwordConfirm = "secret"
controller.signup()

def save() {
    def book = Book(params)
    if (book.save()) {
        // handle
    }
    else {
        render(view:"create", model:[book:book])
    }
}

def bookController = new BookController()
bookController.save()
def model = bookController.modelAndView.model.book

def create() {
    [book: new Book(params.book)]
}

void testCreateWithXML() {
    def controller = new BookController()
    controller.request.contentType = 'text/xml'
    controller.request.content = '''\
            <?xml version="1.0" encoding="ISO-8859-1"?>
            <book>
                <title>The Stand</title>
                …
            </book>
            '''.stripIndent().getBytes() // note we need the bytes
    def model = controller.create()
    assert model.book
    assertEquals "The Stand", model.book.title
}

void testCreateWithJSON() {
    def controller = new BookController()
    controller.request.contentType = "application/json"
    controller.request.content =
            '{"id":1,"class":"Book","title":"The Stand"}'.getBytes()
    def model = controller.create()
    assert model.book
    assertEquals "The Stand", model.book.title
}

class ExampleController {
    def exampleFlow() {
        start {
            on("go") {
                flow.hello = "world"
            }.to "next"
        }
        next {
            on("back").to "start"
            on("go").to "subber"
        }
        subber {
            subflow(action: "sub")
            on("end").to("end")
        }
        end()
    }
    def subFlow() {
        subSubflowState {
            subflow(controller: "other", action: "otherSub")
            on("next").to("next")
        }
        …
    }
}

import grails.test.WebFlowTestCase
class ExampleFlowTests extends WebFlowTestCase {
    def getFlow() { new ExampleController().exampleFlow }
    …
}

import grails.test.WebFlowTestCase
class ExampleFlowTests extends WebFlowTestCase {
    String getFlowId() { "example" }
    …
}

protected void setUp() {
    super.setUp()
    registerFlow("other/otherSub") { // register a simplified mock
        start {
            on("next").to("end")
        }
        end()
    }
    // register the original subflow
    registerFlow("example/sub", new ExampleController().subFlow)
}

void testExampleFlow() {
    def viewSelection = startFlow()
    …
}

void testExampleFlow() {
    …
    signalEvent("go")
    assert "next" == flowExecution.activeSession.state.id
    assert "world" == flowScope.hello
}

class FooTagLib {
    def bar = { attrs, body ->
        out << "<p>Hello World!</p>"
    }
    def bodyTag = { attrs, body ->
        out << "<${attrs.name}>"
        out << body()
        out << "</${attrs.name}>"
    }
}

class FooTagLibTests extends GroovyTestCase {
    void testBarTag() {
        assertEquals "<p>Hello World!</p>",
                     new FooTagLib().bar(null, null).toString()
    }
    void testBodyTag() {
        assertEquals "<p>Hello World!</p>",
                     new FooTagLib().bodyTag(name: "p") {
                         "Hello World!"
                     }.toString()
    }
}

import java.text.SimpleDateFormat
class FormatTagLib {
    def dateFormat = { attrs, body ->
        out << new SimpleDateFormat(attrs.format) << attrs.date
    }
}

class FormatTagLibTests extends GroovyPagesTestCase {
    void testDateFormat() {
        def template =
                '<g:dateFormat format="dd-MM-yyyy" date="${myDate}" />'
        def testDate = … // create the date
        assertOutputEquals('01-01-2008', template, [myDate:testDate])
    }
}

class FormatTagLibTests extends GroovyPagesTestCase {
    void testDateFormat() {
        def template =
                '<g:dateFormat format="dd-MM-yyyy" date="${myDate}" />'
        def testDate = … // create the date
        def result = applyTemplate(template, [myDate:testDate])
        assertEquals '01-01-2008', result
    }
}

void testQuery() {
    def books = [
            new Book(title: "The Stand"),
            new Book(title: "The Shining")]
    books*.save()
    assertEquals 2, Book.list().size()
}

void testQuery() {
    def books = [
            new Book(title: "The Stand"),
            new Book(title: "The Shining")]
    books*.save(flush: true)
    assertEquals 2, Book.list().size()
}

grails test-app functional: -war

grails test-app functional: -https

grails test-app functional: -httpsBaseUrl

grails test-app functional: -baseUrl=http://mycompany.com/grailsapp