Java Code Examples for org.junit.jupiter.api.extension.ExtensionContext#getStore()

@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));
}
 

@Override
public void afterEach(final ExtensionContext context) {
    final ExtensionContext.Store store = context.getStore(NAMESPACE);
    final boolean fails = !ComponentPackage.class.cast(store.get(ComponentPackage.class.getName())).success();
    final String expectedMessage = ExceptionSpec.class
            .cast(context.getStore(NAMESPACE).get(ExceptionSpec.class.getName()))
            .getMessage();
    try {
        ComponentValidator.class.cast(store.get(ComponentValidator.class.getName())).run();
        if (fails) {
            fail("should have failed");
        }
        if (expectedMessage != null) {
            final Collection<String> messages = TestLog.class.cast(store.get(TestLog.class.getName())).messages;
            assertTrue(messages.stream().anyMatch(it -> it.contains(expectedMessage)),
                    expectedMessage + "\n\n> " + messages);
        }
    } catch (final IllegalStateException ise) {
        if (fails) {
            final String exMsg = ise.getMessage();
            assertTrue(exMsg.contains(expectedMessage), expectedMessage + "\n\n> " + exMsg);
        } else {
            fail(ise);
        }
    }
}
 

@Override
public void beforeEach(ExtensionContext context) {
  IdeaMocksImpl ideaMocks = new IdeaMocksImpl();
  Project project = mock(Project.class);
  MessageBus messageBus = mock(MessageBus.class);
  when(project.getMessageBus()).thenReturn(messageBus);
  when(messageBus.syncPublisher(any(Topic.class))).thenAnswer(invocation -> {
    Topic topic = invocation.getArgument(0);
    Class<?> listenerClass = topic.getListenerClass();
    if (ideaMocks.hasMockListener(listenerClass)) {
      return ideaMocks.getMockListener(listenerClass);
    } else {
      return ideaMocks.mockListener(listenerClass);
    }
  });
  Store store = context.getStore(NS);
  ParameterHolder holder = ParameterHolder.getHolder(store);
  holder.register(Project.class, Suppliers.ofInstance(project));
  holder.register(MessageBus.class, Suppliers.ofInstance(messageBus));
  holder.register(IdeaMocks.class, Suppliers.ofInstance(ideaMocks));
}
 

/**
 * Create {@link Injector} or get existing one from test context
 */
private static Optional<Injector> getOrCreateInjector(ExtensionContext context)
    throws NoSuchMethodException, InstantiationException, IllegalAccessException,
    InvocationTargetException {

  Optional<AnnotatedElement> optionalAnnotatedElement = context.getElement();
  if (!optionalAnnotatedElement.isPresent()) {
    return Optional.empty();
  }

  AnnotatedElement element = optionalAnnotatedElement.get();
  Store store = context.getStore(NAMESPACE);

  Injector injector = store.get(element, Injector.class);
  if (injector == null) {
    injector = createInjector(context);
    store.put(element, injector);
  }

  return Optional.of(injector);
}
 

private Object getMock(Parameter parameter, ExtensionContext extensionContext) {
    Class<?> mockType = parameter.getType();
    Store mocks = extensionContext.getStore(Namespace.create(MockitoExtension.class, mockType));
    String mockName = getMockName(parameter);

    if (mockName != null) {
        return mocks.getOrComputeIfAbsent(mockName, key -> mock(mockType, mockName));
    }
    else {
        return mocks.getOrComputeIfAbsent(mockType.getCanonicalName(), key -> mock(mockType));
    }
}
 

private Object getMock(Parameter parameter, ExtensionContext extensionContext) {
    Class<?> mockType = parameter.getType();
    Store mocks = extensionContext.getStore(Namespace.create(MockitoExtension.class, mockType));
    String mockName = getMockName(parameter);

    if (mockName != null) {
        return mocks.getOrComputeIfAbsent(mockName, key -> mock(mockType, mockName));
    }
    else {
        return mocks.getOrComputeIfAbsent(mockType.getCanonicalName(), key -> mock(mockType));
    }
}
 

@Override
public void beforeEach(ExtensionContext context) throws Exception {
	ExtensionContext.Store contextStore = context.getStore(NAMESPACE);
	Neo4jConnectionSupport neo4jConnectionSupport = contextStore
		.get(KEY_DRIVER_INSTANCE, Neo4jConnectionSupport.class);
	checkRequiredFeatures(neo4jConnectionSupport, context.getTags());
}
 

@Override
public void beforeAll(final ExtensionContext context) {
    final ExtensionContext.Store store = context.getStore(NAMESPACE);
    store.put(MonoBase.Instance.class, BASE.startIfNeeded());
    if (isPerClass(context)) {
        doInject(context);
        store.put(LifecyleState.class, onInjection(context, null));
    }
}
 

@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));
}
 

@Override
public void afterAll(ExtensionContext context) throws Exception {
    ExtensionContext.Store store = context.getStore(ExtensionContext.Namespace.create(AppExtension.class, MockApp.class));
    MockApp app = (MockApp) store.get(MockApp.class);
    if (app != null) {
        app.stop();
        new TempDirectory(app.dir()).delete();
    }
}
 

@Override
public void beforeAll(ExtensionContext context) {
    ExtensionContext.Store store = context.getStore(NAMESPACE);
    Class<?> testType = context.getRequiredTestClass();
    ReflectionUtils
            .findFields(testType, isRunnable(), ReflectionUtils.HierarchyTraversalMode.TOP_DOWN)
            .stream()
            .map(f -> getInstance(null, f))
            .forEach(r -> startAndRegisterForShutdown(r, store));
}
 

@Override
public void beforeEach(final ExtensionContext context) {
    final ExtensionContext.Store store = context.getStore(NAMESPACE);
    if (!isPerClass(context)) {
        doInject(context);
        store.put(
            LifecyleState.class,
            onInjection(context.getParent().orElse(context), store.get(LifecyleState.class, LifecyleState.class)));
    }
}
 

private Store getStore(ExtensionContext context) {
    return context.getStore(Namespace.create(getClass(), context));
}
 

private ExtensionContext.Store getStore(ExtensionContext context) {
    return context.getStore(ExtensionContext.Namespace.create(getClass(), context.getRequiredTestMethod()));
}
 

@SuppressWarnings("unchecked")
private Errors getErrors(ExtensionContext extensionContext) {
    ExtensionContext.Store store = extensionContext.getStore(ExtensionContext.Namespace.create(getClass(), extensionContext.getRequiredTestMethod()));
    return (Errors)store.getOrComputeIfAbsent("errors", (key) -> new Errors());
}
 

@Override
public void postProcessTestInstance(final Object testInstance, final ExtensionContext context) {
    Store store = context.getStore(NAMESPACE);
    store.put(TEST_INSTANCE, testInstance);
}
 

private ExtensionContext.Store getStore(ExtensionContext context) {
    return context.getStore(ExtensionContext.Namespace.create(getClass(), context.getRequiredTestMethod()));
}
 

private ExtensionContext.Store getLocalExtensionStore(final ExtensionContext context) {
    // test scoped extension scope (required to differentiate nested classes or parameterized executions)
    return context.getStore(ExtensionContext.Namespace
            .create(GuiceyExtensionsSupport.class, context.getRequiredTestClass()));
}
 

/**
 * We use custom namespace based on this extension class and test class, cannot be stored as static variable as test class
 * name changes throughout testsuite execution
 *
 * @param context {@link ExtensionContext} you are currently using
 * @return {@link ExtensionContext.Store} based on {@link ExtensionContext} and the required test class
 */
private static ExtensionContext.Store getTestStore(ExtensionContext context) {
    return context.getStore(Namespace.create(WeldJunit5Extension.class, context.getRequiredTestClass()));
}
 

/**
 * Get extension store.
 *
 * @param context The extension context.
 * @return The extension store.
 */
private static Store getStore(ExtensionContext context) {
	return context.getStore(NAMESPACE);
}