org.codehaus.plexus.PlexusTestCase Maven / Gradle / Ivy
package org.codehaus.plexus;
/*
* Copyright 2001-2006 Codehaus Foundation.
*
* 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.
*/
import java.io.File;
import java.io.InputStream;
import junit.framework.TestCase;
import org.codehaus.plexus.configuration.PlexusConfiguration;
import org.codehaus.plexus.context.Context;
import org.codehaus.plexus.context.DefaultContext;
/**
* @author Jason van Zyl
* @author Trygve Laugstøl
* @author Michal Maczka
* @version $Id: PlexusTestCase.java 8420 2009-09-18 22:56:56Z hboutemy $
*/
public abstract class PlexusTestCase
extends TestCase
{
private PlexusContainer container;
private static String basedir;
protected void setUp()
throws Exception
{
basedir = getBasedir();
}
protected void setupContainer()
{
// ----------------------------------------------------------------------------
// Context Setup
// ----------------------------------------------------------------------------
DefaultContext context = new DefaultContext();
context.put( "basedir", getBasedir() );
customizeContext( context );
boolean hasPlexusHome = context.contains( "plexus.home" );
if ( !hasPlexusHome )
{
File f = getTestFile( "target/plexus-home" );
if ( !f.isDirectory() )
{
f.mkdir();
}
context.put( "plexus.home", f.getAbsolutePath() );
}
// ----------------------------------------------------------------------------
// Configuration
// ----------------------------------------------------------------------------
String config = getCustomConfigurationName();
ContainerConfiguration containerConfiguration = new DefaultContainerConfiguration()
.setName( "test" )
.setContext( context.getContextData() );
if ( config != null )
{
containerConfiguration.setContainerConfiguration( config );
}
else
{
String resource = getConfigurationName( null );
containerConfiguration.setContainerConfiguration( resource );
}
customizeContainerConfiguration( containerConfiguration );
try
{
container = new DefaultPlexusContainer( containerConfiguration );
}
catch ( PlexusContainerException e )
{
e.printStackTrace();
fail( "Failed to create plexus container." );
}
}
/**
* Allow custom test case implementations do augment the default container configuration before
* executing tests.
*
* @param containerConfiguration
*/
protected void customizeContainerConfiguration( ContainerConfiguration containerConfiguration )
{
}
protected void customizeContext( Context context )
{
}
protected PlexusConfiguration customizeComponentConfiguration()
{
return null;
}
protected 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 );
}
protected InputStream getConfiguration( 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( String subname )
{
return getClass().getName().replace( '.', '/' ) + ".xml";
}
protected InputStream getResourceAsStream( String resource )
{
return getClass().getResourceAsStream( resource );
}
protected ClassLoader getClassLoader()
{
return getClass().getClassLoader();
}
// ----------------------------------------------------------------------
// Container access
// ----------------------------------------------------------------------
protected Object lookup( String componentKey )
throws Exception
{
return getContainer().lookup( componentKey );
}
protected Object lookup( String role,
String roleHint )
throws Exception
{
return getContainer().lookup( role, roleHint );
}
protected T lookup( Class componentClass )
throws Exception
{
return getContainer().lookup( componentClass );
}
protected T lookup( Class componentClass, String roleHint )
throws Exception
{
return getContainer().lookup( componentClass, roleHint );
}
protected void release( Object component )
throws Exception
{
getContainer().release( component );
}
// ----------------------------------------------------------------------
// Helper methods for sub classes
// ----------------------------------------------------------------------
public static File getTestFile( String path )
{
return new File( getBasedir(), path );
}
public static File getTestFile( String basedir,
String path )
{
File basedirFile = new File( basedir );
if ( !basedirFile.isAbsolute() )
{
basedirFile = getTestFile( basedir );
}
return new File( basedirFile, path );
}
public static String getTestPath( String path )
{
return getTestFile( path ).getAbsolutePath();
}
public static String getTestPath( String basedir,
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( Class clazz )
{
String s = clazz.getName().replace( '.', '/' );
return s.substring( 0, s.indexOf( "$" ) ) + ".xml";
}
}