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 java.util.Arrays;
  23 import java.util.Collections;
  24 import java.util.List;
  25
  26 import com.opensymphony.xwork2.Action;
  27 import org.apache.archiva.metadata.model.CiManagement;
  28 import org.apache.archiva.metadata.model.IssueManagement;
  29 import org.apache.archiva.metadata.model.License;
  30 import org.apache.archiva.metadata.model.Organization;
  31 import org.apache.archiva.metadata.model.ProjectVersionMetadata;
  32 import org.apache.archiva.metadata.model.Scm;
  33 import org.apache.archiva.metadata.repository.memory.TestMetadataResolver;
  34 import org.apache.archiva.metadata.repository.storage.maven2.MavenProjectFacet;
  35 import org.apache.archiva.metadata.repository.storage.maven2.MavenProjectParent;
  36 import org.apache.maven.archiva.database.ArchivaDAO;
  37 import org.apache.maven.archiva.database.ArchivaDatabaseException;
  38 import org.apache.maven.archiva.database.ArtifactDAO;
  39 import org.apache.maven.archiva.database.ProjectModelDAO;
  40 import org.apache.maven.archiva.database.constraints.ArtifactsRelatedConstraint;
  41 import org.apache.maven.archiva.model.ArchivaArtifact;
  42 import org.apache.maven.archiva.model.ArchivaArtifactModel;
  43 import org.apache.maven.archiva.model.ArchivaProjectModel;
  44 import org.apache.maven.archiva.model.MailingList;
  45 import org.apache.maven.archiva.model.VersionedReference;
  46 import org.apache.maven.archiva.security.UserRepositories;
  47 import org.apache.maven.archiva.security.UserRepositoriesStub;
  48 import org.apache.maven.archiva.web.action.admin.repositories.ArchivaDAOStub;
  49 import org.codehaus.plexus.spring.PlexusInSpringTestCase;
  50 import org.easymock.MockControl;
  51
  52 public class ShowArtifactActionTest
  53     extends PlexusInSpringTestCase
  54 {
  55     private static final String ACTION_HINT = "showArtifactAction";
  56
  57     private static final String TEST_GROUP_ID = "groupId";
  58
  59     private static final String TEST_ARTIFACT_ID = "artifactId";
  60
  61     private static final String TEST_VERSION = "version";
  62
  63     private static final String TEST_PACKAGING = "packaging";
  64
  65     private static final String TEST_ISSUE_URL = "http://jira.codehaus.org/browse/MRM";
  66
  67     private static final String TEST_ISSUE_SYSTEM = "jira";
  68
  69     private static final String TEST_CI_SYSTEM = "continuum";
  70
  71     private static final String TEST_CI_URL = "http://vmbuild.apache.org/";
  72
  73     private static final String TEST_URL = "url";
  74
  75     private static final String TEST_NAME = "name";
  76
  77     private static final String TEST_DESCRIPTION = "description";
  78
  79     private static final String TEST_PARENT_GROUP_ID = "parentGroupId";
  80
  81     private static final String TEST_PARENT_ARTIFACT_ID = "parentArtifactId";
  82
  83     private static final String TEST_PARENT_VERSION = "parentVersion";
  84
  85     private static final String TEST_ORGANIZATION_NAME = "organizationName";
  86
  87     private static final String TEST_ORGANIZATION_URL = "organizationUrl";
  88
  89     private static final String TEST_LICENSE_URL = "licenseUrl";
  90
  91     private static final String TEST_LICENSE_NAME = "licenseName";
  92
  93     private static final String TEST_LICENSE_URL_2 = "licenseUrl_2";
  94
  95     private static final String TEST_LICENSE_NAME_2 = "licenseName_2";
  96
  97     private static final String TEST_REPO = "test-repo";
  98
  99     private static final String TEST_SCM_CONNECTION = "scmConnection";
 100
 101     private static final String TEST_SCM_DEV_CONNECTION = "scmDevConnection";
 102
 103     private static final String TEST_SCM_URL = "scmUrl";
 104
 105     private static final String TEST_SNAPSHOT_VERSION = "1.0-SNAPSHOT";
 106
 107     private static final String TEST_TS_SNAPSHOT_VERSION = "1.0-20091120.111111-1";
 108
 109     private static final List<String> ALL_TEST_SNAPSHOT_VERSIONS =
 110         Arrays.asList( TEST_TS_SNAPSHOT_VERSION, "1.0-20091120.222222-2", "1.0-20091123.333333-3" );
 111
 112     private static final String OTHER_TEST_REPO = "first-repo";
 113
 114     private ShowArtifactAction action;
 115
 116     private ArchivaDAOStub archivaDao;
 117
 118     private TestMetadataResolver metadataResolver;
 119
 120     public void testInstantiation()
 121     {
 122         assertFalse( action == lookup( Action.class, ACTION_HINT ) );
 123     }
 124
 125     public void testGetArtifactUniqueRelease()
 126     {
 127         metadataResolver.setProjectVersion( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID,
 128                                             createProjectModel( TEST_VERSION ) );
 129
 130         setActionParameters();
 131
 132         String result = action.artifact();
 133
 134         assertActionSuccess( action, result );
 135
 136         assertActionParameters( action );
 137         ArchivaProjectModel model = action.getModel();
 138         assertDefaultModel( model );
 139
 140         assertEquals( TEST_REPO, action.getRepositoryId() );
 141
 142         assertNull( action.getDependees() );
 143         assertNull( action.getDependencies() );
 144         assertNull( action.getMailingLists() );
 145         assertTrue( action.getSnapshotVersions().isEmpty() );
 146     }
 147
 148     public void testGetArtifactUniqueSnapshot()
 149     {
 150         metadataResolver.setProjectVersion( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID,
 151                                             createProjectModel( TEST_SNAPSHOT_VERSION ) );
 152         metadataResolver.setArtifactVersions( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID, TEST_SNAPSHOT_VERSION,
 153                                               ALL_TEST_SNAPSHOT_VERSIONS );
 154
 155         action.setGroupId( TEST_GROUP_ID );
 156         action.setArtifactId( TEST_ARTIFACT_ID );
 157         action.setVersion( TEST_SNAPSHOT_VERSION );
 158
 159         String result = action.artifact();
 160
 161         assertActionSuccess( action, result );
 162
 163         assertEquals( TEST_GROUP_ID, action.getGroupId() );
 164         assertEquals( TEST_ARTIFACT_ID, action.getArtifactId() );
 165         assertEquals( TEST_SNAPSHOT_VERSION, action.getVersion() );
 166         ArchivaProjectModel model = action.getModel();
 167         assertDefaultModel( model, TEST_SNAPSHOT_VERSION );
 168
 169         assertEquals( TEST_REPO, action.getRepositoryId() );
 170
 171         assertEquals( ALL_TEST_SNAPSHOT_VERSIONS, action.getSnapshotVersions() );
 172
 173         assertNull( action.getDependees() );
 174         assertNull( action.getDependencies() );
 175         assertNull( action.getMailingLists() );
 176     }
 177
 178     public void testGetArtifactUniqueSnapshotTimestamped()
 179     {
 180         metadataResolver.setProjectVersion( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID,
 181                                             createProjectModel( TEST_TS_SNAPSHOT_VERSION ) );
 182         metadataResolver.setArtifactVersions( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID, TEST_TS_SNAPSHOT_VERSION,
 183                                               ALL_TEST_SNAPSHOT_VERSIONS );
 184
 185         action.setGroupId( TEST_GROUP_ID );
 186         action.setArtifactId( TEST_ARTIFACT_ID );
 187         action.setVersion( TEST_TS_SNAPSHOT_VERSION );
 188
 189         String result = action.artifact();
 190
 191         assertActionSuccess( action, result );
 192
 193         assertEquals( TEST_GROUP_ID, action.getGroupId() );
 194         assertEquals( TEST_ARTIFACT_ID, action.getArtifactId() );
 195         assertEquals( TEST_TS_SNAPSHOT_VERSION, action.getVersion() );
 196         ArchivaProjectModel model = action.getModel();
 197         assertDefaultModel( model, TEST_TS_SNAPSHOT_VERSION );
 198
 199         assertEquals( TEST_REPO, action.getRepositoryId() );
 200
 201         assertEquals( Arrays.asList( ALL_TEST_SNAPSHOT_VERSIONS.get( 1 ), ALL_TEST_SNAPSHOT_VERSIONS.get( 2 ) ),
 202                       action.getSnapshotVersions() );
 203
 204         assertNull( action.getDependees() );
 205         assertNull( action.getDependencies() );
 206         assertNull( action.getMailingLists() );
 207     }
 208
 209     public void testGetMissingProject()
 210     {
 211         setActionParameters();
 212
 213         String result = action.artifact();
 214         assertError( result );
 215
 216         assertActionParameters( action );
 217         assertNoOutputFields();
 218     }
 219
 220     public void testGetArtifactNoObservableRepos()
 221     {
 222         setObservableRepos( Collections.<String>emptyList() );
 223
 224         setActionParameters();
 225
 226         String result = action.artifact();
 227
 228         // Actually, it'd be better to have an error:
 229         assertError( result );
 230         assertActionParameters( action );
 231         assertNoOutputFields();
 232     }
 233
 234     public void testGetArtifactNotInObservableRepos()
 235     {
 236         metadataResolver.setProjectVersion( OTHER_TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID,
 237                                             createProjectModel( TEST_VERSION ) );
 238
 239         setActionParameters();
 240
 241         String result = action.artifact();
 242         assertError( result );
 243
 244         assertActionParameters( action );
 245         assertNoOutputFields();
 246     }
 247
 248     public void testGetArtifactOnlySeenInSecondObservableRepo()
 249     {
 250         setObservableRepos( Arrays.asList( OTHER_TEST_REPO, TEST_REPO ) );
 251         metadataResolver.setProjectVersion( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID,
 252                                             createProjectModel( TEST_VERSION ) );
 253
 254         setActionParameters();
 255
 256         String result = action.artifact();
 257
 258         assertActionSuccess( action, result );
 259
 260         assertActionParameters( action );
 261         ArchivaProjectModel model = action.getModel();
 262         assertDefaultModel( model );
 263
 264         assertEquals( TEST_REPO, action.getRepositoryId() );
 265
 266         assertNull( action.getDependees() );
 267         assertNull( action.getDependencies() );
 268         assertNull( action.getMailingLists() );
 269         assertTrue( action.getSnapshotVersions().isEmpty() );
 270     }
 271
 272     public void testGetArtifactSeenInBothObservableRepo()
 273     {
 274         setObservableRepos( Arrays.asList( TEST_REPO, OTHER_TEST_REPO ) );
 275         metadataResolver.setProjectVersion( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID,
 276                                             createProjectModel( TEST_VERSION ) );
 277         metadataResolver.setProjectVersion( OTHER_TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID,
 278                                             createProjectModel( TEST_VERSION ) );
 279
 280         setActionParameters();
 281
 282         String result = action.artifact();
 283
 284         assertActionSuccess( action, result );
 285
 286         assertActionParameters( action );
 287         ArchivaProjectModel model = action.getModel();
 288         assertDefaultModel( model );
 289
 290         assertEquals( TEST_REPO, action.getRepositoryId() );
 291
 292         assertNull( action.getDependees() );
 293         assertNull( action.getDependencies() );
 294         assertNull( action.getMailingLists() );
 295         assertTrue( action.getSnapshotVersions().isEmpty() );
 296     }
 297
 298     public void testGetArtifactCanOnlyObserveInOneOfTwoRepos()
 299     {
 300         setObservableRepos( Arrays.asList( TEST_REPO ) );
 301         metadataResolver.setProjectVersion( OTHER_TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID,
 302                                             createProjectModel( TEST_VERSION ) );
 303         metadataResolver.setProjectVersion( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID,
 304                                             createProjectModel( TEST_VERSION ) );
 305
 306         setActionParameters();
 307
 308         String result = action.artifact();
 309
 310         assertActionSuccess( action, result );
 311
 312         assertActionParameters( action );
 313         ArchivaProjectModel model = action.getModel();
 314         assertDefaultModel( model );
 315
 316         assertEquals( TEST_REPO, action.getRepositoryId() );
 317
 318         assertNull( action.getDependees() );
 319         assertNull( action.getDependencies() );
 320         assertNull( action.getMailingLists() );
 321         assertTrue( action.getSnapshotVersions().isEmpty() );
 322     }
 323
 324     public void testGetArtifactNoMavenFacet()
 325     {
 326         ProjectVersionMetadata versionMetadata = new ProjectVersionMetadata();
 327         versionMetadata.setId( TEST_VERSION );
 328         versionMetadata.setUrl( TEST_URL );
 329         versionMetadata.setName( TEST_NAME );
 330         versionMetadata.setDescription( TEST_DESCRIPTION );
 331
 332         metadataResolver.setProjectVersion( TEST_REPO, TEST_GROUP_ID, TEST_ARTIFACT_ID, versionMetadata );
 333
 334         setActionParameters();
 335
 336         String result = action.artifact();
 337
 338         assertActionSuccess( action, result );
 339
 340         assertActionParameters( action );
 341         ArchivaProjectModel model = action.getModel();
 342         assertEquals( TEST_VERSION, model.getVersion() );
 343         assertEquals( TEST_URL, model.getUrl() );
 344         assertEquals( TEST_NAME, model.getName() );
 345         assertEquals( TEST_DESCRIPTION, model.getDescription() );
 346
 347         assertEquals( TEST_REPO, action.getRepositoryId() );
 348
 349         assertNull( action.getDependees() );
 350         assertNull( action.getDependencies() );
 351         assertNull( action.getMailingLists() );
 352         assertTrue( action.getSnapshotVersions().isEmpty() );
 353     }
 354
 355     public void testGetMailingLists()
 356         throws ArchivaDatabaseException
 357     {
 358         List<ArchivaArtifact> artifacts =
 359             Collections.singletonList( createArtifact( TEST_GROUP_ID, TEST_ARTIFACT_ID, TEST_VERSION ) );
 360         MockControl artifactDaoMockControl = createArtifactDaoMock( artifacts, 1 );
 361         ArchivaProjectModel legacyModel = createLegacyProjectModel( TEST_GROUP_ID, TEST_ARTIFACT_ID, TEST_VERSION );
 362         MailingList ml1 = createMailingList( "Users List", "users" );
 363         MailingList ml2 = createMailingList( "Developers List", "dev" );
 364         legacyModel.setMailingLists( Arrays.asList( ml1, ml2 ) );
 365         MockControl projectDaoMockControl = createProjectDaoMock( legacyModel );
 366
 367         setActionParameters();
 368
 369         String result = action.mailingLists();
 370
 371         artifactDaoMockControl.verify();
 372         projectDaoMockControl.verify();
 373
 374         assertActionSuccess( action, result );
 375
 376         assertActionParameters( action );
 377         ArchivaProjectModel model = action.getModel();
 378         assertDefaultModel( model );
 379
 380         assertNotNull( action.getMailingLists() );
 381         assertMailingList( action.getMailingLists().get( 0 ), "Users List", "users" );
 382         assertMailingList( action.getMailingLists().get( 1 ), "Developers List", "dev" );
 383
 384         assertNull( action.getRepositoryId() );
 385         assertNull( action.getDependees() );
 386         assertNull( action.getDependencies() );
 387         assertNull( action.getSnapshotVersions() );
 388     }
 389
 390     private void assertMailingList( MailingList mailingList, String name, String prefix )
 391     {
 392         assertEquals( name, mailingList.getName() );
 393         assertEquals( prefix + "-post@", mailingList.getPostAddress() );
 394         assertEquals( prefix + "-subscribe@", mailingList.getSubscribeAddress() );
 395         assertEquals( prefix + "-unsubscribe@", mailingList.getUnsubscribeAddress() );
 396         assertEquals( prefix + "-archive-url", mailingList.getMainArchiveUrl() );
 397         assertEquals( Arrays.asList( "other-" + prefix + "-archive-url-1", "other-" + prefix + "-archive-url-2" ),
 398                       mailingList.getOtherArchives() );
 399     }
 400
 401     private MailingList createMailingList( String name, String prefix )
 402     {
 403         MailingList ml1 = new MailingList();
 404         ml1.setName( name );
 405         ml1.setPostAddress( prefix + "-post@" );
 406         ml1.setSubscribeAddress( prefix + "-subscribe@" );
 407         ml1.setUnsubscribeAddress( prefix + "-unsubscribe@" );
 408         ml1.setMainArchiveUrl( prefix + "-archive-url" );
 409         ml1.setOtherArchives(
 410             Arrays.asList( "other-" + prefix + "-archive-url-1", "other-" + prefix + "-archive-url-2" ) );
 411         return ml1;
 412     }
 413
 414     private void assertNoOutputFields()
 415     {
 416         assertNull( action.getModel() );
 417         assertNull( action.getDependees() );
 418         assertNull( action.getDependencies() );
 419         assertNull( action.getMailingLists() );
 420         assertTrue( action.getSnapshotVersions().isEmpty() );
 421     }
 422
 423     private void assertError( String result )
 424     {
 425         assertEquals( Action.ERROR, result );
 426         assertEquals( 1, action.getActionErrors().size() );
 427     }
 428
 429     private void setObservableRepos( List<String> repoIds )
 430     {
 431         UserRepositoriesStub repos = (UserRepositoriesStub) lookup( UserRepositories.class );
 432         repos.setObservableRepositoryIds( repoIds );
 433     }
 434
 435     private void assertDefaultModel( ArchivaProjectModel model )
 436     {
 437         assertDefaultModel( model, TEST_VERSION );
 438     }
 439
 440     private void assertDefaultModel( ArchivaProjectModel model, String version )
 441     {
 442         assertEquals( TEST_GROUP_ID, model.getGroupId() );
 443         assertEquals( TEST_ARTIFACT_ID, model.getArtifactId() );
 444         assertEquals( version, model.getVersion() );
 445         assertEquals( TEST_URL, model.getUrl() );
 446         assertEquals( TEST_NAME, model.getName() );
 447         assertEquals( TEST_DESCRIPTION, model.getDescription() );
 448         assertEquals( TEST_ORGANIZATION_NAME, model.getOrganization().getName() );
 449         assertEquals( TEST_ORGANIZATION_URL, model.getOrganization().getUrl() );
 450         assertEquals( 2, model.getLicenses().size() );
 451         org.apache.maven.archiva.model.License l = model.getLicenses().get( 0 );
 452         assertEquals( TEST_LICENSE_NAME, l.getName() );
 453         assertEquals( TEST_LICENSE_URL, l.getUrl() );
 454         l = model.getLicenses().get( 1 );
 455         assertEquals( TEST_LICENSE_NAME_2, l.getName() );
 456         assertEquals( TEST_LICENSE_URL_2, l.getUrl() );
 457         assertEquals( TEST_ISSUE_SYSTEM, model.getIssueManagement().getSystem() );
 458         assertEquals( TEST_ISSUE_URL, model.getIssueManagement().getUrl() );
 459         assertEquals( TEST_CI_SYSTEM, model.getCiManagement().getSystem() );
 460         assertEquals( TEST_CI_URL, model.getCiManagement().getUrl() );
 461         assertEquals( TEST_SCM_CONNECTION, model.getScm().getConnection() );
 462         assertEquals( TEST_SCM_DEV_CONNECTION, model.getScm().getDeveloperConnection() );
 463         assertEquals( TEST_SCM_URL, model.getScm().getUrl() );
 464
 465         assertEquals( TEST_PACKAGING, model.getPackaging() );
 466         assertEquals( TEST_PARENT_GROUP_ID, model.getParentProject().getGroupId() );
 467         assertEquals( TEST_PARENT_ARTIFACT_ID, model.getParentProject().getArtifactId() );
 468         assertEquals( TEST_PARENT_VERSION, model.getParentProject().getVersion() );
 469     }
 470
 471     private void setActionParameters()
 472     {
 473         action.setGroupId( TEST_GROUP_ID );
 474         action.setArtifactId( TEST_ARTIFACT_ID );
 475         action.setVersion( TEST_VERSION );
 476     }
 477
 478     private void assertActionParameters( ShowArtifactAction action )
 479     {
 480         assertEquals( TEST_GROUP_ID, action.getGroupId() );
 481         assertEquals( TEST_ARTIFACT_ID, action.getArtifactId() );
 482         assertEquals( TEST_VERSION, action.getVersion() );
 483     }
 484
 485     private void assertActionSuccess( ShowArtifactAction action, String result )
 486     {
 487         assertEquals( Action.SUCCESS, result );
 488         assertTrue( action.getActionErrors().isEmpty() );
 489         assertTrue( action.getActionMessages().isEmpty() );
 490     }
 491
 492     private ProjectVersionMetadata createProjectModel( String version )
 493     {
 494         ProjectVersionMetadata model = new ProjectVersionMetadata();
 495         model.setId( version );
 496         model.setUrl( TEST_URL );
 497         model.setName( TEST_NAME );
 498         model.setDescription( TEST_DESCRIPTION );
 499         CiManagement ci = new CiManagement();
 500         ci.setSystem( TEST_CI_SYSTEM );
 501         ci.setUrl( TEST_CI_URL );
 502         model.setCiManagement( ci );
 503         IssueManagement issue = new IssueManagement();
 504         issue.setSystem( TEST_ISSUE_SYSTEM );
 505         issue.setUrl( TEST_ISSUE_URL );
 506         model.setIssueManagement( issue );
 507         Organization organization = new Organization();
 508         organization.setName( TEST_ORGANIZATION_NAME );
 509         organization.setUrl( TEST_ORGANIZATION_URL );
 510         model.setOrganization( organization );
 511         License l = new License();
 512         l.setName( TEST_LICENSE_NAME );
 513         l.setUrl( TEST_LICENSE_URL );
 514         model.addLicense( l );
 515         l = new License();
 516         l.setName( TEST_LICENSE_NAME_2 );
 517         l.setUrl( TEST_LICENSE_URL_2 );
 518         model.addLicense( l );
 519         Scm scm = new Scm();
 520         scm.setConnection( TEST_SCM_CONNECTION );
 521         scm.setDeveloperConnection( TEST_SCM_DEV_CONNECTION );
 522         scm.setUrl( TEST_SCM_URL );
 523         model.setScm( scm );
 524
 525         MavenProjectFacet mavenProjectFacet = new MavenProjectFacet();
 526         mavenProjectFacet.setGroupId( TEST_GROUP_ID );
 527         mavenProjectFacet.setArtifactId( TEST_ARTIFACT_ID );
 528         mavenProjectFacet.setPackaging( TEST_PACKAGING );
 529         MavenProjectParent parent = new MavenProjectParent();
 530         parent.setGroupId( TEST_PARENT_GROUP_ID );
 531         parent.setArtifactId( TEST_PARENT_ARTIFACT_ID );
 532         parent.setVersion( TEST_PARENT_VERSION );
 533         mavenProjectFacet.setParent( parent );
 534         model.addFacet( mavenProjectFacet );
 535         return model;
 536     }
 537
 538     private ArchivaProjectModel createLegacyProjectModel( String groupId, String artifactId, String version )
 539     {
 540         ArchivaProjectModel model = new ArchivaProjectModel();
 541         model.setGroupId( groupId );
 542         model.setArtifactId( artifactId );
 543         model.setVersion( version );
 544         model.setPackaging( TEST_PACKAGING );
 545         model.setUrl( TEST_URL );
 546         model.setName( TEST_NAME );
 547         model.setDescription( TEST_DESCRIPTION );
 548         VersionedReference parent = new VersionedReference();
 549         parent.setGroupId( TEST_PARENT_GROUP_ID );
 550         parent.setArtifactId( TEST_PARENT_ARTIFACT_ID );
 551         parent.setVersion( TEST_PARENT_VERSION );
 552         model.setParentProject( parent );
 553         org.apache.maven.archiva.model.CiManagement ci = new org.apache.maven.archiva.model.CiManagement();
 554         ci.setSystem( TEST_CI_SYSTEM );
 555         ci.setUrl( TEST_CI_URL );
 556         model.setCiManagement( ci );
 557         org.apache.maven.archiva.model.IssueManagement issue = new org.apache.maven.archiva.model.IssueManagement();
 558         issue.setSystem( TEST_ISSUE_SYSTEM );
 559         issue.setUrl( TEST_ISSUE_URL );
 560         model.setIssueManagement( issue );
 561         org.apache.maven.archiva.model.Organization org = new org.apache.maven.archiva.model.Organization();
 562         org.setName( TEST_ORGANIZATION_NAME );
 563         org.setUrl( TEST_ORGANIZATION_URL );
 564         model.setOrganization( org );
 565         org.apache.maven.archiva.model.License l = new org.apache.maven.archiva.model.License();
 566         l.setName( TEST_LICENSE_NAME );
 567         l.setUrl( TEST_LICENSE_URL );
 568         model.addLicense( l );
 569         l = new org.apache.maven.archiva.model.License();
 570         l.setName( TEST_LICENSE_NAME_2 );
 571         l.setUrl( TEST_LICENSE_URL_2 );
 572         model.addLicense( l );
 573         org.apache.maven.archiva.model.Scm scm = new org.apache.maven.archiva.model.Scm();
 574         scm.setConnection( TEST_SCM_CONNECTION );
 575         scm.setDeveloperConnection( TEST_SCM_DEV_CONNECTION );
 576         scm.setUrl( TEST_SCM_URL );
 577         model.setScm( scm );
 578         return model;
 579     }
 580
 581     private MockControl createArtifactDaoMock( List<ArchivaArtifact> artifacts, int count )
 582         throws ArchivaDatabaseException
 583     {
 584         return createArtifactDaoMock( artifacts, TEST_VERSION, count );
 585     }
 586
 587     private MockControl createArtifactDaoMock( List<ArchivaArtifact> artifacts, String version, int count )
 588         throws ArchivaDatabaseException
 589     {
 590         // testing deeper than normal with the mocks as we intend to replace RepositoryBrowsing, not just the database
 591         // underneath it - those sections will be adjusted with a mock content repository later
 592         MockControl control = MockControl.createNiceControl( ArtifactDAO.class );
 593         ArtifactDAO dao = (ArtifactDAO) control.getMock();
 594         archivaDao.setArtifactDao( dao );
 595
 596         ArtifactsRelatedConstraint c = new ArtifactsRelatedConstraint( TEST_GROUP_ID, TEST_ARTIFACT_ID, version );
 597         dao.queryArtifacts( c );
 598         control.setReturnValue( artifacts, count );
 599
 600         control.replay();
 601         return control;
 602     }
 603
 604     private MockControl createProjectDaoMock( ArchivaProjectModel project )
 605         throws ArchivaDatabaseException
 606     {
 607         MockControl control = MockControl.createNiceControl( ProjectModelDAO.class );
 608         ProjectModelDAO dao = (ProjectModelDAO) control.getMock();
 609         archivaDao.setProjectDao( dao );
 610
 611         control.expectAndReturn(
 612             dao.getProjectModel( project.getGroupId(), project.getArtifactId(), project.getVersion() ), project );
 613
 614         control.replay();
 615         return control;
 616     }
 617
 618     private ArchivaArtifact createArtifact( String groupId, String artifactId, String version )
 619     {
 620         return createArtifact( groupId, artifactId, version, TEST_REPO );
 621     }
 622
 623     private ArchivaArtifact createArtifact( String groupId, String artifactId, String version, String repoId )
 624     {
 625         ArchivaArtifactModel model = new ArchivaArtifactModel();
 626         model.setGroupId( groupId );
 627         model.setArtifactId( artifactId );
 628         model.setVersion( version );
 629         model.setRepositoryId( repoId );
 630         return new ArchivaArtifact( model );
 631     }
 632
 633     protected void setUp()
 634         throws Exception
 635     {
 636         super.setUp();
 637         action = (ShowArtifactAction) lookup( Action.class, ACTION_HINT );
 638         metadataResolver = (TestMetadataResolver) action.getMetadataResolver();
 639         archivaDao = (ArchivaDAOStub) lookup( ArchivaDAO.class, "jdo" );
 640     }
 641 }