「译」JUnit 5 系列：条件测试

public interface ContainerExecutionCondition extends Extension {
 
    /**     * Evaluate this condition for the supplied ContainerExtensionContext.     *     * An enabled result indicates that the container should be executed;     * whereas, a disabled result indicates that the container should not     * be executed.     *     * @param context the current ContainerExtensionContext; never null     * @return the result of evaluating this condition; never null     */
    ConditionEvaluationResult evaluate(ContainerExtensionContext context);
 
}
 
public interface TestExecutionCondition extends Extension {
 
    /**     * Evaluate this condition for the supplied TestExtensionContext.     *     * An enabled result indicates that the test should be executed;     * whereas, a disabled result indicates that the test should not     * be executed.     *     * @param context the current TestExtensionContext; never null     * @return the result of evaluating this condition; never null     */
    ConditionEvaluationResult evaluate(TestExtensionContext context);
 
}

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@ExtendWith(@DisabledCondition.class)
public @interface Disabled { }

public class DisabledCondition
        implements ContainerExecutionCondition, TestExecutionCondition {
 
    private static final ConditionEvaluationResult ENABLED =
            ConditionEvaluationResult.enabled("@Disabled is not present");
 
    @Override
    public ConditionEvaluationResult evaluate(
            ContainerExtensionContext context) {
        return evaluateIfAnnotated(context.getElement());
    }
 
    @Override
    public ConditionEvaluationResult evaluate(
            TestExtensionContext context) {
        return evaluateIfAnnotated(context.getElement());
    }
 
    private ConditionEvaluationResult evaluateIfAnnotated(
            Optional<AnnotatedElement> element) {
        Optional<Disabled> disabled = AnnotationUtils
                .findAnnotation(element, Disabled.class);
 
        if (disabled.isPresent())
            return ConditionEvaluationResult
                    .disabled(element + " is @Disabled");
 
        return ENABLED;
    }

}

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@ExtendWith(OsCondition.class)
public @interface DisabledOnOs {
 
    OS[] value() default {};
 
}

public class OsCondition 
        implements ContainerExecutionCondition, TestExecutionCondition {
 
    // both `evaluate` methods forward to `evaluateIfAnnotated` as above
 
    private ConditionEvaluationResult evaluateIfAnnotated(
            Optional<AnnotatedElement> element) {
        Optional<DisabledOnOs> disabled = AnnotationUtils
                .findAnnotation(element, DisabledOnOs.class);
 
        if (disabled.isPresent())
            return disabledIfOn(disabled.get().value());
 
        return ENABLED;
    }
 
    private ConditionEvaluationResult disabledIfOn(OS[] disabledOnOs) {
        OS os = OS.determine();
        if (Arrays.asList(disabledOnOs).contains(os))
            return ConditionEvaluationResult
                    .disabled("Test is disabled on " + os + ".");
        else
            return ConditionEvaluationResult
                    .enabled("Test is not disabled on " + os + ".");
    }

}

@Test
@DisabledOnOs(OS.WINDOWS)
voiddoesNotRunOnWindows() {
    assertTrue(false);
}

@TestExceptOnOs(OS.WINDOWS)
voiddoesNotRunOnWindowsEither() {
    assertTrue(false);
}

@Retention(RetentionPolicy.RUNTIME)
@Test
@DisabledOnOs(/* 通过某种方式取得注解下的 `value` 值 */)
public @interface TestExceptOnOs {
 
    OS[] value() default {};
 
}

@Retention(RetentionPolicy.RUNTIME)
@ExtendWith(OsCondition.class)
@Test
public @interface TestExceptOnOs {
 
    OS[] value() default {};
 
}

private ConditionEvaluationResult evaluateIfAnnotated(
        Optional<Annotatedelement> element) {
    Optional<DisabledOnOs> disabled = AnnotationUtils
        .findAnnotation(element, DisabledOnOs.class);
    if (disabled.isPresent()) 
        return disabledIfOn(disabled.get().value());
        
    Optional<TestExceptOnOs> testExcept = AnnotationUtils
        .findAnnotation(element, TestExceptOnOs.class);
    if (testExcept.isPresent()) 
        return disabledIfOn(testExcept.get().value());
            
    return ConditionEvaluationResult.enabled("");
}

@TestOn(WINDOWS)
voiddoesNotRunOnWindoesEither() {
    assertTrue(false);
}

/** * TestExecutionExceptionHandler defines the API for Extensions that wish to react to thrown exceptions in tests. *  * [ ... ] */
public interface TestExecutionExceptionHandler extends ExtensionPoint { 
    /**     * Handle the supplied throwable.     *      * Implementors must perform one of the following.     *      * - Swallow the supplied throwable, thereby preventing propagation     * - Rethrow the incoming throwable as is      * - Throw a new exception, potenially wrapping the supplied throwable      *       * [ ... ]     */
    voidhandleTestExecutionException(
        TestExtensionContext context, Throwable throwable) 
        throws Throwable;    
}

private static final Namespece NAMESPACE = Namespace
    .of("org", "codefx", "CollectExceptions");
private static final String THROWN_EXCEPTIONS_KEY = "THROWN_EXCEPTION_KEY";

@SuppressWarnings("unchecked")
privatestatic Set<Exception> getThrown(ExtensionContext context) {
    ExtensionContext containerContext = getAncestorContainerContext(context)
        .orElseThrow(IllegalStateException::new);
    retrun (Set<Exception>) containerContext
        .getStore(NAMESPACE)
        .getOrComputeIfAbsent(
            THROWN_EXCEPTIONS_KEY,
            ignoredKey -> new HashSet<>());
}

privatestatic Optional<ExtensionContext> getAncestorContainerContext(
        ExtensionContext context) {
    Optional<ExtensionContext> containerContext = Optional.of(context);
    while (containerContext.isPresent()) 
            && !(containerContext.get() instanceof ContainerExtenstionContext)) 
        containerContext = containerContext.get().getParent();
    return containerContext;
}

@Override
publicvoidhandleException(TestExtensionContext context, Throwable throwable) 
        throws Throwable {
    if (throwable instanceof Exception) {
        getThrown(context).add((Exception) throwable);
    throw throwable;

publicstatic Stream<Exception> getThrownExceptions(
        ExtensionContext context) {
    return getThrown(context).stream();
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@ExtendWith(DisabledIfTestFailedCondition.class)
public @interface DisabledIfTestFailedWith {

    Class <? extends Exception>[] value() default {};

}

private ConditionEvaluationResult disableIfExceptionWasThrown(
        TestExtensionContext context,
        Class<? extends Exception>[] exceptions) {
    return Arrays.stream(exceptions)
            .filter(ex -> wasThrown(context, ex))
            .findAny().
            .map(thrown -> ConditionEvaluationResult.disabled(
                    thrown.getSimpleName() + "was thrown."))
            .orElseGet(() -> ConditionEvaluationResult.enabled(""));
}

privatestaticbooleanwasThrown(
        TestExtensionContext context, Class<? extends Exception> exception) {
    return CollectExceptionExtension.getThrownExceptions(context)
            .map(Object::getClass)
            .anyMatch(exception::isAssignableFrom);
}

@CollectExceptions
class DisabledIfFailsTest {
    
    private static boolean failedFirst = false;
    
    @Test
    voidthrowException() {
        System.out.println("I failed!");
        failedFirst = true;
        throw new RuntimeException();
    }
    
    @Test
    @DisabledIfTestFailedWith(RuntimeException.class)
    voiddisableIfOtherFailedFirst() {
        System.out.println("Nobody failed yet! (Right?)");
        assertFalse(failedFirst);
    }
    
}