Spock框架中异常处理逻辑的单元测试最佳实践

import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Random;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyRandomGenerator {
    private static final Logger logger = LoggerFactory.getLogger(MyRandomGenerator.class);

    public Random genRand() {
        try {
            return SecureRandom.getInstanceStrong();
        } catch (NoSuchAlgorithmException e) {
            logger.debug("Failed to get strong SecureRandom: {}", e.getMessage());
            return new SecureRandom();
        }
    }
}

import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Random;

interface SecureRandomProvider {
    /**
     * Attempts to get a strong SecureRandom instance.
     * @throws NoSuchAlgorithmException if a strong algorithm is not available.
     */
    SecureRandom getStrongInstance() throws NoSuchAlgorithmException;

    /**
     * Gets a default SecureRandom instance.
     */
    SecureRandom getDefaultInstance();
}

import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;

class DefaultSecureRandomProvider implements SecureRandomProvider {
    @Override
    public SecureRandom getStrongInstance() throws NoSuchAlgorithmException {
        return SecureRandom.getInstanceStrong();
    }

    @Override
    public SecureRandom getDefaultInstance() {
        return new SecureRandom();
    }
}

import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Random;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyRandomGenerator {
    private static final Logger logger = LoggerFactory.getLogger(MyRandomGenerator.class);
    private final SecureRandomProvider secureRandomProvider;

    // 构造函数注入，便于测试
    public MyRandomGenerator(SecureRandomProvider secureRandomProvider) {
        this.secureRandomProvider = secureRandomProvider;
    }

    // 默认构造函数，用于生产环境
    public MyRandomGenerator() {
        this(new DefaultSecureRandomProvider());
    }

    public Random genRand() {
        try {
            return secureRandomProvider.getStrongInstance();
        } catch (NoSuchAlgorithmException e) {
            logger.debug("Failed to get strong SecureRandom: {}", e.getMessage());
            return secureRandomProvider.getDefaultInstance(); // 使用provider获取默认实例
        }
    }
}

import spock.lang.Specification
import spock.lang.Subject
import java.security.NoSuchAlgorithmException
import java.security.SecureRandom
import java.util.Random
import org.slf4j.Logger // 假设使用SLF4J

class MyRandomGeneratorSpec extends Specification {

    // 模拟SecureRandomProvider依赖
    SecureRandomProvider mockSecureRandomProvider = Mock()
    // 假设logger也可以被注入或通过其他方式模拟，这里暂不深入模拟静态logger
    // Logger mockLogger = Mock()

    // 标记被测试的类实例，并注入模拟的Provider
    @Subject
    MyRandomGenerator generator = new MyRandomGenerator(mockSecureRandomProvider)

    // 测试场景一：try 块成功执行
    def "It returns a strong SecureRandom instance when available"() {
        given: "SecureRandomProvider successfully returns a strong instance"
        def expectedStrongRandom = new SecureRandom() // 创建一个模拟的SecureRandom实例
        mockSecureRandomProvider.getStrongInstance() >> expectedStrongRandom // 桩化方法调用

        when: "genRand() method is called"
        Random result = generator.genRand()

        then: "It returns the strong SecureRandom instance"
        result == expectedStrongRandom
        // 验证 getDefaultInstance() 方法没有被调用，确保没有进入catch块
        0 * mockSecureRandomProvider.getDefaultInstance()
    }

    // 测试场景二：catch 块被触发
    def "It returns a default SecureRandom instance when strong instance is not available"() {
        given: "SecureRandomProvider throws NoSuchAlgorithmException"
        // 桩化 getStrongInstance() 方法，使其抛出 NoSuchAlgorithmException
        mockSecureRandomProvider.getStrongInstance() >> { throw new NoSuchAlgorithmException("No strong algorithm") }

        and: "SecureRandomProvider returns a default instance as fallback"
        def expectedDefaultRandom = new SecureRandom() // 创建一个模拟的默认SecureRandom实例
        mockSecureRandomProvider.getDefaultInstance() >> expectedDefaultRandom // 桩化回退方法调用

        when: "genRand() method is called"
        Random result = generator.genRand()

        then: "It catches the exception and returns the default SecureRandom instance"
        result == expectedDefaultRandom
        // 注意：这里不使用 `thrown(NoSuchAlgorithmException)`，
        // 因为 NoSuchAlgorithmException 在 genRand() 内部被捕获并处理了。
        // 方法 genRand() 本身并没有向外抛出这个异常。
        // 如果需要验证日志被调用，且 logger 是可模拟的依赖，可以添加：
        // 1 * mockLogger.debug(_)
    }
}