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