]> source.dussan.org Git - archiva.git/blob
59694abdbefdf37f9b866eb342c8080f251a0fa8
[archiva.git] /
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  * @version $Id$
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 }