Packages

final class JMockCycle extends AnyRef

Class that wraps and manages the lifecycle of a single org.jmock.Mockery context object, provides some basic syntax sugar for using JMock in Scala.

Using the JMock API directly, you first need a Mockery context object:

val context = new Mockery

JMockCycle uses jMock's ClassImposterizer to support mocking of classes, so the following line would also be needed if you wanted that functionality as well:

context.setImposteriser(ClassImposteriser.INSTANCE)

When using this class, you would instead create an instance of this class (which will create and wrap a Mockery object) and import its members, like this:

val cycle = new JMockCycle
import cycle._

Using the JMock API directly, you would create a mock object like this:

val mockCollaborator = context.mock(classOf[Collaborator])

Having imported the members of an instance of this class, you can shorten that to:

val mockCollaborator = mock[Collaborator]

After creating mocks, you set expectations on them, using syntax like this:

context.checking(
  new Expectations() {
    oneOf (mockCollaborator).documentAdded("Document")
    exactly(3).of (mockCollaborator).documentChanged("Document")
   }
 )

Having imported the members of an instance of this class, you can shorten this step to:

expecting { e => import e._
  oneOf (mockCollaborator).documentAdded("Document")
  exactly(3).of (mockCollaborator).documentChanged("Document")
}

The expecting method will create a new Expectations object, pass it into the function you provide, which sets the expectations. After the function returns, the expecting method will pass the Expectations object to the checking method of its internal Mockery context.

The expecting method passes an instance of class org.scalatest.mock.JMockExpectations to the function you pass into expectations. JMockExpectations extends org.jmock.Expectations and adds several overloaded withArg methods. These withArg methods simply invoke corresponding with methods on themselves. Because with is a keyword in Scala, to invoke these directly you must surround them in back ticks, like this:

oneOf (mockCollaborator).documentAdded(`with`("Document"))

By importing the members of the passed JMockExpectations object, you can instead call withArg with no back ticks needed:

oneOf (mockCollaborator).documentAdded(withArg("Document"))

Once you've set expectations on the mock objects, when using the JMock API directly, you use the mock, then invoke assertIsSatisfied on the Mockery context to make sure the mock was used in accordance with the expectations you set on it. Here's how that looks:

classUnderTest.addDocument("Document", new Array[Byte](0))
classUnderTest.addDocument("Document", new Array[Byte](0))
classUnderTest.addDocument("Document", new Array[Byte](0))
classUnderTest.addDocument("Document", new Array[Byte](0))
context.assertIsSatisfied()

This class enables you to use the following, more declarative syntax instead:

whenExecuting {
  classUnderTest.addDocument("Document", new Array[Byte](0))
  classUnderTest.addDocument("Document", new Array[Byte](0))
  classUnderTest.addDocument("Document", new Array[Byte](0))
  classUnderTest.addDocument("Document", new Array[Byte](0))
}

The whenExecuting method will execute the passed function, then invoke assertIsSatisfied on its internal Mockery context object.

To summarize, here's what a typical test using JMockCycle looks like:

val cycle = new JMockCycle
import cycle._

val mockCollaborator = mock[Collaborator]
expecting { e => import e._ oneOf (mockCollaborator).documentAdded("Document") exactly(3).of (mockCollaborator).documentChanged("Document") }
whenExecuting { classUnderTest.addDocument("Document", new Array[Byte](0)) classUnderTest.addDocument("Document", new Array[Byte](0)) classUnderTest.addDocument("Document", new Array[Byte](0)) classUnderTest.addDocument("Document", new Array[Byte](0)) }

ScalaTest also provides a JMockCycleFixture trait, which will pass a new JMockCycle into each test that needs one.

Source
JMockCycle.scala
Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. JMockCycle
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Instance Constructors

  1. new JMockCycle()

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  6. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  7. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  8. def expecting(fun: (JMockExpectations) => Unit): Unit

    Sets expectations on mock objects.

    Sets expectations on mock objects.

    After creating mocks, you set expectations on them, using syntax like this:

    context.checking(
      new Expectations() {
        oneOf (mockCollaborator).documentAdded("Document")
        exactly(3).of (mockCollaborator).documentChanged("Document")
       }
     )
    

    Having imported the members of an instance of this class, you can shorten this step to:

    expecting { e => import e._
      oneOf (mockCollaborator).documentAdded("Document")
      exactly(3).of (mockCollaborator).documentChanged("Document")
    }
    

    The expecting method will create a new Expectations object, pass it into the function you provide, which sets the expectations. After the function returns, the expecting method will pass the Expectations object to the checking method of its internal Mockery context.

    This method passes an instance of class org.scalatest.mock.JMockExpectations to the passed function. JMockExpectations extends org.jmock.Expectations and adds several overloaded withArg methods. These withArg methods simply invoke corresponding with methods on themselves. Because with is a keyword in Scala, to invoke these directly you must surround them in back ticks, like this:

    oneOf (mockCollaborator).documentAdded(`with`("Document"))
    

    By importing the members of the passed JMockExpectations object, you can instead call withArg with no back ticks needed:

    oneOf (mockCollaborator).documentAdded(withArg("Document"))
    

    fun

    a function that sets expectations on the passed JMockExpectations object

  9. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  10. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  11. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  12. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  13. def mock[T <: AnyRef](implicit classTag: ClassTag[T]): T

    Invokes the mock method on this JMockCycle's internal Mockery context object, passing in a class instance for the specified type parameter.

    Invokes the mock method on this JMockCycle's internal Mockery context object, passing in a class instance for the specified type parameter.

    Using the JMock API directly, you create a mock with:

    val mockCollaborator = context.mock(classOf[Collaborator])
    

    Having imported the members of an instance of this class, you can shorten that to:

    val mockCollaborator = mock[Collaborator]
    

  14. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  15. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  16. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  17. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  18. def toString(): String
    Definition Classes
    AnyRef → Any
  19. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  20. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  21. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  22. def whenExecuting(fun: => Unit): Unit

    Executes code using mocks with expectations set.

    Executes code using mocks with expectations set.

    Once you've set expectations on the mock objects, when using the JMock API directly, you use the mock, then invoke assertIsSatisfied on the Mockery context to make sure the mock was used in accordance with the expectations you set on it. Here's how that looks:

    classUnderTest.addDocument("Document", new Array[Byte](0))
    classUnderTest.addDocument("Document", new Array[Byte](0))
    classUnderTest.addDocument("Document", new Array[Byte](0))
    classUnderTest.addDocument("Document", new Array[Byte](0))
    context.assertIsSatisfied()
    

    This class enables you to use the following, more declarative syntax instead:

    whenExecuting {
      classUnderTest.addDocument("Document", new Array[Byte](0))
      classUnderTest.addDocument("Document", new Array[Byte](0))
      classUnderTest.addDocument("Document", new Array[Byte](0))
      classUnderTest.addDocument("Document", new Array[Byte](0))
    }
    

    The whenExecuting method will execute the passed function, then invoke assertIsSatisfied on its internal Mockery context object.

    fun

    the code to execute under previously set expectations

    Exceptions thrown

    org.mock.ExpectationError if an expectation is not met

Inherited from AnyRef

Inherited from Any

Ungrouped