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

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