Java中随机数生成方法的可测试性：使用依赖注入与DoubleSupplier

Mockito cannot mock this class: class java.util.Random.
Mockito can only mock non-private & non-final classes.

public String foo() {
   Random random = new Random();
   String word = ""; // 初始化word变量
   if(random.nextDouble() <= 0.5) {
      word += "Hello";
   }
   if(random.nextDouble() <= 0.7) { // 注意这里可能需要更精细的逻辑来避免重复调用或累加
      word += "World";
   }
   return word;
}

import com.google.common.annotations.VisibleForTesting; // 可选，用于文档化

import java.util.Random;
import java.util.function.DoubleSupplier;

public class MyRandomService {

    // 生产环境调用的方法
    public String foo() {
        Random random = new Random();
        return foo(random::nextDouble); // 将Random::nextDouble作为DoubleSupplier传递
    }

    // 测试专用或包私有的重载方法
    @VisibleForTesting // Guava库中的注解，表示此方法可见性是为了测试
    String foo(DoubleSupplier randomDoubleSupplier) {
        String word = ""; // 确保word变量被初始化

        // 第一次获取随机数
        double firstRandom = randomDoubleSupplier.getAsDouble();
        if(firstRandom <= 0.5) {
            word += "Hello";
        }

        // 第二次获取随机数，如果逻辑需要两次独立的随机数
        // 注意：原始问题中的示例在同一条件下调用了两次nextDouble()，这可能不是预期行为。
        // 如果需要两次独立随机数，DoubleSupplier应被调用两次。
        // 如果是基于第一次结果的累加条件，则不应再次调用。
        // 这里假设是两次独立的判断，因此再次调用。
        double secondRandom = randomDoubleSupplier.getAsDouble();
        if(secondRandom <= 0.7) {
            word += "World";
        }
        return word;
    }
}

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

import java.util.function.DoubleSupplier;

import static org.mockito.Mockito.when;

public class MyRandomServiceTest {

    @Test
    void testFooReturnsWorld() {
        MyRandomService service = new MyRandomService();

        // 模拟DoubleSupplier
        DoubleSupplier mockDoubleSupplier = Mockito.mock(DoubleSupplier.class);

        // 设置mockDoubleSupplier在第一次调用时返回0.6，第二次调用时返回0.6 (或任何满足条件的值)
        // 根据foo方法的实现，如果条件是 <= 0.5 和 <= 0.7，那么0.6会跳过第一个条件，满足第二个条件。
        // 如果两次调用nextDouble()是独立的，则需要设置两次返回值。
        when(mockDoubleSupplier.getAsDouble())
                .thenReturn(0.6) // 第一次调用
                .thenReturn(0.6); // 第二次调用

        // 调用重载的foo方法进行测试
        String result = service.foo(mockDoubleSupplier);

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

        // 验证getAsDouble()方法被调用了两次
        Mockito.verify(mockDoubleSupplier, Mockito.times(2)).getAsDouble();
    }

    @Test
    void testFooReturnsHello() {
        MyRandomService service = new MyRandomService();
        DoubleSupplier mockDoubleSupplier = Mockito.mock(DoubleSupplier.class);

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

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

    @Test
    void testFooReturnsHelloWorld() {
        MyRandomService service = new MyRandomService();
        DoubleSupplier mockDoubleSupplier = Mockito.mock(DoubleSupplier.class);

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

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

    @Test
    void testFooReturnsEmptyString() {
        MyRandomService service = new MyRandomService();
        DoubleSupplier mockDoubleSupplier = Mockito.mock(DoubleSupplier.class);

        // 设置mockDoubleSupplier在第一次调用时返回0.8，第二次调用时返回0.8
        when(mockDoubleSupplier.getAsDouble())
                .thenReturn(0.8) // 第一次调用，不满足 <= 0.5
                .thenReturn(0.8); // 第二次调用，不满足 <= 0.7

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