1 package org.mockitousage.junitrule; 2 3 import org.junit.Rule; 4 import org.junit.Test; 5 import org.mockito.Mock; 6 import org.mockito.quality.Strictness; 7 import org.mockito.internal.junit.JUnitRule; 8 import org.mockito.internal.util.SimpleMockitoLogger; 9 import org.mockitousage.IMethods; 10 import org.mockitoutil.SafeJUnitRule; 11 12 import static org.junit.Assert.assertEquals; 13 import static org.junit.Assert.assertTrue; 14 import static org.mockito.Mockito.when; 15 import static org.mockitoutil.TestBase.filterLineNo; 16 17 public class StubbingWarningsJUnitRuleTest { 18 19 private SimpleMockitoLogger logger = new SimpleMockitoLogger(); 20 @Rule public SafeJUnitRule rule = new SafeJUnitRule(new JUnitRule(logger, Strictness.WARN)); 21 @Mock IMethods mock; 22 23 @Test no_unused_stubs_reported_on_failure()24 public void no_unused_stubs_reported_on_failure() throws Throwable { 25 //expect 26 rule.expectFailure(new SafeJUnitRule.FailureAssert() { 27 public void doAssert(Throwable t) { 28 assertEquals("x", t.getMessage()); 29 assertTrue(logger.getLoggedInfo().isEmpty()); 30 } 31 }); 32 33 //when 34 declareStubbing(mock); 35 throw new AssertionError("x"); 36 } 37 38 @Test stubbing_arg_mismatch_on_failure()39 public void stubbing_arg_mismatch_on_failure() throws Throwable { 40 //expect 41 rule.expectFailure(new SafeJUnitRule.FailureAssert() { 42 public void doAssert(Throwable t) { 43 assertEquals("x", t.getMessage()); 44 assertEquals( 45 "[MockitoHint] StubbingWarningsJUnitRuleTest.stubbing_arg_mismatch_on_failure (see javadoc for MockitoHint):\n" + 46 "[MockitoHint] 1. Unused... -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n" + 47 "[MockitoHint] ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n", 48 filterLineNo(logger.getLoggedInfo())); 49 } 50 }); 51 52 //when 53 declareStubbingWithArg(mock, "a"); 54 useStubbingWithArg(mock, "b"); 55 throw new AssertionError("x"); 56 } 57 no_stubbing_arg_mismatch_when_no_mismatch_on_fail()58 @Test public void no_stubbing_arg_mismatch_when_no_mismatch_on_fail() throws Throwable { 59 //expect 60 rule.expectFailure(new SafeJUnitRule.FailureAssert() { 61 public void doAssert(Throwable t) { 62 assertEquals("x", t.getMessage()); 63 assertTrue(logger.getLoggedInfo().isEmpty()); 64 } 65 }); 66 67 //when 68 declareStubbingWithArg(mock, "a"); 69 useStubbingWithArg(mock, "a"); 70 throw new AssertionError("x"); 71 } 72 73 @Test no_stubbing_warning_on_pass()74 public void no_stubbing_warning_on_pass() throws Throwable { 75 //expect 76 rule.expectSuccess(new Runnable() { 77 public void run() { 78 assertTrue(logger.isEmpty()); 79 } 80 }); 81 82 //when 83 declareStubbingWithArg(mock, "a"); 84 useStubbingWithArg(mock, "a"); 85 } 86 87 @Test multiple_stubbing_arg_mismatch_on_failure()88 public void multiple_stubbing_arg_mismatch_on_failure() throws Throwable { 89 //expect 90 rule.expectFailure(new SafeJUnitRule.FailureAssert() { 91 public void doAssert(Throwable t) { 92 assertEquals("x", t.getMessage()); 93 assertEquals( 94 "[MockitoHint] StubbingWarningsJUnitRuleTest.multiple_stubbing_arg_mismatch_on_failure (see javadoc for MockitoHint):\n" + 95 "[MockitoHint] 1. Unused... -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n" + 96 "[MockitoHint] ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n" + 97 "[MockitoHint] ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n" + 98 "[MockitoHint] 2. Unused... -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n" + 99 "[MockitoHint] ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n" + 100 "[MockitoHint] ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n", 101 filterLineNo(logger.getLoggedInfo())); 102 } 103 }); 104 105 //when 106 declareStubbingWithArg(mock, "a"); 107 declareStubbingWithArg(mock, "b"); 108 109 useStubbingWithArg(mock, "c"); 110 useStubbingWithArg(mock, "d"); 111 112 throw new AssertionError("x"); 113 } 114 115 @Test reports_only_mismatching_stubs()116 public void reports_only_mismatching_stubs() throws Throwable { 117 //expect 118 rule.expectFailure(new SafeJUnitRule.FailureAssert() { 119 public void doAssert(Throwable t) { 120 assertEquals("x", t.getMessage()); 121 assertEquals( 122 "[MockitoHint] StubbingWarningsJUnitRuleTest.reports_only_mismatching_stubs (see javadoc for MockitoHint):\n" + 123 "[MockitoHint] 1. Unused... -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n" + 124 "[MockitoHint] ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n", 125 filterLineNo(logger.getLoggedInfo())); 126 } 127 }); 128 129 //when 130 declareStubbingWithArg(mock, "a"); // <-- used 131 declareStubbingWithArg(mock, "b"); // <-- unused 132 133 useStubbingWithArg(mock, "a"); 134 useStubbingWithArg(mock, "d"); // <-- arg mismatch 135 136 throw new AssertionError("x"); 137 } 138 139 @Test no_mismatch_when_stub_was_used()140 public void no_mismatch_when_stub_was_used() throws Throwable { 141 //expect 142 rule.expectFailure(new SafeJUnitRule.FailureAssert() { 143 public void doAssert(Throwable t) { 144 assertEquals("x", t.getMessage()); 145 assertTrue(logger.getLoggedInfo().isEmpty()); 146 } 147 }); 148 149 //when 150 declareStubbingWithArg(mock, "a"); 151 152 useStubbingWithArg(mock, "a"); 153 useStubbingWithArg(mock, "d"); // <-- arg mismatch, but the stub was already used 154 155 throw new AssertionError("x"); 156 } 157 158 @Test no_stubbing_arg_mismatch_on_pass()159 public void no_stubbing_arg_mismatch_on_pass() throws Throwable { 160 //expect 161 rule.expectSuccess(new Runnable() { 162 public void run() { 163 assertEquals( 164 "[MockitoHint] StubbingWarningsJUnitRuleTest.no_stubbing_arg_mismatch_on_pass (see javadoc for MockitoHint):\n" + 165 "[MockitoHint] 1. Unused -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n", 166 filterLineNo(logger.getLoggedInfo())); 167 } 168 }); 169 170 //when 171 declareStubbingWithArg(mock, "a"); 172 useStubbingWithArg(mock, "b"); 173 } 174 175 @Test warns_about_unused_stubs_when_passed()176 public void warns_about_unused_stubs_when_passed() throws Throwable { 177 //expect 178 rule.expectSuccess(new Runnable() { 179 public void run() { 180 assertEquals( 181 "[MockitoHint] StubbingWarningsJUnitRuleTest.warns_about_unused_stubs_when_passed (see javadoc for MockitoHint):\n" + 182 "[MockitoHint] 1. Unused -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbing(StubbingWarningsJUnitRuleTest.java:0)\n", 183 filterLineNo(logger.getLoggedInfo())); 184 185 } 186 }); 187 188 //when 189 declareStubbing(mock); 190 } 191 declareStubbingWithArg(IMethods mock, String arg)192 private static void declareStubbingWithArg(IMethods mock, String arg) { 193 when(mock.simpleMethod(arg)).thenReturn("bar"); 194 } 195 declareStubbing(IMethods mock)196 private static void declareStubbing(IMethods mock) { 197 when(mock.simpleMethod("foo")).thenReturn("bar"); 198 } 199 useStubbingWithArg(IMethods mock, String arg)200 private void useStubbingWithArg(IMethods mock, String arg) { 201 mock.simpleMethod(arg); 202 } 203 } 204