org.junit.platform.commons.util.AnnotationUtils Java Examples

@Override
public ConditionEvaluationResult evaluateExecutionCondition(
        ExtensionContext context) {

    Optional<AnnotatedElement> element = context.getElement();
    ConditionEvaluationResult out = ConditionEvaluationResult
            .enabled("@DisabledOnOs is not present");

    Optional<DisabledOnOs> disabledOnOs = AnnotationUtils
            .findAnnotation(element, DisabledOnOs.class);

    if (disabledOnOs.isPresent()) {
        Os myOs = Os.determine();
        if (Arrays.asList(disabledOnOs.get().value()).contains(myOs)) {
            out = ConditionEvaluationResult
                    .disabled("Test is disabled on " + myOs);
        } else {
            out = ConditionEvaluationResult
                    .enabled("Test is not disabled on " + myOs);
        }
    }

    System.out.println("--> " + out.getReason().get());
    return out;
}
 

@Override
public void beforeAll(final ExtensionContext extensionContext) {
    final HttpApi config =
            AnnotationUtils.findAnnotation(extensionContext.getElement(), HttpApi.class).orElse(null);
    if (config != null) {
        setGlobalProxyConfiguration(config.globalProxyConfiguration());
        setLogLevel(config.logLevel());
        setPort(config.port());
        newInstance(config.responseLocator(), ResponseLocator.class).ifPresent(this::setResponseLocator);
        newInstance(config.headerFilter(), Predicate.class).ifPresent(this::setHeaderFilter);
        newInstance(config.executor(), Executor.class).ifPresent(this::setExecutor);
        newInstance(config.sslContext(), Supplier.class)
                .map(s -> SSLContext.class.cast(s.get()))
                .ifPresent(this::setSslContext);
        setSkipProxyHeaders(config.skipProxyHeaders());
        if (config.useSsl()) {
            activeSsl();
        }
    }
    extensionContext.getStore(NAMESPACE).put(HttpApiHandler.class.getName(), this);
    final HandlerImpl<JUnit5HttpApi> handler = new HandlerImpl<>(this, null, null);
    extensionContext.getStore(NAMESPACE).put(HandlerImpl.class.getName(), handler);
    handler.start();
}
 

@Override
public void beforeEach(final ExtensionContext extensionContext) {
    // test name
    final ResponseLocator responseLocator = getResponseLocator();
    if (!DefaultResponseLocator.class.isInstance(responseLocator)) {
        return;
    }
    final String test = extensionContext.getTestMethod().map(m -> {
        final String displayName = sanitizeDisplayName(extensionContext.getDisplayName());
        return AnnotationUtils
                .findAnnotation(m, HttpApiName.class)
                .map(HttpApiName::value)
                .map(it -> it.replace("${class}", m.getDeclaringClass().getName()))
                .map(it -> it.replace("${method}", m.getName()))
                .map(it -> it.replace("${displayName}", displayName))
                .orElseGet(() -> m.getDeclaringClass().getName() + "_" + m.getName()
                        + (displayName.equals(m.getName()) ? "" : ("_" + displayName)));
    }).orElse(null);
    DefaultResponseLocator.class.cast(responseLocator).setTest(test);
}
 

private DBUnitConfig resolveDbUnitConfig(Class callbackAnnotation, Method callbackMethod, Class testClass) {
    Optional<DBUnit> dbUnitAnnotation = AnnotationUtils.findAnnotation(callbackMethod, DBUnit.class);
    if (!dbUnitAnnotation.isPresent()) {
        dbUnitAnnotation = AnnotationUtils.findAnnotation(testClass, DBUnit.class);
    }
    if (!dbUnitAnnotation.isPresent()) {
        Optional<Method> superclassCallbackMethod = findSuperclassCallbackMethod(testClass, callbackAnnotation);
        if (superclassCallbackMethod.isPresent()) {
            dbUnitAnnotation = AnnotationUtils.findAnnotation(superclassCallbackMethod.get(), DBUnit.class);
        }
    }
    if (!dbUnitAnnotation.isPresent() && testClass.getSuperclass() != null) {
        dbUnitAnnotation = AnnotationUtils.findAnnotation(testClass.getSuperclass(), DBUnit.class);
    }
    return dbUnitAnnotation.isPresent() ? DBUnitConfig.from(dbUnitAnnotation.get()) : DBUnitConfig.fromGlobalConfig();
}
 

@Override
public ConditionEvaluationResult evaluateExecutionCondition(
        ExtensionContext context) {

    Optional<AnnotatedElement> element = context.getElement();
    ConditionEvaluationResult out = ConditionEvaluationResult
            .enabled("@DisabledOnOs is not present");

    Optional<DisabledOnOs> disabledOnOs = AnnotationUtils
            .findAnnotation(element, DisabledOnOs.class);

    if (disabledOnOs.isPresent()) {
        Os myOs = Os.determine();
        if (Arrays.asList(disabledOnOs.get().value()).contains(myOs)) {
            out = ConditionEvaluationResult
                    .disabled("Test is disabled on " + myOs);
        } else {
            out = ConditionEvaluationResult
                    .enabled("Test is not disabled on " + myOs);
        }
    }

    System.out.println("--> " + out.getReason().get());
    return out;
}
 

private void executeExpectedDataSetForCallback(ExtensionContext extensionContext, Class callbackAnnotation, Method callbackMethod) throws DatabaseUnitException {
    Class testClass = extensionContext.getTestClass().get();
    // get ExpectedDataSet annotation, if any
    Optional<ExpectedDataSet> expectedDataSetAnnotation = AnnotationUtils.findAnnotation(callbackMethod, ExpectedDataSet.class);
    if (!expectedDataSetAnnotation.isPresent()) {
        Optional<Method> superclassCallbackMethod = findSuperclassCallbackMethod(testClass, callbackAnnotation);
        if (superclassCallbackMethod.isPresent()) {
            expectedDataSetAnnotation = AnnotationUtils.findAnnotation(superclassCallbackMethod.get(), ExpectedDataSet.class);
        }
    }
    if (expectedDataSetAnnotation.isPresent()) {
        ExpectedDataSet expectedDataSet = expectedDataSetAnnotation.get();
        // Resolve DBUnit config from annotation or file
        DBUnitConfig dbUnitConfig = resolveDbUnitConfig(callbackAnnotation, callbackMethod, testClass);
        // Verify expected dataset
        final String executorId = getExecutorId(extensionContext, null);
        ConnectionHolder connectionHolder = getTestConnection(extensionContext, executorId);
        DataSetExecutor dataSetExecutor = DataSetExecutorImpl.instance(executorId, connectionHolder, dbUnitConfig);
        dataSetExecutor.compareCurrentDataSetWith(
                new DataSetConfig(expectedDataSet.value()).disableConstraints(true).datasetProvider(expectedDataSet.provider()),
                expectedDataSet.ignoreCols(),
                expectedDataSet.replacers(),
                expectedDataSet.orderBy(),
                expectedDataSet.compareOperation());
    }
}
 

private void executeDataSetForCallback(ExtensionContext extensionContext, Class callbackAnnotation, Method callbackMethod) {
    Class testClass = extensionContext.getTestClass().get();
    // get DataSet annotation, if any
    Optional<DataSet> dataSetAnnotation = AnnotationUtils.findAnnotation(callbackMethod, DataSet.class);
    if (!dataSetAnnotation.isPresent()) {
        Optional<Method> superclassCallbackMethod = findSuperclassCallbackMethod(testClass, callbackAnnotation);
        if (superclassCallbackMethod.isPresent()) {
            dataSetAnnotation = AnnotationUtils.findAnnotation(superclassCallbackMethod.get(), DataSet.class);
        }
    }
    if (dataSetAnnotation.isPresent()) {
        clearEntityManager();
        DBUnitConfig dbUnitConfig = resolveDbUnitConfig(callbackAnnotation, callbackMethod, testClass);
        DataSet dataSet;
        if (dbUnitConfig.isMergeDataSets()) {
            Optional<DataSet> classLevelDataSetAnnotation = AnnotationUtils.findAnnotation(testClass, DataSet.class);
            dataSet = resolveDataSet(dataSetAnnotation, classLevelDataSetAnnotation);
        } else {
            dataSet = dataSetAnnotation.get();
        }
        // Execute dataset
        final String executorId = getExecutorId(extensionContext, dataSet);
        ConnectionHolder connectionHolder = getTestConnection(extensionContext, executorId);
        DataSetExecutor dataSetExecutor = DataSetExecutorImpl.instance(executorId, connectionHolder, dbUnitConfig);
        dataSetExecutor.createDataSet(new DataSetConfig().from(dataSet));
    }
}
 

@Override
public Stream<TestTemplateInvocationContext> provideTestTemplateInvocationContexts(ExtensionContext context) {
    Method testMethod = context.getRequiredTestMethod();

    return AnnotationUtils.findAnnotation(testMethod, testAnnotationClass)
            .map(annotation -> provideInvocationContexts(context, annotation))
            .orElseThrow(() -> new ExtensionConfigurationException(String.format(
                    "Could not find annotation '%s' on test method '%s'.", testAnnotationClass, testMethod)));
}
 

private Optional<Testcontainers> findTestcontainers(ExtensionContext context) {
    Optional<ExtensionContext> current = Optional.of(context);
    while (current.isPresent()) {
        Optional<Testcontainers> testcontainers = AnnotationUtils.findAnnotation(current.get().getRequiredTestClass(), Testcontainers.class);
        if (testcontainers.isPresent()) {
            return testcontainers;
        }
        current = current.get().getParent();
    }
    return Optional.empty();
}
 

private boolean videoDisabled(Method testMethod) {
  Optional<com.automation.remarks.video.annotations.Video> video = AnnotationUtils.findAnnotation(testMethod, com.automation.remarks.video.annotations.Video.class);

  return video.map(v -> !videoEnabled(v))
          .orElseGet(() -> true);

  //return !video.isPresent() && !videoEnabled(video.get());
}
 

@Override
public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) {

	Optional<RequiresVaultVersion> optional = AnnotationUtils.findAnnotation(context.getElement(),
			RequiresVaultVersion.class);

	if (!optional.isPresent()) {
		return ENABLED_BY_DEFAULT;
	}

	ExtensionContext.Store store = context.getStore(VAULT);

	Version runningVersion = store.getOrComputeIfAbsent(Version.class, versionClass -> {

		VaultInitializer initializer = new VaultInitializer();
		initializer.initialize();
		return initializer.prepare().getVersion();
	}, Version.class);

	RequiresVaultVersion requiredVersion = optional.get();

	Version required = Version.parse(requiredVersion.value());

	if (runningVersion.isGreaterThanOrEqualTo(required)) {
		return ConditionEvaluationResult
				.enabled(String.format("@VaultVersion check passed current Vault version is %s", runningVersion));
	}

	return ConditionEvaluationResult.disabled(String.format(
			"@VaultVersion requires since version %s, current Vault version is %s", required, runningVersion));
}
 

private DataSet resolveDataSet(Optional<DataSet> methodLevelDataSet,
                               Optional<DataSet> classLevelDataSet) {
    if (classLevelDataSet.isPresent()) {
        return com.github.database.rider.core.util.AnnotationUtils.mergeDataSetAnnotations(classLevelDataSet.get(), methodLevelDataSet.get());
    } else {
        return methodLevelDataSet.get();
    }
}
 

@Override
public Stream<TestTemplateInvocationContext> provideTestTemplateInvocationContexts(ExtensionContext context) {
    RegistryServiceTest rst = AnnotationUtils.findAnnotation(context.getRequiredTestMethod(), RegistryServiceTest.class)
                                             .orElseThrow(IllegalStateException::new); // should be there

    String registryUrl = TestUtils.getRegistryUrl(rst);

    ExtensionContext.Store store = context.getStore(ExtensionContext.Namespace.GLOBAL);

    List<TestTemplateInvocationContext> invocationCtxts = new ArrayList<>();

    if (testRegistryClient(REGISTRY_CLIENT_CREATE)) {
        RegistryServiceWrapper plain = store.getOrComputeIfAbsent(
                "plain_client",
                k -> new RegistryServiceWrapper(k, REGISTRY_CLIENT_CREATE, registryUrl),
                RegistryServiceWrapper.class
            );
        invocationCtxts.add(new RegistryServiceTestTemplateInvocationContext(plain, context.getRequiredTestMethod()));
    }

    if (testRegistryClient(REGISTRY_CLIENT_CACHED)) {
        RegistryServiceWrapper cached = store.getOrComputeIfAbsent(
                "cached_client",
                k -> new RegistryServiceWrapper(k, REGISTRY_CLIENT_CACHED, registryUrl),
                RegistryServiceWrapper.class
            );
        invocationCtxts.add(new RegistryServiceTestTemplateInvocationContext(cached, context.getRequiredTestMethod()));
    }

    return invocationCtxts.stream();
}
 

private static String getConfiguredDataSourceBeanName(ExtensionContext extensionContext) {
    Optional<Method> testMethod = extensionContext.getTestMethod();
    if (testMethod.isPresent()) {
        Optional<DBRider> annotation = AnnotationUtils.findAnnotation(testMethod.get(), DBRider.class);
        if (!annotation.isPresent()) {
            annotation = AnnotationUtils.findAnnotation(extensionContext.getRequiredTestClass(), DBRider.class);
        }
        return annotation.map(DBRider::dataSourceBeanName).orElse(EMPTY_STRING);
    } else {
        return EMPTY_STRING;
    }
}
 

private Optional<DataSet> findDataSetAnnotation(ExtensionContext extensionContext) {
    Optional<Method> testMethod = extensionContext.getTestMethod();
    if (testMethod.isPresent()) {
        Optional<DataSet> annDataSet = AnnotationUtils.findAnnotation(testMethod.get(), DataSet.class);
        if (!annDataSet.isPresent()) {
            annDataSet = AnnotationUtils.findAnnotation(extensionContext.getRequiredTestClass(), DataSet.class);
        }
        return annDataSet;
    } else {
        return Optional.empty();
    }
}
 

@Override
public void beforeAll(final ExtensionContext extensionContext) throws Exception {
    temporaryFolderExtension.beforeAll(extensionContext);
    root = TemporaryFolder.class
            .cast(temporaryFolderExtension.findInstance(extensionContext, TemporaryFolder.class))
            .getRoot();

    final ExtensionContext.Store store = extensionContext.getStore(NAMESPACE);
    store.put(BaseSpark.class.getName(), this);
    AnnotationUtils.findAnnotation(extensionContext.getElement(), WithSpark.class).ifPresent(ws -> {
        withSlaves(ws.slaves());
        withHadoopBase(ws.hadoopBase());
        withHadoopVersion(ws.hadoopVersion());
        withInstallWinUtils(ws.installWinUtils());
        withScalaVersion(of(ws.scalaVersion())
                .filter(it -> !"auto".equals(it))
                .orElse(SparkVersions.SPARK_SCALA_VERSION.getValue()));
        withSparkVersion(of(ws.sparkVersion())
                .filter(it -> !"auto".equals(it))
                .orElse(SparkVersions.SPARK_VERSION.getValue()));
    });
    final Instances instances = start();
    if (instances.getException() != null) {
        instances.close();
        if (Exception.class.isInstance(instances.getException())) {
            throw Exception.class.cast(instances.getException());
        }
        if (Error.class.isInstance(instances.getException())) {
            throw Error.class.cast(instances.getException());
        }
        throw new IllegalStateException(instances.getException());
    }
    store.put(AutoCloseable.class, instances);
}
 

@Override
public void beforeAll(final ExtensionContext extensionContext) {
    final WithComponents element = AnnotationUtils
            .findAnnotation(extensionContext.getElement(), WithComponents.class)
            .orElseThrow(() -> new IllegalArgumentException(
                    "No annotation @WithComponents on " + extensionContext.getRequiredTestClass()));
    this.packageName = element.value();
    if (element.isolatedPackages().length > 0) {
        withIsolatedPackage(null, element.isolatedPackages());
    }

    final boolean shouldUseEach = shouldIgnore(extensionContext.getElement());
    if (!shouldUseEach) {
        doStart(extensionContext);
    } else if (!extensionContext.getElement().map(AnnotatedElement::getAnnotations).map(annotations -> {
        int componentIndex = -1;
        for (int i = 0; i < annotations.length; i++) {
            final Class<? extends Annotation> type = annotations[i].annotationType();
            if (type == WithComponents.class) {
                componentIndex = i;
            } else if (type == Environment.class && componentIndex >= 0) {
                return false;
            }
        }
        return true;
    }).orElse(false)) {
        // check the ordering, if environments are put after this then the context is likely wrong
        // this condition is a simple heuristic but enough for most cases
        throw new IllegalArgumentException("If you combine @WithComponents and @Environment, you must ensure "
                + "environment annotations are becoming before the component one otherwise you will run in an "
                + "unexpected context and will not reproduce real execution.");
    }
    extensionContext.getStore(NAMESPACE).put(USE_EACH_KEY, shouldUseEach);
    extensionContext.getStore(NAMESPACE).put(SHARED_INSTANCE, this);
}
 

@Override
public void beforeEach(final ExtensionContext context) {
    closeable = provider
            .start(context.getRequiredTestClass(),
                    Stream
                            .concat(Stream.of(context.getRequiredTestClass().getAnnotations()),
                                    Stream
                                            .of(of(AnnotationUtils
                                                    .findRepeatableAnnotations(context.getRequiredTestClass(),
                                                            EnvironmentConfiguration.class))
                                                                    .filter(it -> !it.isEmpty())
                                                                    .map(l -> new Annotation[] {
                                                                            new EnvironmentConfigurations() {

                                                                                @Override
                                                                                public Class<? extends Annotation>
                                                                                        annotationType() {
                                                                                    return EnvironmentConfigurations.class;
                                                                                }

                                                                                @Override
                                                                                public EnvironmentConfiguration[]
                                                                                        value() {
                                                                                    return l
                                                                                            .toArray(
                                                                                                    new EnvironmentConfiguration[0]);
                                                                                }
                                                                            } })
                                                                    .orElseGet(() -> new Annotation[0])))
                            .toArray(Annotation[]::new));
    ofNullable(componentExtension).ifPresent(c -> {
        c.doStart(context);
        c.doInject(context);
    });
}
 

private static List<Field> retrieveAnnotatedFields(final ExtensionContext context,
                                                   final Class<? extends Annotation> annotationType,
                                                   final Class<?> fieldType) {

	return context.getElement()
			.filter(Class.class::isInstance)
			.map(Class.class::cast)
			.map(testInstanceClass ->
					AnnotationUtils.findAnnotatedFields(testInstanceClass, annotationType, field -> fieldType.isAssignableFrom(field.getType()))
			)
			.orElseGet(Collections::emptyList);
}
 

private boolean shouldIgnore(final Optional<AnnotatedElement> element) {
    return !AnnotationUtils.findRepeatableAnnotations(element, Environment.class).isEmpty();
}
 

@Override
public <T extends Annotation> T getMethodAnnotation(Class<T> clazz) {
    return AnnotationUtils.findAnnotation(extensionContext.getTestMethod(), clazz).orElse(null);
}
 

@Override
public <T extends Annotation> T getClassAnnotation(Class<T> clazz) {
    return AnnotationUtils.findAnnotation(extensionContext.getTestClass(), clazz).orElse(null);
}
 

private Docker findDockerAnnotation(ExtensionContext extensionContext) {
    Class<?> testClass = extensionContext.getTestClass().get();
    return AnnotationUtils.findAnnotation(testClass, Docker.class).orElseThrow(
        () -> new IllegalStateException(String.format("Could not find @Docker on class %s", testClass.getName())));
}
 

@Override
public boolean isAnnotated(Class<? extends Annotation> annotationType) {
	return AnnotationUtils.isAnnotated(parameter, annotationType);
}
 

@Override
public <A extends Annotation> Optional<A> findAnnotation(Class<A> annotationType) {
	return AnnotationUtils.findAnnotation(parameter, annotationType);
}
 

@Override
public <A extends Annotation> List<A> findRepeatableAnnotations(Class<A> annotationType) {
	return AnnotationUtils.findRepeatableAnnotations(parameter, annotationType);
}
 

@Override
public boolean supportsTestTemplate(ExtensionContext context) {
    return AnnotationUtils.isAnnotated(context.getTestMethod(), DualPlannerTest.class) &&
           FDBRecordStoreQueryTestBase.class.isAssignableFrom(context.getRequiredTestClass());
}