Mockito问题：模拟接口内部枚举的from方法失败

我有一个带@Service注解的接口，内部包含一个重载了from方法的枚举类：

public interface Service {
    enum Level {
        NO(0),
        YES(1),
        SOME(2)
        
        public final Integer value;

        Level(Integer value) {
            this.value = value;
        }

        public static Level from(Boolean value) {
            return Boolean.TRUE.equals(value) ? YES : NO;
        }

        public static Level from(Level value) {
            return value;
        }
    }
}

当前业务里，Service的getLevel()方法只返回布尔值，对应Level.YES或NO，但我需要测试SOME分支的逻辑，所以得模拟from方法的行为。

业务实现类Impl的work方法会调用Service.Level.from(service.getLevel())，并根据枚举值执行不同逻辑：

@Component
public class Impl {

    private final Service service;
    private final OtherClass otherClass;

    public void work() {
        Service.Level level = Service.Level.from(service.getLevel());
        switch (level) {
            case YES:
                otherClass.someMethod();
                break;
            case NO:
                otherClass.someOtherMethod();
                break;
            case SOME:
                otherClass.thirdMethod();
                break;
        }
        // 其他逻辑
    }
}

我的测试类用Mockito编写：

@RunWith(MockitoJUnitRunner.class)
public class ImplTest {

    @Mock
    private Service service;

    @Mock
    private OtherClass otherClass;

    @InjectMocks
    private Impl impl;

    @Test
    public void testYes() {
        doReturn(Boolean.TRUE).when(service).getLevel();

        impl.work();

        verify(otherClass).someMethod();
    }

    @Test
    public void testNo() {
        doReturn(Boolean.FALSE).when(service).getLevel();

        impl.work();

        verify(otherClass).someOtherMethod();
    }

    @Test
    public void testSome() {
        doReturn(Boolean.FALSE).when(service).getLevel();

        try (MockedStatic<Service.Level> mockedStatic = mockStatic(Service.Level.class)) {
            mockedStatic.when(() -> Service.Level.from(any(Boolean.class)))
                    .thenReturn(Service.Level.SOME);
        }
        impl.work();

        verify(otherClass).thirdMethod();
    }
}

前两个测试正常通过，但第三个测试里from方法没被成功模拟，还是返回默认的NO。

后来我尝试把MockedStatic改成类级静态变量：

private static MockedStatic<Service.Level> mockedStatic;

@BeforeClass
public static void beforeClass() {
    mockedStatic = mockStatic(Service.Level.class);
}

// 示例测试方法
@Test
public void testNo() {
    doReturn(Boolean.FALSE).when(service).getLevel();

    mockedStatic.when(() -> Service.Level.from(any(Boolean.class))).thenReturn(Service.Level.NO);

    impl.work();

    verify(otherClass).someOtherMethod();
}

结果出现ExceptionInInitializerError和NoClassDefFoundError，根源是Impl.work()的switch语句抛出NullPointerException。调试时调用Service.Level.from能返回正确枚举值，但实际方法调用失败。怀疑是Mock了Service同时静态模拟内部枚举导致的问题，但报错信息不明确，求解决办法。

1. 第一个测试失败的原因 #

你在testSome方法里，把impl.work()调用放在了try-with-resources块外面。MockedStatic通过try-with-resources管理时，代码块执行完毕后静态模拟会自动关闭，此时调用impl.work()，from方法已经恢复默认行为，所以还是返回NO。

2. 第二个方案报错的原因 #

用@BeforeClass初始化静态模拟时，模拟会在所有测试执行前生效，但Mockito的静态模拟会替换整个枚举类的静态方法实现，干扰枚举常量的类加载初始化过程，导致枚举常量无法正常初始化，最终在switch语句中访问枚举常量时抛出NPE。

正确的解决方式 #

把impl.work()调用放到try-with-resources块内部，确保静态模拟在方法执行期间生效：

@Test
public void testSome() {
    doReturn(Boolean.FALSE).when(service).getLevel();

    // 将impl.work()放在try块内，保证模拟生效
    try (MockedStatic<Service.Level> mockedStatic = mockStatic(Service.Level.class)) {
        mockedStatic.when(() -> Service.Level.from(any(Boolean.class)))
                .thenReturn(Service.Level.SOME);
        impl.work(); // 关键：方法调用在模拟生效期间
        verify(otherClass).thirdMethod();
    }
}

额外优化建议 #

如果频繁需要测试枚举分支，建议重构代码避免直接依赖静态方法，降低测试复杂度：

• 把from方法的逻辑抽成单独服务类，通过依赖注入使用，无需静态模拟。
• 给Impl类添加可配置的LevelResolver接口，默认实现调用Service.Level.from，测试时替换为自定义实现返回SOME。

重构后的Impl示例：

@Component
public class Impl {

    private final Service service;
    private final OtherClass otherClass;
    private final LevelResolver levelResolver;

    // 构造注入LevelResolver
    public Impl(Service service, OtherClass otherClass, LevelResolver levelResolver) {
        this.service = service;
        this.otherClass = otherClass;
        this.levelResolver = levelResolver;
    }

    public void work() {
        Service.Level level = levelResolver.resolve(service.getLevel());
        switch (level) {
            // 分支逻辑不变
        }
    }

    // 定义解析接口
    public interface LevelResolver {
        Service.Level resolve(Boolean value);
    }

    // 默认实现
    @Component
    public static class DefaultLevelResolver implements LevelResolver {
        @Override
        public Service.Level resolve(Boolean value) {
            return Service.Level.from(value);
        }
    }
}

测试时直接替换LevelResolver即可：

@Test
public void testSome() {
    doReturn(Boolean.FALSE).when(service).getLevel();
    // 使用自定义解析器返回SOME
    Impl.LevelResolver testResolver = (value) -> Service.Level.SOME;
    Impl testImpl = new Impl(service, otherClass, testResolver);
    
    testImpl.work();
    verify(otherClass).thirdMethod();
}

内容的提问来源于stack exchange，提问作者András Ballai