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.junitrule; 6 7 import static org.assertj.core.api.Assertions.assertThat; 8 import static org.assertj.core.api.Assertions.assertThatThrownBy; 9 import static org.assertj.core.api.Assertions.failBecauseExceptionWasNotThrown; 10 import static org.mockito.Mockito.longThat; 11 import static org.mockito.Mockito.mock; 12 import static org.mockito.Mockito.never; 13 import static org.mockito.Mockito.shortThat; 14 import static org.mockito.Mockito.verify; 15 16 import org.junit.Rule; 17 import org.junit.Test; 18 import org.junit.runner.JUnitCore; 19 import org.junit.runner.Result; 20 import org.mockito.exceptions.base.MockitoAssertionError; 21 import org.mockito.junit.MockitoJUnit; 22 import org.mockito.junit.VerificationCollector; 23 import org.mockitousage.IMethods; 24 25 public class VerificationCollectorImplTest { 26 27 @Test should_not_throw_any_exceptions_when_verifications_are_successful()28 public void should_not_throw_any_exceptions_when_verifications_are_successful() { 29 VerificationCollector collector = MockitoJUnit.collector().assertLazily(); 30 31 IMethods methods = mock(IMethods.class); 32 methods.simpleMethod(); 33 34 verify(methods).simpleMethod(); 35 collector.collectAndReport(); 36 } 37 38 @Test should_collect_verification_failures()39 public void should_collect_verification_failures() { 40 VerificationCollector collector = MockitoJUnit.collector().assertLazily(); 41 42 IMethods methods = mock(IMethods.class); 43 44 verify(methods).simpleMethod(); 45 assertThatThrownBy( 46 () -> { 47 collector.collectAndReport(); 48 }) 49 .isInstanceOf(MockitoAssertionError.class) 50 .hasMessageContainingAll( 51 "There were multiple verification failures:", 52 "1. Wanted but not invoked:", 53 "iMethods.simpleMethod();", 54 "Actually, there were zero interactions with this mock."); 55 } 56 57 @Test should_collect_multiple_verification_failures()58 public void should_collect_multiple_verification_failures() { 59 VerificationCollector collector = MockitoJUnit.collector().assertLazily(); 60 61 IMethods methods = mock(IMethods.class); 62 63 methods.intArgumentMethod(6); 64 65 verify(methods).simpleMethod(); 66 verify(methods).byteReturningMethod(); 67 verify(methods).intArgumentMethod(8); 68 verify(methods).longArg(8L); 69 try { 70 collector.collectAndReport(); 71 failBecauseExceptionWasNotThrown(MockitoAssertionError.class); 72 } catch (MockitoAssertionError error) { 73 assertThat(error).hasMessageContaining("1. Wanted but not invoked:"); 74 assertThat(error).hasMessageContaining("2. Wanted but not invoked:"); 75 assertThat(error).hasMessageContaining("3. Argument(s) are different! Wanted:"); 76 assertThat(error).hasMessageContaining("4. Wanted but not invoked:"); 77 } 78 } 79 80 @Test should_collect_matching_error_from_non_matching_arguments()81 public void should_collect_matching_error_from_non_matching_arguments() { 82 VerificationCollector collector = MockitoJUnit.collector().assertLazily(); 83 84 IMethods methods = mock(IMethods.class); 85 86 methods.intArgumentMethod(6); 87 methods.longArg(8L); 88 methods.forShort((short) 6); 89 90 verify(methods).intArgumentMethod(8); 91 verify(methods) 92 .longArg( 93 longThat( 94 argument -> { 95 throw new AssertionError("custom error message"); 96 })); 97 verify(methods).forShort(shortThat(argument -> false)); 98 99 try { 100 collector.collectAndReport(); 101 failBecauseExceptionWasNotThrown(MockitoAssertionError.class); 102 } catch (MockitoAssertionError error) { 103 assertThat(error).hasMessageContaining("1. Argument(s) are different! Wanted:"); 104 assertThat(error).hasMessageContaining("2. custom error message"); 105 assertThat(error).hasMessageContaining("3. Argument(s) are different! Wanted:"); 106 } 107 } 108 109 @Test should_only_collect_failures_ignore_successful_verifications()110 public void should_only_collect_failures_ignore_successful_verifications() { 111 VerificationCollector collector = MockitoJUnit.collector().assertLazily(); 112 113 IMethods methods = mock(IMethods.class); 114 115 verify(methods, never()).simpleMethod(); 116 verify(methods).byteReturningMethod(); 117 118 this.assertExactlyOneFailure(collector); 119 } 120 121 @Test should_continue_collecting_after_failing_verification()122 public void should_continue_collecting_after_failing_verification() { 123 VerificationCollector collector = MockitoJUnit.collector().assertLazily(); 124 125 IMethods methods = mock(IMethods.class); 126 methods.simpleMethod(); 127 128 verify(methods).byteReturningMethod(); 129 verify(methods).simpleMethod(); 130 131 this.assertExactlyOneFailure(collector); 132 } 133 assertExactlyOneFailure(VerificationCollector collector)134 private void assertExactlyOneFailure(VerificationCollector collector) { 135 try { 136 collector.collectAndReport(); 137 failBecauseExceptionWasNotThrown(MockitoAssertionError.class); 138 } catch (MockitoAssertionError error) { 139 assertThat(error).hasMessageContaining("1. Wanted but not invoked:"); 140 assertThat(error.getMessage()).doesNotContain("2."); 141 } 142 } 143 144 @Test should_invoke_collector_rule_after_test()145 public void should_invoke_collector_rule_after_test() { 146 JUnitCore runner = new JUnitCore(); 147 Result result = runner.run(VerificationCollectorRuleInner.class); 148 149 assertThat(result.getFailureCount()).as("failureCount").isEqualTo(2); 150 assertThat(result.getFailures().get(0).getMessage()) 151 .as("failure1") 152 .contains("1. Wanted but not invoked:"); 153 assertThat(result.getFailures().get(1).getMessage()) 154 .as("failure2") 155 .contains("1. Argument(s) are different! Wanted:") 156 .contains("2. Wanted but not invoked:"); 157 } 158 159 // This class is picked up when running a test suite using an IDE. It fails on purpose. 160 public static class VerificationCollectorRuleInner { 161 162 @Rule public VerificationCollector collector = MockitoJUnit.collector(); 163 164 @Test should_fail()165 public void should_fail() { 166 IMethods methods = mock(IMethods.class); 167 168 verify(methods).simpleMethod(); 169 } 170 171 @Test should_not_fail()172 public void should_not_fail() { 173 IMethods methods = mock(IMethods.class); 174 methods.simpleMethod(); 175 176 verify(methods).simpleMethod(); 177 } 178 179 @Test should_fail_with_args()180 public void should_fail_with_args() { 181 IMethods methods = mock(IMethods.class); 182 methods.intArgumentMethod(8); 183 184 verify(methods).intArgumentMethod(9); 185 verify(methods).byteReturningMethod(); 186 } 187 } 188 } 189