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

   1 package org.apache.maven.archiva.proxy;
   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 org.apache.commons.lang.StringUtils;
  23 import org.apache.maven.archiva.common.utils.VersionUtil;
  24 import org.apache.maven.archiva.model.ArchivaRepositoryMetadata;
  25 import org.apache.maven.archiva.model.ProjectReference;
  26 import org.apache.maven.archiva.model.SnapshotVersion;
  27 import org.apache.maven.archiva.model.VersionedReference;
  28 import org.apache.maven.archiva.policies.CachedFailuresPolicy;
  29 import org.apache.maven.archiva.policies.ChecksumPolicy;
  30 import org.apache.maven.archiva.policies.ReleasesPolicy;
  31 import org.apache.maven.archiva.policies.SnapshotsPolicy;
  32 import org.apache.maven.archiva.repository.metadata.MetadataTools;
  33 import org.apache.maven.archiva.repository.metadata.RepositoryMetadataException;
  34 import org.apache.maven.archiva.repository.metadata.RepositoryMetadataReader;
  35 import org.apache.maven.archiva.repository.metadata.RepositoryMetadataWriter;
  36 import org.apache.maven.wagon.TransferFailedException;
  37 import org.custommonkey.xmlunit.DetailedDiff;
  38 import org.custommonkey.xmlunit.Diff;
  39
  40 import java.io.File;
  41 import java.io.StringWriter;
  42 import java.util.Arrays;
  43
  44 /**
  45  * MetadataTransferTest - Tests the various fetching / merging concepts surrounding the maven-metadata.xml files
  46  * present in the repository.
  47  *
  48  * Test Case Naming is as follows.
  49  *
  50  * <code>
  51  * public void testGet[Release|Snapshot|Project]Metadata[Not]Proxied[Not|On]Local[Not|On|Multiple]Remote
  52  * </code>
  53  *
  54  * <pre>
  55  * Which should leave the following matrix of test cases.
  56  *
  57  *   Metadata  | Proxied  | Local | Remote
  58  *   ----------+----------+-------+---------
  59  *   Release   | Not      | Not   | n/a (1)
  60  *   Release   | Not      | On    | n/a (1)
  61  *   Release   |          | Not   | Not
  62  *   Release   |          | Not   | On
  63  *   Release   |          | Not   | Multiple
  64  *   Release   |          | On    | Not
  65  *   Release   |          | On    | On
  66  *   Release   |          | On    | Multiple
  67  *   Snapshot  | Not      | Not   | n/a (1)
  68  *   Snapshot  | Not      | On    | n/a (1)
  69  *   Snapshot  |          | Not   | Not
  70  *   Snapshot  |          | Not   | On
  71  *   Snapshot  |          | Not   | Multiple
  72  *   Snapshot  |          | On    | Not
  73  *   Snapshot  |          | On    | On
  74  *   Snapshot  |          | On    | Multiple
  75  *   Project   | Not      | Not   | n/a (1)
  76  *   Project   | Not      | On    | n/a (1)
  77  *   Project   |          | Not   | Not
  78  *   Project   |          | Not   | On
  79  *   Project   |          | Not   | Multiple
  80  *   Project   |          | On    | Not
  81  *   Project   |          | On    | On
  82  *   Project   |          | On    | Multiple
  83  *
  84  * (1) If it isn't proxied, no point in having a remote.
  85  * </pre>
  86  *
  87  * @author <a href="mailto:joakime@apache.org">Joakim Erdfelt</a>
  88  * @version $Id$
  89  */
  90 public class MetadataTransferTest
  91     extends AbstractProxyTestCase
  92 {
  93     /**
  94      * @plexus.requirement
  95      */
  96     private MetadataTools metadataTools;
  97
  98     // TODO: same test for other fetch* methods
  99     public void testFetchFromTwoProxiesWhenFirstConnectionFails()
 100         throws Exception
 101     {
 102         // Project metadata that does not exist locally, but has multiple versions in remote repos
 103         String requestedResource = "org/apache/maven/test/get-default-layout/maven-metadata.xml";
 104         setupTestableManagedRepository( requestedResource );
 105
 106         saveRemoteRepositoryConfig( "badproxied1", "Bad Proxied 1", "test://bad.machine.com/repo/", "default" );
 107
 108         // Configure Connector (usually done within archiva.xml configuration)
 109         saveConnector( ID_DEFAULT_MANAGED, "badproxied1", ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 110                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 111         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED2, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 112                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 113
 114         assertResourceNotFound( requestedResource );
 115         assertNoRepoMetadata( "badproxied1", requestedResource );
 116         assertNoRepoMetadata( ID_PROXIED2, requestedResource );
 117
 118         // ensure that a hard failure in the first proxy connector is skipped and the second repository checked
 119         File expectedFile = new File( managedDefaultDir.getAbsoluteFile(),
 120                                       metadataTools.getRepositorySpecificName( "badproxied1", requestedResource ) );
 121         wagonMock.get( requestedResource, new File( expectedFile.getParentFile(), expectedFile.getName() + ".tmp" ) );
 122         wagonMockControl.setThrowable( new TransferFailedException( "can't connect" ) );
 123
 124         wagonMockControl.replay();
 125
 126         assertFetchProject( requestedResource );
 127
 128         wagonMockControl.verify();
 129
 130         assertProjectMetadataContents( requestedResource, new String[] { "1.0.1" }, "1.0.1", "1.0.1" );
 131         assertNoRepoMetadata( "badproxied1", requestedResource );
 132         assertRepoProjectMetadata( ID_PROXIED2, requestedResource, new String[] { "1.0.1" } );
 133     }
 134
 135     /**
 136      * Attempt to get the project metadata for non-existant artifact.
 137      *
 138      * Expected result: the maven-metadata.xml file is not created on the managed repository, nor returned
 139      *                  to the requesting client.
 140      */
 141     public void testGetProjectMetadataNotProxiedNotLocal()
 142         throws Exception
 143     {
 144         // The artifactId "get-default-metadata-nonexistant" does not exist (intentionally).
 145         String requestedResource = "org/apache/maven/test/get-default-metadata-nonexistant/maven-metadata.xml";
 146         setupTestableManagedRepository( requestedResource );
 147
 148         assertResourceNotFound( requestedResource );
 149
 150         // No proxy setup, nothing fetched, failure expected.
 151         assertFetchProjectFailed( requestedResource );
 152
 153         // No local artifactId, and no fetch, should equal no metadata file downloaded / created / updated.
 154         assertResourceNotFound( requestedResource );
 155     }
 156
 157     public void testGetProjectMetadataNotProxiedOnLocal()
 158         throws Exception
 159     {
 160         // Project metadata that exists and has multiple versions
 161         String requestedResource = "org/apache/maven/test/get-project-metadata/maven-metadata.xml";
 162         setupTestableManagedRepository( requestedResource );
 163
 164         assertResourceExists( requestedResource );
 165
 166         // No proxy setup, nothing fetched from remote, but local exists.
 167         assertFetchProject( requestedResource );
 168
 169         // Nothing fetched.  Should only contain contents of what is in the repository.
 170         // A metadata update is not performed in this use case.  Local metadata content is only
 171         // updated via the metadata updater consumer.
 172         assertProjectMetadataContents( requestedResource, new String[] { "1.0" }, null, null );
 173     }
 174
 175     public void testGetProjectMetadataProxiedNotLocalMultipleRemotes()
 176         throws Exception
 177     {
 178         // Project metadata that does not exist locally, but has multiple versions in remote repos
 179         String requestedResource = "org/apache/maven/test/get-default-layout/maven-metadata.xml";
 180         setupTestableManagedRepository( requestedResource );
 181
 182         // Configure Connector (usually done within archiva.xml configuration)
 183         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 184                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 185         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED2, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 186                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 187
 188         assertResourceNotFound( requestedResource );
 189         assertNoRepoMetadata( ID_PROXIED1, requestedResource );
 190         assertNoRepoMetadata( ID_PROXIED2, requestedResource );
 191
 192         // Two proxies setup, metadata fetched from both remotes.
 193         assertFetchProject( requestedResource );
 194
 195         // Nothing fetched.  Should only contain contents of what is in the repository.
 196         assertProjectMetadataContents( requestedResource, new String[] { "1.0", "1.0.1" }, "1.0.1", "1.0.1" );
 197         assertRepoProjectMetadata( ID_PROXIED1, requestedResource, new String[] { "1.0" } );
 198         assertRepoProjectMetadata( ID_PROXIED2, requestedResource, new String[] { "1.0.1" } );
 199     }
 200
 201     public void testGetProjectMetadataProxiedNotLocalNotRemote()
 202         throws Exception
 203     {
 204         // Non-existant project metadata that does not exist locally and doesn't exist on remotes.
 205         String requestedResource = "org/apache/maven/test/get-bogus-artifact/maven-metadata.xml";
 206         setupTestableManagedRepository( requestedResource );
 207
 208         // Configure Connector (usually done within archiva.xml configuration)
 209         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 210                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 211         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED2, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 212                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 213
 214         assertResourceNotFound( requestedResource );
 215         assertNoRepoMetadata( ID_PROXIED1, requestedResource );
 216         assertNoRepoMetadata( ID_PROXIED2, requestedResource );
 217
 218         // Two proxies setup, nothing fetched from remotes, local does not exist.
 219         assertFetchProjectFailed( requestedResource );
 220
 221         // Nothing fetched.  Nothing should exist.
 222         assertResourceNotFound( requestedResource );
 223         assertNoRepoMetadata( ID_PROXIED1, requestedResource );
 224         assertNoRepoMetadata( ID_PROXIED2, requestedResource );
 225     }
 226
 227     public void testGetProjectMetadataProxiedNotLocalOnRemote()
 228         throws Exception
 229     {
 230         // New project metadata that does not exist locally but exists on remote.
 231         String requestedResource = "org/apache/maven/test/get-found-in-proxy/maven-metadata.xml";
 232         setupTestableManagedRepository( requestedResource );
 233
 234         // Configure Connector (usually done within archiva.xml configuration)
 235         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 236                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 237
 238         assertResourceNotFound( requestedResource );
 239         assertNoRepoMetadata( ID_PROXIED1, requestedResource );
 240
 241         // One proxy setup, metadata fetched from remote, local does not exist.
 242         assertFetchProject( requestedResource );
 243
 244         // Remote fetched.  Local created/updated.
 245         assertProjectMetadataContents( requestedResource, new String[] { "1.0.5" }, "1.0.5", "1.0.5" );
 246         assertRepoProjectMetadata( ID_PROXIED1, requestedResource, new String[] { "1.0.5" } );
 247     }
 248
 249     public void testGetProjectMetadataProxiedOnLocalMultipleRemote()
 250         throws Exception
 251     {
 252         // Project metadata that exist locally, and has multiple versions in remote repos
 253         String requestedResource = "org/apache/maven/test/get-on-multiple-repos/maven-metadata.xml";
 254         setupTestableManagedRepository( requestedResource );
 255
 256         // Configure Connector (usually done within archiva.xml configuration)
 257         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 258                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 259         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED2, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 260                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 261
 262         assertProjectMetadataContents( requestedResource, new String[] { "1.0" }, null, null );
 263         assertNoRepoMetadata( ID_PROXIED1, requestedResource );
 264         assertNoRepoMetadata( ID_PROXIED2, requestedResource );
 265
 266         // Two proxies setup, metadata fetched from both remotes.
 267         assertFetchProject( requestedResource );
 268
 269         // metadata fetched from both repos, and merged with local version.
 270         assertProjectMetadataContents( requestedResource, new String[] { "1.0", "1.0.1", "2.0" }, "2.0", "2.0" );
 271         assertRepoProjectMetadata( ID_PROXIED1, requestedResource, new String[] { "1.0", "2.0" } );
 272         assertRepoProjectMetadata( ID_PROXIED2, requestedResource, new String[] { "1.0", "1.0.1" } );
 273     }
 274
 275     public void testGetProjectMetadataProxiedOnLocalNotRemote()
 276         throws Exception
 277     {
 278         // Project metadata that exist locally, and does not exist in remote repos.
 279         String requestedResource = "org/apache/maven/test/get-not-on-remotes/maven-metadata.xml";
 280         setupTestableManagedRepository( requestedResource );
 281
 282         // Configure Connector (usually done within archiva.xml configuration)
 283         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 284                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 285         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED2, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 286                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 287
 288         assertProjectMetadataContents( requestedResource, new String[] { "1.0-beta-2" }, null, null );
 289         assertNoRepoMetadata( ID_PROXIED1, requestedResource );
 290         assertNoRepoMetadata( ID_PROXIED2, requestedResource );
 291
 292         // Two proxies setup, metadata fetch from remotes fail (because they dont exist).
 293         assertFetchProject( requestedResource );
 294
 295         // metadata not fetched from both repos, and local version exists.
 296         // Since there was no updated metadata content from a remote/proxy, a metadata update on
 297         // the local file never ran.  Local only updates are performed via the metadata updater consumer.
 298         assertProjectMetadataContents( requestedResource, new String[] { "1.0-beta-2" }, null, null );
 299         assertNoRepoMetadata( ID_PROXIED1, requestedResource );
 300         assertNoRepoMetadata( ID_PROXIED2, requestedResource );
 301     }
 302
 303     public void testGetProjectMetadataProxiedOnLocalOnRemote()
 304         throws Exception
 305     {
 306         // Project metadata that exist locally and exists on remote.
 307         String requestedResource = "org/apache/maven/test/get-on-local-on-remote/maven-metadata.xml";
 308         setupTestableManagedRepository( requestedResource );
 309
 310         // Configure Connector (usually done within archiva.xml configuration)
 311         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 312                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 313
 314         assertProjectMetadataContents( requestedResource, new String[] { "1.0.8", "1.0.22" }, null, null );
 315         assertNoRepoMetadata( ID_PROXIED1, requestedResource );
 316
 317         // One proxy setup, metadata fetched from remote, local exists.
 318         assertFetchProject( requestedResource );
 319
 320         // Remote fetched.  Local updated.
 321         assertProjectMetadataContents( requestedResource, new String[] { "1.0.8", "1.0.22", "2.0" }, "2.0", "2.0" );
 322         assertRepoProjectMetadata( ID_PROXIED1, requestedResource, new String[] { "1.0.22", "2.0" } );
 323     }
 324
 325     /**
 326      * A request for a release maven-metadata.xml file that does not exist locally, and the managed
 327      * repository has no proxied repositories set up.
 328      *
 329      * Expected result: the maven-metadata.xml file is not created on the managed repository, nor returned
 330      *                  to the requesting client.
 331      */
 332     public void testGetReleaseMetadataNotProxiedNotLocal()
 333         throws Exception
 334     {
 335         // The artifactId "get-default-metadata-nonexistant" does not exist (intentionally).
 336         String requestedResource = "org/apache/maven/test/get-default-metadata-nonexistant/1.0/maven-metadata.xml";
 337         setupTestableManagedRepository( requestedResource );
 338
 339         assertNoMetadata( requestedResource );
 340
 341         // No proxy setup, nothing fetched, failure expected.
 342         assertFetchVersionedFailed( requestedResource );
 343
 344         // No local artifactId, and no fetch, should equal no metadata file downloaded / created / updated.
 345         assertNoMetadata( requestedResource );
 346     }
 347
 348     /**
 349      * A request for a maven-metadata.xml file that does exist locally, and the managed
 350      * repository has no proxied repositories set up.
 351      *
 352      * Expected result: the maven-metadata.xml file is updated locally, based off of the managed repository
 353      *                  information, and then returned to the client.
 354      */
 355     public void testGetReleaseMetadataNotProxiedOnLocal()
 356         throws Exception
 357     {
 358         String requestedResource = "org/apache/maven/test/get-default-metadata/1.0/maven-metadata.xml";
 359         setupTestableManagedRepository( requestedResource );
 360
 361         assertResourceExists( requestedResource );
 362
 363         assertFetchVersioned( requestedResource );
 364
 365         assertReleaseMetadataContents( requestedResource );
 366     }
 367
 368     /**
 369      * A request for a release maven-metadata.xml file that does not exist on the managed repository, but
 370      * exists on multiple remote repositories.
 371      *
 372      * Expected result: the maven-metadata.xml file is downloaded from the remote into the repository specific
 373      *                  file location on the managed repository, a merge of the contents to the requested
 374      *                  maven-metadata.xml is performed, and then the merged maven-metadata.xml file is
 375      *                  returned to the client.
 376      */
 377     public void testGetReleaseMetadataProxiedNotLocalMultipleRemotes()
 378         throws Exception
 379     {
 380         String requestedResource = "org/apache/maven/test/get-default-layout/1.0/maven-metadata.xml";
 381         setupTestableManagedRepository( requestedResource );
 382
 383         // Configure Connector (usually done within archiva.xml configuration)
 384         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 385                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 386         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED2, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 387                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 388
 389         assertResourceNotFound( requestedResource );
 390         assertNoRepoMetadata( ID_PROXIED1, requestedResource );
 391         assertNoRepoMetadata( ID_PROXIED2, requestedResource );
 392
 393         assertFetchVersioned( requestedResource );
 394
 395         assertReleaseMetadataContents( requestedResource );
 396         assertRepoReleaseMetadataContents( ID_PROXIED1, requestedResource );
 397         assertRepoReleaseMetadataContents( ID_PROXIED2, requestedResource );
 398     }
 399
 400     /**
 401      * A request for a maven-metadata.xml file that does not exist locally, nor does it exist in a remote
 402      * proxied repository.
 403      *
 404      * Expected result: the maven-metadata.xml file is created locally, based off of managed repository
 405      *                  information, and then return to the client.
 406      */
 407     public void testGetReleaseMetadataProxiedNotLocalNotRemote()
 408         throws Exception
 409     {
 410         String requestedResource = "org/apache/maven/test/get-bad-metadata/1.0/maven-metadata.xml";
 411         setupTestableManagedRepository( requestedResource );
 412
 413         // Configure Connector (usually done within archiva.xml configuration)
 414         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 415                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 416
 417         assertResourceNotFound( requestedResource );
 418
 419         assertFetchProjectFailed( requestedResource );
 420
 421         assertResourceNotFound( requestedResource );
 422         assertNoRepoMetadata( ID_PROXIED1, requestedResource );
 423     }
 424
 425     /**
 426      * A request for a maven-metadata.xml file that does not exist on the managed repository, but
 427      * exists on 1 remote repository.
 428      *
 429      * Expected result: the maven-metadata.xml file is downloaded from the remote into the repository specific
 430      *                  file location on the managed repository, a merge of the contents to the requested
 431      *                  maven-metadata.xml is performed, and then the merged maven-metadata.xml file is
 432      *                  returned to the client.
 433      */
 434     public void testGetReleaseMetadataProxiedNotLocalOnRemote()
 435         throws Exception
 436     {
 437         String requestedResource = "org/apache/maven/test/get-default-layout/1.0/maven-metadata.xml";
 438         setupTestableManagedRepository( requestedResource );
 439
 440         // Configure Connector (usually done within archiva.xml configuration)
 441         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 442                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 443
 444         assertNoRepoMetadata( ID_PROXIED1, requestedResource );
 445
 446         assertFetchVersioned( requestedResource );
 447
 448         assertReleaseMetadataContents( requestedResource );
 449         assertRepoReleaseMetadataContents( ID_PROXIED1, requestedResource );
 450     }
 451
 452     /**
 453      * A request for a maven-metadata.xml file that exists in the managed repository, but
 454      * not on any remote repository.
 455      *
 456      * Expected result: the maven-metadata.xml file does not exist on the remote proxied repository and
 457      *                  is not downloaded.  There is no repository specific metadata file on the managed
 458      *                  repository.  The managed repository maven-metadata.xml is returned to the
 459      *                  client as-is.
 460      */
 461     public void testGetReleaseMetadataProxiedOnLocalNotRemote()
 462         throws Exception
 463     {
 464         String requestedResource = "org/apache/maven/test/get-not-on-remotes/1.0-beta-2/maven-metadata.xml";
 465         setupTestableManagedRepository( requestedResource );
 466
 467         // Configure Connector (usually done within archiva.xml configuration)
 468         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 469                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 470
 471         assertReleaseMetadataContents( requestedResource );
 472
 473         assertFetchVersioned( requestedResource );
 474
 475         assertReleaseMetadataContents( requestedResource );
 476         assertNoRepoMetadata( ID_PROXIED1, requestedResource );
 477     }
 478
 479     /**
 480      * A request for a maven-metadata.xml file that exists in the managed repository, and on multiple
 481      * remote repositories.
 482      *
 483      * Expected result: the maven-metadata.xml file on the remote proxied repository is downloaded
 484      *                  and merged into the contents of the existing managed repository copy of
 485      *                  the maven-metadata.xml file.
 486      */
 487     public void testGetReleaseMetadataProxiedOnLocalMultipleRemote()
 488         throws Exception
 489     {
 490         String requestedResource = "org/apache/maven/test/get-on-multiple-repos/1.0/maven-metadata.xml";
 491         setupTestableManagedRepository( requestedResource );
 492
 493         // Configure Connector (usually done within archiva.xml configuration)
 494         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 495                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 496         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED2, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 497                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 498
 499         assertReleaseMetadataContents( requestedResource );
 500         assertNoRepoMetadata( ID_PROXIED1, requestedResource );
 501         assertNoRepoMetadata( ID_PROXIED2, requestedResource );
 502
 503         assertFetchVersioned( requestedResource );
 504
 505         assertReleaseMetadataContents( requestedResource );
 506         assertRepoReleaseMetadataContents( ID_PROXIED1, requestedResource );
 507         assertRepoReleaseMetadataContents( ID_PROXIED2, requestedResource );
 508     }
 509
 510     /**
 511      * A request for a maven-metadata.xml file that exists in the managed repository, and on one
 512      * remote repository.
 513      *
 514      * Expected result: the maven-metadata.xml file on the remote proxied repository is downloaded
 515      *                  and merged into the contents of the existing managed repository copy of
 516      *                  the maven-metadata.xml file.
 517      */
 518     public void testGetReleaseMetadataProxiedOnLocalOnRemote()
 519         throws Exception
 520     {
 521         String requestedResource = "org/apache/maven/test/get-on-local-on-remote/1.0.22/maven-metadata.xml";
 522         setupTestableManagedRepository( requestedResource );
 523
 524         // Configure Connector (usually done within archiva.xml configuration)
 525         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 526                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 527
 528         assertReleaseMetadataContents( requestedResource );
 529         assertNoRepoMetadata( ID_PROXIED1, requestedResource );
 530
 531         assertFetchVersioned( requestedResource );
 532
 533         assertReleaseMetadataContents( requestedResource );
 534         assertRepoReleaseMetadataContents( ID_PROXIED1, requestedResource );
 535     }
 536
 537     public void testGetSnapshotMetadataNotProxiedNotLocal()
 538         throws Exception
 539     {
 540         // The artifactId "get-default-metadata-nonexistant" does not exist (intentionally).
 541         String requestedResource = "org/apache/maven/test/get-default-metadata-nonexistant/1.0-SNAPSHOT/maven-metadata.xml";
 542         setupTestableManagedRepository( requestedResource );
 543
 544         assertNoMetadata( requestedResource );
 545
 546         // No proxy setup, nothing fetched, no local file, failure expected.
 547         assertFetchVersionedFailed( requestedResource );
 548
 549         // No local artifactId, and no fetch, should equal no metadata file downloaded / created / updated.
 550         assertNoMetadata( requestedResource );
 551     }
 552
 553     public void testGetSnapshotMetadataNotProxiedOnLocal()
 554         throws Exception
 555     {
 556         // The artifactId exists locally (but not on a remote repo)
 557         String requestedResource = "org/apache/maven/test/get-snapshot-on-local-not-remote/2.0-alpha-2-SNAPSHOT/maven-metadata.xml";
 558         setupTestableManagedRepository( requestedResource );
 559
 560         assertResourceExists( requestedResource );
 561
 562         // No proxy setup, nothing fetched from remote, local file exists, fetch should succeed.
 563         assertFetchVersioned( requestedResource );
 564
 565         // Local metadata exists, should be updated to reflect the latest release.
 566         assertSnapshotMetadataContents( requestedResource, "20070821", "220304", 2 );
 567     }
 568
 569     public void testGetSnapshotMetadataProxiedNotLocalMultipleRemotes()
 570         throws Exception
 571     {
 572         String requestedResource = "org/apache/maven/test/get-timestamped-snapshot-in-both/1.0-SNAPSHOT/maven-metadata.xml";
 573         setupTestableManagedRepository( requestedResource );
 574
 575         // Configure Connector (usually done within archiva.xml configuration)
 576         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 577                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 578         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED2, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 579                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 580
 581         assertResourceNotFound( requestedResource );
 582         assertNoRepoMetadata( ID_PROXIED1, requestedResource );
 583         assertNoRepoMetadata( ID_PROXIED2, requestedResource );
 584
 585         // Proxying 2 repos, both have content, local file updated.
 586         assertFetchVersioned( requestedResource );
 587
 588         assertSnapshotMetadataContents( requestedResource, "20070101", "000103", 2 );
 589         assertRepoSnapshotMetadataContents( ID_PROXIED1, requestedResource, "20061227", "112101", 2 );
 590         assertRepoSnapshotMetadataContents( ID_PROXIED2, requestedResource, "20070101", "000103", 2 );
 591     }
 592
 593     public void testGetSnapshotMetadataProxiedNotLocalNotRemote()
 594         throws Exception
 595     {
 596         // The artifactId "get-default-metadata-nonexistant" does not exist (intentionally).
 597         String requestedResource = "org/apache/maven/test/get-default-metadata-nonexistant/1.0-SNAPSHOT/maven-metadata.xml";
 598         setupTestableManagedRepository( requestedResource );
 599
 600         // Configure Connector (usually done within archiva.xml configuration)
 601         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 602                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 603
 604         assertNoMetadata( requestedResource );
 605
 606         // One proxy setup, nothing fetched, no local file, failure expected.
 607         assertFetchVersionedFailed( requestedResource );
 608
 609         // No local artifactId, and no fetch, should equal no metadata file downloaded / created / updated.
 610         assertNoMetadata( requestedResource );
 611         assertNoRepoMetadata( ID_PROXIED1, requestedResource );
 612     }
 613
 614     public void testGetSnapshotMetadataProxiedNotLocalOnRemote()
 615         throws Exception
 616     {
 617         // Artifact exists only in the proxied1 location.
 618         String requestedResource = "org/apache/maven/test/get-metadata-snapshot/1.0-SNAPSHOT/maven-metadata.xml";
 619         setupTestableManagedRepository( requestedResource );
 620
 621         // Configure Connector (usually done within archiva.xml configuration)
 622         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 623                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 624
 625         assertResourceNotFound( requestedResource );
 626
 627         // One proxy setup, one metadata fetched, local file created/updated.
 628         assertFetchVersioned( requestedResource );
 629
 630         // Local artifact Id should contain latest (which in this case is from proxied download)
 631         assertSnapshotMetadataContents( requestedResource, "20050831", "101112", 1 );
 632         assertRepoSnapshotMetadataContents( ID_PROXIED1, requestedResource, "20050831", "101112", 1 );
 633     }
 634
 635     public void testGetSnapshotMetadataProxiedOnLocalMultipleRemote()
 636         throws Exception
 637     {
 638         String requestedResource = "org/apache/maven/test/get-snapshot-popular/2.0-SNAPSHOT/maven-metadata.xml";
 639         setupTestableManagedRepository( requestedResource );
 640
 641         // Configure Connector (usually done within archiva.xml configuration)
 642         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 643                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 644         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED2, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 645                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 646
 647         assertSnapshotMetadataContents( requestedResource, "20070822", "021008", 3 );
 648         assertNoRepoMetadata( ID_PROXIED1, requestedResource );
 649         assertNoRepoMetadata( ID_PROXIED2, requestedResource );
 650
 651         // Proxying 2 repos, both have content, local file updated.
 652         assertFetchVersioned( requestedResource );
 653
 654         assertSnapshotMetadataContents( requestedResource, "20070823", "212711", 6 );
 655         assertRepoSnapshotMetadataContents( ID_PROXIED1, requestedResource, "20070822", "145534", 9 );
 656         assertRepoSnapshotMetadataContents( ID_PROXIED2, requestedResource, "20070823", "212711", 6 );
 657     }
 658
 659     public void testGetSnapshotMetadataProxiedOnLocalNotRemote()
 660         throws Exception
 661     {
 662         // The artifactId exists locally (but not on a remote repo)
 663         String requestedResource = "org/apache/maven/test/get-snapshot-on-local-not-remote/2.0-alpha-2-SNAPSHOT/maven-metadata.xml";
 664         setupTestableManagedRepository( requestedResource );
 665
 666         // Configure Connector (usually done within archiva.xml configuration)
 667         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 668                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 669         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED2, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 670                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 671
 672         assertResourceExists( requestedResource );
 673         assertNoRepoMetadata( ID_PROXIED1, requestedResource );
 674         assertNoRepoMetadata( ID_PROXIED2, requestedResource );
 675
 676         // two proxies setup, nothing fetched from either remote, local file exists, fetch should succeed.
 677         assertFetchVersioned( requestedResource );
 678
 679         // Local metadata exists, repo metadatas should not exist, local file updated.
 680         assertSnapshotMetadataContents( requestedResource, "20070821", "220304", 2 );
 681         assertNoRepoMetadata( ID_PROXIED1, requestedResource );
 682         assertNoRepoMetadata( ID_PROXIED2, requestedResource );
 683     }
 684
 685     public void testGetSnapshotMetadataProxiedOnLocalOnRemote()
 686         throws Exception
 687     {
 688         // The artifactId exists locally (but not on a remote repo)
 689         String requestedResource = "org/apache/maven/test/get-present-metadata-snapshot/1.0-SNAPSHOT/maven-metadata.xml";
 690         setupTestableManagedRepository( requestedResource );
 691
 692         // Configure Connector (usually done within archiva.xml configuration)
 693         saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
 694                        SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO );
 695
 696         assertSnapshotMetadataContents( requestedResource, "20050831", "101112", 1 );
 697         assertNoRepoMetadata( ID_PROXIED1, requestedResource );
 698
 699         // two proxies setup, nothing fetched from either remote, local file exists, fetch should succeed.
 700         assertFetchVersioned( requestedResource );
 701
 702         // Local metadata exists, repo metadata exists, local file updated.
 703         assertSnapshotMetadataContents( requestedResource, "20050831", "101112", 1 );
 704         assertRepoSnapshotMetadataContents( ID_PROXIED1, requestedResource, "20050831", "101112", 1 );
 705     }
 706
 707     /**
 708      * Transfer the metadata file.
 709      *
 710      * @param requestedResource the requested resource
 711      * @throws Exception
 712      */
 713     private void assertFetchProject( String requestedResource )
 714         throws Exception
 715     {
 716         File expectedFile = new File( managedDefaultDir, requestedResource );
 717
 718         ProjectReference metadata = createProjectReference( requestedResource );
 719
 720         File downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, metadata );
 721
 722         assertNotNull( "Should have downloaded a file.", downloadedFile );
 723         assertNoTempFiles( expectedFile );
 724     }
 725
 726     private ProjectReference createProjectReference( String path )
 727         throws RepositoryMetadataException
 728     {
 729         return metadataTools.toProjectReference( path );
 730     }
 731
 732     /**
 733      * Transfer the metadata file, not expected to succeed.
 734      *
 735      * @param requestedResource the requested resource
 736      * @throws Exception
 737      */
 738     private void assertFetchProjectFailed( String requestedResource )
 739         throws Exception
 740     {
 741         File expectedFile = new File( managedDefaultDir, requestedResource );
 742         ProjectReference metadata = createProjectReference( requestedResource );
 743
 744         File downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, metadata );
 745
 746         assertNull( downloadedFile );
 747         assertNoTempFiles( expectedFile );
 748     }
 749
 750     /**
 751      * Transfer the metadata file.
 752      *
 753      * @param requestedResource the requested resource
 754      * @throws Exception
 755      */
 756     private void assertFetchVersioned( String requestedResource )
 757         throws Exception
 758     {
 759         File expectedFile = new File( managedDefaultDir, requestedResource );
 760
 761         VersionedReference metadata = createVersionedReference( requestedResource );
 762
 763         File downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, metadata );
 764
 765         assertNotNull( "Should have downloaded a file.", downloadedFile );
 766         assertNoTempFiles( expectedFile );
 767     }
 768
 769     private VersionedReference createVersionedReference( String path )
 770         throws RepositoryMetadataException
 771     {
 772         return metadataTools.toVersionedReference( path );
 773     }
 774
 775     /**
 776      * Transfer the metadata file, not expected to succeed.
 777      *
 778      * @param requestedResource the requested resource
 779      * @throws Exception
 780      */
 781     private void assertFetchVersionedFailed( String requestedResource )
 782         throws Exception
 783     {
 784         File expectedFile = new File( managedDefaultDir, requestedResource );
 785         VersionedReference metadata = createVersionedReference( requestedResource );
 786
 787         File downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, metadata );
 788
 789         assertNull( downloadedFile );
 790         assertNoTempFiles( expectedFile );
 791     }
 792
 793     /**
 794      * Test for the existance of the requestedResource in the default managed repository.
 795      *
 796      * @param requestedResource the requested resource
 797      * @throws Exception
 798      */
 799     private void assertResourceExists( String requestedResource )
 800         throws Exception
 801     {
 802         File actualFile = new File( managedDefaultDir, requestedResource );
 803         assertTrue( "Resource should exist: " + requestedResource, actualFile.exists() );
 804     }
 805
 806     private void assertMetadataEquals( String expectedMetadataXml, File actualFile )
 807         throws Exception
 808     {
 809         assertNotNull( "Actual File should not be null.", actualFile );
 810
 811         assertTrue( "Actual file exists.", actualFile.exists() );
 812
 813         StringWriter actualContents = new StringWriter();
 814         ArchivaRepositoryMetadata metadata = RepositoryMetadataReader.read( actualFile );
 815         RepositoryMetadataWriter.write( metadata, actualContents );
 816
 817         DetailedDiff detailedDiff = new DetailedDiff( new Diff( expectedMetadataXml, actualContents.toString() ) );
 818         if ( !detailedDiff.similar() )
 819         {
 820             assertEquals( expectedMetadataXml, actualContents );
 821         }
 822
 823         // assertEquals( "Check file contents.", expectedMetadataXml, actualContents );
 824     }
 825
 826     /**
 827      * Ensures that the requested resource is not present in the managed repository.
 828      *
 829      * @param requestedResource the requested resource
 830      * @throws Exception
 831      */
 832     private void assertNoMetadata( String requestedResource )
 833         throws Exception
 834     {
 835         File expectedFile = new File( managedDefaultDir, requestedResource );
 836         assertFalse( "metadata should not exist: " + expectedFile, expectedFile.exists() );
 837     }
 838
 839     /**
 840      * Ensures that the proxied repository specific maven metadata file does NOT exist in the
 841      * managed repository.
 842      * @param proxiedRepoId the proxied repository id to validate with.
 843      * @param requestedResource the resource requested.
 844      */
 845     private void assertNoRepoMetadata( String proxiedRepoId, String requestedResource )
 846     {
 847         String proxiedFile = metadataTools.getRepositorySpecificName( proxiedRepoId, requestedResource );
 848
 849         File actualFile = new File( managedDefaultDir, proxiedFile );
 850         assertFalse( "Repo specific metadata should not exist: " + actualFile, actualFile.exists() );
 851     }
 852
 853     /**
 854      * Test for the existance of the requestedResource in the default managed repository, and if it exists,
 855      * does it contain the specified list of expected versions?
 856      *
 857      * @param requestedResource the requested resource
 858      * @throws Exception
 859      */
 860     private void assertProjectMetadataContents( String requestedResource, String expectedVersions[],
 861                                                 String latestVersion, String releaseVersion )
 862         throws Exception
 863     {
 864         File actualFile = new File( managedDefaultDir, requestedResource );
 865         assertTrue( actualFile.exists() );
 866
 867         ProjectReference metadata = createProjectReference( requestedResource );
 868
 869         // Build expected metadata XML
 870         StringWriter expectedMetadataXml = new StringWriter();
 871         ArchivaRepositoryMetadata m = new ArchivaRepositoryMetadata();
 872         m.setGroupId( metadata.getGroupId() );
 873         m.setArtifactId( metadata.getArtifactId() );
 874         m.setLatestVersion( latestVersion );
 875         m.setReleasedVersion( releaseVersion );
 876
 877         if ( expectedVersions != null )
 878         {
 879             m.getAvailableVersions().addAll( Arrays.asList( expectedVersions ) );
 880         }
 881
 882         m.setModelEncoding( null );
 883         RepositoryMetadataWriter.write( m, expectedMetadataXml );
 884
 885         // Compare the file to the actual contents.
 886         assertMetadataEquals( expectedMetadataXml.toString(), actualFile );
 887     }
 888
 889     /**
 890      * Test for the existance of the requestedResource in the default managed repository, and if it exists,
 891      * does it contain the expected release maven-metadata.xml contents?
 892      *
 893      * @param requestedResource the requested resource
 894      * @throws Exception
 895      */
 896     private void assertReleaseMetadataContents( String requestedResource )
 897         throws Exception
 898     {
 899         File actualFile = new File( managedDefaultDir, requestedResource );
 900         assertTrue( "Release Metadata should exist: " + requestedResource, actualFile.exists() );
 901
 902         VersionedReference metadata = createVersionedReference( requestedResource );
 903
 904         // Build expected metadata XML
 905         StringWriter expectedMetadataXml = new StringWriter();
 906         ArchivaRepositoryMetadata m = new ArchivaRepositoryMetadata();
 907         m.setGroupId( metadata.getGroupId() );
 908         m.setArtifactId( metadata.getArtifactId() );
 909         m.setVersion( metadata.getVersion() );
 910         m.setModelEncoding( null );
 911         RepositoryMetadataWriter.write( m, expectedMetadataXml );
 912
 913         // Compare the file to the actual contents.
 914         assertMetadataEquals( expectedMetadataXml.toString(), actualFile );
 915     }
 916
 917     /**
 918      * Test for the existance of the snapshot metadata in the default managed repository, and if it exists,
 919      * does it contain the expected release maven-metadata.xml contents?
 920      *
 921      * @param requestedResource the requested resource
 922      * @param expectedDate the date in "yyyyMMdd" format
 923      * @param expectedTime the time in "hhmmss" format
 924      * @param expectedBuildnumber the build number
 925      *
 926      * @throws Exception
 927      */
 928     private void assertSnapshotMetadataContents( String requestedResource, String expectedDate, String expectedTime,
 929                                                  int expectedBuildnumber )
 930         throws Exception
 931     {
 932         File actualFile = new File( managedDefaultDir, requestedResource );
 933         assertTrue( "Snapshot Metadata should exist: " + requestedResource, actualFile.exists() );
 934
 935         VersionedReference actualMetadata = createVersionedReference( requestedResource );
 936
 937         assertSnapshotMetadata( actualFile, actualMetadata, expectedDate, expectedTime, expectedBuildnumber );
 938     }
 939
 940     /**
 941      * Test for the existance of the proxied repository specific snapshot metadata in the default managed
 942      * repository, and if it exists, does it contain the expected release maven-metadata.xml contents?
 943      *
 944      * @param proxiedRepoId the repository id of the proxied repository.
 945      * @param requestedResource the requested resource
 946      * @param expectedDate the date in "yyyyMMdd" format
 947      * @param expectedTime the time in "hhmmss" format
 948      * @param expectedBuildnumber the build number
 949      *
 950      * @throws Exception
 951      */
 952     private void assertRepoSnapshotMetadataContents( String proxiedRepoId, String requestedResource,
 953                                                      String expectedDate, String expectedTime, int expectedBuildnumber )
 954         throws Exception
 955     {
 956         String proxiedFile = metadataTools.getRepositorySpecificName( proxiedRepoId, requestedResource );
 957
 958         File actualFile = new File( managedDefaultDir, proxiedFile );
 959         assertTrue( "Repo Specific Snapshot Metadata should exist: " + requestedResource, actualFile.exists() );
 960
 961         VersionedReference actualMetadata = createVersionedReference( requestedResource );
 962
 963         assertSnapshotMetadata( actualFile, actualMetadata, expectedDate, expectedTime, expectedBuildnumber );
 964     }
 965
 966     private void assertSnapshotMetadata( File actualFile, VersionedReference actualMetadata, String expectedDate,
 967                                          String expectedTime, int expectedBuildnumber )
 968         throws RepositoryMetadataException, Exception
 969     {
 970         // Build expected metadata XML
 971         StringWriter expectedMetadataXml = new StringWriter();
 972         ArchivaRepositoryMetadata m = new ArchivaRepositoryMetadata();
 973         m.setGroupId( actualMetadata.getGroupId() );
 974         m.setArtifactId( actualMetadata.getArtifactId() );
 975         m.setVersion( VersionUtil.getBaseVersion( actualMetadata.getVersion() ) );
 976
 977         m.setSnapshotVersion( new SnapshotVersion() );
 978
 979         if ( StringUtils.isNotBlank( expectedDate ) && StringUtils.isNotBlank( expectedTime ) )
 980         {
 981             m.getSnapshotVersion().setTimestamp( expectedDate + "." + expectedTime );
 982         }
 983
 984         m.getSnapshotVersion().setBuildNumber( expectedBuildnumber );
 985
 986         m.setLastUpdated( expectedDate + expectedTime );
 987
 988         m.setModelEncoding( null );
 989         RepositoryMetadataWriter.write( m, expectedMetadataXml );
 990
 991         // Compare the file to the actual contents.
 992         assertMetadataEquals( expectedMetadataXml.toString(), actualFile );
 993     }
 994
 995     /**
 996      * Ensures that the repository specific maven metadata file exists, and contains the appropriate
 997      * list of expected versions within.
 998      * @param proxiedRepoId
 999      * @param requestedResource
1000      * @param expectedProxyVersions
1001      */
1002     private void assertRepoProjectMetadata( String proxiedRepoId, String requestedResource,
1003                                             String[] expectedProxyVersions )
1004         throws Exception
1005     {
1006         String proxiedFile = metadataTools.getRepositorySpecificName( proxiedRepoId, requestedResource );
1007
1008         File actualFile = new File( managedDefaultDir, proxiedFile );
1009         assertTrue( actualFile.exists() );
1010
1011         ProjectReference metadata = createProjectReference( requestedResource );
1012
1013         // Build expected metadata XML
1014         StringWriter expectedMetadataXml = new StringWriter();
1015         ArchivaRepositoryMetadata m = new ArchivaRepositoryMetadata();
1016         m.setGroupId( metadata.getGroupId() );
1017         m.setArtifactId( metadata.getArtifactId() );
1018
1019         if ( expectedProxyVersions != null )
1020         {
1021             m.getAvailableVersions().addAll( Arrays.asList( expectedProxyVersions ) );
1022         }
1023
1024         m.setModelEncoding( null );
1025         RepositoryMetadataWriter.write( m, expectedMetadataXml );
1026
1027         // Compare the file to the actual contents.
1028         assertMetadataEquals( expectedMetadataXml.toString(), actualFile );
1029     }
1030
1031     /**
1032      * Ensures that the repository specific maven metadata file exists, and contains the appropriate
1033      * list of expected versions within.
1034      *
1035      * @param proxiedRepoId
1036      * @param requestedResource
1037      */
1038     private void assertRepoReleaseMetadataContents( String proxiedRepoId, String requestedResource )
1039         throws Exception
1040     {
1041         String proxiedFile = metadataTools.getRepositorySpecificName( proxiedRepoId, requestedResource );
1042
1043         File actualFile = new File( managedDefaultDir, proxiedFile );
1044         assertTrue( "Release metadata for repo should exist: " + actualFile, actualFile.exists() );
1045
1046         VersionedReference metadata = createVersionedReference( requestedResource );
1047
1048         // Build expected metadata XML
1049         StringWriter expectedMetadataXml = new StringWriter();
1050         ArchivaRepositoryMetadata m = new ArchivaRepositoryMetadata();
1051         m.setGroupId( metadata.getGroupId() );
1052         m.setArtifactId( metadata.getArtifactId() );
1053         m.setVersion( metadata.getVersion() );
1054         m.setModelEncoding( null );
1055         RepositoryMetadataWriter.write( m, expectedMetadataXml );
1056
1057         // Compare the file to the actual contents.
1058         assertMetadataEquals( expectedMetadataXml.toString(), actualFile );
1059     }
1060
1061     /**
1062      * Test for the non-existance of the requestedResource in the default managed repository.
1063      *
1064      * @param requestedResource the requested resource
1065      * @throws Exception
1066      */
1067     private void assertResourceNotFound( String requestedResource )
1068         throws Exception
1069     {
1070         File actualFile = new File( managedDefaultDir, requestedResource );
1071         assertFalse( "Resource should not exist: " + requestedResource, actualFile.exists() );
1072     }
1073
1074     protected void setUp()
1075         throws Exception
1076     {
1077         super.setUp();
1078
1079         metadataTools = (MetadataTools) lookup( MetadataTools.class );
1080     }
1081
1082 }