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