MoonshineRunner.java

/*
 * Copyright 2012 Atteo.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.atteo.moonshine.tests;

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;

import org.atteo.moonshine.Moonshine;
import org.atteo.moonshine.tests.MoonshineConfiguration.Config;
import org.junit.rules.MethodRule;
import org.junit.rules.TestRule;
import org.junit.runner.Description;
import org.junit.runners.BlockJUnit4ClassRunner;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.InitializationError;

import com.google.common.base.Joiner;
import com.google.common.collect.Lists;
import com.google.common.reflect.TypeToken;
import com.google.inject.AbstractModule;
import com.google.inject.TypeLiteral;

/**
 * Runs the tests inside {@link Moonshine} container.
 *
 * <p>
 * You can configure the container by annotating the class with
 * {@link MoonshineConfiguration}.
 * </p>
 * <p>
 * The test class will be instantiated using global Guice injector of the
 * Moonshine container.
 * </p>
 */
public class MoonshineRunner extends BlockJUnit4ClassRunner {

	private MoonshineRule moonshineRule = null;
	private boolean requestPerClass = false;
	private final List<Config> iterationConfigs;
	private final List<String> iterationIds;
	private final Class<?> klass;

	public MoonshineRunner(Class<?> klass) throws InitializationError {
		super(klass);
		this.klass = klass;
		iterationConfigs = Collections.emptyList();
		iterationIds = Collections.emptyList();
	}

	/**
	 * Used by {@link MoonshineMultiRunner}.
	 */
	MoonshineRunner(Class<?> klass, List<Config> iterationConfigs) throws InitializationError {
		super(klass);
		this.klass = klass;
		this.iterationConfigs = iterationConfigs;
		iterationIds = getIterationIds(iterationConfigs);
	}

	@Override
	protected Object createTest() throws Exception {
		return moonshineRule.getGlobalInjector().getInstance(getTestClass().getJavaClass());
	}

	@Override
	protected List<TestRule> classRules() {
		@SuppressWarnings("unchecked")
		Set<Class<?>> ancestorSet = (Set<Class<?>>) TypeToken.of(getTestClass().getJavaClass()).getTypes().rawTypes();
		List<Class<?>> ancestors = Lists.reverse(new ArrayList<>(ancestorSet));

		final List<String> configPaths = new ArrayList<>();
		List<MoonshineConfigurator> configurators = new ArrayList<>();
		AtomicBoolean loadTestConfigXml = new AtomicBoolean(true);

		for (Class<?> ancestor : ancestors) {
			analyseAncestor(ancestor, configPaths, configurators, loadTestConfigXml);
		}

		analyseIterationConfigs(configPaths, configurators);

		moonshineRule = new MoonshineRule(configurators, configPaths.toArray(new String[configPaths.size()]));
		moonshineRule.setLoadTestConfigXml(loadTestConfigXml.get());

		List<TestRule> rules = super.classRules();
		if (requestPerClass) {
			rules.add(new RequestRule());
		}

		rules.add(moonshineRule);
		return rules;
	}

	@Override
	protected String getName() {
		String name = super.getName();
		if (!iterationConfigs.isEmpty()) {
			return name + " with config [" + Joiner.on(",").join(iterationIds) + "]";
		}
		return name;
	}

	@Override
	public Description getDescription() {
		Description description = Description.createTestDescription(klass, getName(), getRunnerAnnotations());
		for (FrameworkMethod child : getChildren()) {
			description.addChild(describeChild(child));
		}
		return description;
	}

	private void analyseIterationConfigs(final List<String> configs, List<MoonshineConfigurator> configurators) {
		if (iterationConfigs.isEmpty()) {
			return;
		}
		for (Config config : iterationConfigs) {
			if (config.value().length != 0) {
				configs.addAll(Arrays.asList(config.value()));
			}
		}

		configurators.add((MoonshineConfigurator) (Moonshine.Builder builder) -> {
			for (Config config : iterationConfigs) {
				if (!config.fromString().isEmpty()) {
					builder.addConfigurationFromString(config.fromString());
				}
			}
			builder.addModule(new AbstractModule() {
				@Override
				protected void configure() {
					bind(new TypeLiteral<List<String>>() {}).annotatedWith(EnabledConfigs.class)
							.toInstance(iterationIds);
				}
			});
			builder.applicationName(klass.getSimpleName() + "[" + Joiner.on(",").join(iterationIds) + "]");
		});
	}

	private static List<String> getIterationIds(List<Config> iterationConfigs) {
		final List<String> iterationIds = new ArrayList<>();
		for (Config config : iterationConfigs) {
			iterationIds.add(config.id());
		}
		return iterationIds;
	}

	private static String getPathToResource(Class<?> klass, String annotationValue) {
		if (annotationValue.startsWith("/")) {
			return annotationValue;
		} else {
			return "/" + klass.getPackage().getName().replace(".", "/") + "/" + annotationValue;
		}
	}

	private void analyseAncestor(Class<?> ancestor, final List<String> configs,
			List<MoonshineConfigurator> configurators, final AtomicBoolean loadTestConfigXml) {
		final MoonshineConfiguration annotation = ancestor.getAnnotation(MoonshineConfiguration.class);
		if (annotation == null) {
			return;
		}
		loadTestConfigXml.set(false);
		for (String config : annotation.value()) {
			configs.add(getPathToResource(ancestor, config));
		}
		requestPerClass = annotation.oneRequestPerClass();
		if ((annotation.forEach().length != 0 || annotation.forCartesianProductOf().length != 0)
				&& iterationConfigs.isEmpty()) {
			throw new RuntimeException("Error on class " + ancestor.getName()
					+ ": @" + MoonshineConfiguration.class.getSimpleName()
					+ " forEach and forCartesianProductOf can be used only with "
					+ MoonshineMultiRunner.class.getSimpleName());
		}
		Class<? extends MoonshineConfigurator> configuratorKlass = annotation.configurator();
		if (configuratorKlass != null && configuratorKlass != MoonshineConfigurator.class) {
			try {
				MoonshineConfigurator configurator = configuratorKlass.getConstructor().newInstance();
				configurators.add(configurator);
			} catch (NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException
					| IllegalArgumentException | InvocationTargetException e) {
				throw new RuntimeException(e);
			}
		}
		if (annotation.autoConfiguration() || annotation.skipDefault() || !annotation.fromString().isEmpty()
				|| annotation.arguments().length != 0) {
			MoonshineConfigurator configurator = (Moonshine.Builder builder) -> {
				if (annotation.autoConfiguration()) {
					builder.autoConfiguration();
				}
				if (annotation.skipDefault()) {
					builder.skipDefaultConfigurationFiles();
				}
				if (!annotation.fromString().isEmpty()) {
					builder.addConfigurationFromString(annotation.fromString());
				}
				
				builder.arguments(annotation.arguments());
			};
			configurators.add(configurator);
		}
	}

	@Override
	protected List<TestRule> getTestRules(Object target) {
		List<TestRule> rules = super.getTestRules(target);
		if (!requestPerClass) {
			rules.add(new RequestRule());
		}
		return rules;
	}

	@Override
	protected List<MethodRule> rules(Object target) {
		List<MethodRule> rules = super.rules(target);
		rules.add(moonshineRule.injectMembers(target));
		rules.add(new MockitoRule());
		return rules;
	}
}