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