| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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.apache.maven.scm; |
| |
| import java.io.File; |
| import java.io.InputStream; |
| import java.util.Map; |
| |
| import com.google.inject.Module; |
| import org.codehaus.plexus.ContainerConfiguration; |
| import org.codehaus.plexus.DefaultContainerConfiguration; |
| import org.codehaus.plexus.DefaultPlexusContainer; |
| import org.codehaus.plexus.PlexusConstants; |
| import org.codehaus.plexus.PlexusContainer; |
| import org.codehaus.plexus.PlexusContainerException; |
| import org.codehaus.plexus.configuration.PlexusConfiguration; |
| import org.codehaus.plexus.context.Context; |
| import org.codehaus.plexus.context.DefaultContext; |
| import org.junit.After; |
| import org.junit.Before; |
| import org.junit.Rule; |
| import org.junit.rules.TestName; |
| |
| import static org.junit.Assert.fail; |
| |
| /** |
| * Based on PlexusTestCase from org.sonatype.sisu:sisu-inject-plexus. |
| * Note: this class is copied from maven-release. |
| * |
| * @author Robert Scholte |
| */ |
| public class PlexusJUnit4TestCase { |
| private PlexusContainer container; |
| |
| private static String basedir; |
| |
| @Rule |
| public TestName testName = new TestName(); |
| |
| @Before |
| public void setUp() throws Exception { |
| basedir = getBasedir(); |
| } |
| |
| public String getName() { |
| return testName.getMethodName(); |
| } |
| |
| protected void setupContainer() { |
| // ---------------------------------------------------------------------------- |
| // Context Setup |
| // ---------------------------------------------------------------------------- |
| |
| final DefaultContext context = new DefaultContext(); |
| |
| context.put("basedir", getBasedir()); |
| |
| customizeContext(context); |
| |
| final boolean hasPlexusHome = context.contains("plexus.home"); |
| |
| if (!hasPlexusHome) { |
| final File f = getTestFile("target/plexus-home"); |
| |
| if (!f.isDirectory()) { |
| f.mkdir(); |
| } |
| |
| context.put("plexus.home", f.getAbsolutePath()); |
| } |
| |
| // ---------------------------------------------------------------------------- |
| // Configuration |
| // ---------------------------------------------------------------------------- |
| |
| final String config = getCustomConfigurationName(); |
| |
| final ContainerConfiguration containerConfiguration = new DefaultContainerConfiguration() |
| .setName("test") |
| .setContext(context.getContextData()) |
| .setAutoWiring(true) |
| .setClassPathScanning(PlexusConstants.SCANNING_CACHE); |
| |
| if (config != null) { |
| containerConfiguration.setContainerConfiguration(config); |
| } else { |
| final String resource = getConfigurationName(null); |
| |
| containerConfiguration.setContainerConfiguration(resource); |
| } |
| |
| customizeContainerConfiguration(containerConfiguration); |
| |
| try { |
| container = new DefaultPlexusContainer(containerConfiguration, getCustomModules()); |
| } catch (final PlexusContainerException e) { |
| e.printStackTrace(); |
| fail("Failed to create plexus container."); |
| } |
| } |
| |
| /** |
| * Allows test to define custom modules. |
| */ |
| public Module[] getCustomModules() { |
| return new Module[0]; |
| } |
| |
| /** |
| * Allow custom test case implementations do augment the default container configuration before executing tests. |
| * |
| * @param containerConfiguration |
| */ |
| protected void customizeContainerConfiguration(final ContainerConfiguration containerConfiguration) {} |
| |
| protected void customizeContext(final Context context) {} |
| |
| protected PlexusConfiguration customizeComponentConfiguration() { |
| return null; |
| } |
| |
| @After |
| public void tearDown() throws Exception { |
| if (container != null) { |
| container.dispose(); |
| |
| container = null; |
| } |
| } |
| |
| protected PlexusContainer getContainer() { |
| if (container == null) { |
| setupContainer(); |
| } |
| |
| return container; |
| } |
| |
| protected InputStream getConfiguration() throws Exception { |
| return getConfiguration(null); |
| } |
| |
| @SuppressWarnings("unused") |
| protected InputStream getConfiguration(final String subname) throws Exception { |
| return getResourceAsStream(getConfigurationName(subname)); |
| } |
| |
| protected String getCustomConfigurationName() { |
| return null; |
| } |
| |
| /** |
| * Allow the retrieval of a container configuration that is based on the name of the test class being run. So if you |
| * have a test class called org.foo.FunTest, then this will produce a resource name of org/foo/FunTest.xml which |
| * would be used to configure the Plexus container before running your test. |
| * |
| * @param subname |
| * @return |
| */ |
| protected String getConfigurationName(final String subname) { |
| return getClass().getName().replace('.', '/') + ".xml"; |
| } |
| |
| protected InputStream getResourceAsStream(final String resource) { |
| return getClass().getResourceAsStream(resource); |
| } |
| |
| protected ClassLoader getClassLoader() { |
| return getClass().getClassLoader(); |
| } |
| |
| // ---------------------------------------------------------------------- |
| // Container access |
| // ---------------------------------------------------------------------- |
| |
| protected Object lookup(final String componentKey) throws Exception { |
| return getContainer().lookup(componentKey); |
| } |
| |
| protected Object lookup(final String role, final String roleHint) throws Exception { |
| return getContainer().lookup(role, roleHint); |
| } |
| |
| protected <T> T lookup(final Class<T> componentClass) throws Exception { |
| return getContainer().lookup(componentClass); |
| } |
| |
| protected <T> T lookup(final Class<T> componentClass, final String roleHint) throws Exception { |
| return getContainer().lookup(componentClass, roleHint); |
| } |
| |
| protected <T> Map<String, T> lookupMap(final Class<T> componentClass) throws Exception { |
| return getContainer().lookupMap(componentClass); |
| } |
| |
| protected void release(final Object component) throws Exception { |
| getContainer().release(component); |
| } |
| |
| // ---------------------------------------------------------------------- |
| // Helper methods for sub classes |
| // ---------------------------------------------------------------------- |
| |
| public static File getTestFile(final String path) { |
| return new File(getBasedir(), path); |
| } |
| |
| @SuppressWarnings("hiding") |
| public static File getTestFile(final String basedir, final String path) { |
| File basedirFile = new File(basedir); |
| |
| if (!basedirFile.isAbsolute()) { |
| basedirFile = getTestFile(basedir); |
| } |
| |
| return new File(basedirFile, path); |
| } |
| |
| public static String getTestPath(final String path) { |
| return getTestFile(path).getAbsolutePath(); |
| } |
| |
| @SuppressWarnings("hiding") |
| public static String getTestPath(final String basedir, final String path) { |
| return getTestFile(basedir, path).getAbsolutePath(); |
| } |
| |
| public static String getBasedir() { |
| if (basedir != null) { |
| return basedir; |
| } |
| |
| basedir = System.getProperty("basedir"); |
| |
| if (basedir == null) { |
| basedir = new File("").getAbsolutePath(); |
| } |
| |
| return basedir; |
| } |
| |
| public String getTestConfiguration() { |
| return getTestConfiguration(getClass()); |
| } |
| |
| public static String getTestConfiguration(final Class<?> clazz) { |
| final String s = clazz.getName().replace('.', '/'); |
| |
| return s.substring(0, s.indexOf("$")) + ".xml"; |
| } |
| } |