Java中测试随机数依赖：使用DoubleSupplier进行依赖注入

public class MyService {
    public String foo() {
        Random random = new Random();
        String word = "";

        if (random.nextDouble() <= 0.5) {
            word += "Hello";
        }
        if (random.nextDouble() <= 0.7) { // 注意：这里会再次生成随机数
            word += "World";
        }
        return word;
    }
}

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import static org.mockito.Mockito.when;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class MyServiceTest {

    @Test
    public void testFooReturnsWorld() {
        // 尝试直接模拟 Random.class
        // Random randomMock = Mockito.mock(Random.class); // 这行代码可能会导致问题
        // when(randomMock.nextDouble()).thenReturn(0.6);
        // ... 如何将这个mock注入到foo()方法中？
        // Assertions.assertEquals("World", new MyService().foo());
    }
}

import java.util.Random;
import java.util.function.DoubleSupplier;
import com.google.common.annotations.VisibleForTesting; // 可选，用于标记测试可见性

public class MyService {

    // 原始方法，用于生产环境，内部创建Random并调用重载方法
    public String foo() {
        Random random = new Random();
        // 使用方法引用将nextDouble()方法作为DoubleSupplier传递
        return foo(random::nextDouble);
    }

    /**
     * @VisibleForTesting 注解表明此方法主要为测试目的而存在，通常是包私有或保护的。
     * 接收一个DoubleSupplier作为随机数源，增强了方法的可测试性。
     */
    @VisibleForTesting // 如果使用Guava库，可以添加此注解
    String foo(DoubleSupplier randomDoubleSupplier) {
        String word = "";

        // 使用传入的DoubleSupplier获取随机数
        if (randomDoubleSupplier.getAsDouble() <= 0.5) {
            word += "Hello";
        }
        // 注意：这里会再次调用getAsDouble()，模拟原始代码的行为
        if (randomDoubleSupplier.getAsDouble() <= 0.7) {
            word += "World";
        }
        return word;
    }
}

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import java.util.function.DoubleSupplier;
import static org.mockito.Mockito.when;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class MyServiceTest {

    private MyService myService = new MyService(); // 实例化被测试服务

    @Test
    public void testFooReturnsWorldWhenRandomIs0_6() {
        // 1. 创建一个DoubleSupplier的模拟对象
        DoubleSupplier mockDoubleSupplier = Mockito.mock(DoubleSupplier.class);

        // 2. 定义模拟对象的行为：第一次调用返回0.6，第二次调用返回一个不影响结果的值
        // 注意：根据foo方法的逻辑，它会调用两次getAsDouble()
        when(mockDoubleSupplier.getAsDouble())
                .thenReturn(0.6) // 第一次调用：0.6 > 0.5，不进入"Hello"分支
                .thenReturn(0.1); // 第二次调用：0.1 <= 0.7，进入"World"分支。这个值是随意设置的，只要不满足0.5的条件即可。
                                  // 如果只关心第二次判断，可以设置为0.6，但为了模拟两次调用，此处演示不同值。
                                  // 实际上，如果测试目标是0.6，那么第一次调用0.6，第二次调用0.6会更符合预期。
                                  // 让我们调整为更精确的模拟：
                                  // when(mockDoubleSupplier.getAsDouble())
                                  //         .thenReturn(0.6) // 第一次调用，用于 if(randomDoubleSupplier.getAsDouble() <= 0.5)
                                  //         .thenReturn(0.6); // 第二次调用，用于 if(randomDoubleSupplier.getAsDouble() <= 0.7)

        // 重新思考一下，原问题中是两次独立的 random.nextDouble() 调用，
        // 且期望0.6能使得结果是"World"。
        // 第一次调用 0.6 不满足 <= 0.5
        // 第二次调用 0.6 满足 <= 0.7
        // 所以，两次调用都返回0.6是合理的。
        when(mockDoubleSupplier.getAsDouble())
                .thenReturn(0.6) // 第一次调用
                .thenReturn(0.6); // 第二次调用

        // 3. 调用重载的foo方法，传入模拟对象
        String result = myService.foo(mockDoubleSupplier);

        // 4. 验证结果
        assertEquals("World", result);

        // 5. 验证mock对象的方法是否被正确调用
        Mockito.verify(mockDoubleSupplier, Mockito.times(2)).getAsDouble();
    }

    @Test
    public void testFooReturnsHelloWorldWhenRandomIs0_4And0_6() {
        DoubleSupplier mockDoubleSupplier = Mockito.mock(DoubleSupplier.class);

        // 第一次调用返回0.4 (满足 <= 0.5)
        // 第二次调用返回0.6 (满足 <= 0.7)
        when(mockDoubleSupplier.getAsDouble())
                .thenReturn(0.4)
                .thenReturn(0.6);

        String result = myService.foo(mockDoubleSupplier);
        assertEquals("HelloWorld", result);
        Mockito.verify(mockDoubleSupplier, Mockito.times(2)).getAsDouble();
    }

    @Test
    public void testFooReturnsEmptyWhenRandomIs0_8() {
        DoubleSupplier mockDoubleSupplier = Mockito.mock(DoubleSupplier.class);

        // 两次调用都返回0.8 (不满足任何条件)
        when(mockDoubleSupplier.getAsDouble())
                .thenReturn(0.8)
                .thenReturn(0.8);

        String result = myService.foo(mockDoubleSupplier);
        assertEquals("", result);
        Mockito.verify(mockDoubleSupplier, Mockito.times(2)).getAsDouble();
    }
}