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

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