Class Specification

Method Details

• thrown

  public <T extends Throwable> T thrown()

  Specifies that the preceding when block should throw an exception. May only occur as the initializer expression of a typed variable declaration in a then block; the expected exception type is inferred from the variable type.

  This form of exception condition is typically used if the thrown exception instance is used in subsequent conditions.

  Example:

   when:
   "".charAt(0)
  
   then:
   IndexOutOfBoundsException e = thrown()
   e.message.contains(...)
   

  Returns:

  the thrown exception instance

• thrown

  public <T extends Throwable> T thrown(Class<T> type)

  Specifies that the preceding when block should throw an exception of the given type. May only occur in a then block.

  This form of exception condition is typically used if the thrown exception instance is not used in subsequent conditions.

  Example:

   when:
   "".charAt(0)
  
   then:
   thrown(IndexOutOfBoundsException)

  Type Parameters:

  T - the expected exception type

  Parameters:

  type - the expected exception type

  Returns:

  the thrown exception instance

• notThrown

  public void notThrown(Class<? extends Throwable> type)

  Specifies that no exception of the given type should be thrown, failing with a UnallowedExceptionThrownError otherwise.

  Parameters:

  type - the exception type that should not be thrown

• noExceptionThrown

  public void noExceptionThrown()

  Specifies that no exception should be thrown, failing with a UnallowedExceptionThrownError otherwise.

• old

  public <T> T old(T expression)

  Used in a then-block to access an expression's value at the time just before the previous where-block was entered.

  Type Parameters:

  T - the expression's type

  Parameters:

  expression - an arbitrary expression, except that it may not reference variables defined in the then-block

  Returns:

  the expression's value at the time the previous where-block was entered

• with

  @Beta public void with(Object target, groovy.lang.Closure<?> closure)

  Sets the specified object as the implicit target of the top-level conditions and/or interactions contained in the specified code block, thereby avoiding the need to repeat the same expression multiple times. Implicit conditions are supported. (In other words, the assert keyword may be omitted.) If the target is null, a SpockAssertionError is thrown.

  A with block can be used anywhere in a spec, including nested positions and helper methods.

  Condition example:

   def fred = new Person(name: "Fred", age: 42)
   def spaceship = new Spaceship(pilot: fred)
  
   expect:
   with(spaceship.pilot) {
     name == "Fred" // shorthand for: spaceship.pilot.name == "Fred"
     age == 42
   }
   

  Interaction example:

   def service = Mock(Service) // has start(), stop(), and doWork() methods
   def app = new Application(service) // controls the lifecycle of the service
  
   when:
   app.run()
  
   then:
   with(service) {
     1 * start() // shorthand for: 1 * service.start()
     1 * doWork()
     1 * stop()
   }
   

  Parameters:

  target - an implicit target for conditions and/or interactions

  closure - a code block containing top-level conditions and/or interactions

• with

  @Beta public void with(Object target, Class<?> type, groovy.lang.Closure closure)

  Same as with(Object, groovy.lang.Closure), except that it also states that the specified target has the specified type, throwing a SpockAssertionError otherwise. As a side effect, this may give better code completion in IDEs.

  Example:

   def fred = new Employee(name: "Fred", age: 42, employer: "MarsTravelUnited")
   def spaceship = new Spaceship(pilot: fred)
  
   expect:
   with(spaceship.pilot, Employee) {
     name == "Fred" // shorthand for: spaceship.pilot.name == "Fred"
     age == 42
     employer == "MarsTravelUnited"
   }
   

  Parameters:

  target - an implicit target for conditions and/or interactions

  type - the expected type of the target

  closure - a code block containing top-level conditions and/or interactions