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

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