Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use Strict method of org.mockito.runners.MockitoJUnitRunner class

Best Mockito code snippet using org.mockito.runners.MockitoJUnitRunner.Strict

Source:MockitoJUnitRunner.java

...15import org.mockito.MockitoSession;16import org.mockito.exceptions.misusing.UnnecessaryStubbingException;17import org.mockito.internal.runners.InternalRunner;18import org.mockito.internal.runners.RunnerFactory;19import org.mockito.internal.runners.StrictRunner;20import org.mockito.quality.MockitoHint;21import org.mockito.quality.Strictness;22import java.lang.reflect.InvocationTargetException;23/**24 * Mockito JUnit Runner keeps tests clean and improves debugging experience.25 * Make sure to try out {@link MockitoJUnitRunner.StrictStubs} which automatically26 * detects <strong>stubbing argument mismatches</strong> and is planned to be the default in Mockito v3.27 * Runner is compatible with JUnit 4.4 and higher and adds following behavior:28 * <ul>29 *   <li>30 *       (new since Mockito 2.1.0) Detects unused stubs in the test code.31 *       See {@link UnnecessaryStubbingException}.32 *       Similar to JUnit rules, the runner also reports stubbing argument mismatches as console warnings33 *       (see {@link MockitoHint}).34 *       To opt-out from this feature, use {@code}&#064;RunWith(MockitoJUnitRunner.Silent.class){@code}35 *   <li>36 *      Initializes mocks annotated with {@link Mock},37 *      so that explicit usage of {@link MockitoAnnotations#initMocks(Object)} is not necessary.38 *      Mocks are initialized before each test method.39 *   <li>40 *      Validates framework usage after each test method. See javadoc for {@link Mockito#validateMockitoUsage()}.41 *   <li>42 *      It is highly recommended to use {@link MockitoJUnitRunner.StrictStubs} variant of the runner.43 *      It drives cleaner tests and improves debugging experience.44 *      The only reason this feature is not turned on by default45 *      is because it would have been an incompatible change46 *      and Mockito strictly follows <a href="http://semver.org">semantic versioning</a>.47 * </ul>48 *49 * Runner is completely optional - there are other ways you can get &#064;Mock working, for example by writing a base class.50 * Explicitly validating framework usage is also optional because it is triggered automatically by Mockito every time you use the framework.51 * See javadoc for {@link Mockito#validateMockitoUsage()}.52 * <p>53 * Read more about &#064;Mock annotation in javadoc for {@link MockitoAnnotations}54 * <pre class="code"><code class="java">55 * <b>&#064;RunWith(MockitoJUnitRunner.StrictStubs.class)</b>56 * public class ExampleTest {57 *58 *     &#064;Mock59 *     private List list;60 *61 *     &#064;Test62 *     public void shouldDoSomething() {63 *         list.add(100);64 *     }65 * }66 * </code></pre>67 *68 * If you would like to take advantage of Mockito JUnit runner features69 * but you cannot use the runner because, for example, you use TestNG, there is a solution!70 * {@link MockitoSession} API is intended to offer cleaner tests and improved debuggability71 * to users that cannot use Mockito's built-in JUnit support (runner or the rule).72 */73public class MockitoJUnitRunner extends Runner implements Filterable {74    /**75     * This Mockito JUnit Runner implementation *ignores*76     * stubbing argument mismatches ({@link MockitoJUnitRunner.StrictStubs})77     * and *does not detect* unused stubbings.78     * The runner remains 'silent' even if incorrect stubbing is present.79     * It is an equivalent of {@link Strictness#LENIENT}.80     * This was the behavior of Mockito JUnit runner in versions 1.x.81     * Using this implementation of the runner is not recommended.82     * Engineers should care for removing unused stubbings because they are dead code,83     * they add unnecessary details, potentially making the test code harder to comprehend.84     * If you have good reasons to use the silent runner, let us know at the mailing list85     * or raise an issue in our issue tracker.86     * The purpose of silent implementation is to satisfy edge/unanticipated use cases,87     * and to offer users an opt-out.88     * Mockito framework is opinionated to drive clean tests but it is not dogmatic.89     * <p>90     * See also {@link UnnecessaryStubbingException}.91     * <p>92     * Usage:93     * <pre class="code"><code class="java">94     * <b>&#064;RunWith(MockitoJUnitRunner.Silent.class)</b>95     * public class ExampleTest {96     *   // ...97     * }98     * </code></pre>99     *100     * @since 2.1.0101     */102    public static class Silent extends MockitoJUnitRunner {103        public Silent(Class<?> klass) throws InvocationTargetException {104            super(new RunnerFactory().create(klass));105        }106    }107    /**108     * Detects unused stubs and reports them as failures. Default behavior in Mockito 2.x.109     * To improve productivity and quality of tests please consider newer API, the {@link StrictStubs}.110     * <p>111     * For more information on detecting unusued stubs, see {@link UnnecessaryStubbingException}.112     * For more information on stubbing argument mismatch warnings see {@link MockitoHint}.113     *114     * @since 2.1.0115     */116    public static class Strict extends MockitoJUnitRunner {117        public Strict(Class<?> klass) throws InvocationTargetException {118            super(new StrictRunner(new RunnerFactory().createStrict(klass), klass));119        }120    }121    /**122     * Improves debugging tests, helps keeping the tests clean.123     * Highly recommended to improve productivity and quality of tests.124     * Planned default behavior for Mockito v3.125     * Adds behavior equivalent to {@link Strictness#STRICT_STUBS}.126     * <p>127     * Usage:128     * <pre class="code"><code class="java">129     * <b>&#064;RunWith(MockitoJUnitRunner.StrictStubs.class)</b>130     * public class ExampleTest {131     *   // ...132     * }133     * </code></pre>134     *135     * @since 2.5.1136     */137    public static class StrictStubs extends MockitoJUnitRunner {138        public StrictStubs(Class<?> klass) throws InvocationTargetException {139            super(new StrictRunner(new RunnerFactory().createStrictStubs(klass), klass));140        }141    }142    private final InternalRunner runner;143    public MockitoJUnitRunner(Class<?> klass) throws InvocationTargetException {144        //by default, StrictRunner is used. We can change that potentially based on feedback from users145        this(new StrictRunner(new RunnerFactory().createStrict(klass), klass));146    }147    MockitoJUnitRunner(InternalRunner runner) throws InvocationTargetException {148        this.runner = runner;149    }150    @Override151    public void run(final RunNotifier notifier) {152        runner.run(notifier);153    }154    @Override155    public Description getDescription() {156        return runner.getDescription();157    }158    public void filter(Filter filter) throws NoTestsRemainException {159        //filter is required because without it UnrootedTests show up in Eclipse...

Strict

Using AI Code Generation

1import org.junit.Test;2import org.junit.runner.RunWith;3import org.mockito.Mock;4import org.mockito.runners.MockitoJUnitRunner;5import static org.junit.Assert.*;6import static org.mockito.Mockito.*;7@RunWith(MockitoJUnitRunner.StrictStubs.class)8public class MockitoJUnitRunnerStrictStubsExample {9    private List mockedList;10    public void test() {11        mockedList.add("one");12        verify(mockedList).add("one");13    }14}15Following stubbings are unnecessary (click to navigate to relevant line of code):161. -> at com.journaldev.mockito.MockitoJUnitRunnerStrictStubsExample.test(MockitoJUnitRunnerStrictStubsExample.java:19)17import org.junit.Test;18import org.junit.runner.RunWith;19import org.mockito.Mock;20import org.mockito.runners.MockitoJUnitRunner;21import static org.junit.Assert.*;22import static org.mockito.Mockito.*;23@RunWith(MockitoJUnitRunner.StrictStubs.class)24public class MockitoJUnitRunnerStrictStubsExample {25    private List mockedList;26    public void test() {27        mockedList.add("one");28        verify(mockedList).add("one");29    }30}31Following stubbings are unnecessary (click to navigate to relevant line of code):321. -> at com.journaldev.mockito.MockitoJUnitRunnerStrictStubsExample.test(MockitoJUnitRunnerStrictStubsExample.java:19)33import org.junit.Test;34import org.junit.runner.RunWith;35import org.mockito.Mock;36import org.mockito.runners.MockitoJUnitRunner;37import static org.junit.Assert.*;38import static org.mockito.Mockito.*;39@RunWith(MockitoJUnitRunner.StrictStubs.class)

Strict

Using AI Code Generation

1public class MockitoJUnitRunnerTest {2    private List mockedList;3    public void shorthand() {4        mockedList.add("one");5        verify(mockedList).add("one");6    }7}8public class MockitoJUnitRunnerTest {9    private List mockedList;10    public void shorthand() {11        mockedList.add("one");12        verify(mockedList).add("one");13    }14}15public class MockitoJUnitRunnerTest {16    private List mockedList;17    public void shorthand() {18        mockedList.add("one");19        verify(mockedList).add("one");20    }21}22public class MockitoJUnitRunnerTest {23    private List mockedList;24    public void shorthand() {25        mockedList.add("one");26        verify(mockedList).add("one");27    }28}29public class MockitoJUnitRunnerTest {30    private List mockedList;31    public void shorthand() {32        mockedList.add("one");33        verify(mockedList).add("one");34    }35}36public class MockitoJUnitRunnerTest {37    private List mockedList;38    public void shorthand() {39        mockedList.add("one");40        verify(mockedList).add("one");41    }42}43public class MockitoJUnitRunnerTest {44    private List mockedList;45    public void shorthand() {

Strict

Using AI Code Generation

1@RunWith(MockitoJUnitRunner.StrictStubs.class)2public class MyTest {3    private List<String> mockList;4    public void test() {5        mockList.add("one");6        verify(mockList).add("one");7    }8}9@RunWith(MockitoJUnitRunner.class)10public class MyTest {11    private List<String> mockList;12    public void test() {13        mockList.add("one");14        verify(mockList).add("one");15    }16}17Missing method call for verify(mock) here:18-> at com.journaldev.mockito.MockitoStrictStubsTest.test(MockitoStrictStubsTest.java:19)19Missing method call for verify(mock) here:20-> at com.journaldev.mockito.MockitoStrictStubsTest.test(MockitoStrictStubsTest.java:19)21at com.journaldev.mockito.MockitoStrictStubsTest.test(MockitoStrictStubsTest.java:19)22at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)23at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)24at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)25at java.lang.reflect.Method.invoke(Method.java:498)26at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)27at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)28at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)29at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)30at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)31at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)32at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)33at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)34at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)35at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)36at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)

Strict

Using AI Code Generation

1@RunWith(MockitoJUnitRunner.StrictStubs.class)2public class StrictMockitoJUnitRunnerTest {3    public interface Foo {4        void bar();5    }6    private Foo foo;7    public void test() {8        foo.bar();9    }10}11-> at com.baeldung.mockito.StrictMockitoJUnitRunnerTest.test(StrictMockitoJUnitRunnerTest.java:27)12-> at com.baeldung.mockito.StrictMockitoJUnitRunnerTest.test(StrictMockitoJUnitRunnerTest.java:27)13    when(mock.isOk()).thenReturn(true);14    doThrow(new RuntimeException()).when(mock).someVoidMethod();15    doAnswer(AdditionalAnswers.returnsFirstArg()).when(mock).someMethod(any());16    doNothing().when(mock).someVoidMethod();17    when(mock.isOk()).thenReturn(true);18    doThrow(new RuntimeException()).when(mock).someVoidMethod();19    doAnswer(AdditionalAnswers.returnsFirstArg()).when(mock).someMethod(any());20    doNothing().when(mock).someVoidMethod();21    MockitoHint.enable(Strictness.LENIENT);22at com.baeldung.mockito.StrictMockitoJUnitRunnerTest.test(StrictMockitoJUnitRunnerTest.java:27)23-> at com.baeldung.mockito.StrictMockitoJUnitRunnerTest.test(StrictMockitoJUnitRunnerTest.java:27)24    when(mock.isOk()).thenReturn(true);25    doThrow(new RuntimeException()).when(mock).someVoidMethod();26    doAnswer(AdditionalAnswers.returnsFirstArg()).when(mock).someMethod(any());27    doNothing().when(mock).someVoidMethod();

Strict

Using AI Code Generation

1@RunWith(MockitoJUnitRunner.Strict.class)2public class MockitoStrictTest {3    private List<String> mockedList;4    public void testMock() {5        mockedList.add("one");6        mockedList.clear();7    }8}91. -> at MockitoStrictTest.testMock(MockitoStrictTest.java:15)10list.clear();11-> at MockitoStrictTest.testMock(MockitoStrictTest.java:16)12	at MockitoStrictTest.testMock(MockitoStrictTest.java:16)13@RunWith(MockitoJUnitRunner.Silent.class)14public class MockitoSilentTest {15    private List<String> mockedList;16    public void testMock() {17        mockedList.add("one");18        mockedList.clear();19    }20}211. -> at MockitoSilentTest.testMock(MockitoSilentTest.java:15)22list.clear();23-> at MockitoSilentTest.testMock(MockitoSilentTest.java:16)24	at MockitoSilentTest.testMock(MockitoSilentTest.java:16)

Strict

Using AI Code Generation

1@RunWith(MockitoJUnitRunner.StrictStubs.class)2public class StrictStubbingTest {3   private List mockedList;4   public void testStubbing() {5      mockedList.add("one");6      mockedList.clear();

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.