1/* 2 * Copyright (c) 2018 Mockito contributors 3 * This program is made available under the terms of the MIT License. 4 */ 5package org.mockitousage.stubbing; 6 7import org.junit.After; 8import org.junit.Test; 9import org.mockito.Mock; 10import org.mockito.MockitoSession; 11import org.mockito.StateMaster; 12import org.mockito.exceptions.base.MockitoException; 13import org.mockito.internal.framework.DefaultMockitoSession; 14import org.mockito.internal.util.SimpleMockitoLogger; 15import org.mockito.quality.Strictness; 16import org.mockitousage.IMethods; 17 18import static java.util.Collections.singletonList; 19import static org.junit.Assert.assertEquals; 20import static org.mockito.BDDMockito.given; 21import static org.mockito.Mockito.verify; 22import static org.mockitoutil.TestBase.filterLineNo; 23 24public class StubbingWarningsTest { 25 26 private static final String TEST_NAME = "test.name"; 27 28 @Mock IMethods mock; 29 30 SimpleMockitoLogger logger = new SimpleMockitoLogger(); 31 MockitoSession mockito = new DefaultMockitoSession(singletonList((Object) this), TEST_NAME, Strictness.WARN, logger); 32 33 @After public void after() { 34 StateMaster stateMaster = new StateMaster(); 35 stateMaster.reset(); 36 stateMaster.clearMockitoListeners(); 37 } 38 39 @Test public void few_interactions() throws Throwable { 40 //when 41 mock.simpleMethod(100); 42 mock.otherMethod(); 43 44 //expect no exception 45 mockito.finishMocking(); 46 logger.assertEmpty(); 47 } 48 49 @Test public void stubbing_used() throws Throwable { 50 //when 51 given(mock.simpleMethod(100)).willReturn("100"); 52 mock.simpleMethod(100); 53 54 //then 55 mockito.finishMocking(); 56 logger.assertEmpty(); 57 } 58 59 @Test public void unused_stubbed_is_not_implicitly_verified() throws Throwable { 60 //when 61 given(mock.simpleMethod(100)).willReturn("100"); 62 mock.simpleMethod(100); // <- stubbing is used 63 mock.simpleMethod(200); // <- other method should not generate arg mismatch 64 65 //then 66 mockito.finishMocking(); 67 logger.assertEmpty(); 68 } 69 70 @Test public void stubbing_argument_mismatch() throws Throwable { 71 //when 72 given(mock.simpleMethod(100)).willReturn("100"); 73 mock.simpleMethod(200); 74 75 mockito.finishMocking(); 76 77 //TODO - currently we warn about "Unused" instead of "Arg mismatch" below 78 //because it was simpler to implement. This can be improved given we put priority to improve the warnings. 79 //then 80 assertEquals(filterLineNo( 81 "[MockitoHint] " + TEST_NAME + " (see javadoc for MockitoHint):\n" + 82 "[MockitoHint] 1. Unused -> at org.mockitousage.stubbing.StubbingWarningsTest.stubbing_argument_mismatch(StubbingWarningsTest.java:0)\n"), 83 filterLineNo(logger.getLoggedInfo())); 84 } 85 86 @Test public void unused_stubbing() throws Throwable { 87 //when 88 given(mock.simpleMethod(100)).willReturn("100"); 89 90 mockito.finishMocking(); 91 92 //then 93 assertEquals(filterLineNo( 94 "[MockitoHint] " + TEST_NAME + " (see javadoc for MockitoHint):\n" + 95 "[MockitoHint] 1. Unused -> at org.mockitousage.stubbing.StubbingWarningsTest.unused_stubbing(StubbingWarningsTest.java:0)\n"), 96 filterLineNo(logger.getLoggedInfo())); 97 } 98 99 @Test(expected = MockitoException.class) public void unfinished_verification_without_throwable() throws Throwable { 100 //when 101 verify(mock); 102 103 mockito.finishMocking(); 104 } 105 106 @Test public void unfinished_verification_with_throwable() throws Throwable { 107 //when 108 verify(mock); 109 110 mockito.finishMocking(new AssertionError()); 111 112 // then 113 logger.assertEmpty(); 114 } 115} 116