Home | History | Annotate | Download | only in stubbing 
      1 /*
      2  * Copyright (c) 2017 Mockito contributors
      3  * This program is made available under the terms of the MIT License.
      4  */
      5 package org.mockitousage.stubbing;
      6 
      7 import org.junit.After;
      8 import org.junit.Test;
      9 import org.junit.runner.JUnitCore;
     10 import org.junit.runner.Result;
     11 import org.mockito.Mock;
     12 import org.mockito.Mockito;
     13 import org.mockito.MockitoSession;
     14 import org.mockito.StateMaster;
     15 import org.mockito.exceptions.misusing.PotentialStubbingProblem;
     16 import org.mockito.exceptions.misusing.UnfinishedMockingSessionException;
     17 import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
     18 import org.mockito.quality.Strictness;
     19 import org.mockitousage.IMethods;
     20 
     21 import java.util.Map;
     22 import java.util.concurrent.ConcurrentHashMap;
     23 
     24 import static org.mockito.BDDMockito.given;
     25 import static org.mockitoutil.ConcurrentTesting.concurrently;
     26 import static org.mockitoutil.JUnitResultAssert.assertThat;
     27 
     28 public class StrictStubbingEndToEndTest {
     29 
     30     JUnitCore junit = new JUnitCore();
     31 
     32     @After public void after() {
     33         new StateMaster().clearMockitoListeners();
     34     }
     35 
     36     @Test public void finish_mocking_exception_does_not_hide_the_exception_from_test() {
     37         Result result = junit.run(UnnecessaryStubbing.class);
     38         assertThat(result)
     39                 //both exceptions are reported to JUnit:
     40                 .fails("unnecessary_stubbing", IllegalStateException.class)
     41                 .fails("unnecessary_stubbing", UnnecessaryStubbingException.class);
     42     }
     43 
     44     @Test public void does_not_report_unused_stubbing_if_mismatch_reported() {
     45         Result result = junit.run(ReportMismatchButNotUnusedStubbing.class);
     46         assertThat(result).fails(1, PotentialStubbingProblem.class);
     47     }
     48 
     49     @Test public void strict_stubbing_does_not_leak_to_other_tests() {
     50         Result result = junit.run(LenientStrictness1.class, StrictStubsPassing.class, LenientStrictness2.class);
     51         //all tests pass, lenient test cases contain incorrect stubbing
     52         assertThat(result).succeeds(5);
     53     }
     54 
     55     @Test public void detects_unfinished_session() {
     56         Result result = junit.run(UnfinishedMocking.class);
     57         assertThat(result)
     58             .fails(UnfinishedMockingSessionException.class, "\n" +
     59                 "Unfinished mocking session detected.\n" +
     60                 "Previous MockitoSession was not concluded with 'finishMocking()'.\n" +
     61                 "For examples of correct usage see javadoc for MockitoSession class.");
     62     }
     63 
     64     @Test public void concurrent_sessions_in_different_threads() throws Exception {
     65         final Map<Class, Result> results = new ConcurrentHashMap<Class, Result>();
     66         concurrently(new Runnable() {
     67                          public void run() {
     68                              results.put(StrictStubsPassing.class, junit.run(StrictStubsPassing.class));
     69                          }
     70                      }, new Runnable() {
     71                          public void run() {
     72                              results.put(ReportMismatchButNotUnusedStubbing.class, junit.run(ReportMismatchButNotUnusedStubbing.class));
     73                          }
     74                      }
     75         );
     76 
     77         assertThat(results.get(StrictStubsPassing.class)).succeeds(1);
     78         assertThat(results.get(ReportMismatchButNotUnusedStubbing.class)).fails(1);
     79     }
     80 
     81     public static class UnnecessaryStubbing {
     82         @Mock IMethods mock;
     83         MockitoSession mockito = Mockito.mockitoSession().initMocks(this).strictness(Strictness.STRICT_STUBS).startMocking();
     84 
     85         @After public void after() {
     86             mockito.finishMocking();
     87         }
     88 
     89         @Test public void unnecessary_stubbing() {
     90             given(mock.simpleMethod("1")).willReturn("one");
     91             throw new IllegalStateException();
     92         }
     93     }
     94 
     95     public static class ReportMismatchButNotUnusedStubbing {
     96         @Mock IMethods mock;
     97         MockitoSession mockito = Mockito.mockitoSession().initMocks(this).strictness(Strictness.STRICT_STUBS).startMocking();
     98 
     99         @After public void after() {
    100             mockito.finishMocking();
    101         }
    102 
    103         @Test public void mismatch() {
    104             given(mock.simpleMethod(1)).willReturn("");
    105             mock.simpleMethod(2);
    106         }
    107     }
    108 
    109     public static class StrictStubsPassing {
    110         @Mock IMethods mock;
    111         MockitoSession mockito = Mockito.mockitoSession().initMocks(this).strictness(Strictness.STRICT_STUBS).startMocking();
    112 
    113         @After public void after() {
    114             mockito.finishMocking();
    115         }
    116 
    117         @Test public void used() {
    118             given(mock.simpleMethod(1)).willReturn("");
    119             mock.simpleMethod(1);
    120         }
    121     }
    122 
    123     public static class LenientStrictness1 {
    124         @Mock IMethods mock = Mockito.mock(IMethods.class);
    125 
    126         @Test public void unused() {
    127             given(mock.simpleMethod(1)).willReturn("");
    128         }
    129 
    130         @Test public void mismatch() {
    131             given(mock.simpleMethod(2)).willReturn("");
    132             mock.simpleMethod(3);
    133         }
    134     }
    135 
    136     public static class LenientStrictness2 {
    137         @Mock IMethods mock = Mockito.mock(IMethods.class);
    138 
    139         @Test public void unused() {
    140             given(mock.simpleMethod(1)).willReturn("");
    141         }
    142 
    143         @Test public void mismatch() {
    144             given(mock.simpleMethod(2)).willReturn("");
    145             mock.simpleMethod(3);
    146         }
    147     }
    148 
    149     public static class UnfinishedMocking {
    150         @Mock IMethods mock;
    151         MockitoSession mockito = Mockito.mockitoSession().initMocks(this).strictness(Strictness.STRICT_STUBS).startMocking();
    152 
    153         @Test public void unused() {
    154             given(mock.simpleMethod("1")).willReturn("one");
    155         }
    156 
    157         @Test public void unused2() {
    158             given(mock.simpleMethod("1")).willReturn("one");
    159         }
    160     }
    161 }
    162