org.junit.jupiter.api.extension.ParameterContext Java Examples

@Override
public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
    try {
        InMemoryIntegrationResources resources = InMemoryIntegrationResources.defaultResources();

        DNSService dnsService = mock(DNSService.class);
        MemoryDomainList domainList = new MemoryDomainList(dnsService);
        MemoryUsersRepository usersRepository = MemoryUsersRepository.withVirtualHosting(domainList);

        QuotaComponents quotaComponents = resources.getMailboxManager().getQuotaComponents();

        return new QuotaSearchTestSystem(
            quotaComponents.getMaxQuotaManager(),
            resources.getMailboxManager(),
            quotaComponents.getQuotaManager(),
            resources.getDefaultUserQuotaRootResolver(),
            new ScanningQuotaSearcher(usersRepository,
                new ClauseConverter(resources.getDefaultUserQuotaRootResolver(), quotaComponents.getQuotaManager())),
            usersRepository,
            domainList,
            resources.getCurrentQuotaManager(),
            NO_AWAIT);
    } catch (Exception e) {
        throw new ParameterResolutionException("Error while resolving parameter", e);
    }
}
 

@Override
public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
  Class<?> type = parameterContext.getParameter().getType();
  ExtensionContext.Store store = extensionContext.getStore(ExtensionContext.Namespace.create(JsonSchemaValidatorExtension.class, extensionContext));
  if (SchemaRouter.class.equals(type))
    return getRouter(extensionContext, store);
  if (Draft7SchemaParser.class.equals(type) || SchemaParser.class.equals(type))
    return store.getOrComputeIfAbsent(
      DRAFT7_PARSER,
      s -> Draft7SchemaParser.create(getRouter(extensionContext, store)),
      Draft7SchemaParser.class
    );
  if (OpenAPI3SchemaParser.class.equals(type))
    return store.getOrComputeIfAbsent(
      OPENAPI3_PARSER,
      s -> OpenAPI3SchemaParser.create(getRouter(extensionContext, store)),
      OpenAPI3SchemaParser.class
    );
  throw new IllegalStateException("Looks like the ParameterResolver needs a fix...");
}
 

@Override
public Object resolveParameter(ParameterContext parameterContext, ExtensionContext context) {
    FlowableDmnTestHelper flowableTestHelper = getTestHelper(context);
    if (parameterContext.isAnnotated(DmnDeploymentId.class)) {
        return flowableTestHelper.getDeploymentIdFromDeploymentAnnotation();
    }

    Class<?> parameterType = parameterContext.getParameter().getType();
    DmnEngine dmnEngine = flowableTestHelper.getDmnEngine();
    if (parameterType.isInstance(dmnEngine)) {
        return dmnEngine;
    } else if (FlowableDmnTestHelper.class.equals(parameterType)) {
        return flowableTestHelper;
    }

    try {
        return DmnEngine.class.getDeclaredMethod("get" + parameterType.getSimpleName()).invoke(dmnEngine);
    } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException ex) {
        throw new ParameterResolutionException("Could not find service " + parameterType, ex);
    }
}
 

@Override
public Method aggregateArguments(
    final ArgumentsAccessor arguments, final ParameterContext context)
    throws ArgumentsAggregationException {
  // Ignore CSV columns that are already used by different parameters
  final int offset = context.getIndex();
  final Class<?> remoteInterface = arguments.get(offset, Class.class);
  final String methodName = arguments.getString(offset + 1);
  final Class<?>[] argumentTypes =
      IntStream.range(offset + 2, arguments.size())
          .mapToObj(i -> arguments.get(i, Class.class))
          .toArray(Class<?>[]::new);
  try {
    return remoteInterface.getMethod(methodName, argumentTypes);
  } catch (final NoSuchMethodException e) {
    throw new ArgumentsAggregationException("Invalid method specified", e);
  }
}
 

@Override
public Object resolveParameter(ParameterContext parameterContext, ExtensionContext context) {
    FlowableCmmnTestHelper flowableTestHelper = getTestHelper(context);
    if (parameterContext.isAnnotated(CmmnDeploymentId.class)) {
        return flowableTestHelper.getDeploymentIdFromDeploymentAnnotation();
    }

    Class<?> parameterType = parameterContext.getParameter().getType();
    CmmnEngine cmmnEngine = flowableTestHelper.getCmmnEngine();
    if (parameterType.isInstance(cmmnEngine)) {
        return cmmnEngine;
    } else if (FlowableCmmnTestHelper.class.equals(parameterType)) {
        return flowableTestHelper;
    }

    try {
        return CmmnEngine.class.getDeclaredMethod("get" + parameterType.getSimpleName()).invoke(cmmnEngine);
    } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException ex) {
        throw new ParameterResolutionException("Could not find service " + parameterType, ex);
    }
}
 

@Override
public Object resolveParameter(ParameterContext parameterContext, ExtensionContext context) {
    FlowableEventTestHelper flowableTestHelper = getTestHelper(context);
    if (parameterContext.isAnnotated(EventDeploymentId.class)) {
        return flowableTestHelper.getDeploymentIdFromDeploymentAnnotation();
    }

    Class<?> parameterType = parameterContext.getParameter().getType();
    EventRegistryEngine eventRegistryEngine = flowableTestHelper.getEventRegistryEngine();
    if (parameterType.isInstance(eventRegistryEngine)) {
        return eventRegistryEngine;
    } else if (FlowableEventTestHelper.class.equals(parameterType)) {
        return flowableTestHelper;
    }

    try {
        return EventRegistryEngine.class.getDeclaredMethod("get" + parameterType.getSimpleName()).invoke(eventRegistryEngine);
    } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException ex) {
        throw new ParameterResolutionException("Could not find service " + parameterType, ex);
    }
}
 

private List<Annotation> resolveQualifiers(ParameterContext pc, BeanManager bm) {
    List<Annotation> qualifiers = new ArrayList<>();
    if (pc.getParameter().getAnnotations().length == 0) {
        return Collections.emptyList();
    } else {
        for (Annotation annotation : pc.getParameter().getAnnotations()) {
            // use BeanManager.isQualifier to be able to detect custom qualifiers which don't need to have @Qualifier
            if (bm.isQualifier(annotation.annotationType())) {
                qualifiers.add(annotation);
            }
        }
    }
    return qualifiers;
}
 

@Override
public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext)
    throws ParameterResolutionException {
  if (tempDirectory == null) {
    try {
      tempDirectory = createTempDirectory(extensionContext.getRequiredTestClass().getSimpleName());
    } catch (IOException e) {
      throw new UncheckedIOException(e);
    }
  }
  return tempDirectory;
}
 

@Override
public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext)
    throws ParameterResolutionException {
  if (vertx == null) {
    System.setProperty("vertx.disableFileCPResolving", "true");
    vertx = Vertx.vertx();
  }
  return vertx;
}
 

@Override
public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext)
        throws ParameterResolutionException {
    try {
        return createFolder(extensionContext);
    } catch (IOException e) {
        throw new ParameterResolutionException("could not make tmp folder", e);
    }
}
 

@Override
public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
    JsonEventSerializer jsonEventSerializer = JsonEventSerializer
        .forModules(DLPConfigurationModules.DLP_CONFIGURATION_STORE, DLPConfigurationModules.DLP_CONFIGURATION_CLEAR)
        .withoutNestedType();

    EventStoreDao eventStoreDao = new EventStoreDao(
        cassandraExtension.getCassandraCluster().getConf(),
        jsonEventSerializer,
        cassandraExtension.getCassandraConsistenciesConfiguration());

    return new EventSourcingDLPConfigurationStore(new CassandraEventStore(eventStoreDao));
}
 

/**
 * Resolve a value for the {@link Parameter} in the supplied {@link ParameterContext} by
 * retrieving the corresponding dependency from the test's {@link ApplicationContext}.
 * <p>Delegates to {@link ParameterResolutionDelegate#resolveDependency}.
 * @see #supportsParameter
 * @see ParameterResolutionDelegate#resolveDependency
 */
@Override
@Nullable
public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) {
	Parameter parameter = parameterContext.getParameter();
	int index = parameterContext.getIndex();
	Class<?> testClass = extensionContext.getRequiredTestClass();
	ApplicationContext applicationContext = getApplicationContext(extensionContext);
	return ParameterResolutionDelegate.resolveDependency(parameter, index, testClass,
			applicationContext.getAutowireCapableBeanFactory());
}
 

@Override
public Object resolveParameter(
    ParameterContext parameterContext, ExtensionContext extensionContext)
    throws ParameterResolutionException {
  if (clazz.isAnnotationPresent(Entity.class)) {
    return ClassNames.newEntityMetamodelClassNameBuilder(clazz.getName(), prefix, suffix)
        .toString();
  }
  throw new AssertionFailedError("annotation not found.");
}
 

Optional<Object> get(ParameterContext parameterContext) {
  return storage.entrySet().stream()
      .filter(entry -> entry.getKey().matches(parameterContext))
      .findAny()
      .map(Map.Entry::getValue)
      .map(provider -> provider.apply(parameterContext));
}
 

/**
 * Simple example that simply resolves the Parameter by returning the Class-Name based on the Parameter-Context.
 */
@Override
public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
    Class<?> contextClass = extensionContext.getTestClass().orElse(null);

    return contextClass == null ? null : contextClass.getSimpleName();
}
 

@Override
public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
    Class<?> paramType = parameterContext.getParameter().getType();
    if (paramType.isAssignableFrom(CassandraCluster.class)) {
        return cassandraCluster;
    } else if (paramType.isAssignableFrom(DockerCassandra.class)) {
        return DockerCassandraSingleton.singleton;
    }
    throw new IllegalArgumentException("Unsupported parameter type " + paramType.getName());
}
 

private DriverHandler getDriverHandler(ParameterContext parameterContext,
        ExtensionContext extensionContext, Parameter parameter,
        Class<?> type, Browser browser, Class<?> constructorClass,
        boolean isRemote) {
    DriverHandler driverHandler = null;
    try {
        driverHandler = getDriverHandler(extensionContext, parameter, type,
                constructorClass, browser, isRemote);

        Optional<DockerBrowser> dockerBrowser = annotationsReader
                .getDocker(parameter);
        String contextId = extensionContext.getUniqueId();
        if (type.equals(RemoteWebDriver.class)
                || type.equals(WebDriver.class) || type.equals(List.class)
                || (dockerBrowser.isPresent()
                        && type.equals(SelenideDriver.class))) {
            initHandlerForDocker(contextId, driverHandler);
        }

        boolean isTemplate = isTestTemplate(extensionContext);
        if (!isTemplate && isGeneric(type) && isRemote) {
            ((RemoteDriverHandler) driverHandler).setParent(this);
            ((RemoteDriverHandler) driverHandler)
                    .setParameterContext(parameterContext);
        }

        putDriverHandlerInMap(extensionContext.getUniqueId(),
                driverHandler);

    } catch (Exception e) {
        handleException(parameter, driverHandler, constructorClass, e);
    }
    return driverHandler;
}
 

@Override
public boolean supportsParameter(ParameterContext parameterContext,
        ExtensionContext extensionContext) {
    Class<?> type = parameterContext.getParameter().getType();
    return (WebDriver.class.isAssignableFrom(type)
            || type.equals(List.class) || type.equals(SelenideDriver.class))
            && !isTestTemplate(extensionContext);
}
 

@Override
public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
    // we did our checks in supportsParameter() method, now we can do simple resolution
    if (getContainerFromStore(extensionContext) != null) {
        List<Annotation> qualifiers = resolveQualifiers(parameterContext, getContainerFromStore(extensionContext).getBeanManager());
        return getContainerFromStore(extensionContext)
                .select(parameterContext.getParameter().getType(), qualifiers.toArray(new Annotation[qualifiers.size()])).get();
    }
    return null;
}
 

@SuppressWarnings("PMD.AvoidUncheckedExceptionsInSignatures")
@Override
public BrokerProperties resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext)
	throws ParameterResolutionException {
	String[] properties = getValueHolderProperties(extensionContext);
	return new BrokerProperties(properties);
}
 

@Test
void it_should_resolve_http_client_parameter_with_auto_strategy() throws Exception {
	final FixtureClass testInstance = new FixtureClass();
	final FakeExtensionContext context = new FakeExtensionContext(testInstance);
	final JunitServerExtension extension = initializeExtension(context);
	final ParameterContext parameterContext = createParameterContext("method_http_client", HttpClient.class);

	final Object result = extension.resolveParameter(parameterContext, context);

	assertThat(result).isNotNull().isInstanceOf(HttpClient.class);
}
 

@Override
public Object resolveParameter(ParameterContext parameterContext,
    ExtensionContext extensionContext)
    throws ParameterResolutionException {
  Parameter parameter = parameterContext.getParameter();
  Key<?> key = getKey(extensionContext.getTestClass(), parameter);
  Injector injector = getInjectorForParameterResolution(extensionContext)
      .orElseThrow(() ->
          new ParameterResolutionException(
              String.format(
                  "Could not create injector for: %s It has no annotated element.",
                  extensionContext.getDisplayName())));

  return injector.getInstance(key);
}
 

@Override
public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext)
    throws ParameterResolutionException {
  CommandRule commandRule = new CommandRule(
          parameterContext.getTarget().orElseThrow(() -> new ParameterResolutionException("no target")));
  commandRule.init();
  return commandRule;
}
 

@SuppressWarnings("unchecked")
@Override
public Object convert(Object input, ParameterContext context) throws ArgumentConversionException {
  TypeToken<?> parameterType = TypeToken.of(context.getParameter().getParameterizedType());
  if (parameterType.getRawType() != Class.class) {
    throw new ArgumentConversionException(
        String.format("Could not convert: %s. Invalid parameter type.", input));
  }

  return convert(input.toString(), (TypeToken<? extends Class<?>>) parameterType);
}
 

@Override
public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
    Object ret = null;
    //
    // Return a random, valid Person object if Person.class is the type of Parameter
    /// to be resolved. Otherwise return null.
    if (parameterContext.getParameter()
        .getType() == Person.class) {
        ret = VALID_PERSONS[new Random().nextInt(VALID_PERSONS.length)];
    }
    return ret;
}
 

@Override
public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext)
		throws ParameterResolutionException {
	return getInitializer(extensionContext);
}
 

@Override
public boolean supportsParameter(ParameterContext parameterContext,
    ExtensionContext extensionContext)
    throws ParameterResolutionException {
  return parameterContext.getParameter().getType() == String[].class;
}
 

@Override
public boolean supportsParameter(ParameterContext parameterContext,
        ExtensionContext extensionContext)
        throws ParameterResolutionException {
    return true;
}
 

@Override
public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
    return rabbitMQ;
}
 

@Override
public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext)
    throws ParameterResolutionException {
  return RESOLVER.resolveParameter(parameterContext, extensionContext);
}