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

The following examples show how to use org.junit.jupiter.api.extension.ExtensionConfigurationException. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example #1
Source File: ApplicationContainer.java    From microshed-testing with Apache License 2.0 6 votes vote down vote up
private static Future<String> resolveImage(Optional<Path> dockerfile) {
    if (isHollow) {
        // Testcontainers won't be used in this case, supply a dummy image to improve performance
        return CompletableFuture.completedFuture("alpine:3.5");
    } else if (dockerfile.isPresent()) {
        if (!Files.exists(dockerfile.get()))
            throw new ExtensionConfigurationException("Dockerfile did not exist at: " + dockerfile.get());
        ImageFromDockerfile image = new ImageFromDockerfile("testcontainers/mpapp-" + Base58.randomString(10).toLowerCase());
        image.withDockerfile(dockerfile.get());
        image.setBaseDirectory(Paths.get("."));
        return image;
    } else {
        // Dockerfile is not present, use a ServerAdapter to build the image
        return resolveAdatper().orElseThrow(() -> {
            return new ExtensionConfigurationException("Unable to resolve Docker image for application because:" +
                                                       "\n - unable to locate Dockerfile in " + dockerfile_root.toAbsolutePath() +
                                                       "\n - unable to locate Dockerfile in " + dockerfile_src_main.toAbsolutePath() +
                                                       "\n - did not find any ServerAdapter to provide a default Dockerfile");
        }).getDefaultImage(findAppFile());
    }
}
 
Example #2
Source File: ContainerGroup.java    From microshed-testing with Apache License 2.0 6 votes vote down vote up
private Set<GenericContainer<?>> discoverContainers(Class<?> clazz) {
    Set<GenericContainer<?>> discoveredContainers = new HashSet<>();
    for (Field containerField : AnnotationSupport.findAnnotatedFields(clazz, Container.class)) {
        if (!Modifier.isPublic(containerField.getModifiers()))
            throw new ExtensionConfigurationException("@Container annotated fields must be public visibility");
        if (!Modifier.isStatic(containerField.getModifiers()))
            throw new ExtensionConfigurationException("@Container annotated fields must be static");
        boolean isStartable = GenericContainer.class.isAssignableFrom(containerField.getType());
        if (!isStartable)
            throw new ExtensionConfigurationException("@Container annotated fields must be a subclass of " + GenericContainer.class);
        try {
            GenericContainer<?> startableContainer = (GenericContainer<?>) containerField.get(null);
            discoveredContainers.add(startableContainer);
        } catch (IllegalArgumentException | IllegalAccessException e) {
            LOG.warn("Unable to access field " + containerField, e);
        }
    }
    return discoveredContainers;
}
 
Example #3
Source File: QuarkusConfiguration.java    From microshed-testing with Apache License 2.0 6 votes vote down vote up
@Override
public void applyConfiguration(Class<?> testClass) {
    containers = discoveredContainers.computeIfAbsent(testClass, clazz -> new ContainerGroup(clazz));

    // Verify that @MicroShedTest comes before @QuarkusTest
    if (containers.allContainers.size() > 0) {
        boolean foundQuarkusTest = false;
        for (Annotation anno : testClass.getAnnotations()) {
            if (anno.annotationType().getCanonicalName().equals("io.quarkus.test.junit.QuarkusTest"))
                foundQuarkusTest = true;
            else if (foundQuarkusTest && anno.annotationType().equals(MicroShedTest.class))
                throw new ExtensionConfigurationException("Must speciy @MicroShedTest annotation before @QuarkusTest so external " +
                                                          "services can be started and discovered before Quarkus starts.");
        }
    }

    String appUrl = getApplicationURL();
    LOG.info("Using Quarkus application URL: " + appUrl);

    ManuallyStartedConfiguration.setRuntimeURL(appUrl);
    super.applyConfiguration(testClass);
}
 
Example #4
Source File: WireMockExtensionTest.java    From wiremock-extension with MIT License 6 votes vote down vote up
@Test
@DisplayName("should raise ExtensionConfigurationException when multiple configs are present.")
void shouldRaiseExceptionWhenMultipleConfigsArePresent() {

	// given
	final Class<?> testClass = InvalidMultipleOptionsTestCase.class;

	// when
	final TestResults results = launchTests(testClass);

	// then
	then(results.getSummary().getTestsFailedCount())
			.describedAs("test instance preparation expected to fail")
			.isEqualTo(1L);
	then(results.getThrowables()).hasSize(1);
	then(results.getThrowables().get(0))
			.isInstanceOf(ExtensionConfigurationException.class)
			.hasMessageContaining("@ConfigureWireMock");
}
 
Example #5
Source File: TestcontainersExtension.java    From testcontainers-java with MIT License 6 votes vote down vote up
@Override
public void beforeAll(ExtensionContext context) {
    Class<?> testClass = context.getTestClass()
        .orElseThrow(() -> new ExtensionConfigurationException("TestcontainersExtension is only supported for classes."));

    Store store = context.getStore(NAMESPACE);
    List<StoreAdapter> sharedContainersStoreAdapters = findSharedContainers(testClass);

    sharedContainersStoreAdapters.forEach(adapter -> store.getOrComputeIfAbsent(adapter.getKey(), k -> adapter.start()));

    List<TestLifecycleAware> lifecycleAwareContainers = sharedContainersStoreAdapters
        .stream()
        .filter(this::isTestLifecycleAware)
        .map(lifecycleAwareAdapter -> (TestLifecycleAware) lifecycleAwareAdapter.container)
        .collect(toList());

    store.put(SHARED_LIFECYCLE_AWARE_CONTAINERS, lifecycleAwareContainers);
    signalBeforeTestToContainers(lifecycleAwareContainers, testDescriptionFrom(context));
}
 
Example #6
Source File: InjectionExtension.java    From xtext-core with Eclipse Public License 2.0 6 votes vote down vote up
private static InjectWith getInjectWith(Class<?> cls) {
	InjectWith result = null;
	Class<?> firstClassMatched = null;
	while (cls != null) {
		InjectWith iw = cls.getAnnotation(InjectWith.class);
		if (iw != null) {
			if(result != null) {
				throw new ExtensionConfigurationException(String.format("Multiple @InjectWith annotations are found (%s and %s). Only a single one is supported.",
						firstClassMatched.getName(), cls.getName()));
			}
			result = iw;
			firstClassMatched = cls;
		}
		cls = cls.getEnclosingClass();
	}
	return result;
}
 
Example #7
Source File: TestcontainersConfiguration.java    From microprofile-sandbox with Apache License 2.0 6 votes vote down vote up
private Set<GenericContainer<?>> discoverContainers(Class<?> clazz) {
    Set<GenericContainer<?>> discoveredContainers = new HashSet<>();
    for (Field containerField : AnnotationSupport.findAnnotatedFields(clazz, Container.class)) {
        if (!Modifier.isPublic(containerField.getModifiers()))
            throw new ExtensionConfigurationException("@Container annotated fields must be public visibility");
        if (!Modifier.isStatic(containerField.getModifiers()))
            throw new ExtensionConfigurationException("@Container annotated fields must be static");
        boolean isStartable = GenericContainer.class.isAssignableFrom(containerField.getType());
        if (!isStartable)
            throw new ExtensionConfigurationException("@Container annotated fields must be a subclass of " + GenericContainer.class);
        try {
            GenericContainer<?> startableContainer = (GenericContainer<?>) containerField.get(null);
            discoveredContainers.add(startableContainer);
        } catch (IllegalArgumentException | IllegalAccessException e) {
            LOG.warn("Unable to access field " + containerField, e);
        }
    }
    return discoveredContainers;
}
 
Example #8
Source File: MicroProfileTestExtension.java    From microprofile-sandbox with Apache License 2.0 6 votes vote down vote up
private static void injectRestClients(Class<?> clazz, TestcontainersConfiguration config) throws Exception {
    List<Field> restClientFields = AnnotationSupport.findAnnotatedFields(clazz, Inject.class);
    if (restClientFields.size() == 0)
        return;

    String mpAppURL = config.getApplicationURL();

    for (Field restClientField : restClientFields) {
        if (!Modifier.isPublic(restClientField.getModifiers()) ||
            !Modifier.isStatic(restClientField.getModifiers()) ||
            Modifier.isFinal(restClientField.getModifiers())) {
            throw new ExtensionConfigurationException("REST-client field must be public, static, and non-final: " + restClientField.getName());
        }
        String jwt = createJwtIfNeeded(restClientField);
        Object restClient = JAXRSUtilities.createRestClient(restClientField.getType(), mpAppURL, jwt);
        //Object restClient = JAXRSUtilities.createRestClient(restClientField.getType(), mpAppURL);
        restClientField.set(null, restClient);
        LOGGER.debug("Injecting rest client for " + restClientField);
    }
}
 
Example #9
Source File: MongoExtension.java    From immutables with Apache License 2.0 5 votes vote down vote up
@Override
public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
  final Class<?> type = parameterContext.getParameter().getType();
  if (MongoDatabase.class.isAssignableFrom(type)) {
    return getOrCreate(extensionContext).instance.database();
  } else if (MongoClient.class.isAssignableFrom(type)) {
    return getOrCreate(extensionContext).instance.client();
  }

  throw new ExtensionConfigurationException(String.format("%s supports only %s or %s but yours was %s", MongoExtension.class.getSimpleName(),
          MongoDatabase.class.getName(), MongoClient.class.getName(), type.getName()));
}
 
Example #10
Source File: AbstractDataProviderInvocationContextProviderTest.java    From junit-dataprovider with Apache License 2.0 5 votes vote down vote up
@Test
void testProvideTestTemplateInvocationContextsShouldThrowProperExceptionIfAnnotationIsNotPresent() {
    // Given:
    when(extensionContext.getRequiredTestMethod()).thenReturn(testMethod);

    // When:
    Exception result = assertThrows(ExtensionConfigurationException.class,
            () -> underTest.provideTestTemplateInvocationContexts(extensionContext));

    // Then:
    assertThat(result).hasMessageMatching("Could not find annotation '.*' on test method '.*'\\.");
}
 
Example #11
Source File: AbstractDataProviderInvocationContextProvider.java    From junit-dataprovider with Apache License 2.0 5 votes vote down vote up
@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)));
}
 
Example #12
Source File: CassandraExtension.java    From calcite with Apache License 2.0 5 votes vote down vote up
@Override public Object resolveParameter(final ParameterContext parameterContext,
    final ExtensionContext extensionContext) throws ParameterResolutionException {

  Class<?> type = parameterContext.getParameter().getType();
  if (Session.class.isAssignableFrom(type)) {
    return getOrCreate(extensionContext).session;
  } else if (Cluster.class.isAssignableFrom(type)) {
    return getOrCreate(extensionContext).cluster;
  }

  throw new ExtensionConfigurationException(
      String.format(Locale.ROOT, "%s supports only %s or %s but yours was %s",
      CassandraExtension.class.getSimpleName(),
      Session.class.getName(), Cluster.class.getName(), type.getName()));
}
 
Example #13
Source File: TestcontainersExtension.java    From testcontainers-java with MIT License 5 votes vote down vote up
private static StoreAdapter getContainerInstance(final Object testInstance, final Field field) {
    try {
        field.setAccessible(true);
        Startable containerInstance = Preconditions.notNull((Startable) field.get(testInstance), "Container " + field.getName() + " needs to be initialized");
        return new StoreAdapter(field.getDeclaringClass(), field.getName(), containerInstance);
    } catch (IllegalAccessException e) {
        throw new ExtensionConfigurationException("Can not access container defined in field " + field.getName());
    }
}
 
Example #14
Source File: TestcontainersExtension.java    From testcontainers-java with MIT License 5 votes vote down vote up
private static Predicate<Field> isContainer() {
    return field -> {
        boolean isAnnotatedWithContainer = AnnotationSupport.isAnnotated(field, Container.class);
        if (isAnnotatedWithContainer) {
            boolean isStartable = Startable.class.isAssignableFrom(field.getType());

            if (!isStartable) {
                throw new ExtensionConfigurationException(String.format("FieldName: %s does not implement Startable", field.getName()));
            }
            return true;
        }
        return false;
    };
}
 
Example #15
Source File: InjectionExtension.java    From xtext-core with Eclipse Public License 2.0 5 votes vote down vote up
@Override
public void beforeEach(ExtensionContext context) throws Exception {
	IInjectorProvider injectorProvider = getOrCreateInjectorProvider(context);
	if (injectorProvider instanceof IRegistryConfigurator) {
		final IRegistryConfigurator registryConfigurator = (IRegistryConfigurator) injectorProvider;
		registryConfigurator.setupRegistry();
	}
	if (injectorProvider != null) {
		Injector injector = injectorProvider.getInjector();
		if (injector != null) {
			Object testInstance = context.getRequiredTestInstance();
			injector.injectMembers(testInstance);
			try {
				TestInstances requiredTestInstances = context.getRequiredTestInstances();
				for (Object o : requiredTestInstances.getEnclosingInstances()) {
					injector.injectMembers(o);
				}
			} catch (NoSuchMethodError e) {
				if (!Modifier.isStatic(testInstance.getClass().getModifiers())) {
					if (testInstance.getClass().getDeclaringClass() != null) {
						throw new ExtensionConfigurationException("Injection of nested classes needs Junit5 >= 5.4", e);
					}
				}
				// OK, getRequiredTestInstances is not there in Junit5 < 5.4
			}
		}
	}
}
 
Example #16
Source File: TestcontainersConfiguration.java    From microprofile-sandbox with Apache License 2.0 5 votes vote down vote up
private MicroProfileApplication<?> autoDiscoverMPApp(Class<?> clazz, boolean errorIfNone) {
    // First check for any MicroProfileApplicaiton directly present on the test class
    List<Field> mpApps = AnnotationSupport.findAnnotatedFields(clazz, Container.class,
                                                               f -> Modifier.isStatic(f.getModifiers()) &&
                                                                    Modifier.isPublic(f.getModifiers()) &&
                                                                    MicroProfileApplication.class.isAssignableFrom(f.getType()),
                                                               HierarchyTraversalMode.TOP_DOWN);
    if (mpApps.size() == 1)
        try {
            return (MicroProfileApplication<?>) mpApps.get(0).get(null);
        } catch (IllegalArgumentException | IllegalAccessException e) {
            // This should never happen because we only look for fields that are public+static
            e.printStackTrace();
        }
    if (mpApps.size() > 1)
        throw new ExtensionConfigurationException("Should be no more than 1 public static MicroProfileApplication field on " + clazz);

    // If none found, check any SharedContainerConfig
    String sharedConfigMsg = "";
    if (sharedConfigClass != null) {
        MicroProfileApplication<?> mpApp = autoDiscoverMPApp(sharedConfigClass, false);
        if (mpApp != null)
            return mpApp;
        sharedConfigMsg = " or " + sharedConfigClass;
    }

    if (errorIfNone)
        throw new ExtensionConfigurationException("No public static MicroProfileApplication fields annotated with @Container were located " +
                                                  "on " + clazz + sharedConfigMsg + " to auto-connect with REST-client fields.");
    return null;
}
 
Example #17
Source File: TestcontainersConfiguration.java    From microprofile-sandbox with Apache License 2.0 5 votes vote down vote up
public String getApplicationURL() {
    MicroProfileApplication<?> mpApp = autoDiscoverMPApp(testClass, true);

    // At this point we have found exactly one MicroProfileApplication
    if (!mpApp.isCreated() || !mpApp.isRunning())
        throw new ExtensionConfigurationException("MicroProfileApplication " + mpApp.getDockerImageName() + " is not running yet. " +
                                                  "The contianer must be running in order to obtain its URL.");

    return mpApp.getApplicationURL();
}
 
Example #18
Source File: KafkaConfigAnnotationProcessor.java    From microshed-testing with Apache License 2.0 5 votes vote down vote up
Properties getConsumerProperties(Field consumerField) {
    KafkaConsumerClient consumerConfig = consumerField.getAnnotation(KafkaConsumerClient.class);
    Properties properties = new Properties();
    String bootstrapServers = consumerConfig.bootstrapServers().isEmpty() ? globalBootstrapServers : consumerConfig.bootstrapServers();
    if (bootstrapServers.isEmpty())
        throw new ExtensionConfigurationException("To use @KafkaConsumerClient on a KafkaConsumer a bootstrap server must be " +
                                                  "defined in the @KafkaConsumerClient annotation or using the " +
                                                  "'org.microshed.kafka.bootstrap.servers' system property");
    properties.put("bootstrap.servers", bootstrapServers);
    properties.put("group.id", consumerConfig.groupId());
    if (isClassPropertySet(consumerConfig.keyDeserializer().getName()))
        properties.put("key.deserializer", consumerConfig.keyDeserializer().getName());
    if (isClassPropertySet(consumerConfig.valueDeserializer().getName()))
        properties.put("value.deserializer", consumerConfig.valueDeserializer().getName());
    for (String prop : consumerConfig.properties()) {
        int split = prop.indexOf("=");
        if (split < 2)
            throw new ExtensionConfigurationException("The property '" + prop + "' for field " + consumerField + " must be in the format 'key=value'");
        properties.put(prop.substring(0, split), prop.substring(split + 1));
    }

    // Auto-detect key/value deserializer if needed
    if (consumerField.getGenericType() instanceof ParameterizedType) {
        if (!properties.containsKey("key.deserializer")) {
            Type keyType = ((ParameterizedType) consumerField.getGenericType()).getActualTypeArguments()[0];
            if (defaultDeserailizers.containsKey(keyType))
                properties.put("key.deserializer", defaultDeserailizers.get(keyType));
        }
        if (!properties.containsKey("value.deserializer")) {
            Type valueType = ((ParameterizedType) consumerField.getGenericType()).getActualTypeArguments()[1];
            if (defaultDeserailizers.containsKey(valueType))
                properties.put("value.deserializer", defaultDeserailizers.get(valueType));
        }
    }

    return properties;
}
 
Example #19
Source File: KafkaConfigAnnotationProcessor.java    From microshed-testing with Apache License 2.0 5 votes vote down vote up
Properties getProducerProperties(Field producerField) {
    KafkaProducerClient producerConfig = producerField.getAnnotation(KafkaProducerClient.class);
    Properties properties = new Properties();
    String bootstrapServers = producerConfig.bootstrapServers().isEmpty() ? globalBootstrapServers : producerConfig.bootstrapServers();
    if (bootstrapServers.isEmpty())
        throw new ExtensionConfigurationException("To use @KafkaProducerClient on a KafkaProducer a bootstrap server must be " +
                                                  "defined in the @KafkaProducerClient annotation or using the " +
                                                  "'org.microshed.kafka.bootstrap.servers' system property");
    properties.put("bootstrap.servers", bootstrapServers);
    if (isClassPropertySet(producerConfig.keySerializer().getName()))
        properties.put("key.serializer", producerConfig.keySerializer().getName());
    if (isClassPropertySet(producerConfig.valueSerializer().getName()))
        properties.put("value.serializer", producerConfig.valueSerializer().getName());
    for (String prop : producerConfig.properties()) {
        int split = prop.indexOf("=");
        if (split < 2)
            throw new ExtensionConfigurationException("The property '" + prop + "' for field " + producerField + " must be in the format 'key=value'");
        properties.put(prop.substring(0, split), prop.substring(split + 1));
    }

    // Auto-detect key/value serializers if needed
    if (producerField.getGenericType() instanceof ParameterizedType) {
        if (!properties.containsKey("key.serializer")) {
            Type keyType = ((ParameterizedType) producerField.getGenericType()).getActualTypeArguments()[0];
            if (defaultSerailizers.containsKey(keyType))
                properties.put("key.serializer", defaultSerailizers.get(keyType));
        }
        if (!properties.containsKey("value.serializer")) {
            Type valueType = ((ParameterizedType) producerField.getGenericType()).getActualTypeArguments()[1];
            if (defaultSerailizers.containsKey(valueType))
                properties.put("value.serializer", defaultSerailizers.get(valueType));
        }
    }

    return properties;
}
 
Example #20
Source File: LibertyAdapter.java    From microshed-testing with Apache License 2.0 5 votes vote down vote up
private void configureKafka(Set<GenericContainer<?>> containers) {
    Class<?> KafkaContainer = tryLoad("org.testcontainers.containers.KafkaContainer");
    if (KafkaContainer == null)
        return;
    Set<GenericContainer<?>> kafkaContainers = containers.stream()
                    .filter(c -> KafkaContainer.isAssignableFrom(c.getClass()))
                    .collect(Collectors.toSet());
    if (kafkaContainers.size() != 1)
        return;

    // At this point we have found exactly 1 kafka container
    GenericContainer<?> kafka = kafkaContainers.iterator().next();

    // Configure app container with bootstrap server
    String bootstrapProperty = "MP_MESSAGING_CONNECTOR_LIBERTY_KAFKA_BOOTSTRAP_SERVERS";
    String bootstrapServer = null;
    if (ApplicationEnvironment.Resolver.isSelected(TestcontainersConfiguration.class)) {
        if (kafka.getNetworkAliases().size() == 0)
            throw new ExtensionConfigurationException("Unable to configure kafka bootstrap server because no network alias is defined");
        bootstrapServer = kafka.getNetworkAliases().get(kafka.getNetworkAliases().size() - 1) + ":9092";
    } else if (ApplicationEnvironment.Resolver.isSelected(HollowTestcontainersConfiguration.class)) {
        bootstrapServer = "localhost:9093";
    } else {
        return;
    }
    String finalBootstrapServers = bootstrapServer;
    LOG.info("Auto-configuring ApplicationContainer instances with " + bootstrapProperty + "=" + finalBootstrapServers);
    containers.stream()
                    .filter(c -> ApplicationContainer.class.isAssignableFrom(c.getClass()))
                    .filter(c -> c.getNetwork().equals(kafka.getNetwork()))
                    .filter(c -> !c.getEnvMap().containsKey(bootstrapProperty))
                    .filter(c -> !c.getEnvMap().containsKey(bootstrapProperty.toLowerCase()))
                    .forEach(c -> c.withEnv(bootstrapProperty, finalBootstrapServers));
}
 
Example #21
Source File: TestcontainersConfiguration.java    From microshed-testing with Apache License 2.0 5 votes vote down vote up
@Override
public String getApplicationURL() {
    ApplicationContainer mpApp = containers.app;
    if (mpApp == null) {
        String sharedConfigMsg = containers.hasSharedConfig() ? " or " + containers.sharedConfigClass : "";
        throw new ExtensionConfigurationException("No public static ApplicationContainer fields annotated with @Container were located " +
                                                  "on " + containers.testClass + sharedConfigMsg + ".");
    }
    return mpApp.getApplicationURL();
}
 
Example #22
Source File: ContainerGroup.java    From microshed-testing with Apache License 2.0 5 votes vote down vote up
public ContainerGroup(Class<?> testClass) {
    this.testClass = testClass;
    sharedConfigClass = testClass.isAnnotationPresent(SharedContainerConfig.class) ? //
                    testClass.getAnnotation(SharedContainerConfig.class).value() : null;
    unsharedContainers = Collections.unmodifiableSet(discoverContainers(testClass));
    sharedContainers = hasSharedConfig() ? //
                    Collections.unmodifiableSet(discoverContainers(sharedConfigClass)) : //
                    Collections.emptySet();
    Set<GenericContainer<?>> all = new HashSet<>(unsharedContainers);
    all.addAll(sharedContainers);
    allContainers = Collections.unmodifiableSet(all);

    Set<ApplicationContainer> apps = allContainers.stream()
                    .filter(c -> c instanceof ApplicationContainer)
                    .map(c -> (ApplicationContainer) c)
                    .collect(Collectors.toSet());
    if (apps.size() == 0) {
        app = null;
    } else if (apps.size() == 1) {
        app = apps.iterator().next();
    } else {
        app = null;
        // Error: Multiple ApplicationContainers were found
        String appString = apps.stream()
                        .map(app -> app.toStringSimple())
                        .collect(Collectors.joining(", "));
        throw new ExtensionConfigurationException("Only 1 ApplicationContainer may be used, but multiple were defined: " +
                                                  appString);
    }
}
 
Example #23
Source File: TestcontainersExtension.java    From testcontainers-java with MIT License 4 votes vote down vote up
@Override
public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) {
    return findTestcontainers(context).map(this::evaluate)
        .orElseThrow(() -> new ExtensionConfigurationException("@Testcontainers not found"));
}
 
Example #24
Source File: TestcontainersConfigurationTest.java    From microshed-testing with Apache License 2.0 4 votes vote down vote up
@Test
public void testTwoApps() {
    assertThrows(ExtensionConfigurationException.class, () -> {
        new TestcontainersConfiguration().applyConfiguration(TwoAppsClass.class);
    });
}