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