Exception while configuring return behaviors using assertThat argument matchers

[gigermocas]

When configuring return behaviors using assertArg i'm getting an exception during the test wiring:

@ExtendWith(MockitoExtension.class)
class FooTests {

	@Mock
	Bar bar;

	@Test
	void compute() {
		var foo = new Foo(bar);

		when(bar.parse(assertArg(arg -> assertEquals("1", arg))))
				.thenReturn(1);

		when(bar.parse(assertArg(arg -> assertEquals("2", arg))))
				.thenReturn(2);

		assertEquals(3, foo.compute());
	}

}

class Foo {

	private Bar bar;

	public Foo(Bar bar) {
		this.bar = bar;
	}

	public int compute() {
		return this.bar.parse("1") + this.bar.parse("2");
	}
}

interface Bar {

	int parse(String number);

}

(this is a trivial example, in my actual code I'm using a recursive comparison assertion from AssertJ for matching complex objects)

org.opentest4j.AssertionFailedError: expected: <1> but was: <null>
	at org.junit.jupiter.api.AssertionFailureBuilder.build(AssertionFailureBuilder.java:151)
	at org.junit.jupiter.api.AssertionFailureBuilder.buildAndThrow(AssertionFailureBuilder.java:132)
	at org.junit.jupiter.api.AssertEquals.failNotEqual(AssertEquals.java:197)
	at org.junit.jupiter.api.AssertEquals.assertEquals(AssertEquals.java:182)
	at org.junit.jupiter.api.AssertEquals.assertEquals(AssertEquals.java:177)
	at org.junit.jupiter.api.Assertions.assertEquals(Assertions.java:1141)
	at com.example.mocktest.FooTests.lambda$0(FooTests.java:22)
	at org.mockito.ThrowingConsumer.accept(ThrowingConsumer.java:15)
	at org.mockito.ArgumentMatchers.lambda$assertArg$1(ArgumentMatchers.java:946)
	at org.mockito.internal.invocation.TypeSafeMatching.apply(TypeSafeMatching.java:35)
	at org.mockito.internal.invocation.MatcherApplicationStrategy.argsMatch(MatcherApplicationStrategy.java:85)
	at org.mockito.internal.invocation.MatcherApplicationStrategy.forEachMatcherAndArgument(MatcherApplicationStrategy.java:71)
	at org.mockito.internal.invocation.InvocationMatcher.argumentsMatch(InvocationMatcher.java:156)
	at org.mockito.internal.invocation.InvocationMatcher.matches(InvocationMatcher.java:82)
	at org.mockito.internal.stubbing.InvocationContainerImpl.findAnswerFor(InvocationContainerImpl.java:92)
	at org.mockito.internal.handler.MockHandlerImpl.handle(MockHandlerImpl.java:91)
	at org.mockito.internal.handler.NullResultGuardian.handle(NullResultGuardian.java:29)
	at org.mockito.internal.handler.InvocationNotifierHandler.handle(InvocationNotifierHandler.java:34)
	at org.mockito.internal.creation.bytebuddy.MockMethodInterceptor.doIntercept(MockMethodInterceptor.java:82)
	at org.mockito.internal.creation.bytebuddy.MockMethodInterceptor.doIntercept(MockMethodInterceptor.java:56)
	at org.mockito.internal.creation.bytebuddy.MockMethodInterceptor$DispatcherDefaultingToRealMethod.interceptAbstract(MockMethodInterceptor.java:161)
	at com.example.mocktest.Bar$MockitoMock$y1lbNFJ5.parse(Unknown Source)
	at com.example.mocktest.FooTests.compute(FooTests.java:25)
	at java.base/java.lang.reflect.Method.invoke(Method.java:568)
	at java.base/java.util.ArrayList.forEach(ArrayList.java:1511)
	at java.base/java.util.ArrayList.forEach(ArrayList.java:1511)

I don't understand this, the test hasn't actually ran, the exception is triggered by the configuration of the second return behavior.

I'm I missing something here?

[TimvdLippe]

assertArg(arg -> assertEquals("2", arg)) itself returns null. Therefore, the code is equivalent to the following:

		when(bar.parse(assertArg(arg -> assertEquals("1", arg))))
				.thenReturn(1);

		when(bar.parse(null))
				.thenReturn(2);

Since the second invocation does not equal to 1, your matcher fails and it stops there. If you want multiple matchers, then do an assertArg which does a check for multiple allowed values and return these values as well.

[gigermocas]

That doesn't seem intuitive to me.

If I don't use the assertArg argument matcher but another one like eq it works as intended:

when(bar.parse(eq("1"))).thenReturn(1);
when(bar.parse(eq("2"))).thenReturn(2);

I would assume I would get the same behavior between both types of argument matchers.

I'm currently in a process of updating my tests, before trying to migrate to assertArg I was using a custom argument matcher, something similar to (for the example provided):

class XEq implements ArgumentMatcher<String> {

	private final String expected;

	public XEq(String expected) {
		this.expected = expected;
	}

	@Override
	public boolean matches(String value) {
		if (value == null) return false;
		try {
			assertEquals(this.expected, value);
			return true;
		} catch (Throwable e) {
			return false;
		}
	}

	@Override
	public Class<?> type() {
		return String.class;
	}

	public static String xEq(String value) {
		return Mockito.argThat(new XEq(value));
	}

}

It also works fine if I switch the assertArg with this xEq implementation.

Also I'm not seeing how I can use a single argument matcher that returns multiple values depending on the argument. Can you elaborate?

[gigermocas]

@TimvdLippe, sorry to bump this, as you selected an answer already you may be missing my response.