使用Spock框架高效测试Java异常处理逻辑

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

// 1. 定义一个工厂接口来抽象 SecureRandom 的创建
interface SecureRandomFactory {
    SecureRandom getInstanceStrong() throws NoSuchAlgorithmException;
    SecureRandom newSecureRandom();
}

// 2. 实现默认的工厂类，用于生产环境
class DefaultSecureRandomFactory implements SecureRandomFactory {
    @Override
    public SecureRandom getInstanceStrong() throws NoSuchAlgorithmException {
        return SecureRandom.getInstanceStrong();
    }

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

// 3. 生产代码 ClassName 接收 SecureRandomFactory 作为依赖
public class ClassName {
    private static final Logger logger = LoggerFactory.getLogger(ClassName.class);
    private final SecureRandomFactory secureRandomFactory;

    // 构造函数注入依赖
    public ClassName(SecureRandomFactory secureRandomFactory) {
        this.secureRandomFactory = secureRandomFactory;
    }

    // 默认构造函数，用于生产环境，使用默认工厂
    public ClassName() {
        this(new DefaultSecureRandomFactory());
    }

    public SecureRandom genRand() {
        try {
            return secureRandomFactory.getInstanceStrong();
        } catch (NoSuchAlgorithmException e) {
            logger.debug("Failed to get strong SecureRandom instance: {}", e.getMessage());
            // 当获取强随机数失败时，提供一个普通的 SecureRandom 作为备用
            return secureRandomFactory.newSecureRandom();
        }
    }
}

import spock.lang.Specification
import spock.lang.Subject

import java.security.SecureRandom

class ClassNameSpec extends Specification {

    // 声明被测试对象，并使用 @Subject 标注
    @Subject
    ClassName classUnderTest

    // 模拟 SecureRandomFactory
    SecureRandomFactory secureRandomFactory = Mock()
    // 模拟 Logger
    Logger mockLogger = Mock()

    def setup() {
        // 注入模拟的 factory
        classUnderTest = new ClassName(secureRandomFactory)

        // 模拟 ClassName 内部的静态 logger，使其返回我们的 mockLogger
        // 注意：Spock 直接模拟静态字段或方法需要 PowerMock 等额外插件，
        // 这里假设 logger 是通过某种方式可被访问或替换的，
        // 或者我们只关注业务逻辑而不深入测试日志本身。
        // 为了演示，我们可以假设 logger 也是可注入的，或者通过反射/PowerMock进行模拟。
        // 如果 logger 是私有静态的，且不引入 PowerMock，则其行为可能无法直接在 Spock 中模拟。
        // 对于本例，我们暂时忽略对静态 logger 的直接模拟，主要关注业务逻辑。
        // 实际项目中，通常会通过构造函数或 setter 注入 Logger 实例。
    }

    def "It returns a strong SecureRandom instance when available"() {
        given: "A strong SecureRandom instance can be obtained"
        def expectedSecureRandom = Mock(SecureRandom) // 模拟一个 SecureRandom 实例
        secureRandomFactory.getInstanceStrong() >> expectedSecureRandom // 模拟工厂方法返回预期实例

        when: "The genRand method is called"
        def result = classUnderTest.genRand()

        then: "The strong SecureRandom instance is returned"
        result == expectedSecureRandom // 验证返回结果
        1 * secureRandomFactory.getInstanceStrong() // 验证 getInstanceStrong 被调用一次
        0 * secureRandomFactory.newSecureRandom() // 验证 newSecureRandom 未被调用
    }
}

import spock.lang.Specification
import spock.lang.Subject

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

class ClassNameSpec extends Specification {

    @Subject
    ClassName classUnderTest

    SecureRandomFactory secureRandomFactory = Mock()
    Logger mockLogger = Mock() // 如果 logger 是可注入的，可以在这里模拟

    def setup() {
        classUnderTest = new ClassName(secureRandomFactory)
        // 如果 logger 是可注入的，可以在这里注入 mockLogger
        // classUnderTest.setLogger(mockLogger)
    }

    def "It returns a default SecureRandom instance if a strong one cannot be found"() {
        given: "Obtaining a strong SecureRandom instance throws an exception"
        secureRandomFactory.getInstanceStrong() >> { throw new NoSuchAlgorithmException("Test algorithm not found") }

        and: "A fallback SecureRandom instance is provided by the factory"
        def defaultSecureRandom = Mock(SecureRandom) // 模拟一个备用的 SecureRandom 实例
        secureRandomFactory.newSecureRandom() >> defaultSecureRandom

        when: "The genRand method is called"
        def result = classUnderTest.genRand()

        then: "A default SecureRandom instance is returned as fallback"
        result == defaultSecureRandom // 验证返回结果是备用实例
        1 * secureRandomFactory.getInstanceStrong() // 验证 getInstanceStrong 被调用一次
        1 * secureRandomFactory.newSecureRandom() // 验证 newSecureRandom 被调用一次

        // 如果 logger 是可模拟的，可以验证日志行为
        // 1 * mockLogger.debug("Failed to get strong SecureRandom instance: {}", "Test algorithm not found")
    }
}

public void doSomethingRisky(boolean shouldFail) throws CustomException {
    if (shouldFail) {
        throw new CustomException("Something went wrong!");
    }
    // ...
}

import spock.lang.Specification

class MyServiceSpec extends Specification {

    MyService service = new MyService() // 假设 MyService 包含 doSomethingRisky

    def "It throws CustomException when shouldFail is true"() {
        when:
        service.doSomethingRisky(true)

        then:
        CustomException e = thrown() // 验证抛出了 CustomException
        e.message == "Something went wrong!" // 验证异常信息
    }

    def "It does not throw exception when shouldFail is false"() {
        when:
        service.doSomethingRisky(false)

        then:
        noExceptionThrown() // 验证没有抛出任何异常
    }
}