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().setUpdatePolicyAnalyzer( new DefaultUpdatePolicyAnalyzer() ) ); 276 277 session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) ); 278 session.setUpdatePolicy( RepositoryPolicy.UPDATE_POLICY_NEVER ); 279 280 RemoteRepository remoteRepo = new RemoteRepository.Builder( "id", "default", "file:///" ).build(); 281 282 Artifact artifact1 = artifact; 283 Artifact artifact2 = artifact.setVersion( "ver2" ); 284 285 ArtifactRequest request1 = new ArtifactRequest( artifact1, Arrays.asList( remoteRepo ), "" ); 286 ArtifactRequest request2 = new ArtifactRequest( artifact2, Arrays.asList( remoteRepo ), "" ); 287 288 connector.setExpectGet( artifact1, artifact2 ); 289 try 290 { 291 resolver.resolveArtifacts( session, Arrays.asList( request1, request2 ) ); 292 fail( "expected exception" ); 293 } 294 catch ( ArtifactResolutionException e ) 295 { 296 connector.assertSeenExpected(); 297 } 298 299 TestFileUtils.writeString( new File( lrm.getRepository().getBasedir(), lrm.getPathForLocalArtifact( artifact2 ) ), 300 "artifact" ); 301 lrm.setArtifactAvailability( artifact2, false ); 302 303 DefaultUpdateCheckManagerTest.resetSessionData( session ); 304 connector.resetActual(); 305 connector.setExpectGet( new Artifact[0] ); 306 try 307 { 308 resolver.resolveArtifacts( session, Arrays.asList( request1, request2 ) ); 309 fail( "expected exception" ); 310 } 311 catch ( ArtifactResolutionException e ) 312 { 313 connector.assertSeenExpected(); 314 for ( ArtifactResult result : e.getResults() ) 315 { 316 Throwable t = result.getExceptions().get( 0 ); 317 assertEquals( t.toString(), true, t instanceof ArtifactNotFoundException ); 318 assertEquals( t.toString(), true, t.getMessage().contains( "cached" ) ); 319 } 320 } 321 } 322 323 @Test 324 public void testResolveFromWorkspace() 325 throws IOException, ArtifactResolutionException 326 { 327 WorkspaceReader workspace = new WorkspaceReader() 328 { 329 330 public WorkspaceRepository getRepository() 331 { 332 return new WorkspaceRepository( "default" ); 333 } 334 335 public List<String> findVersions( Artifact artifact ) 336 { 337 return Arrays.asList( artifact.getVersion() ); 338 } 339 340 public File findArtifact( Artifact artifact ) 341 { 342 try 343 { 344 return TestFileUtils.createTempFile( artifact.toString() ); 345 } 346 catch ( IOException e ) 347 { 348 throw new RuntimeException( e.getMessage(), e ); 349 } 350 } 351 }; 352 session.setWorkspaceReader( workspace ); 353 354 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 355 request.addRepository( new RemoteRepository.Builder( "id", "default", "file:///" ).build() ); 356 357 ArtifactResult result = resolver.resolveArtifact( session, request ); 358 359 assertTrue( result.getExceptions().isEmpty() ); 360 361 Artifact resolved = result.getArtifact(); 362 assertNotNull( resolved.getFile() ); 363 364 assertEquals( resolved.toString(), TestFileUtils.readString( resolved.getFile() ) ); 365 366 resolved = resolved.setFile( null ); 367 assertEquals( artifact, resolved ); 368 369 connector.assertSeenExpected(); 370 } 371 372 @Test 373 public void testResolveFromWorkspaceFallbackToRepository() 374 throws ArtifactResolutionException 375 { 376 WorkspaceReader workspace = new WorkspaceReader() 377 { 378 379 public WorkspaceRepository getRepository() 380 { 381 return new WorkspaceRepository( "default" ); 382 } 383 384 public List<String> findVersions( Artifact artifact ) 385 { 386 return Arrays.asList( artifact.getVersion() ); 387 } 388 389 public File findArtifact( Artifact artifact ) 390 { 391 return null; 392 } 393 }; 394 session.setWorkspaceReader( workspace ); 395 396 connector.setExpectGet( artifact ); 397 repositoryConnectorProvider.setConnector( connector ); 398 399 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 400 request.addRepository( new RemoteRepository.Builder( "id", "default", "file:///" ).build() ); 401 402 ArtifactResult result = resolver.resolveArtifact( session, request ); 403 404 assertTrue( "exception on resolveArtifact", result.getExceptions().isEmpty() ); 405 406 Artifact resolved = result.getArtifact(); 407 assertNotNull( resolved.getFile() ); 408 409 resolved = resolved.setFile( null ); 410 assertEquals( artifact, resolved ); 411 412 connector.assertSeenExpected(); 413 } 414 415 @Test 416 public void testRepositoryEventsSuccessfulLocal() 417 throws ArtifactResolutionException, IOException 418 { 419 RecordingRepositoryListener listener = new RecordingRepositoryListener(); 420 session.setRepositoryListener( listener ); 421 422 File tmpFile = TestFileUtils.createTempFile( "tmp" ); 423 Map<String, String> properties = new HashMap<>(); 424 properties.put( ArtifactProperties.LOCAL_PATH, tmpFile.getAbsolutePath() ); 425 artifact = artifact.setProperties( properties ); 426 427 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 428 resolver.resolveArtifact( session, request ); 429 430 List<RepositoryEvent> events = listener.getEvents(); 431 assertEquals( 2, events.size() ); 432 RepositoryEvent event = events.get( 0 ); 433 assertEquals( EventType.ARTIFACT_RESOLVING, event.getType() ); 434 assertNull( event.getException() ); 435 assertEquals( artifact, event.getArtifact() ); 436 437 event = events.get( 1 ); 438 assertEquals( EventType.ARTIFACT_RESOLVED, event.getType() ); 439 assertNull( event.getException() ); 440 assertEquals( artifact, event.getArtifact().setFile( null ) ); 441 } 442 443 @Test 444 public void testRepositoryEventsUnsuccessfulLocal() 445 { 446 RecordingRepositoryListener listener = new RecordingRepositoryListener(); 447 session.setRepositoryListener( listener ); 448 449 Map<String, String> properties = new HashMap<>(); 450 properties.put( ArtifactProperties.LOCAL_PATH, "doesnotexist" ); 451 artifact = artifact.setProperties( properties ); 452 453 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 454 try 455 { 456 resolver.resolveArtifact( session, request ); 457 fail( "expected exception" ); 458 } 459 catch ( ArtifactResolutionException ignored ) 460 { 461 } 462 463 List<RepositoryEvent> events = listener.getEvents(); 464 assertEquals( 2, events.size() ); 465 466 RepositoryEvent event = events.get( 0 ); 467 assertEquals( artifact, event.getArtifact() ); 468 assertEquals( EventType.ARTIFACT_RESOLVING, event.getType() ); 469 470 event = events.get( 1 ); 471 assertEquals( artifact, event.getArtifact() ); 472 assertEquals( EventType.ARTIFACT_RESOLVED, event.getType() ); 473 assertNotNull( event.getException() ); 474 assertEquals( 1, event.getExceptions().size() ); 475 476 } 477 478 @Test 479 public void testRepositoryEventsSuccessfulRemote() 480 throws ArtifactResolutionException 481 { 482 RecordingRepositoryListener listener = new RecordingRepositoryListener(); 483 session.setRepositoryListener( listener ); 484 485 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 486 request.addRepository( new RemoteRepository.Builder( "id", "default", "file:///" ).build() ); 487 488 resolver.resolveArtifact( session, request ); 489 490 List<RepositoryEvent> events = listener.getEvents(); 491 assertEquals( events.toString(), 4, events.size() ); 492 RepositoryEvent event = events.get( 0 ); 493 assertEquals( EventType.ARTIFACT_RESOLVING, event.getType() ); 494 assertNull( event.getException() ); 495 assertEquals( artifact, event.getArtifact() ); 496 497 event = events.get( 1 ); 498 assertEquals( EventType.ARTIFACT_DOWNLOADING, event.getType() ); 499 assertNull( event.getException() ); 500 assertEquals( artifact, event.getArtifact().setFile( null ) ); 501 502 event = events.get( 2 ); 503 assertEquals( EventType.ARTIFACT_DOWNLOADED, event.getType() ); 504 assertNull( event.getException() ); 505 assertEquals( artifact, event.getArtifact().setFile( null ) ); 506 507 event = events.get( 3 ); 508 assertEquals( EventType.ARTIFACT_RESOLVED, event.getType() ); 509 assertNull( event.getException() ); 510 assertEquals( artifact, event.getArtifact().setFile( null ) ); 511 } 512 513 @Test 514 public void testRepositoryEventsUnsuccessfulRemote() 515 { 516 RecordingRepositoryConnector connector = new RecordingRepositoryConnector() 517 { 518 519 @Override 520 public void get( Collection<? extends ArtifactDownload> artifactDownloads, 521 Collection<? extends MetadataDownload> metadataDownloads ) 522 { 523 super.get( artifactDownloads, metadataDownloads ); 524 ArtifactDownload download = artifactDownloads.iterator().next(); 525 ArtifactTransferException exception = 526 new ArtifactNotFoundException( download.getArtifact(), null, "not found" ); 527 download.setException( exception ); 528 } 529 530 }; 531 repositoryConnectorProvider.setConnector( connector ); 532 533 RecordingRepositoryListener listener = new RecordingRepositoryListener(); 534 session.setRepositoryListener( listener ); 535 536 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 537 request.addRepository( new RemoteRepository.Builder( "id", "default", "file:///" ).build() ); 538 539 try 540 { 541 resolver.resolveArtifact( session, request ); 542 fail( "expected exception" ); 543 } 544 catch ( ArtifactResolutionException ignored ) 545 { 546 } 547 548 List<RepositoryEvent> events = listener.getEvents(); 549 assertEquals( events.toString(), 4, events.size() ); 550 551 RepositoryEvent event = events.get( 0 ); 552 assertEquals( artifact, event.getArtifact() ); 553 assertEquals( EventType.ARTIFACT_RESOLVING, event.getType() ); 554 555 event = events.get( 1 ); 556 assertEquals( artifact, event.getArtifact() ); 557 assertEquals( EventType.ARTIFACT_DOWNLOADING, event.getType() ); 558 559 event = events.get( 2 ); 560 assertEquals( artifact, event.getArtifact() ); 561 assertEquals( EventType.ARTIFACT_DOWNLOADED, event.getType() ); 562 assertNotNull( event.getException() ); 563 assertEquals( 1, event.getExceptions().size() ); 564 565 event = events.get( 3 ); 566 assertEquals( artifact, event.getArtifact() ); 567 assertEquals( EventType.ARTIFACT_RESOLVED, event.getType() ); 568 assertNotNull( event.getException() ); 569 assertEquals( 1, event.getExceptions().size() ); 570 } 571 572 @Test 573 public void testVersionResolverFails() 574 { 575 resolver.setVersionResolver( new VersionResolver() 576 { 577 578 public VersionResult resolveVersion( RepositorySystemSession session, VersionRequest request ) 579 throws VersionResolutionException 580 { 581 throw new VersionResolutionException( new VersionResult( request ) ); 582 } 583 } ); 584 585 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 586 try 587 { 588 resolver.resolveArtifact( session, request ); 589 fail( "expected exception" ); 590 } 591 catch ( ArtifactResolutionException e ) 592 { 593 connector.assertSeenExpected(); 594 assertNotNull( e.getResults() ); 595 assertEquals( 1, e.getResults().size() ); 596 597 ArtifactResult result = e.getResults().get( 0 ); 598 599 assertSame( request, result.getRequest() ); 600 601 assertFalse( result.getExceptions().isEmpty() ); 602 assertTrue( result.getExceptions().get( 0 ) instanceof VersionResolutionException ); 603 604 Artifact resolved = result.getArtifact(); 605 assertNull( resolved ); 606 } 607 } 608 609 @Test 610 public void testRepositoryEventsOnVersionResolverFail() 611 { 612 resolver.setVersionResolver( new VersionResolver() 613 { 614 615 public VersionResult resolveVersion( RepositorySystemSession session, VersionRequest request ) 616 throws VersionResolutionException 617 { 618 throw new VersionResolutionException( new VersionResult( request ) ); 619 } 620 } ); 621 622 RecordingRepositoryListener listener = new RecordingRepositoryListener(); 623 session.setRepositoryListener( listener ); 624 625 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 626 try 627 { 628 resolver.resolveArtifact( session, request ); 629 fail( "expected exception" ); 630 } 631 catch ( ArtifactResolutionException ignored ) 632 { 633 } 634 635 List<RepositoryEvent> events = listener.getEvents(); 636 assertEquals( 2, events.size() ); 637 638 RepositoryEvent event = events.get( 0 ); 639 assertEquals( artifact, event.getArtifact() ); 640 assertEquals( EventType.ARTIFACT_RESOLVING, event.getType() ); 641 642 event = events.get( 1 ); 643 assertEquals( artifact, event.getArtifact() ); 644 assertEquals( EventType.ARTIFACT_RESOLVED, event.getType() ); 645 assertNotNull( event.getException() ); 646 assertEquals( 1, event.getExceptions().size() ); 647 } 648 649 @Test 650 public void testLocalArtifactAvailable() 651 throws ArtifactResolutionException 652 { 653 session.setLocalRepositoryManager( new LocalRepositoryManager() 654 { 655 656 public LocalRepository getRepository() 657 { 658 return null; 659 } 660 661 public String getPathForRemoteMetadata( Metadata metadata, RemoteRepository repository, String context ) 662 { 663 return null; 664 } 665 666 public String getPathForRemoteArtifact( Artifact artifact, RemoteRepository repository, String context ) 667 { 668 return null; 669 } 670 671 public String getPathForLocalMetadata( Metadata metadata ) 672 { 673 return null; 674 } 675 676 public String getPathForLocalArtifact( Artifact artifact ) 677 { 678 return null; 679 } 680 681 public LocalArtifactResult find( RepositorySystemSession session, LocalArtifactRequest request ) 682 { 683 684 LocalArtifactResult result = new LocalArtifactResult( request ); 685 result.setAvailable( true ); 686 try 687 { 688 result.setFile( TestFileUtils.createTempFile( "" ) ); 689 } 690 catch ( IOException e ) 691 { 692 e.printStackTrace(); 693 } 694 return result; 695 } 696 697 public void add( RepositorySystemSession session, LocalArtifactRegistration request ) 698 { 699 } 700 701 public LocalMetadataResult find( RepositorySystemSession session, LocalMetadataRequest request ) 702 { 703 LocalMetadataResult result = new LocalMetadataResult( request ); 704 try 705 { 706 result.setFile( TestFileUtils.createTempFile( "" ) ); 707 } 708 catch ( IOException e ) 709 { 710 e.printStackTrace(); 711 } 712 return result; 713 } 714 715 public void add( RepositorySystemSession session, LocalMetadataRegistration request ) 716 { 717 } 718 } ); 719 720 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 721 request.addRepository( new RemoteRepository.Builder( "id", "default", "file:///" ).build() ); 722 723 ArtifactResult result = resolver.resolveArtifact( session, request ); 724 725 assertTrue( result.getExceptions().isEmpty() ); 726 727 Artifact resolved = result.getArtifact(); 728 assertNotNull( resolved.getFile() ); 729 730 resolved = resolved.setFile( null ); 731 assertEquals( artifact, resolved ); 732 733 } 734 735 @Test 736 public void testFindInLocalRepositoryWhenVersionWasFoundInLocalRepository() 737 throws ArtifactResolutionException 738 { 739 session.setLocalRepositoryManager( new LocalRepositoryManager() 740 { 741 742 public LocalRepository getRepository() 743 { 744 return null; 745 } 746 747 public String getPathForRemoteMetadata( Metadata metadata, RemoteRepository repository, String context ) 748 { 749 return null; 750 } 751 752 public String getPathForRemoteArtifact( Artifact artifact, RemoteRepository repository, String context ) 753 { 754 return null; 755 } 756 757 public String getPathForLocalMetadata( Metadata metadata ) 758 { 759 return null; 760 } 761 762 public String getPathForLocalArtifact( Artifact artifact ) 763 { 764 return null; 765 } 766 767 public LocalArtifactResult find( RepositorySystemSession session, LocalArtifactRequest request ) 768 { 769 770 LocalArtifactResult result = new LocalArtifactResult( request ); 771 result.setAvailable( false ); 772 try 773 { 774 result.setFile( TestFileUtils.createTempFile( "" ) ); 775 } 776 catch ( IOException e ) 777 { 778 e.printStackTrace(); 779 } 780 return result; 781 } 782 783 public void add( RepositorySystemSession session, LocalArtifactRegistration request ) 784 { 785 } 786 787 public LocalMetadataResult find( RepositorySystemSession session, LocalMetadataRequest request ) 788 { 789 return new LocalMetadataResult( request ); 790 } 791 792 public void add( RepositorySystemSession session, LocalMetadataRegistration request ) 793 { 794 } 795 } ); 796 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 797 request.addRepository( new RemoteRepository.Builder( "id", "default", "file:///" ).build() ); 798 799 resolver.setVersionResolver( new VersionResolver() 800 { 801 802 public VersionResult resolveVersion( RepositorySystemSession session, VersionRequest request ) 803 { 804 return new VersionResult( request ).setRepository( new LocalRepository( "id" ) ).setVersion( request.getArtifact().getVersion() ); 805 } 806 } ); 807 ArtifactResult result = resolver.resolveArtifact( session, request ); 808 809 assertTrue( result.getExceptions().isEmpty() ); 810 811 Artifact resolved = result.getArtifact(); 812 assertNotNull( resolved.getFile() ); 813 814 resolved = resolved.setFile( null ); 815 assertEquals( artifact, resolved ); 816 } 817 818 @Test 819 public void testFindInLocalRepositoryWhenVersionRangeWasResolvedFromLocalRepository() 820 throws ArtifactResolutionException 821 { 822 session.setLocalRepositoryManager( new LocalRepositoryManager() 823 { 824 825 public LocalRepository getRepository() 826 { 827 return null; 828 } 829 830 public String getPathForRemoteMetadata( Metadata metadata, RemoteRepository repository, String context ) 831 { 832 return null; 833 } 834 835 public String getPathForRemoteArtifact( Artifact artifact, RemoteRepository repository, String context ) 836 { 837 return null; 838 } 839 840 public String getPathForLocalMetadata( Metadata metadata ) 841 { 842 return null; 843 } 844 845 public String getPathForLocalArtifact( Artifact artifact ) 846 { 847 return null; 848 } 849 850 public LocalArtifactResult find( RepositorySystemSession session, LocalArtifactRequest request ) 851 { 852 853 LocalArtifactResult result = new LocalArtifactResult( request ); 854 result.setAvailable( false ); 855 try 856 { 857 result.setFile( TestFileUtils.createTempFile( "" ) ); 858 } 859 catch ( IOException e ) 860 { 861 e.printStackTrace(); 862 } 863 return result; 864 } 865 866 public void add( RepositorySystemSession session, LocalArtifactRegistration request ) 867 { 868 } 869 870 public LocalMetadataResult find( RepositorySystemSession session, LocalMetadataRequest request ) 871 { 872 return new LocalMetadataResult( request ); 873 } 874 875 public void add( RepositorySystemSession session, LocalMetadataRegistration request ) 876 { 877 } 878 879 } ); 880 ArtifactRequest request = new ArtifactRequest( artifact, null, "" ); 881 882 resolver.setVersionResolver( new VersionResolver() 883 { 884 885 public VersionResult resolveVersion( RepositorySystemSession session, VersionRequest request ) 886 { 887 return new VersionResult( request ).setVersion( request.getArtifact().getVersion() ); 888 } 889 } ); 890 ArtifactResult result = resolver.resolveArtifact( session, request ); 891 892 assertTrue( result.getExceptions().isEmpty() ); 893 894 Artifact resolved = result.getArtifact(); 895 assertNotNull( resolved.getFile() ); 896 897 resolved = resolved.setFile( null ); 898 assertEquals( artifact, resolved ); 899 } 900 901}