All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • io.datakernel.test.DatakernelRunner Maven / Gradle / Ivy

    The newest version!
    package io.datakernel.test;

import io.datakernel.di.core.*;
import io.datakernel.di.module.Module;
import io.datakernel.di.module.Modules;
import io.datakernel.di.util.ReflectionUtils;
import io.datakernel.di.util.Types;
import io.datakernel.test.rules.LambdaStatement;
import org.junit.After;
import org.junit.Before;
import org.junit.runner.Description;
import org.junit.runner.notification.Failure;
import org.junit.runner.notification.RunNotifier;
import org.junit.runners.BlockJUnit4ClassRunner;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.InitializationError;
import org.junit.runners.model.MultipleFailureException;
import org.junit.runners.model.Statement;

import java.lang.annotation.Annotation;
import java.util.*;

import static io.datakernel.common.collection.CollectionUtils.union;
import static java.util.stream.Collectors.toSet;

public class DatakernelRunner extends BlockJUnit4ClassRunner {
	private final Set surroundings = new HashSet<>();
	private final Set staticDependencies;

	private Module currentModule;
	private Set currentDependencies;

	protected Injector currentInjector;

	public DatakernelRunner(Class clazz) throws InitializationError {
		super(clazz);

		surroundings.addAll(getTestClass().getAnnotatedMethods(Before.class));
		surroundings.addAll(getTestClass().getAnnotatedMethods(After.class));

		staticDependencies = surroundings.stream()
				.flatMap(m -> Arrays.stream(ReflectionUtils.toDependencies(clazz, m.getMethod().getParameters())))
				.collect(toSet());
	}

	// runChild is always called before createTest
	@Override
	protected void runChild(FrameworkMethod method, RunNotifier notifier) {
		Description description = describeChild(method);
		if (isIgnored(method)) {
			notifier.fireTestIgnored(description);
			return;
		}
		try {
			Class cls = getTestClass().getJavaClass();

			Set modules = new HashSet<>();

			addClassModules(modules, cls); // add modules from class annotation
			addMethodModules(modules, method); // add modules from current test method
			for (FrameworkMethod m : surroundings) { // add modules from befores and afters
				addMethodModules(modules, m);
			}
			currentModule = Modules.combine(modules);

			currentDependencies =
					Arrays.stream(ReflectionUtils.toDependencies(cls, method.getMethod().getParameters()))
							.collect(toSet());

		} catch (ExceptionInInitializerError e) {
			Throwable cause = e.getCause();
			notifier.fireTestFailure(new Failure(description, cause != null ? cause : e));
			return;
		} catch (Exception e) {
			notifier.fireTestFailure(new Failure(description, e));
			return;
		}

		runLeaf(methodBlock(method), description, notifier);
	}

	private static void addClassModules(Set modules, Class cls) throws IllegalAccessException, InstantiationException, ExceptionInInitializerError {
		while (cls != null) {
			UseModules useModules = cls.getAnnotation(UseModules.class);
			if (useModules != null) {
				for (Class moduleClass : useModules.value()) {
					modules.add(moduleClass.newInstance());
				}
			}
			cls = cls.getSuperclass();
		}
	}

	private static void addMethodModules(Set modules, FrameworkMethod method) throws IllegalAccessException, InstantiationException, ExceptionInInitializerError {
		UseModules useModules = method.getMethod().getAnnotation(UseModules.class);
		if (useModules == null) {
			return;
		}
		for (Class moduleClass : useModules.value()) {
			modules.add(moduleClass.newInstance());
		}
	}

	private static final class DependencyToken {}

	// createTest is always called after runChild
	@Override
	protected Object createTest() throws Exception {
		Object instance = super.createTest();

		Key self = Key.ofType(getTestClass().getJavaClass());

		Key> instanceInjectorKey = Key.ofType(Types.parameterized(InstanceInjector.class, getTestClass().getJavaClass()));

		currentInjector = Injector.of(currentModule, Module.create()
				// scan the test class for @Provide's
				.scan(instance)

				// bind unusable private type with all the extra dependencies so that injector knows about them
				.bind(DependencyToken.class).to(Binding.to(() -> {
					throw new AssertionError("should never be instantiated");
				}).addDependencies(union(currentDependencies, staticDependencies)))

				// bind test class to existing instance if whoever needs it (e.g. for implicit parameter of non-static inner classes)
				.bind(self).toInstance(instance)

				// and generate one of those to handle @Inject's
				.bind(instanceInjectorKey));

		// creating eager stuff right away
		currentInjector.createEagerInstances();

		// and also actually handle the @Inject's
		currentInjector.getInstance(instanceInjectorKey).injectInto(instance);

		return instance;
	}

	// allow test methods to have any arguments
	@Override
	protected void validatePublicVoidNoArgMethods(Class annotation, boolean isStatic, List errors) {
		for (FrameworkMethod testMethod : getTestClass().getAnnotatedMethods(annotation)) {
			testMethod.validatePublicVoid(isStatic, errors);
		}
	}

	// invoke methods with args fetched from current injector
	@Override
	protected Statement methodInvoker(FrameworkMethod method, Object test) {
		return new LambdaStatement(() -> method.invokeExplosively(test, getArgs(method)));
	}

	protected Object[] getArgs(FrameworkMethod method) {
		return Arrays.stream(ReflectionUtils.toDependencies(getTestClass().getJavaClass(), method.getMethod().getParameters()))
				.map(dependency -> dependency.isRequired() ?
						currentInjector.getInstance(dependency.getKey()) :
						currentInjector.getInstanceOrNull(dependency.getKey()))
				.toArray(Object[]::new);
	}

	// same as original except that methods are called like in methodInvoker method
	@Override
	protected Statement withBefores(FrameworkMethod method, Object target, Statement test) {
		List methods = getTestClass().getAnnotatedMethods(Before.class);
		if (methods.isEmpty()) {
			return test;
		}
		return new LambdaStatement(() -> {
			for (FrameworkMethod m : methods) {
				m.invokeExplosively(target, getArgs(m));
			}
			test.evaluate();
		});
	}

	// same as above
	@Override
	protected Statement withAfters(FrameworkMethod method, Object target, Statement test) {
		List methods = getTestClass().getAnnotatedMethods(After.class);
		if (methods.isEmpty()) {
			return test;
		}
		return new LambdaStatement(() -> {
			List errors = new ArrayList<>();
			try {
				test.evaluate();
			} catch (Throwable e) {
				errors.add(e);
			} finally {
				for (FrameworkMethod m : methods) {
					try {
						m.invokeExplosively(target, getArgs(m));
					} catch (Throwable e) {
						errors.add(e);
					}
				}
			}
			MultipleFailureException.assertEmpty(errors);
		});
	}
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy