Here are the slides from the talk a gave yesterday. If you have any
questions, please ask.
Couple of years ago I wasn't a big fan of unit testing. It was obvious to me that well prepared unit tests are crucial though. I didn't known why exactly crucial yet then. I just felt they are important. My disliking to write automation tests was mostly related to the effort necessary to prepare them. Also a spaghetti code was easily spotted in test sources.apply plugin: 'groovy'As you can see the build.gradle file is almost self-explanatory. Groovy plugin is applied to compile groovy code. It needs groovy-all.jar - declared in version 2.0 at dependencies block just next to Spock in version 0.7. What's most important, mentioned Maven repository URL is added at repositories block.
apply plugin: 'idea'
def langLevel = 1.7
sourceCompatibility = langLevel
targetCompatibility = langLevel
group = 'com.tamashumi.example.testwithspock'
version = '0.1'
repositories {
mavenLocal()
mavenCentral()
maven { url 'http://oss.sonatype.org/content/repositories/snapshots/' }
}
dependencies {
groovy 'org.codehaus.groovy:groovy-all:2.0.1'
testCompile 'org.spockframework:spock-core:0.7-groovy-2.0-SNAPSHOT'
}
idea {
project {
jdkName = langLevel
languageLevel = langLevel
}
}
<project root>To build a project now you can type command gradle build or gradle test to only run tests.
│
├── build.gradle
└── src
├── main
│ ├── groovy
└── test
└── groovy
apply plugin: 'java'This way if you don't want or just can't deploy Groovy compiled stuff into your production JVM for any reason, still whole goodness of testing with Spock and Groovy is at your hand.
public class SimpleJavaClass {
public int sumAll(int... args) {
int sum = 0;
for (int arg : args){
sum += arg;
}
return sum;
}
}class SimpleGroovyClass {
String concatenateAll(char separator, String... args) {
args.join(separator as String)
}
}class JustASpecification extends Specification {
@Unroll('Sums integers #integers into: #expectedResult')
def "Can sum different amount of integers"() {
given:
def instance = new SimpleJavaClass()
when:
def result = instance.sumAll(* integers)
then:
result == expectedResult
where:
expectedResult | integers
11 | [3, 3, 5]
8 | [3, 5]
254 | [2, 4, 8, 16, 32, 64, 128]
22 | [7, 5, 6, 2, 2]
}
@Unroll('Concatenates strings #strings with separator "#separator" into: #expectedResult')
def "Can concatenate different amount of integers with a specified separator"() {
given:
def instance = new SimpleGroovyClass()
when:
def result = instance.concatenateAll(separator, * strings)
then:
result == expectedResult
where:
expectedResult | separator | strings
'Whasup dude?' | ' ' as char | ['Whasup', 'dude?']
'2012/09/15' | '/' as char | ['2012', '09', '15']
'nice-to-meet-you' | '-' as char | ['nice', 'to', 'meet', 'you']
}
} To run tests with Gradle simply execute command gradle test. Test reports can be found at <project root>/build/reports/tests/index.html and look kind a like this.
apply plugin: 'war'in the build.gradle file and create a directory src/main/webapp.
apply plugin: 'groovy'
apply plugin: 'idea'
def langLevel = 1.7
sourceCompatibility = langLevel
targetCompatibility = langLevel
group = 'com.tamashumi.example.testwithspock'
version = '0.1'
repositories {
mavenLocal()
mavenCentral()
}
dependencies {
groovy 'org.codehaus.groovy:groovy-all:2.0.5'
testCompile 'org.spockframework:spock-core:0.7-groovy-2.0'
}
idea {
project {
jdkName = langLevel
languageLevel = langLevel
}
}
I've encountered strange behavior with a domain class in my project: services that should be injected were null. I've became suspicious as why is that? Services are injected properly in other domain classes so why this one is different?
I've created an experiment. I've created empty LibraryService that should be injected and Book domain class like this:
class Book {
def libraryService
String author
String title
int pageCount
Book() {
println("Finished constructor Book()")
}
Book(String author) {
this()
this.@author = author
println("Finished constructor Book(String author)")
}
Book(String author, String title) {
super()
this.@author = author
this.@title = title
println("Finished constructor Book(String author, String title)")
}
Book(String author, String title, int pageCount) {
this.@author = author
this.@title = title
this.@pageCount = pageCount
println("Finished constructor Book(String author, String title, int pageCount)")
}
void logInjectedService() {
println(" Service libraryService is injected? -> $libraryService")
}
}class LibraryService {
def serviceMethod() {
}
}Book has 4 explicit constructors. I want to check which constructor is injecting dependecies. This is my method that constructs Book objects and I called it in controller:
class BookController {
def index() {
constructAndExamineBooks()
}
static constructAndExamineBooks() {
println("Started constructAndExamineBooks")
Book book1 = new Book().logInjectedService()
Book book2 = new Book("foo").logInjectedService()
Book book3 = new Book("foo", 'bar').logInjectedService()
Book book4 = new Book("foo", 'bar', 100).logInjectedService()
Book book5 = new Book(author: "foo", title: 'bar')
println("Finished constructor Book(Map params)")
book5.logInjectedService()
}
}Output looks like this:
Started constructAndExamineBooks
Finished constructor Book()
Service libraryService is injected? -> eu.spoonman.refaktor.LibraryService@2affcce2
Finished constructor Book()
Finished constructor Book(String author)
Service libraryService is injected? -> eu.spoonman.refaktor.LibraryService@2affcce2
Finished constructor Book(String author, String title)
Service libraryService is injected? -> null
Finished constructor Book(String author, String title, int pageCount)
Service libraryService is injected? -> null
Finished constructor Book()
Finished constructor Book(Map params)
Service libraryService is injected? -> eu.spoonman.refaktor.LibraryService@2affcce2What do we see?
Always explicitily invoke empty constructor in your Grail domain classes to ensure Dependency Injection! I didn't know until today either!