001package org.eclipse.aether.internal.impl; 002 003/* 004 * Licensed to the Apache Software Foundation (ASF) under one 005 * or more contributor license agreements. See the NOTICE file 006 * distributed with this work for additional information 007 * regarding copyright ownership. The ASF licenses this file 008 * to you under the Apache License, Version 2.0 (the 009 * "License"); you may not use this file except in compliance 010 * with the License. You may obtain a copy of the License at 011 * 012 * http://www.apache.org/licenses/LICENSE-2.0 013 * 014 * Unless required by applicable law or agreed to in writing, 015 * software distributed under the License is distributed on an 016 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 017 * KIND, either express or implied. See the License for the 018 * specific language governing permissions and limitations 019 * under the License. 020 */ 021 022import static org.junit.Assert.*; 023 024import java.io.File; 025import java.io.IOException; 026import java.util.Arrays; 027import java.util.Collection; 028import java.util.HashMap; 029import java.util.List; 030import java.util.Map; 031 032import org.eclipse.aether.DefaultRepositorySystemSession; 033import org.eclipse.aether.RepositoryEvent; 034import org.eclipse.aether.RepositorySystemSession; 035import org.eclipse.aether.RepositoryEvent.EventType; 036import org.eclipse.aether.artifact.Artifact; 037import org.eclipse.aether.artifact.ArtifactProperties; 038import org.eclipse.aether.artifact.DefaultArtifact; 039import org.eclipse.aether.impl.UpdateCheckManager; 040import org.eclipse.aether.impl.VersionResolver; 041import org.eclipse.aether.internal.impl.DefaultArtifactResolver; 042import org.eclipse.aether.internal.impl.DefaultUpdateCheckManager; 043import org.eclipse.aether.internal.test.util.TestFileProcessor; 044import org.eclipse.aether.internal.test.util.TestFileUtils; 045import org.eclipse.aether.internal.test.util.TestLocalRepositoryManager; 046import org.eclipse.aether.internal.test.util.TestUtils; 047import org.eclipse.aether.metadata.Metadata; 048import org.eclipse.aether.repository.LocalArtifactRegistration; 049import org.eclipse.aether.repository.LocalArtifactRequest; 050import org.eclipse.aether.repository.LocalArtifactResult; 051import org.eclipse.aether.repository.LocalMetadataRegistration; 052import org.eclipse.aether.repository.LocalMetadataRequest; 053import org.eclipse.aether.repository.LocalMetadataResult; 054import org.eclipse.aether.repository.LocalRepository; 055import org.eclipse.aether.repository.LocalRepositoryManager; 056import org.eclipse.aether.repository.RemoteRepository; 057import org.eclipse.aether.repository.RepositoryPolicy; 058import org.eclipse.aether.repository.WorkspaceReader; 059import org.eclipse.aether.repository.WorkspaceRepository; 060import org.eclipse.aether.resolution.ArtifactRequest; 061import org.eclipse.aether.resolution.ArtifactResolutionException; 062import org.eclipse.aether.resolution.ArtifactResult; 063import org.eclipse.aether.resolution.VersionRequest; 064import org.eclipse.aether.resolution.VersionResolutionException; 065import org.eclipse.aether.resolution.VersionResult; 066import org.eclipse.aether.spi.connector.ArtifactDownload; 067import org.eclipse.aether.spi.connector.MetadataDownload; 068import org.eclipse.aether.transfer.ArtifactNotFoundException; 069import org.eclipse.aether.transfer.ArtifactTransferException; 070import org.eclipse.aether.util.repository.SimpleResolutionErrorPolicy; 071import org.junit.After; 072import org.junit.Before; 073import org.junit.Test; 074 075/** 076 */ 077public class DefaultArtifactResolverTest 078{ 079 private DefaultArtifactResolver resolver; 080 081 private DefaultRepositorySystemSession session; 082 083 private TestLocalRepositoryManager lrm; 084 085 private StubRepositoryConnectorProvider repositoryConnectorProvider; 086 087 private Artifact artifact; 088 089 private RecordingRepositoryConnector connector; 090 091 @Before 092 public void setup() 093 { 094 UpdateCheckManager updateCheckManager = new StaticUpdateCheckManager( true ); 095 repositoryConnectorProvider = new StubRepositoryConnectorProvider(); 096 VersionResolver versionResolver = new StubVersionResolver(); 097 session = TestUtils.newSession(); 098 lrm = (TestLocalRepositoryManager) session.getLocalRepositoryManager(); 099 resolver = new DefaultArtifactResolver(); 100 resolver.setFileProcessor( new TestFileProcessor() ); 101 resolver.setRepositoryEventDispatcher( new StubRepositoryEventDispatcher() ); 102 resolver.setVersionResolver( versionResolver ); 103 resolver.setUpdateCheckManager( updateCheckManager ); 104 resolver.setRepositoryConnectorProvider( repositoryConnectorProvider ); 105 resolver.setRemoteRepositoryManager( new StubRemoteRepositoryManager() ); 106 resolver.setSyncContextFactory( new StubSyncContextFactory() ); 107 resolver.setOfflineController( new DefaultOfflineController() ); 108 109 artifact = new DefaultArtifact( "gid", "aid", "", "ext", "ver" ); 110 111 connector = new RecordingRepositoryConnector(); 112 repositoryConnectorProvider.setConnector( connector ); 113 } 114 115 @After 116 public void teardown() 117 throws Exception 118 { 119 if ( session.getLocalRepository() != null ) 120 { 121 TestFileUtils.deleteFile( session.getLocalRepository().getBasedir() ); 122 } 123 } 124 125 @Test 126 public void testResolveLocalArtifactSuccessful() 127 throws IOException, ArtifactResolutionException 128 { 129 File tmpFile = TestFileUtils.createTempFile( "tmp" ); 130 Map<String, String> properties = new HashMap<>(); 131 properties.put( ArtifactProperties.LOCAL_PATH, tmpFile.getAbsolutePath() ); 132 artifact = artifact.setProperties( properties ); 133 134 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 135 ArtifactResult result = resolver.resolveArtifact( session, request ); 136 137 assertTrue( result.getExceptions().isEmpty() ); 138 139 Artifact resolved = result.getArtifact(); 140 assertNotNull( resolved.getFile() ); 141 resolved = resolved.setFile( null ); 142 143 assertEquals( artifact, resolved ); 144 } 145 146 @Test 147 public void testResolveLocalArtifactUnsuccessful() 148 throws IOException 149 { 150 File tmpFile = TestFileUtils.createTempFile( "tmp" ); 151 Map<String, String> properties = new HashMap<>(); 152 properties.put( ArtifactProperties.LOCAL_PATH, tmpFile.getAbsolutePath() ); 153 artifact = artifact.setProperties( properties ); 154 155 tmpFile.delete(); 156 157 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 158 159 try 160 { 161 resolver.resolveArtifact( session, request ); 162 fail( "expected exception" ); 163 } 164 catch ( ArtifactResolutionException e ) 165 { 166 assertNotNull( e.getResults() ); 167 assertEquals( 1, e.getResults().size() ); 168 169 ArtifactResult result = e.getResults().get( 0 ); 170 171 assertSame( request, result.getRequest() ); 172 173 assertFalse( result.getExceptions().isEmpty() ); 174 assertTrue( result.getExceptions().get( 0 ) instanceof ArtifactNotFoundException ); 175 176 Artifact resolved = result.getArtifact(); 177 assertNull( resolved ); 178 } 179 180 } 181 182 @Test 183 public void testResolveRemoteArtifact() 184 throws ArtifactResolutionException 185 { 186 connector.setExpectGet( artifact ); 187 188 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 189 request.addRepository( new RemoteRepository.Builder( "id", "default", "file:///" ).build() ); 190 191 ArtifactResult result = resolver.resolveArtifact( session, request ); 192 193 assertTrue( result.getExceptions().isEmpty() ); 194 195 Artifact resolved = result.getArtifact(); 196 assertNotNull( resolved.getFile() ); 197 198 resolved = resolved.setFile( null ); 199 assertEquals( artifact, resolved ); 200 201 connector.assertSeenExpected(); 202 } 203 204 @Test 205 public void testResolveRemoteArtifactUnsuccessful() 206 { 207 RecordingRepositoryConnector connector = new RecordingRepositoryConnector() 208 { 209 210 @Override 211 public void get( Collection<? extends ArtifactDownload> artifactDownloads, 212 Collection<? extends MetadataDownload> metadataDownloads ) 213 { 214 super.get( artifactDownloads, metadataDownloads ); 215 ArtifactDownload download = artifactDownloads.iterator().next(); 216 ArtifactTransferException exception = 217 new ArtifactNotFoundException( download.getArtifact(), null, "not found" ); 218 download.setException( exception ); 219 } 220 221 }; 222 223 connector.setExpectGet( artifact ); 224 repositoryConnectorProvider.setConnector( connector ); 225 226 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 227 request.addRepository( new RemoteRepository.Builder( "id", "default", "file:///" ).build() ); 228 229 try 230 { 231 resolver.resolveArtifact( session, request ); 232 fail( "expected exception" ); 233 } 234 catch ( ArtifactResolutionException e ) 235 { 236 connector.assertSeenExpected(); 237 assertNotNull( e.getResults() ); 238 assertEquals( 1, e.getResults().size() ); 239 240 ArtifactResult result = e.getResults().get( 0 ); 241 242 assertSame( request, result.getRequest() ); 243 244 assertFalse( result.getExceptions().isEmpty() ); 245 assertTrue( result.getExceptions().get( 0 ) instanceof ArtifactNotFoundException ); 246 247 Artifact resolved = result.getArtifact(); 248 assertNull( resolved ); 249 } 250 251 } 252 253 @Test 254 public void testArtifactNotFoundCache() 255 throws Exception 256 { 257 RecordingRepositoryConnector connector = new RecordingRepositoryConnector() 258 { 259 @Override 260 public void get( Collection<? extends ArtifactDownload> artifactDownloads, 261 Collection<? extends MetadataDownload> metadataDownloads ) 262 { 263 super.get( artifactDownloads, metadataDownloads ); 264 for ( ArtifactDownload download : artifactDownloads ) 265 { 266 download.getFile().delete(); 267 ArtifactTransferException exception = 268 new ArtifactNotFoundException( download.getArtifact(), null, "not found" ); 269 download.setException( exception ); 270 } 271 } 272 }; 273 274 repositoryConnectorProvider.setConnector( connector ); 275 resolver.setUpdateCheckManager( new DefaultUpdateCheckManager() 276 .setUpdatePolicyAnalyzer( new DefaultUpdatePolicyAnalyzer() ) 277 .setTrackingFileManager( new DefaultTrackingFileManager() ) 278 ); 279 280 session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) ); 281 session.setUpdatePolicy( RepositoryPolicy.UPDATE_POLICY_NEVER ); 282 283 RemoteRepository remoteRepo = new RemoteRepository.Builder( "id", "default", "file:///" ).build(); 284 285 Artifact artifact1 = artifact; 286 Artifact artifact2 = artifact.setVersion( "ver2" ); 287 288 ArtifactRequest request1 = new ArtifactRequest( artifact1, Arrays.asList( remoteRepo ), "" ); 289 ArtifactRequest request2 = new ArtifactRequest( artifact2, Arrays.asList( remoteRepo ), "" ); 290 291 connector.setExpectGet( artifact1, artifact2 ); 292 try 293 { 294 resolver.resolveArtifacts( session, Arrays.asList( request1, request2 ) ); 295 fail( "expected exception" ); 296 } 297 catch ( ArtifactResolutionException e ) 298 { 299 connector.assertSeenExpected(); 300 } 301 302 TestFileUtils.writeString( new File( lrm.getRepository().getBasedir(), lrm.getPathForLocalArtifact( artifact2 ) ), 303 "artifact" ); 304 lrm.setArtifactAvailability( artifact2, false ); 305 306 DefaultUpdateCheckManagerTest.resetSessionData( session ); 307 connector.resetActual(); 308 connector.setExpectGet( new Artifact[0] ); 309 try 310 { 311 resolver.resolveArtifacts( session, Arrays.asList( request1, request2 ) ); 312 fail( "expected exception" ); 313 } 314 catch ( ArtifactResolutionException e ) 315 { 316 connector.assertSeenExpected(); 317 for ( ArtifactResult result : e.getResults() ) 318 { 319 Throwable t = result.getExceptions().get( 0 ); 320 assertEquals( t.toString(), true, t instanceof ArtifactNotFoundException ); 321 assertEquals( t.toString(), true, t.getMessage().contains( "cached" ) ); 322 } 323 } 324 } 325 326 @Test 327 public void testResolveFromWorkspace() 328 throws IOException, ArtifactResolutionException 329 { 330 WorkspaceReader workspace = new WorkspaceReader() 331 { 332 333 public WorkspaceRepository getRepository() 334 { 335 return new WorkspaceRepository( "default" ); 336 } 337 338 public List<String> findVersions( Artifact artifact ) 339 { 340 return Arrays.asList( artifact.getVersion() ); 341 } 342 343 public File findArtifact( Artifact artifact ) 344 { 345 try 346 { 347 return TestFileUtils.createTempFile( artifact.toString() ); 348 } 349 catch ( IOException e ) 350 { 351 throw new RuntimeException( e.getMessage(), e ); 352 } 353 } 354 }; 355 session.setWorkspaceReader( workspace ); 356 357 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 358 request.addRepository( new RemoteRepository.Builder( "id", "default", "file:///" ).build() ); 359 360 ArtifactResult result = resolver.resolveArtifact( session, request ); 361 362 assertTrue( result.getExceptions().isEmpty() ); 363 364 Artifact resolved = result.getArtifact(); 365 assertNotNull( resolved.getFile() ); 366 367 assertEquals( resolved.toString(), TestFileUtils.readString( resolved.getFile() ) ); 368 369 resolved = resolved.setFile( null ); 370 assertEquals( artifact, resolved ); 371 372 connector.assertSeenExpected(); 373 } 374 375 @Test 376 public void testResolveFromWorkspaceFallbackToRepository() 377 throws ArtifactResolutionException 378 { 379 WorkspaceReader workspace = new WorkspaceReader() 380 { 381 382 public WorkspaceRepository getRepository() 383 { 384 return new WorkspaceRepository( "default" ); 385 } 386 387 public List<String> findVersions( Artifact artifact ) 388 { 389 return Arrays.asList( artifact.getVersion() ); 390 } 391 392 public File findArtifact( Artifact artifact ) 393 { 394 return null; 395 } 396 }; 397 session.setWorkspaceReader( workspace ); 398 399 connector.setExpectGet( artifact ); 400 repositoryConnectorProvider.setConnector( connector ); 401 402 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 403 request.addRepository( new RemoteRepository.Builder( "id", "default", "file:///" ).build() ); 404 405 ArtifactResult result = resolver.resolveArtifact( session, request ); 406 407 assertTrue( "exception on resolveArtifact", result.getExceptions().isEmpty() ); 408 409 Artifact resolved = result.getArtifact(); 410 assertNotNull( resolved.getFile() ); 411 412 resolved = resolved.setFile( null ); 413 assertEquals( artifact, resolved ); 414 415 connector.assertSeenExpected(); 416 } 417 418 @Test 419 public void testRepositoryEventsSuccessfulLocal() 420 throws ArtifactResolutionException, IOException 421 { 422 RecordingRepositoryListener listener = new RecordingRepositoryListener(); 423 session.setRepositoryListener( listener ); 424 425 File tmpFile = TestFileUtils.createTempFile( "tmp" ); 426 Map<String, String> properties = new HashMap<>(); 427 properties.put( ArtifactProperties.LOCAL_PATH, tmpFile.getAbsolutePath() ); 428 artifact = artifact.setProperties( properties ); 429 430 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 431 resolver.resolveArtifact( session, request ); 432 433 List<RepositoryEvent> events = listener.getEvents(); 434 assertEquals( 2, events.size() ); 435 RepositoryEvent event = events.get( 0 ); 436 assertEquals( EventType.ARTIFACT_RESOLVING, event.getType() ); 437 assertNull( event.getException() ); 438 assertEquals( artifact, event.getArtifact() ); 439 440 event = events.get( 1 ); 441 assertEquals( EventType.ARTIFACT_RESOLVED, event.getType() ); 442 assertNull( event.getException() ); 443 assertEquals( artifact, event.getArtifact().setFile( null ) ); 444 } 445 446 @Test 447 public void testRepositoryEventsUnsuccessfulLocal() 448 { 449 RecordingRepositoryListener listener = new RecordingRepositoryListener(); 450 session.setRepositoryListener( listener ); 451 452 Map<String, String> properties = new HashMap<>(); 453 properties.put( ArtifactProperties.LOCAL_PATH, "doesnotexist" ); 454 artifact = artifact.setProperties( properties ); 455 456 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 457 try 458 { 459 resolver.resolveArtifact( session, request ); 460 fail( "expected exception" ); 461 } 462 catch ( ArtifactResolutionException ignored ) 463 { 464 } 465 466 List<RepositoryEvent> events = listener.getEvents(); 467 assertEquals( 2, events.size() ); 468 469 RepositoryEvent event = events.get( 0 ); 470 assertEquals( artifact, event.getArtifact() ); 471 assertEquals( EventType.ARTIFACT_RESOLVING, event.getType() ); 472 473 event = events.get( 1 ); 474 assertEquals( artifact, event.getArtifact() ); 475 assertEquals( EventType.ARTIFACT_RESOLVED, event.getType() ); 476 assertNotNull( event.getException() ); 477 assertEquals( 1, event.getExceptions().size() ); 478 479 } 480 481 @Test 482 public void testRepositoryEventsSuccessfulRemote() 483 throws ArtifactResolutionException 484 { 485 RecordingRepositoryListener listener = new RecordingRepositoryListener(); 486 session.setRepositoryListener( listener ); 487 488 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 489 request.addRepository( new RemoteRepository.Builder( "id", "default", "file:///" ).build() ); 490 491 resolver.resolveArtifact( session, request ); 492 493 List<RepositoryEvent> events = listener.getEvents(); 494 assertEquals( events.toString(), 4, events.size() ); 495 RepositoryEvent event = events.get( 0 ); 496 assertEquals( EventType.ARTIFACT_RESOLVING, event.getType() ); 497 assertNull( event.getException() ); 498 assertEquals( artifact, event.getArtifact() ); 499 500 event = events.get( 1 ); 501 assertEquals( EventType.ARTIFACT_DOWNLOADING, event.getType() ); 502 assertNull( event.getException() ); 503 assertEquals( artifact, event.getArtifact().setFile( null ) ); 504 505 event = events.get( 2 ); 506 assertEquals( EventType.ARTIFACT_DOWNLOADED, event.getType() ); 507 assertNull( event.getException() ); 508 assertEquals( artifact, event.getArtifact().setFile( null ) ); 509 510 event = events.get( 3 ); 511 assertEquals( EventType.ARTIFACT_RESOLVED, event.getType() ); 512 assertNull( event.getException() ); 513 assertEquals( artifact, event.getArtifact().setFile( null ) ); 514 } 515 516 @Test 517 public void testRepositoryEventsUnsuccessfulRemote() 518 { 519 RecordingRepositoryConnector connector = new RecordingRepositoryConnector() 520 { 521 522 @Override 523 public void get( Collection<? extends ArtifactDownload> artifactDownloads, 524 Collection<? extends MetadataDownload> metadataDownloads ) 525 { 526 super.get( artifactDownloads, metadataDownloads ); 527 ArtifactDownload download = artifactDownloads.iterator().next(); 528 ArtifactTransferException exception = 529 new ArtifactNotFoundException( download.getArtifact(), null, "not found" ); 530 download.setException( exception ); 531 } 532 533 }; 534 repositoryConnectorProvider.setConnector( connector ); 535 536 RecordingRepositoryListener listener = new RecordingRepositoryListener(); 537 session.setRepositoryListener( listener ); 538 539 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 540 request.addRepository( new RemoteRepository.Builder( "id", "default", "file:///" ).build() ); 541 542 try 543 { 544 resolver.resolveArtifact( session, request ); 545 fail( "expected exception" ); 546 } 547 catch ( ArtifactResolutionException ignored ) 548 { 549 } 550 551 List<RepositoryEvent> events = listener.getEvents(); 552 assertEquals( events.toString(), 4, events.size() ); 553 554 RepositoryEvent event = events.get( 0 ); 555 assertEquals( artifact, event.getArtifact() ); 556 assertEquals( EventType.ARTIFACT_RESOLVING, event.getType() ); 557 558 event = events.get( 1 ); 559 assertEquals( artifact, event.getArtifact() ); 560 assertEquals( EventType.ARTIFACT_DOWNLOADING, event.getType() ); 561 562 event = events.get( 2 ); 563 assertEquals( artifact, event.getArtifact() ); 564 assertEquals( EventType.ARTIFACT_DOWNLOADED, event.getType() ); 565 assertNotNull( event.getException() ); 566 assertEquals( 1, event.getExceptions().size() ); 567 568 event = events.get( 3 ); 569 assertEquals( artifact, event.getArtifact() ); 570 assertEquals( EventType.ARTIFACT_RESOLVED, event.getType() ); 571 assertNotNull( event.getException() ); 572 assertEquals( 1, event.getExceptions().size() ); 573 } 574 575 @Test 576 public void testVersionResolverFails() 577 { 578 resolver.setVersionResolver( new VersionResolver() 579 { 580 581 public VersionResult resolveVersion( RepositorySystemSession session, VersionRequest request ) 582 throws VersionResolutionException 583 { 584 throw new VersionResolutionException( new VersionResult( request ) ); 585 } 586 } ); 587 588 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 589 try 590 { 591 resolver.resolveArtifact( session, request ); 592 fail( "expected exception" ); 593 } 594 catch ( ArtifactResolutionException e ) 595 { 596 connector.assertSeenExpected(); 597 assertNotNull( e.getResults() ); 598 assertEquals( 1, e.getResults().size() ); 599 600 ArtifactResult result = e.getResults().get( 0 ); 601 602 assertSame( request, result.getRequest() ); 603 604 assertFalse( result.getExceptions().isEmpty() ); 605 assertTrue( result.getExceptions().get( 0 ) instanceof VersionResolutionException ); 606 607 Artifact resolved = result.getArtifact(); 608 assertNull( resolved ); 609 } 610 } 611 612 @Test 613 public void testRepositoryEventsOnVersionResolverFail() 614 { 615 resolver.setVersionResolver( new VersionResolver() 616 { 617 618 public VersionResult resolveVersion( RepositorySystemSession session, VersionRequest request ) 619 throws VersionResolutionException 620 { 621 throw new VersionResolutionException( new VersionResult( request ) ); 622 } 623 } ); 624 625 RecordingRepositoryListener listener = new RecordingRepositoryListener(); 626 session.setRepositoryListener( listener ); 627 628 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 629 try 630 { 631 resolver.resolveArtifact( session, request ); 632 fail( "expected exception" ); 633 } 634 catch ( ArtifactResolutionException ignored ) 635 { 636 } 637 638 List<RepositoryEvent> events = listener.getEvents(); 639 assertEquals( 2, events.size() ); 640 641 RepositoryEvent event = events.get( 0 ); 642 assertEquals( artifact, event.getArtifact() ); 643 assertEquals( EventType.ARTIFACT_RESOLVING, event.getType() ); 644 645 event = events.get( 1 ); 646 assertEquals( artifact, event.getArtifact() ); 647 assertEquals( EventType.ARTIFACT_RESOLVED, event.getType() ); 648 assertNotNull( event.getException() ); 649 assertEquals( 1, event.getExceptions().size() ); 650 } 651 652 @Test 653 public void testLocalArtifactAvailable() 654 throws ArtifactResolutionException 655 { 656 session.setLocalRepositoryManager( new LocalRepositoryManager() 657 { 658 659 public LocalRepository getRepository() 660 { 661 return null; 662 } 663 664 public String getPathForRemoteMetadata( Metadata metadata, RemoteRepository repository, String context ) 665 { 666 return null; 667 } 668 669 public String getPathForRemoteArtifact( Artifact artifact, RemoteRepository repository, String context ) 670 { 671 return null; 672 } 673 674 public String getPathForLocalMetadata( Metadata metadata ) 675 { 676 return null; 677 } 678 679 public String getPathForLocalArtifact( Artifact artifact ) 680 { 681 return null; 682 } 683 684 public LocalArtifactResult find( RepositorySystemSession session, LocalArtifactRequest request ) 685 { 686 687 LocalArtifactResult result = new LocalArtifactResult( request ); 688 result.setAvailable( true ); 689 try 690 { 691 result.setFile( TestFileUtils.createTempFile( "" ) ); 692 } 693 catch ( IOException e ) 694 { 695 e.printStackTrace(); 696 } 697 return result; 698 } 699 700 public void add( RepositorySystemSession session, LocalArtifactRegistration request ) 701 { 702 } 703 704 public LocalMetadataResult find( RepositorySystemSession session, LocalMetadataRequest request ) 705 { 706 LocalMetadataResult result = new LocalMetadataResult( request ); 707 try 708 { 709 result.setFile( TestFileUtils.createTempFile( "" ) ); 710 } 711 catch ( IOException e ) 712 { 713 e.printStackTrace(); 714 } 715 return result; 716 } 717 718 public void add( RepositorySystemSession session, LocalMetadataRegistration request ) 719 { 720 } 721 } ); 722 723 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 724 request.addRepository( new RemoteRepository.Builder( "id", "default", "file:///" ).build() ); 725 726 ArtifactResult result = resolver.resolveArtifact( session, request ); 727 728 assertTrue( result.getExceptions().isEmpty() ); 729 730 Artifact resolved = result.getArtifact(); 731 assertNotNull( resolved.getFile() ); 732 733 resolved = resolved.setFile( null ); 734 assertEquals( artifact, resolved ); 735 736 } 737 738 @Test 739 public void testFindInLocalRepositoryWhenVersionWasFoundInLocalRepository() 740 throws ArtifactResolutionException 741 { 742 session.setLocalRepositoryManager( new LocalRepositoryManager() 743 { 744 745 public LocalRepository getRepository() 746 { 747 return null; 748 } 749 750 public String getPathForRemoteMetadata( Metadata metadata, RemoteRepository repository, String context ) 751 { 752 return null; 753 } 754 755 public String getPathForRemoteArtifact( Artifact artifact, RemoteRepository repository, String context ) 756 { 757 return null; 758 } 759 760 public String getPathForLocalMetadata( Metadata metadata ) 761 { 762 return null; 763 } 764 765 public String getPathForLocalArtifact( Artifact artifact ) 766 { 767 return null; 768 } 769 770 public LocalArtifactResult find( RepositorySystemSession session, LocalArtifactRequest request ) 771 { 772 773 LocalArtifactResult result = new LocalArtifactResult( request ); 774 result.setAvailable( false ); 775 try 776 { 777 result.setFile( TestFileUtils.createTempFile( "" ) ); 778 } 779 catch ( IOException e ) 780 { 781 e.printStackTrace(); 782 } 783 return result; 784 } 785 786 public void add( RepositorySystemSession session, LocalArtifactRegistration request ) 787 { 788 } 789 790 public LocalMetadataResult find( RepositorySystemSession session, LocalMetadataRequest request ) 791 { 792 return new LocalMetadataResult( request ); 793 } 794 795 public void add( RepositorySystemSession session, LocalMetadataRegistration request ) 796 { 797 } 798 } ); 799 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 800 request.addRepository( new RemoteRepository.Builder( "id", "default", "file:///" ).build() ); 801 802 resolver.setVersionResolver( new VersionResolver() 803 { 804 805 public VersionResult resolveVersion( RepositorySystemSession session, VersionRequest request ) 806 { 807 return new VersionResult( request ).setRepository( new LocalRepository( "id" ) ).setVersion( request.getArtifact().getVersion() ); 808 } 809 } ); 810 ArtifactResult result = resolver.resolveArtifact( session, request ); 811 812 assertTrue( result.getExceptions().isEmpty() ); 813 814 Artifact resolved = result.getArtifact(); 815 assertNotNull( resolved.getFile() ); 816 817 resolved = resolved.setFile( null ); 818 assertEquals( artifact, resolved ); 819 } 820 821 @Test 822 public void testFindInLocalRepositoryWhenVersionRangeWasResolvedFromLocalRepository() 823 throws ArtifactResolutionException 824 { 825 session.setLocalRepositoryManager( new LocalRepositoryManager() 826 { 827 828 public LocalRepository getRepository() 829 { 830 return null; 831 } 832 833 public String getPathForRemoteMetadata( Metadata metadata, RemoteRepository repository, String context ) 834 { 835 return null; 836 } 837 838 public String getPathForRemoteArtifact( Artifact artifact, RemoteRepository repository, String context ) 839 { 840 return null; 841 } 842 843 public String getPathForLocalMetadata( Metadata metadata ) 844 { 845 return null; 846 } 847 848 public String getPathForLocalArtifact( Artifact artifact ) 849 { 850 return null; 851 } 852 853 public LocalArtifactResult find( RepositorySystemSession session, LocalArtifactRequest request ) 854 { 855 856 LocalArtifactResult result = new LocalArtifactResult( request ); 857 result.setAvailable( false ); 858 try 859 { 860 result.setFile( TestFileUtils.createTempFile( "" ) ); 861 } 862 catch ( IOException e ) 863 { 864 e.printStackTrace(); 865 } 866 return result; 867 } 868 869 public void add( RepositorySystemSession session, LocalArtifactRegistration request ) 870 { 871 } 872 873 public LocalMetadataResult find( RepositorySystemSession session, LocalMetadataRequest request ) 874 { 875 return new LocalMetadataResult( request ); 876 } 877 878 public void add( RepositorySystemSession session, LocalMetadataRegistration request ) 879 { 880 } 881 882 } ); 883 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 884 885 resolver.setVersionResolver( new VersionResolver() 886 { 887 888 public VersionResult resolveVersion( RepositorySystemSession session, VersionRequest request ) 889 { 890 return new VersionResult( request ).setVersion( request.getArtifact().getVersion() ); 891 } 892 } ); 893 ArtifactResult result = resolver.resolveArtifact( session, request ); 894 895 assertTrue( result.getExceptions().isEmpty() ); 896 897 Artifact resolved = result.getArtifact(); 898 assertNotNull( resolved.getFile() ); 899 900 resolved = resolved.setFile( null ); 901 assertEquals( artifact, resolved ); 902 } 903 904}