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