背景

當我們進行單元測試的時候，經(jīng)常會用到 Mockito 對接口進行打樁測試。

一般我們會想下面這個測試用例一樣，對接口同一個類型的參數(shù)進行Mock返回結果。

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

public class Test {

    @Test
    public void test() {
        
        // mock一個對象
        String s = Mockito.mock(String.class);
        // 打樁 對方法傳入任何對應類型的參數(shù)，都返回指定的值
        Mockito.when(s.equals(Mockito.any(String.class))).thenReturn(true);
        
        // 當然也可以這樣，返回多次不同的結果，但是結果順序要和測試情況一一對應
        Mockito.when(s.compareTo(Mockito.any(String.class))).thenReturn(-1, 0, 1);
    }
}

這樣子雖然能滿足大部分情況，但是某些特定情況需要根據(jù)不同條件返回不同結果，而且Mockito.when中傳入固定值的話又會報錯，那我們應該怎么做呢？

解決

我們可以用 Java 的 Predicate 接口來實現(xiàn)。

Maven依賴如下：

<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.test</groupId>
    <artifactId>test-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>test-demo</name>

    <properties>
        <java.version>17</java.version>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring-boot.version>3.4.2</spring-boot.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <version>${spring-boot.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>${spring-boot.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>
	

Java 測試代碼如下：

package com.test.demo;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentMatcher;
import org.mockito.Mockito;

public class Test {
    
    @Test
    public void test() {
       
        String s = Mockito.mock(String.class);

        // 注意：這兒是接口對應入?yún)⒌男畔?        // null 入?yún)闆r
        Predicate<String> predicateNull = new Predicate<String>() {
            @Override
            public boolean test(String string) {
                return string == null;
            }
        };

        Mockito.when(s.equals(predicateNull)).thenReturn(true);

        // a 入?yún)闆r
        Predicate<String> predicateA = new Predicate<String>() {
            @Override
            public boolean test(String string) {
                if ("a".equals(string)) {
                    return true;
                }
                return false;
            }
        };

        Mockito.when(s.equals(predicateA)).thenReturn(false);

        // b 入?yún)闆r
        Predicate<String> predicateB = new Predicate<String>() {
            @Override
            public boolean test(String string) {
                if ("b".equals(string)) {
                    return true;
                }
                return false;
            }
        };
        
        Mockito.when(s.equals(predicateB)).thenReturn(true);

    }
    
    
    /**
     * 參數(shù)匹配器
     * @param argument
     * @return
     * @param <T>
     */
    public <T> T argumentMatcher (Predicate<T> argument) {
        return Mockito.argThat(new ArgumentMatcher<T>() {
            @Override
            public boolean matches(T object) {
                // 這里面也可以自定義一些其他判定條件， 比如判空或者其他
                
                return argument.test(object);
            }
        });
    }
}