org.scalatest.mock

# JMockCycle

#### 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(<span class="stReserved">with</span>("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.

Attributes
  final

Linear Supertypes
AnyRef, Any
Ordering

1. Alphabetic
2. By inheritance

Inherited

1. Hide All
2. Show all

1. JMockCycle
2. AnyRef
3. Any

Visibility

1. Public
2. All

### Instance Constructors

1. #### new JMockCycle ()

### Value Members

1. #### def != (arg0: AnyRef): Boolean

   Attributes
     final
   Definition Classes
     AnyRef

2. #### def != (arg0: Any): Boolean

   Attributes
     final
   Definition Classes
     Any

3. #### def ## (): Int

   Attributes
     final
   Definition Classes
     AnyRef → Any

4. #### def == (arg0: AnyRef): Boolean

   Attributes
     final
   Definition Classes
     AnyRef

5. #### def == (arg0: Any): Boolean

   Attributes
     final
   Definition Classes
     Any

6. #### def asInstanceOf [T0] : T0

   Attributes
     final
   Definition Classes
     Any

7. #### def clone (): AnyRef

   Attributes
     protected[lang]
   Definition Classes
     AnyRef
   Annotations
     @throws()

8. #### def eq (arg0: AnyRef): Boolean

   Attributes
     final
   Definition Classes
     AnyRef

9. #### def equals (arg0: Any): Boolean

   Definition Classes
     AnyRef → Any

10. #### 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(<span class="stReserved">with</span>("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

11. #### def finalize (): Unit

    Attributes
      protected[lang]
    Definition Classes
      AnyRef
    Annotations
      @throws()

12. #### def getClass (): java.lang.Class[_]

    Attributes
      final
    Definition Classes
      AnyRef

13. #### def hashCode (): Int

    Definition Classes
      AnyRef → Any

14. #### def isInstanceOf [T0] : Boolean

    Attributes
      final
    Definition Classes
      Any

15. #### def mock [T <: AnyRef] (implicit manifest: Manifest[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]

16. #### def ne (arg0: AnyRef): Boolean

    Attributes
      final
    Definition Classes
      AnyRef

17. #### def notify (): Unit

    Attributes
      final
    Definition Classes
      AnyRef

18. #### def notifyAll (): Unit

    Attributes
      final
    Definition Classes
      AnyRef

19. #### def synchronized [T0] (arg0: ⇒ T0): T0

    Attributes
      final
    Definition Classes
      AnyRef

20. #### def toString (): String

    Definition Classes
      AnyRef → Any

21. #### def wait (): Unit

    Attributes
      final
    Definition Classes
      AnyRef
    Annotations
      @throws()

22. #### def wait (arg0: Long, arg1: Int): Unit

    Attributes
      final
    Definition Classes
      AnyRef
    Annotations
      @throws()

23. #### def wait (arg0: Long): Unit

    Attributes
      final
    Definition Classes
      AnyRef
    Annotations
      @throws()

24. #### 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

### Inherited from AnyRef

### Inherited from Any