| package org.eclipse.aether.internal.impl; |
| |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| import static org.junit.Assert.*; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.List; |
| |
| import org.eclipse.aether.RepositorySystemSession; |
| import org.eclipse.aether.artifact.Artifact; |
| import org.eclipse.aether.internal.test.util.TestFileUtils; |
| import org.eclipse.aether.metadata.Metadata; |
| import org.eclipse.aether.spi.connector.ArtifactDownload; |
| import org.eclipse.aether.spi.connector.ArtifactUpload; |
| import org.eclipse.aether.spi.connector.MetadataDownload; |
| import org.eclipse.aether.spi.connector.MetadataUpload; |
| import org.eclipse.aether.spi.connector.RepositoryConnector; |
| import org.eclipse.aether.spi.connector.Transfer; |
| import org.eclipse.aether.transfer.ArtifactTransferException; |
| import org.eclipse.aether.transfer.MetadataTransferException; |
| import org.eclipse.aether.transfer.TransferEvent; |
| import org.eclipse.aether.transfer.TransferListener; |
| import org.eclipse.aether.transfer.TransferResource; |
| |
| /** |
| * A repository connector recording all get/put-requests and faking the results. |
| */ |
| class RecordingRepositoryConnector |
| implements RepositoryConnector |
| { |
| |
| RepositorySystemSession session; |
| |
| boolean fail; |
| |
| private Artifact[] expectGet; |
| |
| private Artifact[] expectPut; |
| |
| private Metadata[] expectGetMD; |
| |
| private Metadata[] expectPutMD; |
| |
| private List<Artifact> actualGet = new ArrayList<Artifact>(); |
| |
| private List<Metadata> actualGetMD = new ArrayList<Metadata>(); |
| |
| private List<Artifact> actualPut = new ArrayList<Artifact>(); |
| |
| private List<Metadata> actualPutMD = new ArrayList<Metadata>(); |
| |
| public RecordingRepositoryConnector( RepositorySystemSession session, Artifact[] expectGet, Artifact[] expectPut, |
| Metadata[] expectGetMD, Metadata[] expectPutMD ) |
| { |
| this.session = session; |
| this.expectGet = expectGet; |
| this.expectPut = expectPut; |
| this.expectGetMD = expectGetMD; |
| this.expectPutMD = expectPutMD; |
| } |
| |
| public RecordingRepositoryConnector( RepositorySystemSession session ) |
| { |
| this.session = session; |
| } |
| |
| public RecordingRepositoryConnector() |
| { |
| } |
| |
| public void get( Collection<? extends ArtifactDownload> artifactDownloads, |
| Collection<? extends MetadataDownload> metadataDownloads ) |
| { |
| try |
| { |
| if ( artifactDownloads != null ) |
| { |
| for ( ArtifactDownload download : artifactDownloads ) |
| { |
| fireInitiated( download ); |
| Artifact artifact = download.getArtifact(); |
| this.actualGet.add( artifact ); |
| if ( fail ) |
| { |
| download.setException( new ArtifactTransferException( artifact, null, "forced failure" ) ); |
| } |
| else |
| { |
| TestFileUtils.writeString( download.getFile(), artifact.toString() ); |
| } |
| fireDone( download ); |
| } |
| } |
| if ( metadataDownloads != null ) |
| { |
| for ( MetadataDownload download : metadataDownloads ) |
| { |
| fireInitiated( download ); |
| Metadata metadata = download.getMetadata(); |
| this.actualGetMD.add( metadata ); |
| if ( fail ) |
| { |
| download.setException( new MetadataTransferException( metadata, null, "forced failure" ) ); |
| } |
| else |
| { |
| TestFileUtils.writeString( download.getFile(), metadata.toString() ); |
| } |
| fireDone( download ); |
| } |
| } |
| } |
| catch ( Exception e ) |
| { |
| throw new IllegalStateException( e ); |
| } |
| } |
| |
| public void put( Collection<? extends ArtifactUpload> artifactUploads, |
| Collection<? extends MetadataUpload> metadataUploads ) |
| { |
| try |
| { |
| if ( artifactUploads != null ) |
| { |
| for ( ArtifactUpload upload : artifactUploads ) |
| { |
| // mimic "real" connector |
| fireInitiated( upload ); |
| if ( upload.getFile() == null ) |
| { |
| upload.setException( new ArtifactTransferException( upload.getArtifact(), null, "no file" ) ); |
| } |
| else if ( fail ) |
| { |
| upload.setException( new ArtifactTransferException( upload.getArtifact(), null, |
| "forced failure" ) ); |
| } |
| this.actualPut.add( upload.getArtifact() ); |
| fireDone( upload ); |
| } |
| } |
| if ( metadataUploads != null ) |
| { |
| for ( MetadataUpload upload : metadataUploads ) |
| { |
| // mimic "real" connector |
| fireInitiated( upload ); |
| if ( upload.getFile() == null ) |
| { |
| upload.setException( new MetadataTransferException( upload.getMetadata(), null, "no file" ) ); |
| } |
| else if ( fail ) |
| { |
| upload.setException( new MetadataTransferException( upload.getMetadata(), null, |
| "forced failure" ) ); |
| } |
| this.actualPutMD.add( upload.getMetadata() ); |
| fireDone( upload ); |
| } |
| } |
| } |
| catch ( Exception e ) |
| { |
| throw new IllegalStateException( e ); |
| } |
| } |
| |
| private void fireInitiated( Transfer transfer ) |
| throws Exception |
| { |
| TransferListener listener = transfer.getListener(); |
| if ( listener == null ) |
| { |
| return; |
| } |
| TransferEvent.Builder event = |
| new TransferEvent.Builder( session, new TransferResource( null, null, null, null, transfer.getTrace() ) ); |
| event.setType( TransferEvent.EventType.INITIATED ); |
| listener.transferInitiated( event.build() ); |
| } |
| |
| private void fireDone( Transfer transfer ) |
| throws Exception |
| { |
| TransferListener listener = transfer.getListener(); |
| if ( listener == null ) |
| { |
| return; |
| } |
| TransferEvent.Builder event = |
| new TransferEvent.Builder( session, new TransferResource( null, null, null, null, transfer.getTrace() ) ); |
| event.setException( transfer.getException() ); |
| if ( transfer.getException() != null ) |
| { |
| listener.transferFailed( event.setType( TransferEvent.EventType.FAILED ).build() ); |
| } |
| else |
| { |
| listener.transferSucceeded( event.setType( TransferEvent.EventType.SUCCEEDED ).build() ); |
| } |
| } |
| |
| public void close() |
| { |
| } |
| |
| public void assertSeenExpected() |
| { |
| assertSeenExpected( actualGet, expectGet ); |
| assertSeenExpected( actualGetMD, expectGetMD ); |
| assertSeenExpected( actualPut, expectPut ); |
| assertSeenExpected( actualPutMD, expectPutMD ); |
| } |
| |
| private void assertSeenExpected( List<? extends Object> actual, Object[] expected ) |
| { |
| if ( expected == null ) |
| { |
| expected = new Object[0]; |
| } |
| |
| assertEquals( "different number of expected and actual elements:\n", expected.length, actual.size() ); |
| int idx = 0; |
| for ( Object actualObject : actual ) |
| { |
| assertEquals( "seen object differs", expected[idx++], actualObject ); |
| } |
| } |
| |
| public List<Artifact> getActualArtifactGetRequests() |
| { |
| return actualGet; |
| } |
| |
| public List<Metadata> getActualMetadataGetRequests() |
| { |
| return actualGetMD; |
| } |
| |
| public List<Artifact> getActualArtifactPutRequests() |
| { |
| return actualPut; |
| } |
| |
| public List<Metadata> getActualMetadataPutRequests() |
| { |
| return actualPutMD; |
| } |
| |
| public void setExpectGet( Artifact... expectGet ) |
| { |
| this.expectGet = expectGet; |
| } |
| |
| public void setExpectPut( Artifact... expectPut ) |
| { |
| this.expectPut = expectPut; |
| } |
| |
| public void setExpectGet( Metadata... expectGetMD ) |
| { |
| this.expectGetMD = expectGetMD; |
| } |
| |
| public void setExpectPut( Metadata... expectPutMD ) |
| { |
| this.expectPutMD = expectPutMD; |
| } |
| |
| public void resetActual() |
| { |
| this.actualGet = new ArrayList<Artifact>(); |
| this.actualGetMD = new ArrayList<Metadata>(); |
| this.actualPut = new ArrayList<Artifact>(); |
| this.actualPutMD = new ArrayList<Metadata>(); |
| } |
| |
| } |