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
- Alphabetic
- By Inheritance
- JMockCycle
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Instance Constructors
- new JMockCycle()
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
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 newExpectations
object, pass it into the function you provide, which sets the expectations. After the function returns, theexpecting
method will pass theExpectations
object to thechecking
method of its internalMockery
context.This method passes an instance of class
org.scalatest.mock.JMockExpectations
to the passed function.JMockExpectations
extendsorg.jmock.Expectations
and adds several overloadedwithArg
methods. ThesewithArg
methods simply invoke correspondingwith
methods on themselves. Becausewith
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 callwithArg
with no back ticks needed:oneOf (mockCollaborator).documentAdded(withArg("Document"))
- fun
a function that sets expectations on the passed
JMockExpectations
object
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
mock[T <: AnyRef](implicit classTag: ClassTag[T]): T
Invokes the
mock
method on thisJMockCycle
's internalMockery
context object, passing in a class instance for the specified type parameter.Invokes the
mock
method on thisJMockCycle
's internalMockery
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]
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
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 theMockery
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 invokeassertIsSatisfied
on its internalMockery
context object.- fun
the code to execute under previously set expectations
- Exceptions thrown
org.mock.ExpectationError
if an expectation is not met