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