--- /dev/null
+package org.apache.archiva.dependency.tree.maven2;
+/*
+ * 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 org.apache.archiva.admin.model.RepositoryAdminException;
+import org.apache.archiva.admin.model.beans.ManagedRepository;
+import org.apache.archiva.admin.model.beans.NetworkProxy;
+import org.apache.archiva.admin.model.beans.ProxyConnector;
+import org.apache.archiva.admin.model.beans.RemoteRepository;
+import org.apache.archiva.admin.model.managed.ManagedRepositoryAdmin;
+import org.apache.archiva.admin.model.networkproxy.NetworkProxyAdmin;
+import org.apache.archiva.admin.model.proxyconnector.ProxyConnectorAdmin;
+import org.apache.archiva.admin.model.remote.RemoteRepositoryAdmin;
+import org.apache.archiva.common.plexusbridge.PlexusSisuBridge;
+import org.apache.archiva.common.plexusbridge.PlexusSisuBridgeException;
+import org.apache.archiva.metadata.repository.storage.RepositoryPathTranslator;
+import org.apache.archiva.metadata.repository.storage.maven2.RepositoryModelResolver;
+import org.apache.archiva.proxy.common.WagonFactory;
+import org.apache.maven.RepositoryUtils;
+import org.apache.maven.artifact.Artifact;
+import org.apache.maven.artifact.factory.ArtifactFactory;
+import org.apache.maven.artifact.versioning.VersionRange;
+import org.apache.maven.model.DependencyManagement;
+import org.apache.maven.model.Exclusion;
+import org.apache.maven.model.Model;
+import org.apache.maven.model.building.DefaultModelBuilderFactory;
+import org.apache.maven.model.building.DefaultModelBuildingRequest;
+import org.apache.maven.model.building.ModelBuilder;
+import org.apache.maven.model.building.ModelBuildingException;
+import org.apache.maven.model.building.ModelBuildingRequest;
+import org.apache.maven.model.resolution.UnresolvableModelException;
+import org.apache.maven.project.DefaultDependencyResolutionRequest;
+import org.apache.maven.project.DefaultProjectBuildingRequest;
+import org.apache.maven.project.DependencyResolutionException;
+import org.apache.maven.project.DependencyResolutionResult;
+import org.apache.maven.project.MavenProject;
+import org.codehaus.plexus.util.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.sonatype.aether.RepositorySystem;
+import org.sonatype.aether.RepositorySystemSession;
+import org.sonatype.aether.RequestTrace;
+import org.sonatype.aether.artifact.ArtifactType;
+import org.sonatype.aether.artifact.ArtifactTypeRegistry;
+import org.sonatype.aether.collection.CollectRequest;
+import org.sonatype.aether.collection.DependencyCollectionException;
+import org.sonatype.aether.graph.Dependency;
+import org.sonatype.aether.graph.DependencyFilter;
+import org.sonatype.aether.impl.internal.SimpleLocalRepositoryManager;
+import org.sonatype.aether.resolution.DependencyRequest;
+import org.sonatype.aether.util.DefaultRepositorySystemSession;
+import org.sonatype.aether.util.DefaultRequestTrace;
+import org.sonatype.aether.util.artifact.ArtifacIdUtils;
+import org.sonatype.aether.util.artifact.JavaScopes;
+import org.sonatype.aether.version.VersionConstraint;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.PostConstruct;
+import javax.inject.Inject;
+import javax.inject.Named;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author Olivier Lamy
+ */
+@Service( "dependencyTreeBuilder#maven3" )
+public class Maven3DependencyTreeBuilder
+{
+ private Logger log = LoggerFactory.getLogger( getClass() );
+
+ @Inject
+ private PlexusSisuBridge plexusSisuBridge;
+
+ @Inject
+ @Named( value = "repositoryPathTranslator#maven2" )
+ private RepositoryPathTranslator pathTranslator;
+
+ @Inject
+ private WagonFactory wagonFactory;
+
+ @Inject
+ private ManagedRepositoryAdmin managedRepositoryAdmin;
+
+ @Inject
+ private ProxyConnectorAdmin proxyConnectorAdmin;
+
+ @Inject
+ private NetworkProxyAdmin networkProxyAdmin;
+
+ @Inject
+ private RemoteRepositoryAdmin remoteRepositoryAdmin;
+
+ private ArtifactFactory factory;
+
+ private ModelBuilder builder;
+
+
+ private RepositorySystem repoSystem;
+
+ @PostConstruct
+ public void initialize()
+ throws PlexusSisuBridgeException
+ {
+ factory = plexusSisuBridge.lookup( ArtifactFactory.class, "default" );
+
+ repoSystem = plexusSisuBridge.lookup( RepositorySystem.class );
+ DefaultModelBuilderFactory defaultModelBuilderFactory = new DefaultModelBuilderFactory();
+ builder = defaultModelBuilderFactory.newInstance();
+ }
+
+ public DependencyResolutionResult buildDependencyTree( List<String> repositoryIds, String groupId,
+ String artifactId, String version )
+ throws Exception
+ {
+ Artifact projectArtifact = factory.createProjectArtifact( groupId, artifactId, version );
+ ManagedRepository repository = null;
+ try
+ {
+ repository = findArtifactInRepositories( repositoryIds, projectArtifact );
+ }
+ catch ( RepositoryAdminException e )
+ {
+ // FIXME better exception
+ throw new Exception( "Cannot build project dependency tree " + e.getMessage(), e );
+ }
+
+ if ( repository == null )
+ {
+ // metadata could not be resolved
+ return new DefaultDependencyResolutionResult();
+ }
+
+ // MRM-1411
+ // TODO: this is a workaround for a lack of proxy capability in the resolvers - replace when it can all be
+ // handled there. It doesn't cache anything locally!
+ List<RemoteRepository> remoteRepositories = new ArrayList<RemoteRepository>();
+ Map<String, NetworkProxy> networkProxies = new HashMap<String, NetworkProxy>();
+
+ Map<String, List<ProxyConnector>> proxyConnectorsMap = proxyConnectorAdmin.getProxyConnectorAsMap();
+ List<ProxyConnector> proxyConnectors = proxyConnectorsMap.get( repository.getId() );
+ if ( proxyConnectors != null )
+ {
+ for ( ProxyConnector proxyConnector : proxyConnectors )
+ {
+ remoteRepositories.add( remoteRepositoryAdmin.getRemoteRepository( proxyConnector.getTargetRepoId() ) );
+
+ NetworkProxy networkProxyConfig = networkProxyAdmin.getNetworkProxy( proxyConnector.getProxyId() );
+
+ if ( networkProxyConfig != null )
+ {
+ // key/value: remote repo ID/proxy info
+ networkProxies.put( proxyConnector.getTargetRepoId(), networkProxyConfig );
+ }
+ }
+ }
+
+ Model model = buildProject(
+ new RepositoryModelResolver( repository, pathTranslator, wagonFactory, remoteRepositories, networkProxies,
+ repository ), groupId, artifactId, version );
+
+ MavenProject project = new MavenProject( model );
+
+ DefaultRepositorySystemSession repositorySystemSession = new DefaultRepositorySystemSession();
+
+ // FIXME take care of relative path for getLocation
+ repositorySystemSession.setLocalRepositoryManager(
+ new SimpleLocalRepositoryManager( new File( repository.getLocation() ) ) );
+
+ DefaultProjectBuildingRequest projectBuildingRequest = new DefaultProjectBuildingRequest();
+
+ project.setProjectBuildingRequest( projectBuildingRequest );
+
+ projectBuildingRequest.setRepositorySession( repositorySystemSession );
+
+ DefaultDependencyResolutionRequest request =
+ new DefaultDependencyResolutionRequest( project, projectBuildingRequest.getRepositorySession() );
+
+ //DependencyFilter dependencyFilter
+ //request.setResolutionFilter( )
+
+ //DependencyResolutionResult result = projectDependenciesResolver.resolve( request );
+
+ //DependencyNode dependencyNode = buildDependencyNode( null, result.getDependencyGraph(), projectArtifact, null );
+ /*DependencyNode dependencyNode = dependencyGraphBuilder.buildDependencyGraph( project, new ArtifactFilter()
+ {
+ public boolean include( Artifact artifact )
+ {
+ return true;
+ }
+ } );*/
+
+ DependencyResolutionResult resolutionResult = resolve( request );
+
+ log.debug( "dependency graph build" );
+
+ return resolutionResult;
+ }
+
+ private DependencyResolutionResult resolve( DefaultDependencyResolutionRequest request )
+ throws DependencyResolutionException
+ {
+
+ RequestTrace trace = DefaultRequestTrace.newChild( null, request );
+
+ DefaultDependencyResolutionResult result = new DefaultDependencyResolutionResult();
+
+ MavenProject project = request.getMavenProject();
+ RepositorySystemSession session = request.getRepositorySession();
+ DependencyFilter filter = request.getResolutionFilter();
+
+ ArtifactTypeRegistry stereotypes = session.getArtifactTypeRegistry();
+
+ CollectRequest collect = new CollectRequest();
+ collect.setRequestContext( "project" );
+ collect.setRepositories( project.getRemoteProjectRepositories() );
+
+ if ( project.getDependencyArtifacts() == null )
+ {
+ for ( org.apache.maven.model.Dependency dependency : project.getDependencies() )
+ {
+ if ( StringUtils.isEmpty( dependency.getGroupId() ) || StringUtils.isEmpty( dependency.getArtifactId() )
+ || StringUtils.isEmpty( dependency.getVersion() ) )
+ {
+ // guard against case where best-effort resolution for invalid models is requested
+ continue;
+ }
+ collect.addDependency( RepositoryUtils.toDependency( dependency, stereotypes ) );
+ }
+ }
+ else
+ {
+ Map<String, org.apache.maven.model.Dependency> dependencies =
+ new HashMap<String, org.apache.maven.model.Dependency>();
+ for ( org.apache.maven.model.Dependency dependency : project.getDependencies() )
+ {
+ String classifier = dependency.getClassifier();
+ if ( classifier == null )
+ {
+ ArtifactType type = stereotypes.get( dependency.getType() );
+ if ( type != null )
+ {
+ classifier = type.getClassifier();
+ }
+ }
+ String key = ArtifacIdUtils.toVersionlessId( dependency.getGroupId(), dependency.getArtifactId(),
+ dependency.getType(), classifier );
+ dependencies.put( key, dependency );
+ }
+ for ( Artifact artifact : project.getDependencyArtifacts() )
+ {
+ String key = artifact.getDependencyConflictId();
+ org.apache.maven.model.Dependency dependency = dependencies.get( key );
+ Collection<Exclusion> exclusions = dependency != null ? dependency.getExclusions() : null;
+ org.sonatype.aether.graph.Dependency dep = RepositoryUtils.toDependency( artifact, exclusions );
+ if ( !JavaScopes.SYSTEM.equals( dep.getScope() ) && dep.getArtifact().getFile() != null )
+ {
+ // enable re-resolution
+ org.sonatype.aether.artifact.Artifact art = dep.getArtifact();
+ art = art.setFile( null ).setVersion( art.getBaseVersion() );
+ dep = dep.setArtifact( art );
+ }
+ collect.addDependency( dep );
+ }
+ }
+
+ DependencyManagement depMngt = project.getDependencyManagement();
+ if ( depMngt != null )
+ {
+ for ( org.apache.maven.model.Dependency dependency : depMngt.getDependencies() )
+ {
+ collect.addManagedDependency( RepositoryUtils.toDependency( dependency, stereotypes ) );
+ }
+ }
+
+ DependencyRequest depRequest = new DependencyRequest( collect, filter );
+ depRequest.setTrace( trace );
+
+ org.sonatype.aether.graph.DependencyNode node;
+ try
+ {
+ collect.setTrace( DefaultRequestTrace.newChild( trace, depRequest ) );
+ node = repoSystem.collectDependencies( session, collect ).getRoot();
+ result.setDependencyGraph( node );
+ }
+ catch ( DependencyCollectionException e )
+ {
+ result.setDependencyGraph( e.getResult().getRoot() );
+ result.setCollectionErrors( e.getResult().getExceptions() );
+
+ throw new DependencyResolutionException( result,
+ "Could not resolve dependencies for project " + project.getId()
+ + ": " + e.getMessage(), e );
+ }
+
+ depRequest.setRoot( node );
+
+ return result;
+ }
+
+ private String getVersionSelectedFromRange( VersionConstraint constraint )
+ {
+ if ( ( constraint == null ) || ( constraint.getVersion() != null ) )
+ {
+ return null;
+ }
+
+ StringBuilder sb = new StringBuilder();
+ for ( org.sonatype.aether.version.VersionRange range : constraint.getRanges() )
+ {
+ if ( sb.length() > 0 )
+ {
+ sb.append( ',' );
+ }
+ sb.append( range );
+ }
+
+ return sb.toString();
+ }
+
+ private Artifact getDependencyArtifact( Dependency dep )
+ {
+ org.sonatype.aether.artifact.Artifact artifact = dep.getArtifact();
+
+ return factory.createDependencyArtifact( artifact.getGroupId(), artifact.getArtifactId(),
+ VersionRange.createFromVersion( artifact.getVersion() ),
+ artifact.getExtension(), artifact.getClassifier(), dep.getScope(),
+ dep.isOptional() );
+ }
+
+ private Model buildProject( RepositoryModelResolver modelResolver, String groupId, String artifactId,
+ String version )
+ throws ModelBuildingException, UnresolvableModelException
+ {
+ DefaultModelBuildingRequest req = new DefaultModelBuildingRequest();
+ req.setProcessPlugins( false );
+ req.setModelSource( modelResolver.resolveModel( groupId, artifactId, version ) );
+ req.setModelResolver( modelResolver );
+ req.setValidationLevel( ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL );
+ //MRM-1607. olamy this will resolve jdk profiles on the current running archiva jvm
+ req.setSystemProperties( System.getProperties() );
+
+ return builder.build( req ).getEffectiveModel();
+ }
+
+ private ManagedRepository findArtifactInRepositories( List<String> repositoryIds, Artifact projectArtifact )
+ throws RepositoryAdminException
+ {
+ for ( String repoId : repositoryIds )
+ {
+ ManagedRepository managedRepository = managedRepositoryAdmin.getManagedRepository( repoId );
+
+ File repoDir = new File( managedRepository.getLocation() );
+ File file = pathTranslator.toFile( repoDir, projectArtifact.getGroupId(), projectArtifact.getArtifactId(),
+ projectArtifact.getBaseVersion(),
+ projectArtifact.getArtifactId() + "-" + projectArtifact.getVersion()
+ + ".pom" );
+
+ if ( file.exists() )
+ {
+ return managedRepository;
+ }
+ }
+ return null;
+ }
+
+ public static class DefaultDependencyResolutionResult
+ implements DependencyResolutionResult
+ {
+
+ private org.sonatype.aether.graph.DependencyNode root;
+
+ private List<Dependency> dependencies = new ArrayList<Dependency>();
+
+ private List<Dependency> resolvedDependencies = new ArrayList<Dependency>();
+
+ private List<Dependency> unresolvedDependencies = new ArrayList<Dependency>();
+
+ private List<Exception> collectionErrors = new ArrayList<Exception>();
+
+ private Map<Dependency, List<Exception>> resolutionErrors = new IdentityHashMap<Dependency, List<Exception>>();
+
+ public org.sonatype.aether.graph.DependencyNode getDependencyGraph()
+ {
+ return root;
+ }
+
+ public void setDependencyGraph( org.sonatype.aether.graph.DependencyNode root )
+ {
+ this.root = root;
+ }
+
+ public List<Dependency> getDependencies()
+ {
+ return dependencies;
+ }
+
+ public List<Dependency> getResolvedDependencies()
+ {
+ return resolvedDependencies;
+ }
+
+ public void addResolvedDependency( Dependency dependency )
+ {
+ dependencies.add( dependency );
+ resolvedDependencies.add( dependency );
+ }
+
+ public List<Dependency> getUnresolvedDependencies()
+ {
+ return unresolvedDependencies;
+ }
+
+ public List<Exception> getCollectionErrors()
+ {
+ return collectionErrors;
+ }
+
+ public void setCollectionErrors( List<Exception> exceptions )
+ {
+ if ( exceptions != null )
+ {
+ this.collectionErrors = exceptions;
+ }
+ else
+ {
+ this.collectionErrors = new ArrayList<Exception>();
+ }
+ }
+
+ public List<Exception> getResolutionErrors( Dependency dependency )
+ {
+ List<Exception> errors = resolutionErrors.get( dependency );
+ return ( errors != null ) ? errors : Collections.<Exception>emptyList();
+ }
+
+ public void setResolutionErrors( Dependency dependency, List<Exception> errors )
+ {
+ dependencies.add( dependency );
+ unresolvedDependencies.add( dependency );
+ resolutionErrors.put( dependency, errors );
+ }
+
+ }
+}
--- /dev/null
+package org.apache.archiva.dependency.tree.maven2;
+
+/*
+ * 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 junit.framework.TestCase;
+import org.apache.archiva.common.plexusbridge.PlexusSisuBridge;
+import org.apache.archiva.configuration.ArchivaConfiguration;
+import org.apache.archiva.configuration.Configuration;
+import org.apache.archiva.configuration.ManagedRepositoryConfiguration;
+import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner;
+import org.apache.maven.project.DependencyResolutionResult;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.sonatype.aether.RepositorySystem;
+import org.sonatype.aether.RepositorySystemSession;
+import org.sonatype.aether.artifact.Artifact;
+import org.sonatype.aether.collection.CollectRequest;
+import org.sonatype.aether.collection.CollectResult;
+import org.sonatype.aether.collection.DependencyCollectionException;
+import org.sonatype.aether.graph.Dependency;
+import org.sonatype.aether.graph.DependencyNode;
+import org.sonatype.aether.impl.DependencyCollector;
+import org.sonatype.aether.impl.internal.DefaultRepositorySystem;
+import org.sonatype.aether.util.artifact.DefaultArtifact;
+import org.sonatype.aether.util.graph.DefaultDependencyNode;
+import org.springframework.test.context.ContextConfiguration;
+
+import javax.inject.Inject;
+import javax.inject.Named;
+import java.io.File;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+@RunWith( ArchivaSpringJUnit4ClassRunner.class )
+@ContextConfiguration( locations = { "classpath*:/META-INF/spring-context.xml", "classpath:/spring-context.xml" } )
+public class DependencyTreeBuilderTestMaven3
+ extends TestCase
+{
+ @Inject
+ @Named( value = "dependencyTreeBuilder#maven3" )
+ private Maven3DependencyTreeBuilder builder;
+
+ @Inject
+ private PlexusSisuBridge plexusSisuBridge;
+
+ private static final String TEST_REPO_ID = "test";
+
+ private static final String TEST_VERSION = "1.2.1";
+
+ private static final String TEST_ARTIFACT_ID = "archiva-common";
+
+ private static final String TEST_GROUP_ID = "org.apache.archiva";
+
+ private DefaultRepositorySystem defaultRepositorySystem;
+
+
+ @Inject
+ @Named( value = "archivaConfiguration#test" )
+ ArchivaConfiguration config;
+
+ @Before
+ public void setUp()
+ throws Exception
+ {
+ super.setUp();
+
+ defaultRepositorySystem = (DefaultRepositorySystem) plexusSisuBridge.lookup( RepositorySystem.class );
+
+ final Map<String, DependencyNode> nodes = new HashMap<String, DependencyNode>();
+
+ DefaultDependencyNode springContext = new DefaultDependencyNode(
+ new Dependency( createArtifact( "org.springframework", "spring-context", "2.5.6" ), "compile" ) );
+
+ springContext.setPremanagedVersion( "2.5.5" );
+
+ nodes.put( getId( springContext.getDependency().getArtifact() ), springContext );
+
+ DefaultDependencyNode springTest = new DefaultDependencyNode(
+ new Dependency( createArtifact( "org.springframework", "spring-test", "2.5.5" ), "test" ) );
+
+ nodes.put( getId( springTest.getDependency().getArtifact() ), springTest );
+
+ DefaultDependencyNode plexusUtils = new DefaultDependencyNode(
+ new Dependency( createArtifact( "org.codehaus.plexus", "plexus-utils", "1.4.5" ), "compile" ) );
+
+ plexusUtils.setPremanagedVersion( "1.5.1" );
+
+ nodes.put( getId( plexusUtils.getDependency().getArtifact() ), plexusUtils );
+
+ DefaultDependencyNode slf4jLog4j12 = new DefaultDependencyNode(
+ new Dependency( createArtifact( "org.slf4j", "slf4j-log4j12", "1.5.0" ), "runtime" ) );
+
+ slf4jLog4j12.setPremanagedScope( "test" );
+
+ nodes.put( getId( slf4jLog4j12.getDependency().getArtifact() ), slf4jLog4j12 );
+
+ DefaultDependencyNode plexusLog4j = new DefaultDependencyNode(
+ new Dependency( createArtifact( "org.codehaus.plexus", "plexus-log4j-logging", "1.1-alpha-3" ), "test" ) );
+
+ nodes.put( getId( plexusLog4j.getDependency().getArtifact() ), plexusLog4j );
+
+ DefaultDependencyNode log4j =
+ new DefaultDependencyNode( new Dependency( createArtifact( "log4j", "log4j", "1.2.14" ), "test" ) );
+
+ nodes.put( getId( log4j.getDependency().getArtifact() ), log4j );
+
+ DefaultDependencyNode mavenArtifact = new DefaultDependencyNode(
+ new Dependency( createArtifact( "org.apache.maven", "maven-artifact", "2.0.8" ), "test" ) );
+
+ nodes.put( getId( mavenArtifact.getDependency().getArtifact() ), mavenArtifact );
+
+ DefaultDependencyNode mavenProject = new DefaultDependencyNode(
+ new Dependency( createArtifact( "org.apache.maven", "maven-project", "2.0.8" ), "test" ) );
+
+ nodes.put( getId( mavenProject.getDependency().getArtifact() ), mavenProject );
+
+ DefaultDependencyNode mavenCore = new DefaultDependencyNode(
+ new Dependency( createArtifact( "org.apache.maven", "maven-core", "2.0.8" ), "test" ) );
+
+ nodes.put( getId( mavenCore.getDependency().getArtifact() ), mavenCore );
+
+ DefaultDependencyNode mavenSettings = new DefaultDependencyNode(
+ new Dependency( createArtifact( "org.apache.maven", "maven-settings", "2.0.8" ), "test" ) );
+
+ nodes.put( getId( mavenSettings.getDependency().getArtifact() ), mavenSettings );
+
+ DefaultDependencyNode mavenModel = new DefaultDependencyNode(
+ new Dependency( createArtifact( "org.apache.maven", "maven-model", "2.0.8" ), "test" ) );
+
+ nodes.put( getId( mavenModel.getDependency().getArtifact() ), mavenModel );
+
+ DefaultDependencyNode plexusCommandLine = new DefaultDependencyNode(
+ new Dependency( createArtifact( "org.codehaus.plexus", "plexus-command-line", "1.0-alpha-2" ), "test" ) );
+
+ nodes.put( getId( plexusCommandLine.getDependency().getArtifact() ), plexusCommandLine );
+
+ DefaultDependencyNode plexusRegistryCommons = new DefaultDependencyNode(
+ new Dependency( createArtifact( "org.codehaus.plexus.registry", "plexus-registry-commons", "1.0-alpha-2" ),
+ "test" ) );
+
+ nodes.put( getId( plexusRegistryCommons.getDependency().getArtifact() ), plexusRegistryCommons );
+
+ plexusRegistryCommons.setPremanagedVersion( "1.0-alpha-3" );
+
+ DefaultDependencyNode plexusRegistryApi = new DefaultDependencyNode(
+ new Dependency( createArtifact( "org.codehaus.plexus.registry", "plexus-registry-api", "1.0-alpha-2" ),
+ "test" ) );
+
+ nodes.put( getId( plexusRegistryApi.getDependency().getArtifact() ), plexusRegistryApi );
+
+ plexusRegistryApi.setPremanagedVersion( "1.0-alpha-3" );
+
+ DefaultDependencyNode plexusSpring = new DefaultDependencyNode(
+ new Dependency( createArtifact( "org.codehaus.plexus", "plexus-spring", "1.2" ), "test" ) );
+
+ nodes.put( getId( plexusSpring.getDependency().getArtifact() ), plexusSpring );
+
+ plexusSpring.getChildren().add( springContext );
+ plexusSpring.getChildren().add( springTest );
+ plexusSpring.getChildren().add( plexusUtils );
+ plexusSpring.getChildren().add( slf4jLog4j12 );
+ plexusSpring.getChildren().add( plexusLog4j );
+ plexusSpring.getChildren().add( log4j );
+ plexusSpring.getChildren().add( mavenArtifact );
+ plexusSpring.getChildren().add( mavenProject );
+ plexusSpring.getChildren().add( mavenCore );
+ plexusSpring.getChildren().add( mavenSettings );
+ plexusSpring.getChildren().add( mavenModel );
+ plexusSpring.getChildren().add( plexusCommandLine );
+ plexusSpring.getChildren().add( plexusRegistryCommons );
+ plexusSpring.getChildren().add( plexusRegistryApi );
+
+ DefaultDependencyNode commonsLang = new DefaultDependencyNode(
+ new Dependency( createArtifact( "commons-lang", "commons-lang", "2.2" ), "compile" ) );
+
+ nodes.put( getId( commonsLang.getDependency().getArtifact() ), commonsLang );
+
+ DefaultDependencyNode commonsIO = new DefaultDependencyNode(
+ new Dependency( createArtifact( "commons-io", "commons-io", "1.4" ), "compile" ) );
+
+ nodes.put( getId( commonsIO.getDependency().getArtifact() ), commonsIO );
+
+ DefaultDependencyNode slf4j = new DefaultDependencyNode(
+ new Dependency( createArtifact( "org.slf4j", "slf4j-api", "1.5.0" ), "compile" ) );
+
+ nodes.put( getId( slf4j.getDependency().getArtifact() ), slf4j );
+
+ DefaultDependencyNode plexusAPI = new DefaultDependencyNode(
+ new Dependency( createArtifact( "org.codehaus.plexus", "plexus-component-api", "1.0-alpha-22" ),
+ "compile" ) );
+
+ nodes.put( getId( plexusAPI.getDependency().getArtifact() ), plexusAPI );
+
+ DefaultDependencyNode xalan =
+ new DefaultDependencyNode( new Dependency( createArtifact( "xalan", "xalan", "2.7.0" ), "compile" ) );
+
+ nodes.put( getId( xalan.getDependency().getArtifact() ), xalan );
+
+ DefaultDependencyNode dom4j =
+ new DefaultDependencyNode( new Dependency( createArtifact( "dom4j", "dom4j", "1.6.1" ), "test" ) );
+
+ nodes.put( getId( dom4j.getDependency().getArtifact() ), dom4j );
+
+ //dom4j.setFailedUpdateScope("compile");
+
+ DefaultDependencyNode junit =
+ new DefaultDependencyNode( new Dependency( createArtifact( "junit", "junit", "3.8.1" ), "test" ) );
+
+ nodes.put( getId( junit.getDependency().getArtifact() ), junit );
+
+ DefaultDependencyNode easymock = new DefaultDependencyNode(
+ new Dependency( createArtifact( "easymock", "easymock", "1.2_Java1.3" ), "test" ) );
+
+ nodes.put( getId( easymock.getDependency().getArtifact() ), easymock );
+
+ DefaultDependencyNode easymockExt = new DefaultDependencyNode(
+ new Dependency( createArtifact( "easymock", "easymockclassextension", "1.2" ), "test" ) );
+
+ nodes.put( getId( easymockExt.getDependency().getArtifact() ), easymockExt );
+
+ DependencyNode mainNode = new DefaultDependencyNode(
+ new Dependency( createArtifact( TEST_GROUP_ID, TEST_ARTIFACT_ID, TEST_VERSION ), "compile" ) );
+
+ nodes.put( getId( mainNode.getDependency().getArtifact() ), mainNode );
+
+ mainNode.getChildren().add( commonsLang );
+ mainNode.getChildren().add( commonsIO );
+ mainNode.getChildren().add( slf4j );
+ mainNode.getChildren().add( plexusAPI );
+ mainNode.getChildren().add( plexusSpring );
+ mainNode.getChildren().add( xalan );
+ mainNode.getChildren().add( dom4j );
+ mainNode.getChildren().add( junit );
+ mainNode.getChildren().add( easymock );
+ mainNode.getChildren().add( easymockExt );
+
+ defaultRepositorySystem.setDependencyCollector( new DependencyCollector()
+ {
+
+ public CollectResult collectDependencies( RepositorySystemSession session, CollectRequest request )
+ throws DependencyCollectionException
+ {
+ CollectResult collectResult = new CollectResult( request );
+ collectResult.setRoot( new DefaultDependencyNode() );
+ for ( Dependency dependency : request.getDependencies() )
+ {
+ DependencyNode node = nodes.get( getId( dependency.getArtifact() ) );
+ if ( node != null )
+ {
+ collectResult.getRoot().getChildren().add( node );
+ }
+ }
+ return collectResult;
+ }
+ } );
+
+ Configuration configuration = new Configuration();
+ ManagedRepositoryConfiguration repoConfig = new ManagedRepositoryConfiguration();
+ repoConfig.setId( TEST_REPO_ID );
+ repoConfig.setLocation( new File( "target/test-repository" ).getAbsolutePath() );
+ configuration.addManagedRepository( repoConfig );
+ config.save( configuration );
+
+ //artifactFactory = ((DefaultDependencyTreeBuilder)this.builder).getFactory();
+ }
+
+
+ private Artifact createArtifact( String groupId, String artifactId, String version )
+ {
+ return new DefaultArtifact( groupId, artifactId, null, version );
+ }
+
+ private String getId( Artifact artifact )
+ {
+ return artifact.getGroupId() + ":" + artifact.getArtifactId() + ":" + artifact.getVersion();
+ }
+
+ @Test
+ public void testBuilderDependencies()
+ throws Exception
+ {
+
+ DependencyResolutionResult resolutionResult =
+ builder.buildDependencyTree( Collections.singletonList( TEST_REPO_ID ), TEST_GROUP_ID, TEST_ARTIFACT_ID,
+ TEST_VERSION );
+
+ assertNotNull( resolutionResult );
+ assertEquals( 10, resolutionResult.getDependencies().size() );
+
+ }
+}
projects / archiva.git / commitdiff