source.dussan.org Git - archiva.git/blob

   1 package org.apache.maven.archiva.repository.project.filters;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *  http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import org.apache.maven.archiva.model.ArchivaProjectModel;
  23 import org.apache.maven.archiva.model.ArchivaRepository;
  24 import org.apache.maven.archiva.model.Dependency;
  25 import org.apache.maven.archiva.model.Individual;
  26 import org.apache.maven.archiva.repository.project.ProjectModelException;
  27 import org.apache.maven.archiva.repository.project.ProjectModelFilter;
  28 import org.apache.maven.archiva.repository.project.ProjectModelReader;
  29 import org.apache.maven.archiva.repository.project.ProjectModelResolver;
  30 import org.apache.maven.archiva.repository.project.readers.ProjectModel400Reader;
  31 import org.apache.maven.archiva.repository.project.resolvers.RepositoryProjectResolver;
  32 import org.codehaus.plexus.PlexusTestCase;
  33
  34 import java.io.File;
  35 import java.util.HashMap;
  36 import java.util.Iterator;
  37 import java.util.List;
  38 import java.util.Map;
  39
  40 /**
  41  * EffectiveProjectModelFilterTest
  42  *
  43  * @author <a href="mailto:joakim@erdfelt.com">Joakim Erdfelt</a>
  44  * @version $Id$
  45  */
  46 public class EffectiveProjectModelFilterTest
  47     extends PlexusTestCase
  48 {
  49     private static final String DEFAULT_REPOSITORY = "src/test/repositories/default-repository";
  50
  51     private EffectiveProjectModelFilter lookupEffective()
  52         throws Exception
  53     {
  54         return (EffectiveProjectModelFilter) lookup( ProjectModelFilter.class, "effective" );
  55     }
  56
  57     private ArchivaProjectModel createArchivaProjectModel( String path )
  58         throws ProjectModelException
  59     {
  60         ProjectModelReader reader = new ProjectModel400Reader();
  61
  62         File pomFile = new File( getBasedir(), path );
  63
  64         return reader.read( pomFile );
  65     }
  66
  67     private ProjectModelResolver createDefaultRepositoryResolver()
  68     {
  69         File defaultRepoDir = new File( getBasedir(), DEFAULT_REPOSITORY );
  70
  71         ArchivaRepository repo = new ArchivaRepository( "defaultTestRepo", "Default Test Repo", "file://"
  72             + defaultRepoDir.getAbsolutePath() );
  73
  74         RepositoryProjectResolver resolver = new RepositoryProjectResolver( repo );
  75
  76         return resolver;
  77     }
  78
  79     public void testBuildEffectiveProject()
  80         throws Exception
  81     {
  82         EffectiveProjectModelFilter filter = lookupEffective();
  83
  84         filter.addProjectModelResolver( createDefaultRepositoryResolver() );
  85
  86         ArchivaProjectModel startModel = createArchivaProjectModel( DEFAULT_REPOSITORY
  87             + "/org/apache/maven/archiva/archiva-model/1.0-SNAPSHOT/archiva-model-1.0-SNAPSHOT.pom" );
  88
  89         ArchivaProjectModel effectiveModel = filter.filter( startModel );
  90
  91         ArchivaProjectModel expectedModel = createArchivaProjectModel( "src/test/effective-poms/"
  92             + "/archiva-model-effective.pom" );
  93
  94         assertModel( expectedModel, effectiveModel );
  95     }
  96
  97     private void assertModel( ArchivaProjectModel expectedModel, ArchivaProjectModel effectiveModel )
  98     {
  99         assertEquals( "Equivalent Models", expectedModel, effectiveModel );
 100
 101         assertContainsSameIndividuals( "Individuals", expectedModel.getIndividuals(), effectiveModel.getIndividuals() );
 102         dumpDependencyList( "Expected", expectedModel.getDependencies() );
 103         dumpDependencyList( "Effective", effectiveModel.getDependencies() );
 104         assertContainsSameDependencies( "Dependencies", expectedModel.getDependencies(),
 105                                                         effectiveModel.getDependencies() );
 106         assertContainsSameDependencies( "DependencyManagement", expectedModel.getDependencyManagement(),
 107                                                                 effectiveModel.getDependencyManagement() );
 108     }
 109
 110     private void dumpDependencyList( String type, List deps )
 111     {
 112         if ( deps == null )
 113         {
 114             System.out.println( " Dependencies [" + type + "] is null." );
 115             return;
 116         }
 117
 118         if ( deps.isEmpty() )
 119         {
 120             System.out.println( " Dependencies [" + type + "] dependency list is empty." );
 121             return;
 122         }
 123
 124         System.out.println( ".\\ [" + type + "] Dependency List (size:" + deps.size() + ") \\.________________" );
 125         Iterator it = deps.iterator();
 126         while ( it.hasNext() )
 127         {
 128             Dependency dep = (Dependency) it.next();
 129             System.out.println( "  " + Dependency.toKey( dep ) );
 130         }
 131         System.out.println( "" );
 132     }
 133
 134     private void assertEquivalentLists( String listId, List expectedList, List effectiveList )
 135     {
 136         if ( ( expectedList == null ) && ( effectiveList == null ) )
 137         {
 138             return;
 139         }
 140
 141         if ( ( expectedList == null ) && ( effectiveList != null ) )
 142         {
 143             fail( "Effective [" + listId + "] List is instantiated, while expected List is null." );
 144         }
 145
 146         if ( ( expectedList != null ) && ( effectiveList == null ) )
 147         {
 148             fail( "Effective [" + listId + "] List is null, while expected List is instantiated." );
 149         }
 150
 151         assertEquals( "[" + listId + "] List Size", expectedList.size(), expectedList.size() );
 152     }
 153
 154     private void assertContainsSameIndividuals( String listId, List expectedList, List effectiveList )
 155     {
 156         assertEquivalentLists( listId, expectedList, effectiveList );
 157
 158         Map expectedMap = getIndividualsMap( expectedList );
 159         Map effectiveMap = getIndividualsMap( effectiveList );
 160
 161         Iterator it = expectedMap.keySet().iterator();
 162         while ( it.hasNext() )
 163         {
 164             String key = (String) it.next();
 165
 166             assertTrue( "Should exist in Effective [" + listId + "] list: " + key, effectiveMap.containsKey( key ) );
 167         }
 168     }
 169
 170     private void assertContainsSameDependencies( String listId, List expectedList, List effectiveList )
 171     {
 172         assertEquivalentLists( listId, expectedList, effectiveList );
 173
 174         Map expectedMap = getDependencyMap( expectedList );
 175         Map effectiveMap = getDependencyMap( effectiveList );
 176
 177         Iterator it = expectedMap.keySet().iterator();
 178         while ( it.hasNext() )
 179         {
 180             String key = (String) it.next();
 181
 182             assertTrue( "Should exist in Effective [" + listId + "] list: " + key, effectiveMap.containsKey( key ) );
 183         }
 184     }
 185
 186     private Map getIndividualsMap( List deps )
 187     {
 188         Map map = new HashMap();
 189         Iterator it = deps.iterator();
 190         while ( it.hasNext() )
 191         {
 192             Object o = it.next();
 193             assertTrue( "List contains Individual entries. (found " + o.getClass().getName() + " instead)",
 194                         o instanceof Individual );
 195             Individual individual = (Individual) o;
 196             String key = individual.getEmail();
 197             map.put( key, individual );
 198         }
 199         return map;
 200     }
 201
 202     private Map getDependencyMap( List deps )
 203     {
 204         Map map = new HashMap();
 205         Iterator it = deps.iterator();
 206         while ( it.hasNext() )
 207         {
 208             Object o = it.next();
 209             assertTrue( "List contains Dependency entries. (found " + o.getClass().getName() + " instead)",
 210                         o instanceof Dependency );
 211             Dependency dep = (Dependency) o;
 212             String key = Dependency.toVersionlessKey( dep );
 213             map.put( key, dep );
 214         }
 215         return map;
 216     }
 217 }