/*
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
package org.mockitousage.verification;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.exceptions.verification.NeverWantedButInvoked;
import org.mockito.exceptions.verification.NoInteractionsWanted;
import org.mockito.exceptions.verification.WantedButNotInvoked;
import org.mockito.exceptions.verification.junit.ArgumentsAreDifferent;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
import static junit.framework.TestCase.fail;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.AdditionalMatchers.aryEq;
import static org.mockito.Mockito.*;
public class DescriptiveMessagesWhenVerificationFailsTest extends TestBase {
private IMethods mock;
@Before
public void setup() {
mock = Mockito.mock(IMethods.class, "iMethods");
}
@Test
public void should_print_method_name() {
try {
verify(mock).simpleMethod();
fail();
} catch (WantedButNotInvoked e) {
String expectedMessage =
"\n" +
"Wanted but not invoked:" +
"\n" +
"iMethods.simpleMethod();" +
"\n" +
"-> at";
assertThat(e).hasMessageContaining(expectedMessage);
}
}
private class Foo {
public String toString() {
return "foo";
}
}
@Test
public void should_print_method_name_and_arguments() {
try {
verify(mock).threeArgumentMethod(12, new Foo(), "xx");
fail();
} catch (WantedButNotInvoked e) {
assertThat(e).hasMessageContaining("iMethods.threeArgumentMethod(12, foo, \"xx\")");
}
}
@Test
public void should_print_actual_and_wanted_in_line() {
mock.varargs(1, 2);
try {
verify(mock).varargs(1, 1000);
fail();
} catch (ArgumentsAreDifferent e) {
String wanted =
"\n" +
"Argument(s) are different! Wanted:" +
"\n" +
"iMethods.varargs(1, 1000);";
assertThat(e).hasMessageContaining(wanted);
String actual =
"\n" +
"Actual invocation has different arguments:" +
"\n" +
"iMethods.varargs(1, 2);";
assertThat(e).hasMessageContaining(actual);
}
}
@Test
public void should_print_actual_and_wanted_in_multiple_lines() {
mock.varargs("this is very long string", "this is another very long string");
try {
verify(mock).varargs("x", "y", "z");
fail();
} catch (ArgumentsAreDifferent e) {
String wanted =
"\n" +
"Argument(s) are different! Wanted:" +
"\n" +
"iMethods.varargs(" +
"\n" +
" \"x\"," +
"\n" +
" \"y\"," +
"\n" +
" \"z\"" +
"\n" +
");";
assertThat(e).hasMessageContaining(wanted);
String actual =
"\n" +
"Actual invocation has different arguments:" +
"\n" +
"iMethods.varargs(" +
"\n" +
" \"this is very long string\"," +
"\n" +
" \"this is another very long string\"" +
"\n" +
");";
assertThat(e).hasMessageContaining(actual);
}
}
@Test
public void should_print_actual_and_wanted_when_actual_method_name_and_wanted_method_name_are_the_same() {
mock.simpleMethod();
try {
verify(mock).simpleMethod(10);
fail();
} catch (ArgumentsAreDifferent e) {
assertThat(e).hasMessageContaining("simpleMethod(10)").hasMessageContaining("simpleMethod()");
}
}
@Test
public void should_print_actual_and_unverified_wanted_when_the_difference_is_about_arguments() {
mock.twoArgumentMethod(1, 1);
mock.twoArgumentMethod(2, 2);
verify(mock).twoArgumentMethod(1, 1);
try {
verify(mock).twoArgumentMethod(2, 1000);
fail();
} catch (ArgumentsAreDifferent e) {
assertThat(e).hasMessageContaining("(2, 1000)").hasMessageContaining("(2, 2)");
}
}
@Test
public void should_print_first_unexpected_invocation() {
mock.oneArg(true);
mock.oneArg(false);
mock.threeArgumentMethod(1, "2", "3");
verify(mock).oneArg(true);
try {
verifyNoMoreInteractions(mock);
fail();
} catch (NoInteractionsWanted e) {
String expectedMessage =
"\n" +
"No interactions wanted here:" +
"\n" +
"-> at";
assertThat(e).hasMessageContaining(expectedMessage);
String expectedCause =
"\n" +
"But found this interaction on mock '" + mock + "':" +
"\n" +
"-> at";
assertThat(e).hasMessageContaining(expectedCause);
}
}
@Test
public void should_print_first_unexpected_invocation_when_verifying_zero_interactions() {
mock.twoArgumentMethod(1, 2);
mock.threeArgumentMethod(1, "2", "3");
try {
verifyZeroInteractions(mock);
fail();
} catch (NoInteractionsWanted e) {
String expected =
"\n" +
"No interactions wanted here:" +
"\n" +
"-> at";
assertThat(e).hasMessageContaining(expected);
String expectedCause =
"\n" +
"But found this interaction on mock '" + mock + "':" +
"\n" +
"-> at";
assertThat(e).hasMessageContaining(expectedCause);
}
}
@Test
public void should_print_first_unexpected_invocation_when_verifying_no_interactions() {
mock.twoArgumentMethod(1, 2);
mock.threeArgumentMethod(1, "2", "3");
try {
verifyNoInteractions(mock);
fail();
} catch (NoInteractionsWanted e) {
String expected =
"\n" +
"No interactions wanted here:" +
"\n" +
"-> at";
assertThat(e).hasMessageContaining(expected);
String expectedCause =
"\n" +
"But found these interactions on mock '" + mock + "':" +
"\n" +
"-> at";
assertThat(e).hasMessageContaining(expectedCause);
}
}
@Test
public void should_print_method_name_when_verifying_at_least_once() throws Exception {
try {
verify(mock, atLeastOnce()).twoArgumentMethod(1, 2);
fail();
} catch (WantedButNotInvoked e) {
assertThat(e).hasMessageContaining("twoArgumentMethod(1, 2)");
}
}
@Test
public void should_print_method_when_matcher_used() throws Exception {
try {
verify(mock, atLeastOnce()).twoArgumentMethod(anyInt(), eq(100));
fail();
} catch (WantedButNotInvoked e) {
String expectedMessage =
"\n" +
"Wanted but not invoked:" +
"\n" +
"iMethods.twoArgumentMethod(\n" +
" <any integer>,\n" +
" 100\n" +
");";
assertThat(e).hasMessageContaining(expectedMessage);
}
}
@Test
public void should_print_method_when_missing_invocation_with_array_matcher() {
mock.oneArray(new boolean[] { true, false, false });
try {
verify(mock).oneArray(aryEq(new boolean[] { false, false, false }));
fail();
} catch (ArgumentsAreDifferent e) {
assertThat(e)
.hasMessageContaining("[false, false, false]")
.hasMessageContaining("[true, false, false]");
}
}
@Test
public void should_print_method_when_missing_invocation_with_vararg_matcher() {
mock.varargsString(10, "xxx", "yyy", "zzz");
try {
verify(mock).varargsString(10, "111", "222", "333");
fail();
} catch (ArgumentsAreDifferent e) {
assertThat(e)
.hasMessageContaining("111")
.hasMessageContaining("\"xxx\"");
}
}
@Test
public void should_print_method_when_missing_invocation_with_matcher() {
mock.simpleMethod("foo");
try {
verify(mock).simpleMethod(matches("burrito from Exmouth"));
fail();
} catch (ArgumentsAreDifferent e) {
assertThat(e)
.hasMessageContaining("matches(\"burrito from Exmouth\")")
.hasMessageContaining("\"foo\"");
}
}
@Test
public void should_print_null_arguments() throws Exception {
mock.simpleMethod(null, (Integer) null);
try {
verify(mock).simpleMethod("test");
fail();
} catch (ArgumentsAreDifferent e) {
assertThat(e).hasMessageContaining("simpleMethod(null, null);");
}
}
@Test
public void should_say_never_wanted_but_invoked() throws Exception {
mock.simpleMethod(1);
verify(mock, never()).simpleMethod(2);
try {
verify(mock, never()).simpleMethod(1);
fail();
} catch (NeverWantedButInvoked e) {
assertThat(e)
.hasMessageContaining("Never wanted here:")
.hasMessageContaining("But invoked here:");
}
}
@Test
public void should_show_right_actual_method() throws Exception {
mock.simpleMethod(9191);
mock.simpleMethod("foo");
try {
verify(mock).simpleMethod("bar");
fail();
} catch (ArgumentsAreDifferent e) {
assertThat(e)
.hasMessageContaining("bar")
.hasMessageContaining("foo");
}
}
@Mock private IMethods iHavefunkyName;
@Test
public void should_print_field_name_when_annotations_used() throws Exception {
iHavefunkyName.simpleMethod(10);
try {
verify(iHavefunkyName).simpleMethod(20);
fail();
} catch (ArgumentsAreDifferent e) {
assertThat(e)
.hasMessageContaining("iHavefunkyName.simpleMethod(20)")
.hasMessageContaining("iHavefunkyName.simpleMethod(10)");
}
}
@Test
public void should_print_interactions_on_mock_when_ordinary_verification_fail() throws Exception {
mock.otherMethod();
mock.booleanReturningMethod();
try {
verify(mock).simpleMethod();
fail();
} catch (WantedButNotInvoked e) {
// assertContains("")
}
}
@Mock private IMethods veeeeeeeeeeeeeeeeeeeeeeeerylongNameMock;
@Test
public void should_never_break_method_string_when_no_args_in_method() throws Exception {
try {
verify(veeeeeeeeeeeeeeeeeeeeeeeerylongNameMock).simpleMethod();
fail();
} catch(WantedButNotInvoked e) {
assertThat(e).hasMessageContaining("veeeeeeeeeeeeeeeeeeeeeeeerylongNameMock.simpleMethod()");
}
}
@Test
public void should_print_method_name_and_arguments_of_other_interactions_with_different_methods() throws Exception {
try {
mock.arrayMethod(new String[] {"a", "b", "c"});
mock.forByte((byte) 25);
verify(mock).threeArgumentMethod(12, new Foo(), "xx");
fail();
} catch (WantedButNotInvoked e) {
assertThat(e)
.hasMessageContaining("iMethods.threeArgumentMethod(12, foo, \"xx\")")
.hasMessageContaining("iMethods.arrayMethod([\"a\", \"b\", \"c\"])")
.hasMessageContaining("iMethods.forByte((byte) 0x19)");
}
}
@Test
@Ignore("issue 380 related")
public void should_print_method_name_and_arguments_of_other_interactions_of_same_method() throws Exception {
try {
mock.forByte((byte) 25);
mock.forByte((byte) 12);
verify(mock).forByte((byte) 42);
fail();
} catch (WantedButNotInvoked e) {
assertThat(e)
.hasMessageContaining("iMethods.forByte(42)")
.hasMessageContaining("iMethods.forByte(25)")
.hasMessageContaining("iMethods.forByte(12)");
}
}
@Test
@Ignore("issue 380 related")
public void test1() {
AnInterface m = Mockito.mock(AnInterface.class);
for (int i = 1; i <= 2; i++) {
m.foo(i);
}
verify(m).foo(1);
verify(m).foo(2);
verify(m).foo(3); // XXX: doesn't mention the parameters of foo(1) and foo(2)
verify(m).foo(4);
}
@Test
@Ignore("issue 380 related")
public void test2() {
AnInterface m = Mockito.mock(AnInterface.class);
for (int i = 1; i <= 4; i++) {
m.foo(i);
}
verify(m).foo(1);
verify(m).foo(2);
verify(m).foo(5); // XXX: doesn't mention foo(4) at all
}
public interface AnInterface {
void foo(int i);
}
}