This document provides an overview of testing in Grails and Spock testing framework. It discusses unit testing, the advantages of unit testing like facilitating change and improving quality. It also covers Spock basics like specification, fields, blocks, expectations. It demonstrates how to write unit tests in Spock including mocking, stubbing, data-driven testing and verification of interactions. The document recommends using the code coverage plugin to analyze test coverage.

2. GRAILS SPOCK
TESTING

3. Agenda
1. Testingoverview
2. Understanding UnitTesting
3. Spock UnitTesting
4. Writing Unit test cases
5. Demo
6. Exercise

4. What do we test ?
What a program issupposed to do
==
What the program actuallydoes

5. Motivation
Peopleare not perfect
We make errorsin design and code

6. Testing is an Investment
Over the time the tests build, the
early investment in writingtest
cases pays dividends later as the
sizeof the application grows

7. A way Of Thinking
• Design and Coding are creative while Testing isDestructive
• Primarygoal isto break the software
• Very often the same person does coding and testing. He needs a
splitpersonality
• One needs to be paranoid and malicious
• Surprisinglyhard to do as people don't like finding themselves making
mistakes

8. MailService.groovy
• Testing isa process of executing software with the intention of finding
errors
• Good testing has high probability of finding yet undiscovered errors
• Successful testing discoverserrors
• Ifit did not, need to ask whether our testing approach isgood or not

9. Integral Part of Development
• Testingneedstobe integralpartateach levelof development
• Types:
• Unit testing (whitebox)
• Integration testing (whitebox)
• Functional testing (blackbox)
• Acceptance testing

10. Understanding Unit testing
• Individual units of source code are tested
• A unit isthe smallest testable part of the application
• Each test case isindependent of the others
• Substituteslike mock, stubs areused
• Testsindividual methods or blocks without considering the
surrounding infrastructure
• A unit test provides a strict contract that a piece of code MUSTsatisfy

11. Disadvantages of Unit testing
• Test cases ‐written to suit programmer’simplementation(not
necessarily specification)
• The actual database or external file isnever tested directly
• Highly reliant on Refactoring and Programming skils

12. Advantages of Unit testing
• Facilitates change
• Allows refactoring at a later date and makes sure the
module stil workscorrectly
• SimplifiesIntegration
• Byremoving uncertainty among units themselves
• Acts asDocumentation
• Acts as a living documentation of a system

13. Advantages of Unit testing
• Evolvesdesign
• In“Test Driven Approach”, the unit test may take the
place of formal design. Each unit test case acts as a
design element for classes, methods and behaviour
• Improves the Quality Of the Software

14. Spock
• A developer testing framework for Java and Groovy application
• Based onGroovy
• What makes it stand out from the crowd isitsbeautiful and highly
expressive specification language

15. Basics
Spockletsyouwritespecificationsthatdescribeexpected features
(properties,aspects)exhibitedby a systemof interest

16. import spock.lang.*
Package spock.lang contains themostimportanttypesfor writing
specifications

17. Specification
• A specification isrepresented as a Groovy class that extends from
spock.lang.Specification, e.g.,
• class MyFirstSpecification extends Specification{
• }
• Class names of Spock tests must end in either “Spec” or
“Specification”. Otherwise the Grails test runner won't find them.

18. … contd
• Specification contains a number of useful methods for writing
specifications
• Instructs JUnit to run specification withSputnik, Spock's JUnitrunner

19. Fields
• Declarations:
• def obj =newClass()
• @Shared res =new VeryExpensiveResource()

20. Fixture Methods
• Fixture methods are responsible for setting up and cleaning up the
environment in which feature methods are run.
• def setup(){}
• def cleanup(){}
• def setupSpec(){}
• def cleanupSpec() {}

21. Blocks
• A test case can have following blocks:
• setup
• when //forstimulus
• then //output comparison
• expect
• where

22. Example

23. Expect Block
• Itisuseful in situations where itis
more natural to describestimulus
and expected response in a
singleexpression

24. Where block
• Itisused to write data-driven featuremethods

25. Data Driven Testing
• Itisuseful to exercise the same test code multiple times, with varying
inputs and expected results.
• Itisa firstclass feature in Spock

26. Data Tables
• A convenient way to exercise a
feature method with a fixed set
of data

27. Data Pipes
• A data pipe, indicated by the
left-shift (<<)operator, connects a
data variable to a data provider.

28. @Unroll
• A method annotated with @Unrol will have itsiterations reported
independently

29. Exception Conditions
• They are used to describe that a when block should throw an
exception

30. Mocking
• Mock objects literally implement (or extend) the type they stand in
for
• Initiallymock objects have no behavior
• Calling methods on them is allowed but has no effect otherthan
returning the default value for the method’s return type, except for
equals and toString
• A mock object isonly equal to itself, has a unique hash code, and a
string representation that includes the name of the type it represents

31. ..contd.
• Thisdefault behavior isoverrideable by stubbing the methods
• Mock objects are created with the MockingApi.Mock()
• def subscriber =Mock(Subscriber)
• Subscriber subsriber =Mock()

32. mockDomain()
• Takesa class and mock implementations of all the domain class
methods accessible onit
• mockDomain() provides a versionof domain classes in which the
database issimply listof domain instances in memory.
• mockDomain(Person, [persons])
• All mocked methods like save(),get() etc work against thislist.

33. mockForConstraintsTest()
• Highly specialized mocking for domain classes and command
objects that allows you to check whether the constraints are
behaving as expectedor not
• Itsimply adds a validate() method to a given domain class.
• mockForConstraintsTests(Person, [persons])

34. Test Mixins
• Since Grails 2.0,a collection of unit testing mixinsisprovided by Grails,
that enhances the behavior of a typical Junit or Spock test
• Common examplesare:
• @TestFor(BookController)
• @Mock([Book,Author])

35. TestFor Annotation
• The TestFor annotation defines a class under test and will
automatically create a field for the type of class under test
• For example, @TestFor(BookController) this will automaticallycreate
“controller” field
• IfTestForwas defined for a service then a “service” field would be
created

36. Mock Annotation
• The Mock annotation creates a mock version of any collaborators
• There isan in-memory implementation of GORM that will simulate
most interactions with GORM API
• For those interactions that are not automatically mocked, you need
to define mocksprogrammatically

37. Cardinality
• The cardinality of an interaction describes how often a method call is
expected. Itcan either be a fixed number or a range
• 1 *subscriber.receive(“hello”)
• 0..1)*subscriber.receive(“hello”)
• 0.._)*subscriber.receive(“hello”)
• 1 *subscriber._(“hello”)

38. Verification Of Interactions

39. Stubbing
• Stubbing isthe act of making collaborators respond to method calls
in acertain way
• Inother words stubbing isjustproviding dummy implementation of a
method

40. Stubbing Examples
• Returning FixedValues:
• subscriber.receive(_)>>”Ok”
• Toreturn different values on successive invocations, use the triple-
right-shift(>>>)operator
• subscriber.receive(_) >>>["ok","error","error", "ok"]

41. ...contd.
• Accessing Method Arguments
• subscriber.receive(_) >>{String message ->message.size()
>3 ? "ok":"fail"}
• Throw anexception:
• subscriber.receive(_) >>{throw new InternalError("ouch")}

42. Test Code Coverage Plugin
• Creates test code coverage for your code
• Add dependency:
• test ":code-coverage:1.2.6"
• Torun:
• grails test-app -coverage
• The script will create HTLMreports and place them in the
tests/report/cobertura directory.

43. References
• https://code.google.com/p/spock/wiki/SpockBasics
• https://code.google.com/p/spock/wiki/GettingStarted
• http://docs.spockframework.org/en/latest/
• http://meetspock.appspot.com/
• http://naleid.com/blog/2012/05/01/upgrading-to-grails-2-unit-
testing/

44. Contact us
Our Office
Client
Location
Click Here To Know More!
Have more queries on Grails?
Talk to our GRAILS experts
Now!
Talk To Our Experts
Here's how the world's
biggest Grails team is
building enterprise
applications on Grails!