GR8 Conf US: Spock Soup to Nuts

@TestFor(LibraryController)
@Mock([Book, Library])

class LibraryControllerTests extends Speciﬁcation{
LibraryControllerSpec {
   void testReturnBookToLibrary() { libraray"() {
"sucessfully return book to
   Book book = new Book(isdn:book & a library"
given: "I have a checked out '1234567ABC').save()
   Library library = new Library(name: 'Carnegie').save()
   controller.catalogService = new CatalogService()
   params.id = library.id for controller"
and: "all dependancies
   params.isdn = book.isdn
and: "we submit the isdn and library id"
   controller.returnBook()
     JSONElement json = response.getJson()

   assertEquals( json.isdn, book.isdn )
when: "submit the form"
   assertEquals( json.status, 'FILED' )
   }
} then: "verify the returned book is FILED"
json.isdn == book.isdn
json.status == 'FILED'


   given: "I have a checked out book & a library"
   Book book = new Book(isdn: '1234567ABC').save()
   and: "all dependancies for controller"
params.id = library.id


then: "verify the returned book is FILED"
} json.isdn == book.isdn
}



}
}



json.isdn == book.isdn book.isdn )
assertEquals( json.isdn,
}
}

void "add 2 things together"() {
  expect:
  1 + 2 == 3
'Bat' + 'man' == 'Bat man'
  99 + 1 == 100
}

Condition not satisﬁed:

'Bat' + 'man' == 'Bat man'
  | |
  Batman  false
  1 difference (85% similarity)
  Bat(-)man
  Bat( )man

  expect:"a + b = c"
  a + b == c
  where:
  a << [1, 'Bat', 99]
  b << [1, 'man', 1]
  c << [2, 'Batman', '100']
}

@Unroll
  expect:"a + b = c"
  a + b == c
  where:
  a << [1, 'Bat', 99]
  b << [1, 'man', 1]
  c << [2, 'Batman', '100']
}

@Unroll('#a + #b = #c')
  expect:"a + b = c"
  a + b == c
  where:
  a << [1, 'Bat', 99]
  b << [1, 'man', 1]
  c << [2, 'Batman', '100']
}

@Unroll
void "#a + #b = #c"() {
  expect:"a + b = c"
  a + b == c
  where:
  a << [1, 'Bat', 99]
  b << [1, 'man', 1]
  c << [2, 'Batman', '100']
}

@Unroll('#a + #b = #c')
  expect:"a + b = c"
  a + b == c
  where:
  a   | b || c
  1   | 1 || 2
  99 | 1 || 100
  "Bat" | "man" || "Batman"

}

void "custom data provider" () {
  expect:"a + b = c"
  a + b == c

  where:
  [a, b, c] << new ABCDataProvider()
}

class ABCDataProvider implements Iterator{

  List list = [[1,2,3], [1,99, 100], ['Bat', 'man', 'Batman']]
  int position = 0

  boolean hasNext() {
  position < list.size()
  }

  Object next() {
  def result = list[position]
  position += 1
  result
  }

  def size() {
  list.size()
  }

  def close(){ }

  void remove() { }
}

def catalogService = Mock(CatalogService)

CatalogService catalogService = Mock()

void "test interaction scoping"() {
  given:"create mock CatalogService"
  CatalogService service = Mock()
  controller.catalogService = service
  and: "make sure it can ﬁle books"
  service.isAvailable(_ as Book) >> true

  when:"we verify isdn"
  def result = controller.verifyISDN()

  then:"verify the book was ﬁled"
  1 * service.inquired(_)
  result == true
}


  when:"we verify isdn" Global

  result == true
}


  when:"we verify isdn" Local

  result == true
}


  when:"we verify isdn" Required

  result == true
}


  when:"we verify isdn" Optional

  result == true
}

1 * catalogService.ﬁle(book, library) >> 'FILED'

Carnality

(0..3) * catalogService.ﬁle(book, library) >> 'FILED'

Carnality

(3.._) * catalogService.ﬁle(book, library) >> 'FILED'

Carnality

(_..3) * catalogService.ﬁle(book, library) >> 'FILED'

Carnality

TooFewInvocationsError
TooManyInvocationsError


Carnality Target Constraint

(_..3) * _.ﬁle(book, library) >> 'FILED'

Target Constraint


Target Constraint Conststraint
Method

(_..3) * catalogService./f.*/(book, library) >> 'FILED'

Method Conststraint

(_..3) * catalogService._(book, library) >> 'FILED'

Method Conststraint


Method Conststraint List Constraint
Argument

(_..3) * catalogService.ﬁle(_, _) >> 'FILED'

Argument List Constraint

(_..3) * catalogService.ﬁle(*_) >> 'FILED'


(_..3) * catalogService.ﬁle(_ as Book, _) >> 'FILED'


(_..3) * catalogService.ﬁle(_ as Book, !null) >> 'FILED'


(_..3) * catalogService.ﬁle({it.isdn > 1}, !null) >> 'FILED'


1 * catalogService.ﬁle(book, library) >> 'FILED'

Return Values Constraint
Argument List

3 * catalogService.ﬁle(book, library) >>> ['FILED',‘ERROR’]

Return Values

3 * catalogService.ﬁle(book, library) >> {
book.status = FILED
return book
}

Return Values

3 * catalogService.ﬁle(book, library) >> {
throw new TimeoutException()
}

Return Values

foo.bar() >> { throw new IOException() } >>> [1, 2, 3] >> { throw new RuntimeException() }

Return Values

Order Is NOT enforced

void "test ordered interactions"() {
  ...

2 * service.notifyLibrarian(*_)
  result == true
}

Interactions are NOT ordered

void "test ordered interactions"() {
  ...

  then:"verify an inquiry was add to the book"
then:"verify that all librarians are notiﬁed "
2 * service.notifyLibrarian(*_)
  result == true
}

@Timeout()
@Timeout(10)
@Timeout(value=10, unit=TimeUnit.MILLISECONDS)

@AutoCleanup()
@AutoCleanup(‘dispose’)
@AutoCleanup(quite=true)

void "test the Use annotation"() {
  when:"call awesomeness"
  def result = new Dynamic().awesomeness('very')
  then:"check result"
  result == 'so very awesome'

}

class DynamicCategory {

  static String awesomeness(Dynamic dynamic, String foo) {
      “so $foo awesome”
  }

}

@Use(DynamicCategory)
  then:"check result"

}

use(DynamicCategory){
}
  then:"check result"

}

@ConfineMetaClassChanges([Class])

~/.spock/SpockConfig.groovy
import spock.util.mop.Use
import spock.lang.*
import grails.plugin.spock.IntegrationSpec

runner {
  optimizeRunOrder true
  ﬁlterStackTrace false

  include Unroll, Use

  exclude {
  baseClass IntegrationSpec
  }

}

>$ grails -Dspock.configuration=test/SpockConfig.groovy test-app

Rolling your own
Spock Extensions

import spock.lang.*

@SayOnFail
class MyFirstSpec extends Speciﬁcation {

  @SayOnFail(value="Danger! Danger!", voice='Zarvox')
  def "let's try this!"() {
  expect:
  Math.max(1, 2) == 3
  }
}

Step 1: Create Annotation
@Retention(RetentionPolicy.RUNTIME)
@Target([ElementType.TYPE, ElementType.METHOD])
@ExtensionAnnotation(SayOnFailExtension)

public @interface SayOnFail {
String value() default ''
String voice() default "Alex"
}


public @interface SayOnFail { Retention
}


public @interface SayOnFail { Target
}


public @interface SayOnFail { Extension
}


Default Values
public @interface SayOnFail {
}

Step 2: Create Extension
class SayOnFailExtension extends AbstractAnnotationDrivenExtension<SayOnFail>{

  @Override
  void visitSpecAnnotation(SayOnFail sayOnError, SpecInfo spec) {
  spec.features.each {FeatureInfo feature ->
  if(!feature.featureMethod.reﬂection.isAnnotationPresent(SayOnFail)) {
  visitFeatureAnnotation(sayOnError, feature)
  }
  }
  }

  @Override
  void visitFeatureAnnotation(SayOnFail sayOnError, FeatureInfo feature) {
  def interceptor = new SayOnFailInterceptor(sayOnError, feature)
  feature.getFeatureMethod().addInterceptor(interceptor)
  }
}


  @Override
  }
  }
  } Extend
  @Override
  }
}


  @Override
  }
  }
  } Override for spec
  @Override
  }
}


  @Override
  }
  } Add interceptor to all
  }
methods
  @Override
  }
}


  @Override
  }
  }
  } Override for feature
  @Override
  }
}


  @Override
  }
  }
  } Create Interceptor
  @Override
  }
}


  @Override
  }
  }
  } Add to Feature
  @Override
  }
}

Step 3: Create Intercepter
class SayOnFailInterceptor implements IMethodInterceptor{

  SayOnFail sayOnError
  FeatureInfo featureInfo

  SayOnFailInterceptor(SayOnFail sayOnError, FeatureInfo featureInfo) {
  this.sayOnError = sayOnError
  this.featureInfo = featureInfo
  }

  void intercept(IMethodInvocation invocation) {
  try {
invocation.proceed()
  } catch(Throwable t) {
  def methodName = featureInfo.getFeatureMethod().name
  def voiceName = sayOnError.voice()
  def sayText = sayOnError.value() ?: "Danger! Failure for: $methodName"
  try {
  "say -v $voiceName $sayText".execute()
  } catch (IOException ex) {}

  throw t
  }
  }
}



  }
Implement Interface
  try {
  try {

  throw t
  }
  }
}



  }
Override
  try {
  try {

  throw t
  }
  }
}



  }
run method
  try {
  try {

  throw t
  }
  }
}



  }
if test fails
  try {
  try {

  throw t
  }
  }
}



  }
do your thing
  try {
  try {

  throw t
  }
  }
}



  }
Throw Execption!
  try {
  try {

  throw t
  }
  }
}

@Document
class LibraryControllerSpec extends Speciﬁcation{

  @Author('Zan')
  @JiraIssue('MBL-42')
  void "successfully return book to library"() {
  given: "there is a checked out book and a active library"
  Book book = new Book(isdn: '1234567ABC').save(validate: false)
  and:"the controller has all dependancy"
  CatalogService catalogService = Mock()
  controller.catalogService = catalogService
  and: "submit library id and isdn"

  and: "get the JSON from the response"

  json.status == 'FILE'
  }
}

@Target([ElementType.TYPE])
@ExtensionAnnotation(DocumentExtension)

public @interface Document {}

class DocumentExtension extends AbstractAnnotationDrivenExtension<Document> {
  @Override
  void visitSpecAnnotation(Document document, SpecInfo specInfo) {
  specInfo.addListener(new DocumentListener(document))
  }

}

class DocumentListener extends AbstractRunListener{
  private Document document
  File baseDir = new File("src/docs/ref/Tests")
  File output

  DocumentListener(Document document) {
  this.document = document
  baseDir.mkdirs()
  }

  void beforeSpec(SpecInfo specInfo) {...}

  void beforeFeature(FeatureInfo featureInfo) {...}

  void beforeIteration(IterationInfo iterationInfo) {...}

  void afterIteration(IterationInfo iterationInfo) {...}

  void afterFeature(FeatureInfo featureInfo) {...}

  void error(ErrorInfo errorInfo) {...}

  void featureSkipped(FeatureInfo featureInfo) {...}

  void afterSpec(SpecInfo specInfo) {...}

  void specSkipped(SpecInfo specInfo) {...}

}

Core Spock Links
http://meetspock.appspot.com/

http://code.google.com/p/spock/wiki

https://github.com/spockframework/spock

Insightful Posts
http://kousenit.wordpress.com/2011/08/20/i-think-i-get-spock-mocks-now/

http://hamletdarcy.blogspot.com/2009/05/peek-inside-spock-framework.html

Extensions
https://github.com/zanthrash/spock-extensions

https://github.com/robfletcher/spock-extensions

GR8 Conf US: Spock Soup to Nuts

Recommended

Recommended

More Related Content

Recently uploaded

Recently uploaded (20)

Featured

Featured (20)

GR8 Conf US: Spock Soup to Nuts

Editor's Notes