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