JMockCycle
Related Doc:
package jmock
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"))
a function that sets expectations on the passed JMockExpectations
object
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]
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.
the code to execute under previously set expectations
org.mock.ExpectationError if an expectation is not met
Class that wraps and manages the lifecycle of a single
org.jmock.Mockerycontext object, provides some basic syntax sugar for using JMock in Scala.Using the JMock API directly, you first need a
Mockerycontext object:JMockCycleuses jMock'sClassImposterizerto support mocking of classes, so the following line would also be needed if you wanted that functionality as well:When using this class, you would instead create an instance of this class (which will create and wrap a
Mockeryobject) and import its members, like this:Using the JMock API directly, you would create a mock object like this:
Having imported the members of an instance of this class, you can shorten that to:
After creating mocks, you set expectations on them, using syntax like this:
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
expectingmethod will create a newExpectationsobject, pass it into the function you provide, which sets the expectations. After the function returns, theexpectingmethod will pass theExpectationsobject to thecheckingmethod of its internalMockerycontext.The
expectingmethod passes an instance of classorg.scalatest.mock.JMockExpectationsto the function you pass intoexpectations.JMockExpectationsextendsorg.jmock.Expectationsand adds several overloadedwithArgmethods. ThesewithArgmethods simply invoke correspondingwithmethods on themselves. Becausewithis a keyword in Scala, to invoke these directly you must surround them in back ticks, like this:By importing the members of the passed
JMockExpectationsobject, you can instead callwithArgwith 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
assertIsSatisfiedon theMockerycontext to make sure the mock was used in accordance with the expectations you set on it. Here's how that looks: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
whenExecutingmethod will execute the passed function, then invokeassertIsSatisfiedon its internalMockerycontext object.To summarize, here's what a typical test using
JMockCyclelooks like:ScalaTest also provides a
JMockCycleFixturetrait, which will pass a newJMockCycleinto each test that needs one.