
- •brief contents
- •contents
- •foreword
- •preface
- •acknowledgments
- •about this book
- •Roadmap
- •Code conventions and downloads
- •Author Online
- •About the author
- •about the cover illustration
- •1 Why add Groovy to Java?
- •1.1 Issues with Java
- •1.1.1 Is static typing a bug or a feature?
- •1.1.2 Methods must be in a class, even if you don’t need or want one
- •1.1.3 Java is overly verbose
- •1.1.4 Groovy makes testing Java much easier
- •1.1.5 Groovy tools simplify your build
- •1.2 Groovy features that help Java
- •1.3 Java use cases and how Groovy helps
- •1.3.1 Spring framework support for Groovy
- •1.3.2 Simplified database access
- •1.3.3 Building and accessing web services
- •1.3.4 Web application enhancements
- •1.4 Summary
- •2 Groovy by example
- •2.1 Hello, Groovy
- •2.2 Accessing Google Chart Tools
- •2.2.1 Assembling the URL with query string
- •2.2.2 Transmitting the URL
- •2.2.3 Creating a UI with SwingBuilder
- •2.3 Groovy Baseball
- •2.3.1 Database data and Plain Old Groovy Objects
- •2.3.2 Parsing XML
- •2.3.3 HTML builders and groovlets
- •2.4 Summary
- •3 Code-level integration
- •3.1 Integrating Java with other languages
- •3.2 Executing Groovy scripts from Java
- •3.2.1 Using JSR223 scripting for the Java Platform API
- •3.2.2 Working with the Groovy Eval class
- •3.2.3 Working with the GroovyShell class
- •3.2.4 Calling Groovy from Java the easy way
- •3.2.5 Calling Java from Groovy
- •3.3 Summary
- •4 Using Groovy features in Java
- •4.1 Treating POJOs like POGOs
- •4.2 Implementing operator overloading in Java
- •4.3 Making Java library classes better: the Groovy JDK
- •4.4 Cool AST transformations
- •4.4.1 Delegating to contained objects
- •4.4.2 Creating immutable objects
- •4.4.3 Creating singletons
- •4.5 Working with XML
- •4.6 Working with JSON data
- •4.7 Summary
- •5 Build processes
- •5.1 The build challenge
- •5.2 The Java approach, part 1: Ant
- •5.3 Making Ant Groovy
- •5.3.1 The <groovy> Ant task
- •5.3.2 The <groovyc> Ant task
- •5.3.3 Writing your build in Groovy with AntBuilder
- •5.3.4 Custom build scripts with Gant
- •5.3.5 Ant summary
- •5.4 The Java approach, part 2: Maven
- •5.4.2 The GMaven project
- •5.4.3 Maven summary
- •5.5 Grapes and @Grab
- •5.6 The Gradle build system
- •5.6.1 Basic Gradle builds
- •5.6.2 Interesting configurations
- •5.7 Summary
- •6 Testing Groovy and Java projects
- •6.1 Working with JUnit
- •6.1.1 A Java test for the Groovy implementation
- •6.1.2 A Groovy test for the Java implementation
- •6.1.3 A GroovyTestCase test for a Java implementation
- •6.2 Testing scripts written in Groovy
- •6.2.1 Useful subclasses of GroovyTestCase: GroovyShellTestCase
- •6.2.2 Useful subclasses of GroovyTestCase: GroovyLogTestCase
- •6.3 Testing classes in isolation
- •6.3.1 Coerced closures
- •6.3.2 The Expando class
- •6.3.3 StubFor and MockFor
- •6.4 The future of testing: Spock
- •6.4.1 The Search for Spock
- •6.4.2 Test well, and prosper
- •6.4.4 The trouble with tribbles
- •6.4.5 Other Spock capabilities
- •6.5 Summary
- •7 The Spring framework
- •7.1 A Spring application
- •7.2 Refreshable beans
- •7.3 Spring AOP with Groovy beans
- •7.4 Inline scripted beans
- •7.5 Groovy with JavaConfig
- •7.6 Building beans with the Grails BeanBuilder
- •7.7 Summary
- •8 Database access
- •8.1 The Java approach, part 1: JDBC
- •8.2 The Groovy approach, part 1: groovy.sql.Sql
- •8.3 The Java approach, part 2: Hibernate and JPA
- •8.4 The Groovy approach, part 2: Groovy and GORM
- •8.4.1 Groovy simplifications
- •8.5 Groovy and NoSQL databases
- •8.5.1 Populating Groovy vampires
- •8.5.2 Querying and mapping MongoDB data
- •8.6 Summary
- •9 RESTful web services
- •9.1 The REST architecture
- •9.3 Implementing JAX-RS with Groovy
- •9.4 RESTful Clients
- •9.5 Hypermedia
- •9.5.1 A simple example: Rotten Tomatoes
- •9.5.2 Adding transitional links
- •9.5.3 Adding structural links
- •9.5.4 Using a JsonBuilder to control the output
- •9.6 Other Groovy approaches
- •9.6.1 Groovlets
- •9.6.2 Ratpack
- •9.6.3 Grails and REST
- •9.7 Summary
- •10 Building and testing web applications
- •10.1 Groovy servlets and ServletCategory
- •10.2 Easy server-side development with groovlets
- •10.2.1 A “Hello, World!” groovlet
- •10.2.2 Implicit variables in groovlets
- •10.3.2 Integration testing with Gradle
- •10.3.3 Automating Jetty in the Gradle build
- •10.4 Grails: the Groovy “killer app”
- •10.4.1 The quest for the holy Grails
- •10.5 Summary
- •A.1 Installing a JDK
- •A.2 Installing Groovy
- •A.3 Testing your installation
- •A.4 IDE support
- •A.5 Installing other projects in the Groovy ecosystem
- •B.1 Scripts and the traditional example
- •B.2 Variables, numbers, and strings
- •B.2.1 Numbers
- •B.2.2 Strings and Groovy strings
- •B.3 Plain Old Groovy Objects
- •B.4 Collections
- •B.4.1 Ranges
- •B.4.2 Lists
- •B.4.3 Maps
- •B.5 Closures
- •B.6 Loops and conditionals
- •B.6.1 Loops
- •B.6.2 Conditionals
- •B.6.3 Elvis
- •B.6.4 Safe de-reference
- •B.7 File I/O
- •B.8.1 Parsing and slurping XML
- •B.8.2 Generating XML
- •B.8.3 Validation
- •B.9 JSON support
- •B.9.1 Slurping JSON
- •B.9.2 Building JSON
- •index
- •Symbols

164 |
CHAPTER 6 Testing Groovy and Java projects |
Lessons learned (Spock)
1Spock tests extend spock.lang.Specification.
2The Specification class has a JUnit runner, so Spock tests run in your existing JUnit infrastructure.
3Spock test names are descriptive sentences. The framework uses AST transformations to convert them to legal Groovy.
4The tests are composed of blocks, like expect or when/then. Expressions in an expect or then block are evaluated for the Groovy Truth automatically.
5The old method from spock.lang.Specification evaluates its argument before the when block is executed.
6The where block is used to iterate over test data, either from a table, a database result, or any data structure over which Groovy can iterate.
7Spock has its own built-in mocking capabilities.
The wiki for Spock contains many examples, as well as detailed documentation about mock details (called interactions) and more. The source code also comes with a Spock example project that you can use as a basis for your project. Spock is built with Gradle, which configures all the dependencies, and can plug into other APIs like Spring. See the docs and APIs for details.26
6.5Summary
This chapter covered a lot of ground in the testing arena. Groovy brings a simple assert statement into play that can be used for scripts and includes the GroovyTestCase class that extends JUnit’s capabilities. When it comes to managing dependencies, you can build a stub implementation of an interface using closures, and you can build a more complete stub using the Expando class.
Groovy also has the StubFor and MockFor classes, which can be used to test interactions. They can even create mock objects for classes that are instantiated as local variables, which is pretty amazing.
Finally, if you’re willing to add an additional library, the Spock testing framework provides a simple yet versatile API that still runs on your existing JUnit-based infrastructure. It also has its own mock abilities and integrates with other libraries, like Spring and Tapestry.
Adding Groovy also adds a wide variety of options for testing Java and mixed Java/ Groovy projects. Hopefully the techniques in this chapter will help you decide where you can get the most benefit from them.
26 See also the Manning book Spock in Action, by Ken Sipe, coming soon.
www.it-ebooks.info

Part 3
Groovy in the real world
In part 3, “Groovy in the real world,” I try to address the sorts of challenges Java developers face on a regular basis.
I start with the Spring framework, which is probably the most commonly used open source project in the Java world. Spring and Groovy are old friends and work together beautifully. Chapter 7 shows how to use Groovy classes as Spring beans anywhere in your system, including aspects. It then shows Spring capabilities unique to dynamic languages, like refreshable beans, inline scripted beans, and the BeanBuilder class from Grails.
Chapter 8 covers Groovy interactions with persistent storage. Groovy includes a very useful façade over JDBC known as the groovy.sql.Sql class, which is effective when working with relational databases. The chapter also provides an example of working with the GMongo project, a Groovy wrapper around the Java API for working with MongoDB. This is a typical Groovy idiom—taking a Java library and making it easier to use. Finally, the chapter discusses many of the issues associated with GORM, the Grails Object Relational Mapping layer from Grails, which is probably the most common domain-specific language in Groovy used today.
Chapter 9 focuses on RESTful web services, with an emphasis on the JAX-RS 2.0 specification. Most of the JAX-RS capabilities operate the same way under Groovy as under Java, but examples are provided to show how to work with hypermedia applications as well.
www.it-ebooks.info
The last chapter in this section is about web application development. Chapter 10 starts with a nice example of Groovy metaprogramming using categories. Specifically, the ServletCategory class is presented as an example of what can be done quickly and easily with Groovy. Next comes a discussion of groovlets, which are Groovy scripts executed through a servlet that make it easy to get a simple application running. The chapter concludes with a demonstration of the Grails framework as a beautiful combination of Groovy DSLs that combine and configure Spring/Hibernate-based web applications.
www.it-ebooks.info