View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *   http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.eclipse.aether;
20  
21  import java.io.ByteArrayOutputStream;
22  import java.io.IOException;
23  import java.io.ObjectOutputStream;
24  import java.util.Arrays;
25  import java.util.Collections;
26  
27  import org.eclipse.aether.artifact.Artifact;
28  import org.eclipse.aether.artifact.DefaultArtifact;
29  import org.eclipse.aether.collection.CollectRequest;
30  import org.eclipse.aether.collection.CollectResult;
31  import org.eclipse.aether.collection.DependencyCollectionException;
32  import org.eclipse.aether.collection.UnsolvableVersionConflictException;
33  import org.eclipse.aether.graph.DefaultDependencyNode;
34  import org.eclipse.aether.graph.Dependency;
35  import org.eclipse.aether.graph.DependencyNode;
36  import org.eclipse.aether.metadata.DefaultMetadata;
37  import org.eclipse.aether.metadata.Metadata;
38  import org.eclipse.aether.repository.LocalRepository;
39  import org.eclipse.aether.repository.NoLocalRepositoryManagerException;
40  import org.eclipse.aether.repository.Proxy;
41  import org.eclipse.aether.repository.RemoteRepository;
42  import org.eclipse.aether.resolution.ArtifactDescriptorException;
43  import org.eclipse.aether.resolution.ArtifactDescriptorRequest;
44  import org.eclipse.aether.resolution.ArtifactDescriptorResult;
45  import org.eclipse.aether.resolution.ArtifactRequest;
46  import org.eclipse.aether.resolution.ArtifactResolutionException;
47  import org.eclipse.aether.resolution.ArtifactResult;
48  import org.eclipse.aether.resolution.DependencyRequest;
49  import org.eclipse.aether.resolution.DependencyResolutionException;
50  import org.eclipse.aether.resolution.DependencyResult;
51  import org.eclipse.aether.resolution.VersionRangeRequest;
52  import org.eclipse.aether.resolution.VersionRangeResolutionException;
53  import org.eclipse.aether.resolution.VersionRangeResult;
54  import org.eclipse.aether.resolution.VersionRequest;
55  import org.eclipse.aether.resolution.VersionResolutionException;
56  import org.eclipse.aether.resolution.VersionResult;
57  import org.eclipse.aether.transfer.ArtifactNotFoundException;
58  import org.eclipse.aether.transfer.ArtifactTransferException;
59  import org.eclipse.aether.transfer.MetadataNotFoundException;
60  import org.eclipse.aether.transfer.MetadataTransferException;
61  import org.eclipse.aether.transfer.NoRepositoryConnectorException;
62  import org.eclipse.aether.transfer.NoRepositoryLayoutException;
63  import org.eclipse.aether.transfer.NoTransporterException;
64  import org.eclipse.aether.transfer.RepositoryOfflineException;
65  import org.junit.jupiter.api.Test;
66  
67  import static org.junit.jupiter.api.Assertions.assertEquals;
68  
69  public class RepositoryExceptionTest {
70  
71      private void assertSerializable(RepositoryException e) {
72          try {
73              ObjectOutputStream oos = new ObjectOutputStream(new ByteArrayOutputStream());
74              oos.writeObject(e);
75              oos.close();
76          } catch (IOException ioe) {
77              throw new IllegalStateException(ioe);
78          }
79      }
80  
81      private RequestTrace newTrace() {
82          return new RequestTrace("test");
83      }
84  
85      private Artifact newArtifact() {
86          return new DefaultArtifact("gid", "aid", "ext", "1");
87      }
88  
89      private Metadata newMetadata() {
90          return new DefaultMetadata("maven-metadata.xml", Metadata.Nature.RELEASE_OR_SNAPSHOT);
91      }
92  
93      private RemoteRepository newRepo() {
94          Proxy proxy = new Proxy(Proxy.TYPE_HTTP, "localhost", 8080, null);
95          return new RemoteRepository.Builder("id", "test", "http://localhost")
96                  .setProxy(proxy)
97                  .build();
98      }
99  
100     @Test
101     void testArtifactDescriptorException_Serializable() {
102         ArtifactDescriptorRequest request = new ArtifactDescriptorRequest();
103         request.setArtifact(newArtifact()).addRepository(newRepo()).setTrace(newTrace());
104         ArtifactDescriptorResult result = new ArtifactDescriptorResult(request);
105         assertSerializable(new ArtifactDescriptorException(result));
106     }
107 
108     @Test
109     void testArtifactResolutionException_Serializable() {
110         ArtifactRequest request = new ArtifactRequest();
111         request.setArtifact(newArtifact()).addRepository(newRepo()).setTrace(newTrace());
112         ArtifactResult result = new ArtifactResult(request);
113         assertSerializable(new ArtifactResolutionException(Arrays.asList(result)));
114     }
115 
116     @Test
117     void testArtifactResolutionExceptionMessageIncludesFailuresFromAllRepositories() {
118         RemoteRepository central =
119                 new RemoteRepository.Builder("central", "default", "https://repo.maven.apache.org/maven2").build();
120         RemoteRepository corporate = new RemoteRepository.Builder(
121                         "corporate", "default", "https://repo.internal.example/repository/maven")
122                 .build();
123         Artifact artifact = newArtifact();
124         ArtifactRequest request = new ArtifactRequest()
125                 .setArtifact(artifact)
126                 .addRepository(central)
127                 .addRepository(corporate);
128         ArtifactResult result = new ArtifactResult(request);
129         result.addException(central, new ArtifactNotFoundException(artifact, central, "not found in central"));
130         result.addException(corporate, new ArtifactTransferException(artifact, corporate, "DNS lookup failed"));
131 
132         ArtifactResolutionException exception = new ArtifactResolutionException(Collections.singletonList(result));
133         String message = exception.getMessage();
134 
135         assertEquals(
136                 "The following artifacts could not be resolved: gid:aid:ext:1: DNS lookup failed "
137                         + "(additional failures: gid:aid:ext:1 from central: not found in central)",
138                 message);
139 
140         ArtifactResult reversed = new ArtifactResult(request);
141         reversed.addException(corporate, new ArtifactTransferException(artifact, corporate, "DNS lookup failed"));
142         reversed.addException(central, new ArtifactNotFoundException(artifact, central, "not found in central"));
143         assertEquals(message, new ArtifactResolutionException(Collections.singletonList(reversed)).getMessage());
144 
145         ArtifactResult singleFailure = new ArtifactResult(request);
146         singleFailure.addException(corporate, new ArtifactTransferException(artifact, corporate, "DNS lookup failed"));
147         assertEquals(
148                 "The following artifacts could not be resolved: gid:aid:ext:1: DNS lookup failed",
149                 new ArtifactResolutionException(Collections.singletonList(singleFailure)).getMessage());
150     }
151 
152     @Test
153     void testArtifactTransferException_Serializable() {
154         assertSerializable(new ArtifactTransferException(newArtifact(), newRepo(), "error"));
155     }
156 
157     @Test
158     void testArtifactNotFoundException_Serializable() {
159         assertSerializable(new ArtifactNotFoundException(newArtifact(), newRepo(), "error"));
160     }
161 
162     @Test
163     void testDependencyCollectionException_Serializable() {
164         CollectRequest request = new CollectRequest();
165         request.addDependency(new Dependency(newArtifact(), "compile"));
166         request.addRepository(newRepo());
167         request.setTrace(newTrace());
168         CollectResult result = new CollectResult(request);
169         assertSerializable(new DependencyCollectionException(result));
170     }
171 
172     @Test
173     void testDependencyResolutionException_Serializable() {
174         CollectRequest request = new CollectRequest();
175         request.addDependency(new Dependency(newArtifact(), "compile"));
176         request.addRepository(newRepo());
177         request.setTrace(newTrace());
178         DependencyRequest req = new DependencyRequest();
179         req.setTrace(newTrace());
180         req.setCollectRequest(request);
181         DependencyResult result = new DependencyResult(req);
182         assertSerializable(new DependencyResolutionException(result, null));
183     }
184 
185     @Test
186     void testMetadataTransferException_Serializable() {
187         assertSerializable(new MetadataTransferException(newMetadata(), newRepo(), "error"));
188     }
189 
190     @Test
191     void testMetadataNotFoundException_Serializable() {
192         assertSerializable(new MetadataNotFoundException(newMetadata(), newRepo(), "error"));
193     }
194 
195     @Test
196     void testNoLocalRepositoryManagerException_Serializable() {
197         assertSerializable(new NoLocalRepositoryManagerException(new LocalRepository("/tmp")));
198     }
199 
200     @Test
201     void testNoRepositoryConnectorException_Serializable() {
202         assertSerializable(new NoRepositoryConnectorException(newRepo()));
203     }
204 
205     @Test
206     void testNoRepositoryLayoutException_Serializable() {
207         assertSerializable(new NoRepositoryLayoutException(newRepo()));
208     }
209 
210     @Test
211     void testNoTransporterException_Serializable() {
212         assertSerializable(new NoTransporterException(newRepo()));
213     }
214 
215     @Test
216     void testRepositoryOfflineException_Serializable() {
217         assertSerializable(new RepositoryOfflineException(newRepo()));
218     }
219 
220     @Test
221     void testUnsolvableVersionConflictException_Serializable() {
222         DependencyNode node = new DefaultDependencyNode(new Dependency(newArtifact(), "test"));
223         assertSerializable(new UnsolvableVersionConflictException(Collections.singleton(Arrays.asList(node))));
224     }
225 
226     @Test
227     void testVersionResolutionException_Serializable() {
228         VersionRequest request = new VersionRequest();
229         request.setArtifact(newArtifact()).addRepository(newRepo()).setTrace(newTrace());
230         VersionResult result = new VersionResult(request);
231         assertSerializable(new VersionResolutionException(result));
232     }
233 
234     @Test
235     void testVersionRangeResolutionException_Serializable() {
236         VersionRangeRequest request = new VersionRangeRequest();
237         request.setArtifact(newArtifact()).addRepository(newRepo()).setTrace(newTrace());
238         VersionRangeResult result = new VersionRangeResult(request);
239         assertSerializable(new VersionRangeResolutionException(result));
240     }
241 }