package org.apache.maven.plugin;
/*
* 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.
*/
import java.util.List;
import org.apache.maven.AbstractCoreMavenComponentTestCase;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.repository.DefaultRepositoryRequest;
import org.apache.maven.artifact.repository.RepositoryRequest;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.model.Plugin;
import org.apache.maven.plugin.descriptor.MojoDescriptor;
import org.apache.maven.plugin.descriptor.PluginDescriptor;
import org.apache.maven.project.MavenProject;
import org.codehaus.plexus.component.annotations.Requirement;
import org.codehaus.plexus.component.repository.ComponentDescriptor;
public class PluginManagerTest
extends AbstractCoreMavenComponentTestCase
{
@Requirement
private DefaultBuildPluginManager pluginManager;
protected void setUp()
throws Exception
{
super.setUp();
pluginManager = (DefaultBuildPluginManager) lookup( BuildPluginManager.class );
}
@Override
protected void tearDown()
throws Exception
{
pluginManager = null;
super.tearDown();
}
protected String getProjectsDirectory()
{
return "src/test/projects/plugin-manager";
}
public void testPluginLoading()
throws Exception
{
MavenSession session = createMavenSession( null );
Plugin plugin = new Plugin();
plugin.setGroupId( "org.apache.maven.its.plugins" );
plugin.setArtifactId( "maven-it-plugin" );
plugin.setVersion( "0.1" );
PluginDescriptor pluginDescriptor =
pluginManager.loadPlugin( plugin, session.getCurrentProject().getRemotePluginRepositories(),
session.getRepositorySession() );
assertNotNull( pluginDescriptor );
}
public void testMojoDescriptorRetrieval()
throws Exception
{
MavenSession session = createMavenSession( null );
String goal = "it";
Plugin plugin = new Plugin();
plugin.setGroupId( "org.apache.maven.its.plugins" );
plugin.setArtifactId( "maven-it-plugin" );
plugin.setVersion( "0.1" );
MojoDescriptor mojoDescriptor =
pluginManager.getMojoDescriptor( plugin, goal, session.getCurrentProject().getRemotePluginRepositories(),
session.getRepositorySession() );
assertNotNull( mojoDescriptor );
assertEquals( goal, mojoDescriptor.getGoal() );
// igorf: plugin realm comes later
// assertNotNull( mojoDescriptor.getRealm() );
PluginDescriptor pluginDescriptor = mojoDescriptor.getPluginDescriptor();
assertNotNull( pluginDescriptor );
assertEquals( "org.apache.maven.its.plugins", pluginDescriptor.getGroupId() );
assertEquals( "maven-it-plugin", pluginDescriptor.getArtifactId() );
assertEquals( "0.1", pluginDescriptor.getVersion() );
}
// -----------------------------------------------------------------------------------------------
// Tests which exercise the lifecycle executor when it is dealing with individual goals.
// -----------------------------------------------------------------------------------------------
//TODO: These two tests display a lack of symmetry with respect to the input which is a free form string and the
// mojo descriptor which comes back. All the free form parsing needs to be done somewhere else, this is
// really the function of the CLI, and then the pre-processing of that output still needs to be fed into
// a hinting process which helps flesh out the full specification of the plugin. The plugin manager should
// only deal in concrete terms -- all version finding mumbo jumbo is a customization to base functionality
// the plugin manager provides.
public void testRemoteResourcesPlugin()
throws Exception
{
//TODO: turn an equivalent back on when the RR plugin is released.
/*
This will not work until the RR plugin is released to get rid of the binding to the reporting exception which is a mistake.
This happpens after removing the reporting API from the core:
java.lang.NoClassDefFoundError: org/apache/maven/reporting/MavenReportException
MavenSession session = createMavenSession( getProject( "project-with-inheritance" ) );
String goal = "process";
Plugin plugin = new Plugin();
plugin.setGroupId( "org.apache.maven.plugins" );
plugin.setArtifactId( "maven-remote-resources-plugin" );
plugin.setVersion( "1.0-beta-2" );
MojoDescriptor mojoDescriptor = pluginManager.getMojoDescriptor( plugin, goal, session.getCurrentProject(), session.getLocalRepository() );
assertPluginDescriptor( mojoDescriptor, "org.apache.maven.plugins", "maven-remote-resources-plugin", "1.0-beta-2" );
MojoExecution mojoExecution = new MojoExecution( mojoDescriptor );
pluginManager.executeMojo( session, mojoExecution );
*/
}
//TODO: this will be the basis of the customizable lifecycle execution so need to figure this out quickly.
public void testSurefirePlugin()
throws Exception
{
/*
MavenSession session = createMavenSession( getProject( "project-with-inheritance" ) );
String goal = "test";
Plugin plugin = new Plugin();
plugin.setGroupId( "org.apache.maven.plugins" );
plugin.setArtifactId( "maven-surefire-plugin" );
plugin.setVersion( "2.4.2" );
// The project has already been fully interpolated so getting the raw mojoDescriptor is not going to have the processes configuration.
MojoDescriptor mojoDescriptor = pluginManager.getMojoDescriptor( plugin, goal, session.getLocalRepository(), session.getCurrentProject().getPluginArtifactRepositories() );
assertPluginDescriptor( mojoDescriptor, "org.apache.maven.plugins", "maven-surefire-plugin", "2.4.2" );
System.out.println( session.getCurrentProject().getBuild().getPluginsAsMap() );
Xpp3Dom configuration = (Xpp3Dom) session.getCurrentProject().getBuild().getPluginsAsMap().get( plugin.getKey() ).getExecutions().get( 0 ).getConfiguration();
MojoExecution mojoExecution = new MojoExecution( mojoDescriptor, configuration );
pluginManager.executeMojo( session, mojoExecution );
*/
}
public void testMojoConfigurationIsMergedCorrectly()
throws Exception
{
}
/**
* The case where the user wants to specify an alternate version of the underlying tool. Common case
* is in the Antlr plugin which comes bundled with a version of Antlr but the user often times needs
* to use a specific version. We need to make sure the version that they specify takes precedence.
*/
public void testMojoWhereInternallyStatedDependencyIsOverriddenByProject()
throws Exception
{
}
/**
* The case where you have a plugin in the current build that you want to be used on projects in
* the current build.
*/
public void testMojoThatIsPresentInTheCurrentBuild()
throws Exception
{
}
/**
* This is the case where the Mojo wants to execute on every project and then do something at the end
* with the results of each project.
*/
public void testAggregatorMojo()
throws Exception
{
}
/**
* This is the case where a Mojo needs the lifecycle run to a certain phase before it can do
* anything useful.
*/
public void testMojoThatRequiresExecutionToAGivenPhaseBeforeExecutingItself()
throws Exception
{
}
// test that mojo which does not require dependency resolution trigger no downloading of dependencies
// test interpolation of basedir values in mojo configuration
// test a build where projects use different versions of the same plugin
public void testThatPluginDependencyThatHasSystemScopeIsResolved()
throws Exception
{
/*
File systemPath = new File( getBasedir(), "pom.xml" );
Plugin plugin = new PluginBuilder( "org.apache.maven", "project-test", "1.0" )
.addDependency( "org.apache.maven", "system-dependency", "1.0", Artifact.SCOPE_SYSTEM, systemPath.getAbsolutePath() )
.get();
MavenProject pluginProject = new ProjectBuilder( "org.apache.maven", "project-test", "1.0" )
.addPlugin( plugin )
.addDependency( "junit", "junit", "3.8.1", Artifact.SCOPE_COMPILE )
.get();
// i'm making this artifact which is assumed to come from a pom in the metadata processor, then it tries to create a POM artifact
// and parse it for the dependencies and it blows up.
//
// we need to pass this through as is so it doesn't get parsed again.
Artifact pluginArtifact = new ProjectArtifact( pluginProject );
Set<Artifact> artifacts = pluginManager.getPluginArtifacts( pluginArtifact, plugin, getLocalRepository(), getPluginArtifactRepositories() );
System.out.println( artifacts );
*/
MavenSession session = createMavenSession( getProject( "project-contributing-system-scope-plugin-dep" ) );
MavenProject project = session.getCurrentProject();
Plugin plugin = project.getPlugin( "org.apache.maven.its.plugins:maven-it-plugin" );
RepositoryRequest repositoryRequest = new DefaultRepositoryRequest();
repositoryRequest.setLocalRepository( getLocalRepository() );
repositoryRequest.setRemoteRepositories( getPluginArtifactRepositories() );
PluginDescriptor pluginDescriptor =
pluginManager.loadPlugin( plugin, session.getCurrentProject().getRemotePluginRepositories(),
session.getRepositorySession() );
pluginManager.getPluginRealm( session, pluginDescriptor );
List<Artifact> artifacts = pluginDescriptor.getArtifacts();
for ( Artifact a : artifacts )
{
if ( a.getGroupId().equals( "org.apache.maven.its.mng3586" ) && a.getArtifactId().equals( "tools" ) )
{
// The system scoped dependencies will be present in the classloader for the plugin
return;
}
}
fail( "Can't find the system scoped dependency in the plugin artifacts." );
}
// -----------------------------------------------------------------------------------------------
// Testing help
// -----------------------------------------------------------------------------------------------
protected void assertPluginDescriptor( MojoDescriptor mojoDescriptor, String groupId, String artifactId, String version )
{
assertNotNull( mojoDescriptor );
PluginDescriptor pd = mojoDescriptor.getPluginDescriptor();
assertNotNull( pd );
assertEquals( groupId, pd.getGroupId() );
assertEquals( artifactId, pd.getArtifactId() );
assertEquals( version, pd.getVersion() );
}
public void testPluginRealmCache()
throws Exception
{
RepositoryRequest repositoryRequest = new DefaultRepositoryRequest();
repositoryRequest.setLocalRepository( getLocalRepository() );
repositoryRequest.setRemoteRepositories( getPluginArtifactRepositories() );
// prime realm cache
MavenSession session = createMavenSession( getProject( "project-contributing-system-scope-plugin-dep" ) );
MavenProject project = session.getCurrentProject();
Plugin plugin = project.getPlugin( "org.apache.maven.its.plugins:maven-it-plugin" );
PluginDescriptor pluginDescriptor =
pluginManager.loadPlugin( plugin, session.getCurrentProject().getRemotePluginRepositories(),
session.getRepositorySession() );
pluginManager.getPluginRealm( session, pluginDescriptor );
assertEquals( 1, pluginDescriptor.getDependencies().size() );
for ( ComponentDescriptor<?> descriptor : pluginDescriptor.getComponents() )
{
assertNotNull( descriptor.getRealm() );
assertNotNull( descriptor.getImplementationClass() );
}
// reload plugin realm from cache
session = createMavenSession( getProject( "project-contributing-system-scope-plugin-dep" ) );
project = session.getCurrentProject();
plugin = project.getPlugin( "org.apache.maven.its.plugins:maven-it-plugin" );
pluginDescriptor =
pluginManager.loadPlugin( plugin, session.getCurrentProject().getRemotePluginRepositories(),
session.getRepositorySession() );
pluginManager.getPluginRealm( session, pluginDescriptor );
assertEquals( 1, pluginDescriptor.getDependencies().size() );
for ( ComponentDescriptor<?> descriptor : pluginDescriptor.getComponents() )
{
assertNotNull( descriptor.getRealm() );
assertNotNull( descriptor.getImplementationClass() );
}
}
}