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