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