PotentialStubbingProblem not counted if the invocations are in the same source file as the stubbings. What is the rationale behind this design?

[NadChel]

Here's an MRE:

package com.example.mockitomre;

public interface DocumentedEndpoint {
    EndpointDetails getDetails();
}

package com.example.mockitomre;

public interface EndpointDetails {
    String getPath();
}

package com.example.mockitomre;

public interface EndpointSieve {
    boolean isAllowed(DocumentedEndpoint endpoint);
}

package com.example.mockitomre;

import org.springframework.util.AntPathMatcher;

public class EndpointSieveConfig {
    public EndpointSieve errorPathEndpointSieve(GatewayMeta gatewayMeta, AntPathMatcher antPathMatcher) {
        return endpoint -> gatewayMeta.getIgnoredPatterns().stream()
                .noneMatch(ignoredPattern -> antPathMatcher.match(ignoredPattern, endpoint.getDetails().getPath()));
    }
}

package com.example.mockitomre;

import lombok.Getter;

import java.util.List;

@Getter
public final class GatewayMeta {
    private List<String> ignoredPatterns;
}

package com.example.mockitomre;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.util.AntPathMatcher;

import java.util.List;

import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class)
class ErrorPathEndpointSieveTest {
    private final EndpointSieveConfig endpointSieveConfig = new EndpointSieveConfig();
    @Mock
    private GatewayMeta gatewayMetaMock;
    @Mock
    private AntPathMatcher antPathMatcherMock;
    private EndpointSieve errorPathEndpointSieve;

    @Test
    void doesntAllowIgnoredPatterns() {
        String ignoredPattern = "/ignored-path/**";
        String anotherIgnoredPattern = "/*/another-ignored-path";
        when(gatewayMetaMock.getIgnoredPatterns()).thenReturn(List.of(
                ignoredPattern, anotherIgnoredPattern
        ));

        String pathToExclude = "/ignored-path";
        String anotherPathToExclude = "/it-is/another-ignored-path";

        when(antPathMatcherMock.match(ignoredPattern, pathToExclude)).thenReturn(true);
        when(antPathMatcherMock.match(anotherIgnoredPattern, anotherPathToExclude)).thenReturn(true);

        DocumentedEndpoint endpointToExclude = mock(DocumentedEndpoint.class, RETURNS_DEEP_STUBS);
        when(endpointToExclude.getDetails().getPath()).thenReturn(pathToExclude);

        DocumentedEndpoint anotherEndpointToExclude = mock(DocumentedEndpoint.class, RETURNS_DEEP_STUBS);
        when(anotherEndpointToExclude.getDetails().getPath()).thenReturn(anotherPathToExclude);

        String okPath = "/another-ignored-path/on-second-thought-it-is-not";
        DocumentedEndpoint endpointToKeep = mock(DocumentedEndpoint.class, RETURNS_DEEP_STUBS);
        when(endpointToKeep.getDetails().getPath()).thenReturn(okPath);

        errorPathEndpointSieve = endpointSieveConfig.errorPathEndpointSieve(gatewayMetaMock, antPathMatcherMock);

        assertThat(errorPathEndpointSieve.isAllowed(endpointToExclude)).isFalse();
        assertThat(errorPathEndpointSieve.isAllowed(anotherEndpointToExclude)).isFalse();

        assertThat(errorPathEndpointSieve.isAllowed(endpointToKeep)).isTrue();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.2</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>mockito-mre</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mockito-mre</name>
    <description>mockito-mre</description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

So here's the problem: once I run the test, I get

org.mockito.exceptions.misusing.PotentialStubbingProblem: 
Strict stubbing argument mismatch. Please check:
 - this invocation of 'match' method:
    antPathMatcherMock.match(
    "/ignored-path/**",
    "/it-is/another-ignored-path"
);
    -> at com.example.mockitomre.EndpointSieveConfig.lambda$errorPathEndpointSieve$0(EndpointSieveConfig.java:8)
 - has following stubbing(s) with different arguments:
    1. antPathMatcherMock.match(
    "/*/another-ignored-path",
    "/it-is/another-ignored-path"
);
      -> at com.example.mockitomre.ErrorPathEndpointSieveTest.doesntAllowIgnoredPatterns(ErrorPathEndpointSieveTest.java:37)
Typically, stubbing argument mismatch indicates user mistake when writing tests.
Mockito fails early so that you can debug potential problem easily.
However, there are legit scenarios when this exception generates false negative signal:
  - stubbing the same method multiple times using 'given().will()' or 'when().then()' API
    Please use 'will().given()' or 'doReturn().when()' API for stubbing.
  - stubbed method is intentionally invoked with different arguments by code under test
    Please use default or 'silent' JUnit Rule (equivalent of Strictness.LENIENT).
For more information see javadoc for PotentialStubbingProblem class.

	at org.springframework.util.AntPathMatcher.match(AntPathMatcher.java:195)
	at com.example.mockitomre.EndpointSieveConfig.lambda$errorPathEndpointSieve$0(EndpointSieveConfig.java:8)

Is Mockito unhappy that I don't stub match("/*/another-ignored-path","/it-is/another-ignored-path") even though I call the method with those args? Nope. Replace the test method with this, it passes

// SNIPPET A

// here, Mockito is fine with calling match("/ignored-path/**", "/it-is/another-ignored-path")

    @Test
    void doesntAllowIgnoredPatterns() {
        when(antPathMatcherMock.match("/ignored-path/**", "/ignored-path")).thenReturn(true);
        when(antPathMatcherMock.match("/*/another-ignored-path", "/it-is/another-ignored-path")).thenReturn(true);

        antPathMatcherMock.match("/ignored-path/**", "/ignored-path");
        antPathMatcherMock.match("/*/another-ignored-path", "/it-is/another-ignored-path");

        antPathMatcherMock.match("/ignored-path/**", "/it-is/another-ignored-path");
    }

QUESTION №1. So what does Mockito want from me then?

You know what helps (beside ditching Mockito's extension altogether)? Making EndpointSieveConfig a nested class of ErrorPathEndpointSieveTest like so:

// SNIPPET B

package com.example.mockitomre;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.util.AntPathMatcher;

import java.util.List;

import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class)
class ErrorPathEndpointSieveTest {
    private final EndpointSieveConfig endpointSieveConfig = new EndpointSieveConfig();
    @Mock
    private GatewayMeta gatewayMetaMock;
    @Mock
    private AntPathMatcher antPathMatcherMock;
    private EndpointSieve errorPathEndpointSieve;

    @Test
    void doesntAllowIgnoredPatterns() {
        String ignoredPattern = "/ignored-path/**";
        String anotherIgnoredPattern = "/*/another-ignored-path";
        when(gatewayMetaMock.getIgnoredPatterns()).thenReturn(List.of(
                ignoredPattern, anotherIgnoredPattern
        ));

        String pathToExclude = "/ignored-path";
        String anotherPathToExclude = "/it-is/another-ignored-path";

        when(antPathMatcherMock.match(ignoredPattern, pathToExclude)).thenReturn(true);
        when(antPathMatcherMock.match(anotherIgnoredPattern, anotherPathToExclude)).thenReturn(true);

        DocumentedEndpoint endpointToExclude = mock(DocumentedEndpoint.class, RETURNS_DEEP_STUBS);
        when(endpointToExclude.getDetails().getPath()).thenReturn(pathToExclude);

        DocumentedEndpoint anotherEndpointToExclude = mock(DocumentedEndpoint.class, RETURNS_DEEP_STUBS);
        when(anotherEndpointToExclude.getDetails().getPath()).thenReturn(anotherPathToExclude);

        String okPath = "/another-ignored-path/on-second-thought-it-is-not";
        DocumentedEndpoint endpointToKeep = mock(DocumentedEndpoint.class, RETURNS_DEEP_STUBS);
        when(endpointToKeep.getDetails().getPath()).thenReturn(okPath);

        errorPathEndpointSieve = endpointSieveConfig.errorPathEndpointSieve(gatewayMetaMock, antPathMatcherMock);

        assertThat(errorPathEndpointSieve.isAllowed(endpointToExclude)).isFalse();
        assertThat(errorPathEndpointSieve.isAllowed(anotherEndpointToExclude)).isFalse();

        assertThat(errorPathEndpointSieve.isAllowed(endpointToKeep)).isTrue();
    }

    public class EndpointSieveConfig {
        public EndpointSieve errorPathEndpointSieve(GatewayMeta gatewayMeta, AntPathMatcher antPathMatcher) {
            return endpoint -> gatewayMeta.getIgnoredPatterns().stream()
                    .noneMatch(ignoredPattern -> antPathMatcher.match(ignoredPattern, endpoint.getDetails().getPath()));
        }
    }
}

Now it passes!

Question №2. Why does moving the class solves the problem?

Thankfully, they helped me to find the culprit over there on StackOverflow. Here it is:

private static List<Invocation> potentialArgMismatches(
        Invocation invocation, Collection<Stubbing> stubbings) {
    List<Invocation> matchingStubbings = new LinkedList<>();
    for (Stubbing s : stubbings) {
        if (UnusedStubbingReporting.shouldBeReported(s)
                && Objects.equals(
                        s.getInvocation().getMethod().getName(),
                        invocation.getMethod().getName())
                // If stubbing and invocation are in the same source file we assume they are in
                // the test code,
                // and we don't flag it as mismatch:
                && !Objects.equals(
                        s.getInvocation().getLocation().getSourceFile(),
                        invocation.getLocation().getSourceFile())) {
            matchingStubbings.add(s.getInvocation());
        }
    }
    return matchingStubbings;
}

So now I realize that both "Snipppet A" and "Snippet B" didn't throw the PotentialStubbingProblem exception because the invocations were in the same source file as the stubbings

The (real) question. Why does it even matter?

"We assume it's test, we don't count". Can Mockito's team elaborate on this please? I fail to grasp the overall logic of it yet

P.S.: By the way, the StackOverflow user that helped me, discovered that this way of creating a strict mock

private PathMatcher pathMatcherMock = Mockito.mock(PathMatcher.class, withSettings().strictness(org.mockito.quality.Strictness.STRICT_STUBS));

doesn't work. You may want to look into it