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

   1 package org.apache.archiva.web.action;
   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 com.opensymphony.xwork2.Action;
  23 import net.sf.beanlib.provider.replicator.BeanReplicator;
  24 import org.apache.archiva.admin.model.beans.ManagedRepository;
  25 import org.apache.archiva.metadata.model.ArtifactMetadata;
  26 import org.apache.archiva.metadata.model.Dependency;
  27 import org.apache.archiva.metadata.model.MailingList;
  28 import org.apache.archiva.metadata.model.ProjectVersionMetadata;
  29 import org.apache.archiva.metadata.model.ProjectVersionReference;
  30 import org.apache.archiva.metadata.repository.MetadataRepository;
  31 import org.apache.archiva.metadata.repository.RepositorySession;
  32 import org.apache.archiva.maven2.model.Artifact;
  33 import org.apache.archiva.webtest.memory.TestMetadataResolver;
  34 import org.apache.archiva.webtest.memory.TestRepositorySessionFactory;
  35 import org.apache.archiva.metadata.repository.storage.maven2.MavenArtifactFacet;
  36 import org.apache.archiva.reports.RepositoryProblemFacet;
  37 import org.apache.archiva.common.utils.VersionUtil;
  38 import org.apache.archiva.configuration.ArchivaConfiguration;
  39 import org.apache.archiva.configuration.Configuration;
  40 import org.apache.archiva.configuration.ManagedRepositoryConfiguration;
  41 import org.apache.archiva.repository.ManagedRepositoryContent;
  42 import org.apache.archiva.repository.RepositoryContentFactory;
  43 import org.apache.archiva.repository.content.ManagedDefaultRepositoryContent;
  44
  45 import java.io.File;
  46 import java.util.Arrays;
  47 import java.util.Collections;
  48 import java.util.List;
  49 import java.util.Map;
  50
  51 import org.junit.Before;
  52 import org.junit.Test;
  53
  54 import static org.mockito.Mockito.mock;
  55 import static org.mockito.Mockito.when;
  56
  57 public class ShowArtifactActionTest
  58     extends AbstractActionTestCase
  59 {
  60     private static final String ACTION_HINT = "showArtifactAction";
  61
  62     private static final String TEST_VERSION = "version";
  63
  64     private static final String TEST_SNAPSHOT_VERSION = "1.0-SNAPSHOT";
  65
  66     private static final String TEST_TS_SNAPSHOT_VERSION = "1.0-20091120.111111-1";
  67
  68     private static final String TEST_NAMESPACE = "namespace";
  69
  70     private static final String OTHER_TEST_REPO = "first-repo";
  71
  72     private ShowArtifactAction action;
  73
  74     private static final List<ArtifactMetadata> TEST_SNAPSHOT_ARTIFACTS =
  75         Arrays.asList( createArtifact( TEST_TS_SNAPSHOT_VERSION ),
  76                        createArtifact( "1.0-20091120.222222-2", "20091120.222222", 2 ),
  77                        createArtifact( "1.0-20091123.333333-3", "20091123.333333", 3 ) );
  78
  79     private static final long TEST_SIZE = 12345L;
  80
  81     private static final String TEST_TYPE = "jar";
  82
  83     @Override
  84     @Before
  85     public void setUp()
  86         throws Exception
  87     {
  88         super.setUp();
  89         action = (ShowArtifactAction) getActionProxy( "/showArtifact.action" ).getAction();
  90
  91         metadataResolver = new TestMetadataResolver();
  92         MetadataRepository repo = mock( MetadataRepository.class );
  93         RepositorySession repositorySession = mock( RepositorySession.class );
  94         when( repositorySession.getResolver() ).thenReturn( metadataResolver );
  95         when( repositorySession.getRepository() ).thenReturn( repo );
  96         TestRepositorySessionFactory repositorySessionFactory =
  97             applicationContext.getBean( "repositorySessionFactory#test", TestRepositorySessionFactory.class );
  98         repositorySessionFactory.setRepositorySession( repositorySession );
  99
 100         RepositoryContentFactory factory = mock( RepositoryContentFactory.class );
 101
 102         action.setRepositoryFactory( factory );
 103
 104         ManagedRepository config = new ManagedRepository();
 105         config.setId( TEST_REPO );
 106         config.setLocation( new File( "target/test-repo" ).getAbsolutePath() );
 107
 108         ManagedRepositoryContent content = new ManagedDefaultRepositoryContent();
 109         content.setRepository( config );
 110         when( factory.getManagedRepositoryContent( TEST_REPO ) ).thenReturn( content );
 111
 112         ArchivaConfiguration archivaConfig = mock( ArchivaConfiguration.class );
 113
 114         Configuration configuration = new Configuration();
 115         configuration.addManagedRepository(
 116             new BeanReplicator().replicateBean( config, ManagedRepositoryConfiguration.class ) );
 117         when( archivaConfig.getConfiguration() ).thenReturn( configuration );
 118
 119         when( factory.getArchivaConfiguration() ).thenReturn( archivaConfig );
 120
 121     }
 122
 123     @Test
 124     public void testInstantiation()
 125     {
 126         assertFalse( action == getActionProxy( "/showArtifact.action" ).getAction() );
 127     }
 128
 129     @Test
 130     public void testGetArtifactUniqueRelease()
 131     {
 132         metadataResolver.setProjectVersion( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID,
 133                                             createProjectModel( TEST_VERSION ) );
 134
 135         setActionParameters();
 136
 137         String result = action.artifact();
 138
 139         assertActionSuccess( action, result );
 140
 141         assertActionParameters( action );
 142         ProjectVersionMetadata model = action.getModel();
 143         assertDefaultModel( model );
 144
 145         assertEquals( TEST_REPO, action.getRepositoryId() );
 146
 147         assertNull( action.getDependees() );
 148         assertNull( action.getDependencies() );
 149         assertNull( action.getMailingLists() );
 150         assertTrue( action.getArtifacts().isEmpty() );
 151     }
 152
 153     @Test
 154     public void testGetArtifactUniqueSnapshot()
 155     {
 156         metadataResolver.setProjectVersion( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID,
 157                                             createProjectModel( TEST_SNAPSHOT_VERSION ) );
 158         metadataResolver.setArtifacts( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID, TEST_SNAPSHOT_VERSION,
 159                                        TEST_SNAPSHOT_ARTIFACTS );
 160
 161         action.setGroupId( TEST_GROUP_ID );
 162         action.setArtifactId( TEST_ARTIFACT_ID );
 163         action.setVersion( TEST_SNAPSHOT_VERSION );
 164
 165         String result = action.artifact();
 166
 167         assertActionSuccess( action, result );
 168
 169         assertEquals( TEST_GROUP_ID, action.getGroupId() );
 170         assertEquals( TEST_ARTIFACT_ID, action.getArtifactId() );
 171         assertEquals( TEST_SNAPSHOT_VERSION, action.getVersion() );
 172         ProjectVersionMetadata model = action.getModel();
 173         assertDefaultModel( model, TEST_SNAPSHOT_VERSION );
 174
 175         assertEquals( TEST_REPO, action.getRepositoryId() );
 176
 177         assertArtifacts( TEST_SNAPSHOT_ARTIFACTS, action.getArtifacts() );
 178
 179         assertNull( action.getDependees() );
 180         assertNull( action.getDependencies() );
 181         assertNull( action.getMailingLists() );
 182     }
 183
 184     @Test
 185     public void testGetArtifactUniqueSnapshotTimestamped()
 186     {
 187         metadataResolver.setProjectVersion( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID,
 188                                             createProjectModel( TEST_SNAPSHOT_VERSION ) );
 189         metadataResolver.setArtifacts( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID, TEST_SNAPSHOT_VERSION,
 190                                        TEST_SNAPSHOT_ARTIFACTS );
 191
 192         action.setGroupId( TEST_GROUP_ID );
 193         action.setArtifactId( TEST_ARTIFACT_ID );
 194         action.setVersion( TEST_TS_SNAPSHOT_VERSION );
 195
 196         String result = action.artifact();
 197         assertError( result );
 198         assertNoOutputFields();
 199     }
 200
 201     @Test
 202     public void testGetMissingProject()
 203     {
 204         setActionParameters();
 205
 206         String result = action.artifact();
 207         assertError( result );
 208
 209         assertActionParameters( action );
 210         assertNoOutputFields();
 211     }
 212
 213     @Test
 214     public void testGetArtifactNoObservableRepos()
 215     {
 216         setObservableRepos( Collections.<String>emptyList() );
 217
 218         setActionParameters();
 219
 220         String result = action.artifact();
 221
 222         // Actually, it'd be better to have an error:
 223         assertError( result );
 224         assertActionParameters( action );
 225         assertNoOutputFields();
 226     }
 227
 228     @Test
 229     public void testGetArtifactNotInObservableRepos()
 230     {
 231         metadataResolver.setProjectVersion( OTHER_TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID,
 232                                             createProjectModel( TEST_VERSION ) );
 233
 234         setActionParameters();
 235
 236         String result = action.artifact();
 237         assertError( result );
 238
 239         assertActionParameters( action );
 240         assertNoOutputFields();
 241     }
 242
 243     @Test
 244     public void testGetArtifactOnlySeenInSecondObservableRepo()
 245     {
 246         setObservableRepos( Arrays.asList( OTHER_TEST_REPO, TEST_REPO ) );
 247         metadataResolver.setProjectVersion( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID,
 248                                             createProjectModel( TEST_VERSION ) );
 249
 250         setActionParameters();
 251
 252         String result = action.artifact();
 253
 254         assertActionSuccess( action, result );
 255
 256         assertActionParameters( action );
 257         ProjectVersionMetadata model = action.getModel();
 258         assertDefaultModel( model );
 259
 260         assertEquals( TEST_REPO, action.getRepositoryId() );
 261
 262         assertNull( action.getDependees() );
 263         assertNull( action.getDependencies() );
 264         assertNull( action.getMailingLists() );
 265         assertTrue( action.getArtifacts().isEmpty() );
 266     }
 267
 268     @Test
 269     public void testGetArtifactSeenInBothObservableRepo()
 270     {
 271         setObservableRepos( Arrays.asList( TEST_REPO, OTHER_TEST_REPO ) );
 272         metadataResolver.setProjectVersion( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID,
 273                                             createProjectModel( TEST_VERSION ) );
 274         metadataResolver.setProjectVersion( OTHER_TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID,
 275                                             createProjectModel( TEST_VERSION ) );
 276
 277         setActionParameters();
 278
 279         String result = action.artifact();
 280
 281         assertActionSuccess( action, result );
 282
 283         assertActionParameters( action );
 284         ProjectVersionMetadata model = action.getModel();
 285         assertDefaultModel( model );
 286
 287         assertEquals( TEST_REPO, action.getRepositoryId() );
 288
 289         assertNull( action.getDependees() );
 290         assertNull( action.getDependencies() );
 291         assertNull( action.getMailingLists() );
 292         assertTrue( action.getArtifacts().isEmpty() );
 293     }
 294
 295     @Test
 296     public void testGetArtifactCanOnlyObserveInOneOfTwoRepos()
 297     {
 298         setObservableRepos( Arrays.asList( TEST_REPO ) );
 299         metadataResolver.setProjectVersion( OTHER_TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID,
 300                                             createProjectModel( TEST_VERSION ) );
 301         metadataResolver.setProjectVersion( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID,
 302                                             createProjectModel( TEST_VERSION ) );
 303
 304         setActionParameters();
 305
 306         String result = action.artifact();
 307
 308         assertActionSuccess( action, result );
 309
 310         assertActionParameters( action );
 311         ProjectVersionMetadata model = action.getModel();
 312         assertDefaultModel( model );
 313
 314         assertEquals( TEST_REPO, action.getRepositoryId() );
 315
 316         assertNull( action.getDependees() );
 317         assertNull( action.getDependencies() );
 318         assertNull( action.getMailingLists() );
 319         assertTrue( action.getArtifacts().isEmpty() );
 320     }
 321
 322     @Test
 323     public void testGetArtifactNoMavenFacet()
 324     {
 325         ProjectVersionMetadata versionMetadata = new ProjectVersionMetadata();
 326         versionMetadata.setId( TEST_VERSION );
 327         versionMetadata.setUrl( TEST_URL );
 328         versionMetadata.setName( TEST_NAME );
 329         versionMetadata.setDescription( TEST_DESCRIPTION );
 330
 331         metadataResolver.setProjectVersion( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID, versionMetadata );
 332
 333         setActionParameters();
 334
 335         String result = action.artifact();
 336
 337         assertActionSuccess( action, result );
 338
 339         assertActionParameters( action );
 340         ProjectVersionMetadata model = action.getModel();
 341         assertEquals( TEST_VERSION, model.getVersion() );
 342         assertEquals( TEST_URL, model.getUrl() );
 343         assertEquals( TEST_NAME, model.getName() );
 344         assertEquals( TEST_DESCRIPTION, model.getDescription() );
 345
 346         assertEquals( TEST_REPO, action.getRepositoryId() );
 347
 348         assertNull( action.getDependees() );
 349         assertNull( action.getDependencies() );
 350         assertNull( action.getMailingLists() );
 351         assertTrue( action.getArtifacts().isEmpty() );
 352     }
 353
 354     @Test
 355     public void testMetadataHasRepositoryFacetProblem()
 356     {
 357         String errMsg = "Error in resolving artifact's parent POM file: Sample Parent POM not found";
 358         ProjectVersionMetadata metaData = createProjectModel( TEST_SNAPSHOT_VERSION );
 359         metaData.addFacet(
 360             createRepositoryProblemFacet( TEST_REPO, errMsg, TEST_GROUP_ID, TEST_SNAPSHOT_VERSION, TEST_NAMESPACE ) );
 361
 362         metadataResolver.setProjectVersion( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID, metaData );
 363
 364         metadataResolver.setArtifacts( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID, TEST_SNAPSHOT_VERSION,
 365                                        TEST_SNAPSHOT_ARTIFACTS );
 366
 367         action.setGroupId( TEST_GROUP_ID );
 368         action.setArtifactId( TEST_ARTIFACT_ID );
 369         action.setVersion( TEST_SNAPSHOT_VERSION );
 370
 371         String result = action.artifact();
 372
 373         assertEquals( Action.SUCCESS, result );
 374
 375         assertTrue( action.hasActionErrors() );
 376         assertFalse( action.hasActionMessages() );
 377         assertEquals( "Artifact metadata is incomplete: " + errMsg, action.getActionErrors().toArray()[0].toString() );
 378     }
 379
 380     @Test
 381     public void testMetadataIncomplete()
 382     {
 383         ProjectVersionMetadata metaData = createProjectModel( TEST_SNAPSHOT_VERSION );
 384         metaData.setIncomplete( true );
 385
 386         metadataResolver.setProjectVersion( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID, metaData );
 387
 388         metadataResolver.setArtifacts( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID, TEST_SNAPSHOT_VERSION,
 389                                        TEST_SNAPSHOT_ARTIFACTS );
 390
 391         action.setGroupId( TEST_GROUP_ID );
 392         action.setArtifactId( TEST_ARTIFACT_ID );
 393         action.setVersion( TEST_SNAPSHOT_VERSION );
 394
 395         String result = action.artifact();
 396
 397         assertEquals( Action.SUCCESS, result );
 398
 399         assertTrue( action.hasActionErrors() );
 400         assertFalse( action.hasActionMessages() );
 401
 402         assertEquals( "Artifact metadata is incomplete.", action.getActionErrors().toArray()[0].toString() );
 403     }
 404
 405     @Test
 406     public void testGetMailingLists()
 407     {
 408         ProjectVersionMetadata versionMetadata = createProjectModel( TEST_VERSION );
 409         MailingList ml1 = createMailingList( "Users List", "users" );
 410         MailingList ml2 = createMailingList( "Developers List", "dev" );
 411         versionMetadata.setMailingLists( Arrays.asList( ml1, ml2 ) );
 412         metadataResolver.setProjectVersion( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID, versionMetadata );
 413
 414         setActionParameters();
 415
 416         String result = action.mailingLists();
 417
 418         assertActionSuccess( action, result );
 419
 420         assertActionParameters( action );
 421         ProjectVersionMetadata model = action.getModel();
 422         assertDefaultModel( model );
 423
 424         assertNotNull( action.getMailingLists() );
 425         assertMailingList( action.getMailingLists().get( 0 ), "Users List", "users" );
 426         assertMailingList( action.getMailingLists().get( 1 ), "Developers List", "dev" );
 427
 428         assertEquals( TEST_REPO, action.getRepositoryId() );
 429         assertNull( action.getDependees() );
 430         assertNull( action.getDependencies() );
 431         assertTrue( action.getArtifacts().isEmpty() );
 432     }
 433
 434     @Test
 435     public void testGetDependencies()
 436     {
 437         ProjectVersionMetadata versionMetadata = createProjectModel( TEST_VERSION );
 438         Dependency dependency1 = createDependencyBasic( "artifactId1" );
 439         Dependency dependency2 = createDependencyExtended( "artifactId2" );
 440         versionMetadata.setDependencies( Arrays.asList( dependency1, dependency2 ) );
 441         metadataResolver.setProjectVersion( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID, versionMetadata );
 442
 443         setActionParameters();
 444
 445         String result = action.dependencies();
 446
 447         assertActionSuccess( action, result );
 448
 449         assertActionParameters( action );
 450         ProjectVersionMetadata model = action.getModel();
 451         assertDefaultModel( model );
 452
 453         assertNotNull( action.getDependencies() );
 454         assertDependencyBasic( action.getDependencies().get( 0 ), "artifactId1" );
 455         assertDependencyExtended( action.getDependencies().get( 1 ), "artifactId2" );
 456
 457         assertEquals( TEST_REPO, action.getRepositoryId() );
 458         assertNull( action.getDependees() );
 459         assertNull( action.getMailingLists() );
 460         assertTrue( action.getArtifacts().isEmpty() );
 461     }
 462
 463     @Test
 464     public void testGetDependees()
 465         throws Exception
 466     {
 467         setObservableRepos( Arrays.asList( TEST_REPO ) );
 468         ProjectVersionMetadata versionMetadata = createProjectModel( TEST_VERSION );
 469         metadataResolver.setProjectVersion( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID, versionMetadata );
 470         ProjectVersionReference dependee1 = createReference( "artifactId1" );
 471         ProjectVersionReference dependee2 = createReference( "artifactId2" );
 472         metadataResolver.setProjectReferences( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID, TEST_VERSION,
 473                                                Arrays.asList( dependee1, dependee2 ) );
 474
 475         setActionParameters();
 476
 477         String result = action.dependees();
 478
 479         assertActionSuccess( action, result );
 480
 481         assertActionParameters( action );
 482         ProjectVersionMetadata model = action.getModel();
 483         assertDefaultModel( model );
 484
 485         assertNotNull( action.getDependees() );
 486         assertCoordinate( action.getDependees().get( 0 ), "artifactId1" );
 487         assertCoordinate( action.getDependees().get( 1 ), "artifactId2" );
 488
 489         assertEquals( TEST_REPO, action.getRepositoryId() );
 490         assertNull( action.getDependencies() );
 491         assertNull( action.getMailingLists() );
 492         assertTrue( action.getArtifacts().isEmpty() );
 493     }
 494
 495     @Test
 496     public void testGetProjectMetadata()
 497     {
 498         ProjectVersionMetadata versionMetadata = createProjectModel( TEST_VERSION );
 499
 500         metadataResolver.setProjectVersion( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID, versionMetadata );
 501
 502         setActionParameters();
 503
 504         String result = action.projectMetadata();
 505
 506         assertActionSuccess( action, result );
 507
 508         assertActionParameters( action );
 509
 510         Map<String, String> genericMetadata = action.getGenericMetadata();
 511         assertNotNull( genericMetadata.get( TEST_GENERIC_METADATA_PROPERTY_NAME ) );
 512         assertEquals( genericMetadata.get( TEST_GENERIC_METADATA_PROPERTY_NAME ),
 513                       TEST_GENERIC_METADATA_PROPERTY_VALUE );
 514
 515         assertEquals( TEST_REPO, action.getRepositoryId() );
 516         assertNotNull( action.getModel() );
 517         assertNull( action.getDependees() );
 518         assertNull( action.getDependencies() );
 519         assertNull( action.getMailingLists() );
 520         assertTrue( action.getArtifacts().isEmpty() );
 521     }
 522
 523     @Test
 524     public void testAddAndDeleteMetadataProperty()
 525     {
 526         ProjectVersionMetadata versionMetadata = createProjectModel( TEST_VERSION );
 527
 528         metadataResolver.setProjectVersion( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID, versionMetadata );
 529
 530         setActionParameters();
 531         action.setPropertyName( "foo" );
 532         action.setPropertyValue( "bar" );
 533         action.setRepositoryId( TEST_REPO );
 534
 535         String result = action.addMetadataProperty();
 536
 537         assertActionSuccess( action, result );
 538         assertActionParameters( action );
 539
 540         Map<String, String> genericMetadata = action.getGenericMetadata();
 541         assertNotNull( genericMetadata.get( TEST_GENERIC_METADATA_PROPERTY_NAME ) );
 542         assertEquals( genericMetadata.get( TEST_GENERIC_METADATA_PROPERTY_NAME ),
 543                       TEST_GENERIC_METADATA_PROPERTY_VALUE );
 544
 545         assertNotNull( genericMetadata.get( "foo" ) );
 546         assertEquals( "bar", genericMetadata.get( "foo" ) );
 547
 548         assertEquals( TEST_REPO, action.getRepositoryId() );
 549         assertNotNull( action.getModel() );
 550         assertNull( action.getDependees() );
 551         assertNull( action.getDependencies() );
 552         assertNull( action.getMailingLists() );
 553         assertTrue( action.getArtifacts().isEmpty() );
 554
 555         // test delete property
 556         setActionParameters();
 557         action.setDeleteItem( "foo" );
 558
 559         result = action.deleteMetadataEntry();
 560
 561         assertEquals( Action.SUCCESS, result );
 562         assertActionParameters( action );
 563         assertTrue( !action.getActionMessages().isEmpty() );
 564         assertTrue( action.getActionMessages().contains( "Property successfully deleted." ) );
 565
 566         genericMetadata = action.getGenericMetadata();
 567         assertNotNull( genericMetadata.get( TEST_GENERIC_METADATA_PROPERTY_NAME ) );
 568         assertEquals( genericMetadata.get( TEST_GENERIC_METADATA_PROPERTY_NAME ),
 569                       TEST_GENERIC_METADATA_PROPERTY_VALUE );
 570
 571         assertNull( genericMetadata.get( "foo" ) );
 572
 573         assertEquals( TEST_REPO, action.getRepositoryId() );
 574         assertNotNull( action.getModel() );
 575         assertNull( action.getDependees() );
 576         assertNull( action.getDependencies() );
 577         assertNull( action.getMailingLists() );
 578         assertTrue( action.getArtifacts().isEmpty() );
 579     }
 580
 581     private void assertArtifacts( List<ArtifactMetadata> expectedArtifacts,
 582                                   Map<String, List<Artifact>> artifactMap )
 583     {
 584         // assuming only one of each version at this point
 585         assertEquals( expectedArtifacts.size(), artifactMap.size() );
 586         for ( ArtifactMetadata artifact : expectedArtifacts )
 587         {
 588             assertTrue( artifactMap.containsKey( artifact.getVersion() ) );
 589             List<Artifact> list = artifactMap.get( artifact.getVersion() );
 590             Artifact actual = list.get( 0 );
 591             assertEquals( artifact.getNamespace(), actual.getGroupId() );
 592             assertEquals( artifact.getId(),actual.getId() );
 593             // olamy test has no more sense as we reuse an other object now
 594             //assertEquals( artifact.getProject(), actual.getGroupId() );
 595             assertEquals( artifact.getRepositoryId(), actual.getRepositoryId() );
 596             assertEquals( artifact.getVersion(), actual.getVersion() );
 597             assertEquals( TEST_TYPE, actual.getPackaging() );
 598             assertEquals( "12.06 K", actual.getSize() );
 599             // FIXME url path test
 600             //assertEquals( artifact.getNamespace() + "/" + artifact.getProject() + "/" + TEST_SNAPSHOT_VERSION + "/"
 601             //                  + artifact.getId(), actual.getPath() );
 602         }
 603     }
 604
 605     private static ArtifactMetadata createArtifact( String version )
 606     {
 607         return createArtifact( version, null, 0 );
 608     }
 609
 610     private static ArtifactMetadata createArtifact( String version, String timestamp, int buildNumber )
 611     {
 612         ArtifactMetadata metadata = new ArtifactMetadata();
 613         metadata.setProject( TEST_ARTIFACT_ID );
 614         metadata.setId( TEST_ARTIFACT_ID + "-" + version + ".jar" );
 615         metadata.setNamespace( TEST_GROUP_ID );
 616         metadata.setRepositoryId( TEST_REPO );
 617         metadata.setSize( TEST_SIZE );
 618         metadata.setProjectVersion( VersionUtil.getBaseVersion( version ) );
 619         metadata.setVersion( version );
 620
 621         MavenArtifactFacet facet = new MavenArtifactFacet();
 622         facet.setType( "jar" );
 623         facet.setTimestamp( timestamp );
 624         facet.setBuildNumber( buildNumber );
 625         metadata.addFacet( facet );
 626
 627         return metadata;
 628     }
 629
 630     private ProjectVersionReference createReference( String projectId )
 631     {
 632         ProjectVersionReference reference = new ProjectVersionReference();
 633         reference.setNamespace( "groupId" );
 634         reference.setProjectId( projectId );
 635         reference.setProjectVersion( "version" );
 636         reference.setReferenceType( ProjectVersionReference.ReferenceType.DEPENDENCY );
 637         return reference;
 638     }
 639
 640     private void assertCoordinate( ProjectVersionReference dependee, String artifactId )
 641     {
 642         assertEquals( artifactId, dependee.getProjectId() );
 643         assertEquals( "groupId", dependee.getNamespace() );
 644         assertEquals( "version", dependee.getProjectVersion() );
 645     }
 646
 647     private void assertDependencyBasic( Dependency dependency, String artifactId )
 648     {
 649         assertEquals( artifactId, dependency.getArtifactId() );
 650         assertEquals( "groupId", dependency.getGroupId() );
 651         assertEquals( "version", dependency.getVersion() );
 652     }
 653
 654     private void assertDependencyExtended( Dependency dependency, String artifactId )
 655     {
 656         assertDependencyBasic( dependency, artifactId );
 657         assertEquals( true, dependency.isOptional() );
 658         assertEquals( "classifier", dependency.getClassifier() );
 659         assertEquals( "type", dependency.getType() );
 660         assertEquals( "scope", dependency.getScope() );
 661         assertEquals( "systemPath", dependency.getSystemPath() );
 662     }
 663
 664     private Dependency createDependencyExtended( String artifactId )
 665     {
 666         Dependency dependency = createDependencyBasic( artifactId );
 667         dependency.setClassifier( "classifier" );
 668         dependency.setOptional( true );
 669         dependency.setScope( "scope" );
 670         dependency.setSystemPath( "systemPath" );
 671         dependency.setType( "type" );
 672         return dependency;
 673     }
 674
 675     private Dependency createDependencyBasic( String artifactId )
 676     {
 677         Dependency dependency = new Dependency();
 678         dependency.setArtifactId( artifactId );
 679         dependency.setGroupId( "groupId" );
 680         dependency.setVersion( "version" );
 681         return dependency;
 682     }
 683
 684     private void assertMailingList( MailingList mailingList, String name, String prefix )
 685     {
 686         assertEquals( name, mailingList.getName() );
 687         assertEquals( prefix + "-post@", mailingList.getPostAddress() );
 688         assertEquals( prefix + "-subscribe@", mailingList.getSubscribeAddress() );
 689         assertEquals( prefix + "-unsubscribe@", mailingList.getUnsubscribeAddress() );
 690         assertEquals( prefix + "-archive-url", mailingList.getMainArchiveUrl() );
 691         assertEquals( Arrays.asList( "other-" + prefix + "-archive-url-1", "other-" + prefix + "-archive-url-2" ),
 692                       mailingList.getOtherArchives() );
 693     }
 694
 695     private MailingList createMailingList( String name, String prefix )
 696     {
 697         MailingList ml1 = new MailingList();
 698         ml1.setName( name );
 699         ml1.setPostAddress( prefix + "-post@" );
 700         ml1.setSubscribeAddress( prefix + "-subscribe@" );
 701         ml1.setUnsubscribeAddress( prefix + "-unsubscribe@" );
 702         ml1.setMainArchiveUrl( prefix + "-archive-url" );
 703         ml1.setOtherArchives(
 704             Arrays.asList( "other-" + prefix + "-archive-url-1", "other-" + prefix + "-archive-url-2" ) );
 705         return ml1;
 706     }
 707
 708     private void assertNoOutputFields()
 709     {
 710         assertNull( action.getModel() );
 711         assertNull( action.getDependees() );
 712         assertNull( action.getDependencies() );
 713         assertNull( action.getMailingLists() );
 714         assertTrue( action.getArtifacts().isEmpty() );
 715     }
 716
 717     private void assertError( String result )
 718     {
 719         assertEquals( Action.ERROR, result );
 720         assertEquals( 1, action.getActionErrors().size() );
 721     }
 722
 723     private void assertDefaultModel( ProjectVersionMetadata model )
 724     {
 725         assertDefaultModel( model, TEST_VERSION );
 726     }
 727
 728     private void setActionParameters()
 729     {
 730         action.setGroupId( TEST_GROUP_ID );
 731         action.setArtifactId( TEST_ARTIFACT_ID );
 732         action.setVersion( TEST_VERSION );
 733     }
 734
 735     private void assertActionParameters( ShowArtifactAction action )
 736     {
 737         assertEquals( TEST_GROUP_ID, action.getGroupId() );
 738         assertEquals( TEST_ARTIFACT_ID, action.getArtifactId() );
 739         assertEquals( TEST_VERSION, action.getVersion() );
 740     }
 741
 742     private void assertActionSuccess( ShowArtifactAction action, String result )
 743     {
 744         assertEquals( Action.SUCCESS, result );
 745         assertTrue( action.getActionErrors().isEmpty() );
 746         assertTrue( action.getActionMessages().isEmpty() );
 747     }
 748
 749     private RepositoryProblemFacet createRepositoryProblemFacet( String repoId, String errMsg, String projectId,
 750                                                                  String projectVersion, String namespace )
 751     {
 752         RepositoryProblemFacet repoProblemFacet = new RepositoryProblemFacet();
 753         repoProblemFacet.setRepositoryId( repoId );
 754         repoProblemFacet.setId( repoId );
 755         repoProblemFacet.setMessage( errMsg );
 756         repoProblemFacet.setProblem( errMsg );
 757         repoProblemFacet.setProject( projectId );
 758         repoProblemFacet.setVersion( projectVersion );
 759         repoProblemFacet.setNamespace( namespace );
 760         return repoProblemFacet;
 761     }
 762 }