How to use method of org.jmock.integration.junit4.JUnitRuleMockery class

1package org.jmock.integration.junit4;
2
3import org.jmock.auto.internal.Mockomatic;
4import org.jmock.internal.AllDeclaredFields;
5import org.junit.rules.MethodRule;
6import org.junit.runners.model.FrameworkMethod;
7import org.junit.runners.model.Statement;
8
9import java.lang.reflect.Field;
10import java.util.List;
11
12import static org.junit.Assert.fail;
13
14/**
15 * A <code>JUnitRuleMockery</code> is a JUnit Rule that manages JMock expectations
16 * and allowances, and asserts that expectations have been met after each test
17 * has finished. To use it, add a field to the test class (note that you don't 
18 * have to specify <code>@RunWith(JMock.class)</code> any more). For example,  
19 * 
20 * <pre>public class ATestWithSatisfiedExpectations {
21 *  @Rule public final JUnitRuleMockery context = new JUnitRuleMockery();
22 *  private final Runnable runnable = context.mock(Runnable.class);
23 *     
24 *  @Test
25 *  public void doesSatisfyExpectations() {
26 *    context.checking(new Expectations() {{
27 *      oneOf (runnable).run();
28 *    }});
29 *          
30 *    runnable.run();
31 *  }
32 *}</pre>
33 *
34 * Note that the Rule field must be declared public and as a <code>JUnitRuleMockery</code>
35 * (not a <code>Mockery</code>) for JUnit to recognise it, as it's checked statically.
36 * 
37 * @author smgf
38 */
39
40public class JUnitRuleMockery extends JUnit4Mockery implements MethodRule {
41    private final Mockomatic mockomatic = new Mockomatic(this);
42
43    @Override
44    public Statement apply(final Statement base, FrameworkMethod method, final Object target) {
45        return new Statement() {
46            @Override
47            public void evaluate() throws Throwable {
48                prepare(target);
49                base.evaluate();
50                assertIsSatisfied();
51            }
52
53            private void prepare(final Object target) {
54                List<Field> allFields = AllDeclaredFields.in(target.getClass());
55                assertOnlyOneJMockContextIn(allFields);
56                fillInAutoMocks(target, allFields);
57            }
58
59            private void assertOnlyOneJMockContextIn(List<Field> allFields) {
60                Field contextField = null;
61                for (Field field : allFields) {
62                    if (JUnitRuleMockery.class.isAssignableFrom(field.getType())) {
63                        if (null != contextField) {
64                            fail("Test class should only have one JUnitRuleMockery field, found "
65                                  + contextField.getName() + " and " + field.getName());
66                        }
67                        contextField = field;
68                    }
69                }
70            }
71
72            private void fillInAutoMocks(final Object target, List<Field> allFields) {
73                mockomatic.fillIn(target, allFields);
74            }
75        };
76    }
77}
78

Source: JUnitRuleMockery.java

package org.jmock.integration.junit4;

import org.jmock.auto.internal.Mockomatic;
import org.jmock.internal.AllDeclaredFields;
import org.junit.rules.MethodRule;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.Statement;

import java.lang.reflect.Field;
import java.util.List;

import static org.junit.Assert.fail;

/**
 * A <code>JUnitRuleMockery</code> is a JUnit Rule that manages JMock expectations
 * and allowances, and asserts that expectations have been met after each test
 * has finished. To use it, add a field to the test class (note that you don't 
 * have to specify <code>@RunWith(JMock.class)</code> any more). For example,  
 * 
 * <pre>public class ATestWithSatisfiedExpectations {
 *  @Rule public final JUnitRuleMockery context = new JUnitRuleMockery();
 *  private final Runnable runnable = context.mock(Runnable.class);
 *     
 *  @Test
 *  public void doesSatisfyExpectations() {
 *    context.checking(new Expectations() {{
 *      oneOf (runnable).run();
 *    }});
 *          
 *    runnable.run();
 *  }
 *}</pre>
 *
 * Note that the Rule field must be declared public and as a <code>JUnitRuleMockery</code>
 * (not a <code>Mockery</code>) for JUnit to recognise it, as it's checked statically.
 * 
 * @author smgf
 */

public class JUnitRuleMockery extends JUnit4Mockery implements MethodRule {
    private final Mockomatic mockomatic = new Mockomatic(this);

    @Override
    public Statement apply(final Statement base, FrameworkMethod method, final Object target) {
        return new Statement() {
            @Override
            public void evaluate() throws Throwable {
                prepare(target);
                base.evaluate();
                assertIsSatisfied();
            }

            private void prepare(final Object target) {
                List<Field> allFields = AllDeclaredFields.in(target.getClass());
                assertOnlyOneJMockContextIn(allFields);
                fillInAutoMocks(target, allFields);
            }

            private void assertOnlyOneJMockContextIn(List<Field> allFields) {
                Field contextField = null;
                for (Field field : allFields) {
                    if (JUnitRuleMockery.class.isAssignableFrom(field.getType())) {
                        if (null != contextField) {
                            fail("Test class should only have one JUnitRuleMockery field, found "
                                  + contextField.getName() + " and " + field.getName());
                        }
                        contextField = field;
                    }
                }
            }

            private void fillInAutoMocks(final Object target, List<Field> allFields) {
                mockomatic.fillIn(target, allFields);
            }
        };
    }
}