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.
Trait that will pass a new JMockCycle
into any test that needs one.
Trait that will pass a new JMockCycle
into any test that needs one.
This trait, which must be mixed into a fixture.Suite
, defines the
Fixture
type to be JMockCycle
and defines a
withFixture
method that instantiates a new JMockCycle
and passes it to the test function.
Subclass of org.jmock.Expectations
that provides withArg
alternatives to the with
methods defined in its superclass.
Subclass of org.jmock.Expectations
that provides withArg
alternatives to the with
methods defined in its superclass.
JMockCycle
's expecting
method of passes an instance of this class
to the function passed into expectations
. Because JMockExpectations
extends org.jmock.Expectations
, all of the Expectations
methods are
available to be invoked on instances of this class, in addition to
several overloaded withArg
methods defined in this class. These withArg
methods simply
invoke corresponding with
methods on this
. 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 JMockExpectations
object passed to
a JMockCycle
's executing
method, you can
instead call withArg
with no back ticks needed:
oneOf (mockCollaborator).documentAdded(withArg("Document"))
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:JMockCycle
uses jMock'sClassImposterizer
to 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
Mockery
object) 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:
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.The
expecting
method passes an instance of classorg.scalatest.mock.JMockExpectations
to the function you pass intoexpectations
.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:By importing the members of the passed
JMockExpectations
object, you can instead callwithArg
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 theMockery
context 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:
The
whenExecuting
method will execute the passed function, then invokeassertIsSatisfied
on its internalMockery
context object.To summarize, here's what a typical test using
JMockCycle
looks like:ScalaTest also provides a
JMockCycleFixture
trait, which will pass a newJMockCycle
into each test that needs one.