This document provides an overview and roadmap for a workshop on testing with Spock and Gradle. It introduces Spock and how to write specifications and feature methods using Spock's domain-specific language. It walks through examples of creating specifications to test races, voyages, spaceships, weapons damage, exceptions, interactions, and other features. It also discusses extensions, timeouts, ignoring tests, shared objects, and other Spock mechanisms. Finally, it provides an introduction to using Geb for browser-based testing with Spock.

1. Workshop
SPOCK: Testing (in the) Enterprise!
Fernando Redondo Ramírez
@pronoide_fer

2. Roadmap

3. Roadmap

4. Roadmap

5. Roadmap

6. Roadmap

7. How do I start with Gradle?

8. • Who am I
• …
• Hands on!

9. • Who am I
• …
• Hands on!

10. Hands on!
Before start, you have to…
1. Start Groovy/Grails Tool Suite 3.6 (GGTS) and create a workspace (remember run
it with a JDK and install the gradle extension for eclipse). Groovy 2.4 compiler as
well.
2. Download http://pronoide.com/downloads/greach-workshop-2015.zip
and unzip it into workspace folder. Or take it from
https://github.com/fredondo/greach2015-spock-workshop
3. Hold on! Please wait me right here…

11. Stage I: Import the workshop project
i. Import gradle Project (enterprise.mission)

12. Specifications
- Test classes are named Specifications
- All specifications (Specs) must extend from
spock.lang.Specification
- Each specification must have at least ONE test
method, all of these are called feature methods
- The most simple assert within a feature method is the
expect block, all its sentences must be evaluated to
true so that the feature will be OK

13. Specifications
- A very simple specification

14. Stage II: Creating Specs
Complete the following specification and acomplish the challenges
(org.startrek.challenges.n01.RacesSpec)

15. Stage II: Creating Specs
Did you get it right?
(org.startrek.solutions.n01.RacesSpec)

16. Stage II: Creating Specs
• Run the spec class as JUnit test
• Or execute the test gradle task (gradle quick task launcher)

17. Specfication methods
- Within any specification we can found
- Feature methods (or test methods) with diferent
blocks of code for stating the scenario under spec
- Fixture methods that will be called automatically
before or after any single feature methods or before
and after the specification:
- setup, cleanup, setupSpec and cleanupSpeck
- Helper methods that can be called at any time from
other methods and can be convenient for code clarity
and code reuse

18. Stage III: Inside the Specs
Complete the following specification and acomplish the challenge
(org.startrek.challenges.n02.VoyageSpec)

19. Stage III: Inside the Specs
This is not rocket science (org.startrek.solutions.n02.VoyageSpec)

20. Whoami
• Entrepreneur and Business Manager at
Pronoide since 2003
• Currently working for Hybris (SAP) as technical
trainer
• Java & Friends Trainer
• Doing things with Java from 1999 on
• Computer Engineer
• Happily married and proud father of two children
• Not that Trekky (Sure!)

21. Stage IV: Inside the feature
Complete the following feature methods and probe your courage
(org.startrek.challenges.n03.SpaceshipSpec)

22. Stage IV: Inside the feature
Easy peasy!! (org.startrek.solutions.n03.SpaceshipSpec)

23. Feature method blocks
- These are the kinds of blocks (continuation):
- when and then blocks always occur together. They describe
a stimulus and the expected response. when blocks can
contain arbitrary code, then blocks are restricted to
conditions, exception conditions, interactions, and variable
definitions (which mean more options available that for
expect blocks). There can be multiples pair ocurrencies
within a feature.

24. Stage IV: Inside the feature
Fill in the next feature method if you dare!
(org.startrek.challenges.n03.StarfleetSpec)

25. Stage IV: Inside the feature
It was piece of cake!! (org.startrek.solutions.n03.SpaceshipSpec)

26. Feature method blocks
- These are the kinds of blocks (cont.):
- A where block always comes last in a feature method, and
cannot be repeated. It is used to write data-driven feature
methods. As a matter of convenience it can be written in
two different ways:
- A row per variable with the << symbol
- A column per variable with | symbol
- A data-drive feature method can be annotated with
@unroll, in that case, the method will be invoked multiple
times with the provider data variables. these can be used in
the method description with placeholders (#). For each
iteration the placeholders are replaced with correct values.

27. Stage IV: Inside the feature
The thing gets tougher!
(org.startrek.challenges.n03.WeaponsDamageSpec)

28. Stage IV: Inside the feature
As easy as pie!! (org.startrek.solutions.n03.WeaponsDamageSpec)

29. Testing exceptions
- In order to deal with specification that
throw or not exceptions, Spock provides the
following exception conditions
- thrown(ExceptionClass) and notThrow(ExceptionClass)
- It’s also possible to get the exception instance, to
access its atributtes:
def ex=thrown()

30. Stage V: Exception Conditions
Complete these two features
(org.startrek.challenges.n04.DestructionSpec)

31. Stage V: Exception Conditions
Keep it up! (org.startrek.solutions.n04.DestructionSpec)

32. Interactions
- Interaction-based testing is a design and testing
technique that focusing more on the behavior of
objects rather than their state, it explores how the
object(s) under spec interact, by way of method
calls, with their collaborators
- We need to mock the collaborator implementations via
def colaborator=Mock(Class) Or Class colaborator=Mock()
– Mocks are usually created using Dynamic Proxies or cglib
– we can track interactions with collaborators within then block:
when:
spock.teletransport()
then:
1 * transporter.use()

33. Stage VI: Interactions
Write down this feature method
(org.startrek.challenges.n05.ShipManagementSpec)

34. Stage VI: Interactions
It’s not that complicated, is it?
(org.startrek.solutions.n05. ShipManagementSpec)

35. Useful stuff
- In daily life Spock use, we usually will make use of:
- Share objects among feature via @Shared class
attributes, other way they won’t share them
– There are two kinds of conditions to validate a feature: Implicit
and Explicit. Implicit conditions appear in expect and then blocks.
To use conditions in other places, you can use assert keyword
– Sometimes feature methods are large or contain duplicated code.
It can make sense to introduce helper methods
– Specifications as Documentation, Spock provides a way to attach
textual descriptions to blocks
When: “everything start”
– You can leverage the use of Hamcrest

36. Stage VI: Other mechanisms
In the following spec identify with mechanisms are used
(org.startrek.challenges.n06.MoviesSpec)

37. Stage VI: Other mechanisms
No brainer (org.startrek.solutions.n06. MoviesSpec)

38. Extensions
- Spock offers lots of functionality for writing specs. But, there
always comes a time when something else is needed. Spock
provides an interception-based extension mechanism.
Extensions are activated by annotations called directives.
These are some directives:
- @Timeout Sets a timeout for execution of a feature or fixture
- @Ignore Ignores a feature method
- @IgnoreRest Ignores all feature methods not carrying this annotation.
@IgnoreIf To ignore a feature method under certain conditions
- @FailsWith Expects a feature method to complete abruptly
- @Requires To execute a feature method under certain conditions
- @Stepwise executes features in the order that they are declared
- @Title and @Narrative To attach a natural-language name to a spec
- @Issue indicates that a feature or spec relates to one or more issues in an
external tracking system
- Many more and you can also create your own ones.

39. Brief introduction
- Groovy based testing and
specification framework
- Can test anything that runs inside the JVM
(even Java)
- Beautiful and highly expressive specification
language
- Compatible with most IDEs, build tools, and
continuous integration servers (JUnit runner)

40. Extra ball: Geb!
- Geb is a framework for automatization of
functional web testing. It is based on the
following technologies:
– Groovy Language (and it’s incredible with Spock)
– Selenium WebDriver
– JQuery CSS Content Selector
– Page Object Model
- We have to change add dependencies to our build.gradle:
testCompile 'org.gebish:geb-spock:0.10.0'
testCompile "org.seleniumhq.selenium:selenium-chrome-driver:2.43.1”
We have to configure our driver (automated browser) in
src/test/resources/GebConfig.groovy

41. Extra ball: Geb!
Create a simple driver configuration & download the driver
(src/test/resources/GebConfig.groovy)

42. Extra ball: Geb!
Let’s perform a search for apock in memory-alpha.org
(org.startrek.challenges.n07.WebNavigationSpec.groovy)

43. Extra ball: Geb!
That’s great! But, Can YOU do it in a better way?

44. Extra ball: Geb!
Let’s keep it simple an reusable! Functional Spec.
(org.startrek.solutions.n07.WebNavigationSpec2.groovy)

45. Extra ball: Geb!
Let’s keep it simple an reusable! Reusable Page Model.
(org.startrek.solutions.n07. MemoryAlphaPage.groovy and
org.startrek.solutions.n07. MemoryAlphaResultsPage.groovy )

46. Thanks!
• @pronoide_fer
• https://github.com/fredondo/
• fredondo@pronoide.com
• http://pronoide.com
• http://blog.pronoide.es