1
2
3
4
5
6
7
8
9
10
11 package org.eclipse.jgit.http.test;
12
13 import static org.hamcrest.MatcherAssert.assertThat;
14 import static org.hamcrest.Matchers.is;
15 import static org.junit.Assert.assertEquals;
16 import static org.junit.Assert.assertFalse;
17 import static org.junit.Assert.assertNotNull;
18 import static org.junit.Assert.assertNull;
19 import static org.junit.Assert.assertTrue;
20 import static org.junit.Assert.fail;
21
22 import java.io.File;
23 import java.io.OutputStream;
24 import java.net.URI;
25 import java.net.URL;
26 import java.text.MessageFormat;
27 import java.util.List;
28
29 import javax.servlet.http.HttpServletRequest;
30
31 import org.eclipse.jetty.servlet.DefaultServlet;
32 import org.eclipse.jetty.servlet.ServletContextHandler;
33 import org.eclipse.jetty.servlet.ServletHolder;
34 import org.eclipse.jgit.errors.NoRemoteRepositoryException;
35 import org.eclipse.jgit.errors.RepositoryNotFoundException;
36 import org.eclipse.jgit.errors.TransportException;
37 import org.eclipse.jgit.http.server.GitServlet;
38 import org.eclipse.jgit.internal.JGitText;
39 import org.eclipse.jgit.junit.TestRepository;
40 import org.eclipse.jgit.junit.http.AccessEvent;
41 import org.eclipse.jgit.junit.http.AppServer;
42 import org.eclipse.jgit.lib.Constants;
43 import org.eclipse.jgit.lib.Ref;
44 import org.eclipse.jgit.lib.RefUpdate;
45 import org.eclipse.jgit.lib.Repository;
46 import org.eclipse.jgit.lib.StoredConfig;
47 import org.eclipse.jgit.revwalk.RevCommit;
48 import org.eclipse.jgit.transport.FetchConnection;
49 import org.eclipse.jgit.transport.HttpTransport;
50 import org.eclipse.jgit.transport.PacketLineIn;
51 import org.eclipse.jgit.transport.PacketLineOut;
52 import org.eclipse.jgit.transport.Transport;
53 import org.eclipse.jgit.transport.URIish;
54 import org.eclipse.jgit.transport.UsernamePasswordCredentialsProvider;
55 import org.eclipse.jgit.transport.http.HttpConnection;
56 import org.eclipse.jgit.transport.http.HttpConnectionFactory;
57 import org.junit.Before;
58 import org.junit.Test;
59
60 public class HttpClientTests extends AllFactoriesHttpTestCase {
61
62 private TestRepository<Repository> remoteRepository;
63
64 private URIish dumbAuthNoneURI;
65
66 private URIish dumbAuthBasicURI;
67
68 private URIish smartAuthNoneURI;
69
70 private URIish smartAuthBasicURI;
71
72 public HttpClientTests(HttpConnectionFactory cf) {
73 super(cf);
74 }
75
76 @Override
77 @Before
78 public void setUp() throws Exception {
79 super.setUp();
80
81 remoteRepository = createTestRepository();
82 remoteRepository.update(master, remoteRepository.commit().create());
83
84 ServletContextHandler dNone = dumb("/dnone");
85 ServletContextHandler dBasic = server.authBasic(dumb("/dbasic"));
86
87 ServletContextHandler sNone = smart("/snone");
88 ServletContextHandler sBasic = server.authBasic(smart("/sbasic"));
89
90 server.setUp();
91
92 final String srcName = nameOf(remoteRepository.getRepository());
93 dumbAuthNoneURI = toURIish(dNone, srcName);
94 dumbAuthBasicURI = toURIish(dBasic, srcName);
95
96 smartAuthNoneURI = toURIish(sNone, srcName);
97 smartAuthBasicURI = toURIish(sBasic, srcName);
98 }
99
100 private ServletContextHandler dumb(String path) {
101 final File srcGit = remoteRepository.getRepository().getDirectory();
102 final URI base = srcGit.getParentFile().toURI();
103
104 ServletContextHandler ctx = server.addContext(path);
105 ctx.setResourceBase(base.toString());
106 ServletHolder holder = ctx.addServlet(DefaultServlet.class, "/");
107
108 holder.setInitParameter("aliases", "true");
109 return ctx;
110 }
111
112 private ServletContextHandler smart(String path) {
113 GitServlet gs = new GitServlet();
114 gs.setRepositoryResolver((HttpServletRequest req, String name) -> {
115 final Repository db = remoteRepository.getRepository();
116 if (!name.equals(nameOf(db))) {
117 throw new RepositoryNotFoundException(name);
118 }
119 db.incrementOpen();
120 return db;
121 });
122
123 ServletContextHandler ctx = server.addContext(path);
124 ctx.addServlet(new ServletHolder(gs), "/*");
125 return ctx;
126 }
127
128 private static String nameOf(Repository db) {
129 return db.getDirectory().getName();
130 }
131
132 @Test
133 public void testRepositoryNotFound_Dumb() throws Exception {
134 URIish uri = toURIish("/dumb.none/not-found");
135 Repository dst = createBareRepository();
136 try (Transport t = Transport.open(dst, uri)) {
137 try {
138 t.openFetch();
139 fail("connection opened to not found repository");
140 } catch (NoRemoteRepositoryException err) {
141 String exp = uri + ": " + uri
142 + "/info/refs?service=git-upload-pack not found";
143 assertNotNull(err.getMessage());
144 assertTrue("Unexpected error message",
145 err.getMessage().startsWith(exp));
146 }
147 }
148 }
149
150 @Test
151 public void testRepositoryNotFound_Smart() throws Exception {
152 URIish uri = toURIish("/smart.none/not-found");
153 Repository dst = createBareRepository();
154 try (Transport t = Transport.open(dst, uri)) {
155 try {
156 t.openFetch();
157 fail("connection opened to not found repository");
158 } catch (NoRemoteRepositoryException err) {
159 String exp = uri + ": " + uri
160 + "/info/refs?service=git-upload-pack not found";
161 assertNotNull(err.getMessage());
162 assertTrue("Unexpected error message",
163 err.getMessage().startsWith(exp));
164 }
165 }
166 }
167
168 @Test
169 public void testListRemote_Dumb_DetachedHEAD() throws Exception {
170 Repository src = remoteRepository.getRepository();
171 RefUpdate u = src.updateRef(Constants.HEAD, true);
172 RevCommit Q = remoteRepository.commit().message("Q").create();
173 u.setNewObjectId(Q);
174 assertEquals(RefUpdate.Result.FORCED, u.forceUpdate());
175
176 Repository dst = createBareRepository();
177 Ref head;
178 try (Transport t = Transport.open(dst, dumbAuthNoneURI);
179 FetchConnection c = t.openFetch()) {
180 head = c.getRef(Constants.HEAD);
181 }
182 assertNotNull("has " + Constants.HEAD, head);
183 assertEquals(Q, head.getObjectId());
184 }
185
186 @Test
187 public void testListRemote_Dumb_NoHEAD() throws Exception {
188 Repository src = remoteRepository.getRepository();
189 File headref = new File(src.getDirectory(), Constants.HEAD);
190 assertTrue("HEAD used to be present", headref.delete());
191 assertFalse("HEAD is gone", headref.exists());
192
193 Repository dst = createBareRepository();
194 Ref head;
195 try (Transport t = Transport.open(dst, dumbAuthNoneURI);
196 FetchConnection c = t.openFetch()) {
197 head = c.getRef(Constants.HEAD);
198 }
199 assertNull("has no " + Constants.HEAD, head);
200 }
201
202 @Test
203 public void testListRemote_Smart_DetachedHEAD() throws Exception {
204 Repository src = remoteRepository.getRepository();
205 RefUpdate u = src.updateRef(Constants.HEAD, true);
206 RevCommit Q = remoteRepository.commit().message("Q").create();
207 u.setNewObjectId(Q);
208 assertEquals(RefUpdate.Result.FORCED, u.forceUpdate());
209
210 Repository dst = createBareRepository();
211 Ref head;
212 try (Transport t = Transport.open(dst, smartAuthNoneURI);
213 FetchConnection c = t.openFetch()) {
214 head = c.getRef(Constants.HEAD);
215 }
216 assertNotNull("has " + Constants.HEAD, head);
217 assertEquals(Q, head.getObjectId());
218 }
219
220 @Test
221 public void testListRemote_Smart_WithQueryParameters() throws Exception {
222 URIish myURI = toURIish("/snone/do?r=1&p=test.git");
223 Repository dst = createBareRepository();
224 try (Transport t = Transport.open(dst, myURI)) {
225 try {
226 t.openFetch();
227 fail("test did not fail to find repository as expected");
228 } catch (NoRemoteRepositoryException err) {
229
230 }
231 }
232
233 List<AccessEvent> requests = getRequests();
234 assertEquals(1, requests.size());
235
236 AccessEvent info = requests.get(0);
237 assertEquals("GET", info.getMethod());
238 assertEquals("/snone/do", info.getPath());
239 assertEquals(3, info.getParameters().size());
240 assertEquals("1", info.getParameter("r"));
241 assertEquals("test.git/info/refs", info.getParameter("p"));
242 assertEquals("git-upload-pack", info.getParameter("service"));
243 assertEquals(404, info.getStatus());
244 }
245
246 @Test
247 public void testListRemote_Dumb_NeedsAuth() throws Exception {
248 Repository dst = createBareRepository();
249 try (Transport t = Transport.open(dst, dumbAuthBasicURI)) {
250 try {
251 t.openFetch();
252 fail("connection opened even info/refs needs auth basic");
253 } catch (TransportException err) {
254 String exp = dumbAuthBasicURI + ": "
255 + JGitText.get().noCredentialsProvider;
256 assertEquals(exp, err.getMessage());
257 }
258 }
259 }
260
261 @Test
262 public void testListRemote_Dumb_Auth() throws Exception {
263 Repository dst = createBareRepository();
264 try (Transport t = Transport.open(dst, dumbAuthBasicURI)) {
265 t.setCredentialsProvider(new UsernamePasswordCredentialsProvider(
266 AppServer.username, AppServer.password));
267 t.openFetch().close();
268 }
269 try (Transport t = Transport.open(dst, dumbAuthBasicURI)) {
270 t.setCredentialsProvider(new UsernamePasswordCredentialsProvider(
271 AppServer.username, ""));
272 try {
273 t.openFetch();
274 fail("connection opened even info/refs needs auth basic and we provide wrong password");
275 } catch (TransportException err) {
276 String exp = dumbAuthBasicURI + ": "
277 + JGitText.get().notAuthorized;
278 assertEquals(exp, err.getMessage());
279 }
280 }
281 }
282
283 @Test
284 public void testListRemote_Smart_UploadPackNeedsAuth() throws Exception {
285 Repository dst = createBareRepository();
286 try (Transport t = Transport.open(dst, smartAuthBasicURI)) {
287 try {
288 t.openFetch();
289 fail("connection opened even though service disabled");
290 } catch (TransportException err) {
291 String exp = smartAuthBasicURI + ": "
292 + JGitText.get().noCredentialsProvider;
293 assertEquals(exp, err.getMessage());
294 }
295 }
296 }
297
298 @Test
299 public void testListRemote_Smart_UploadPackDisabled() throws Exception {
300 Repository src = remoteRepository.getRepository();
301 final StoredConfig cfg = src.getConfig();
302 cfg.setBoolean("http", null, "uploadpack", false);
303 cfg.save();
304
305 Repository dst = createBareRepository();
306 try (Transport t = Transport.open(dst, smartAuthNoneURI)) {
307 try {
308 t.openFetch();
309 fail("connection opened even though service disabled");
310 } catch (TransportException err) {
311 String exp = smartAuthNoneURI + ": "
312 + MessageFormat.format(
313 JGitText.get().serviceNotPermitted,
314 smartAuthNoneURI.toString() + "/",
315 "git-upload-pack");
316 assertEquals(exp, err.getMessage());
317 }
318 }
319 }
320
321 @Test
322 public void testListRemoteWithoutLocalRepository() throws Exception {
323 try (Transport t = Transport.open(smartAuthNoneURI);
324 FetchConnection c = t.openFetch()) {
325 Ref head = c.getRef(Constants.HEAD);
326 assertNotNull(head);
327 }
328 }
329
330 @Test
331 public void testHttpClientWantsV2AndServerNotConfigured() throws Exception {
332 String url = smartAuthNoneURI.toString() + "/info/refs?service=git-upload-pack";
333 HttpConnection c = HttpTransport.getConnectionFactory()
334 .create(new URL(url));
335 c.setRequestMethod("GET");
336 c.setRequestProperty("Git-Protocol", "version=2");
337 assertEquals(200, c.getResponseCode());
338
339 PacketLineIn pckIn = new PacketLineIn(c.getInputStream());
340 assertThat(pckIn.readString(), is("version 2"));
341 }
342
343 @Test
344 public void testHttpServerConfiguredToV0() throws Exception {
345 remoteRepository.getRepository().getConfig().setInt(
346 "protocol", null, "version", 0);
347 String url = smartAuthNoneURI.toString() + "/info/refs?service=git-upload-pack";
348 HttpConnection c = HttpTransport.getConnectionFactory()
349 .create(new URL(url));
350 c.setRequestMethod("GET");
351 c.setRequestProperty("Git-Protocol", "version=2");
352 assertEquals(200, c.getResponseCode());
353
354 PacketLineIn pckIn = new PacketLineIn(c.getInputStream());
355
356
357 assertThat(pckIn.readString(), is("# service=git-upload-pack"));
358 assertTrue(PacketLineIn.isEnd(pckIn.readString()));
359 assertTrue(pckIn.readString().matches("[0-9a-f]{40} HEAD.*"));
360 }
361
362 @Test
363 public void testV2HttpFirstResponse() throws Exception {
364 String url = smartAuthNoneURI.toString() + "/info/refs?service=git-upload-pack";
365 HttpConnection c = HttpTransport.getConnectionFactory()
366 .create(new URL(url));
367 c.setRequestMethod("GET");
368 c.setRequestProperty("Git-Protocol", "version=2");
369 assertEquals(200, c.getResponseCode());
370
371 PacketLineIn pckIn = new PacketLineIn(c.getInputStream());
372 assertThat(pckIn.readString(), is("version 2"));
373
374
375
376 for (String s : pckIn.readStrings()) {
377 assertTrue(!s.isEmpty());
378 }
379 }
380
381 @Test
382 public void testV2HttpSubsequentResponse() throws Exception {
383 String url = smartAuthNoneURI.toString() + "/git-upload-pack";
384 HttpConnection c = HttpTransport.getConnectionFactory()
385 .create(new URL(url));
386 c.setRequestMethod("POST");
387 c.setRequestProperty("Content-Type", "application/x-git-upload-pack-request");
388 c.setRequestProperty("Git-Protocol", "version=2");
389 c.setDoOutput(true);
390
391
392
393
394
395 try (OutputStream os = c.getOutputStream()) {
396 PacketLineOut pckOut = new PacketLineOut(os);
397 pckOut.writeString("command=ls-refs");
398 pckOut.writeDelim();
399 pckOut.end();
400 }
401
402 PacketLineIn pckIn = new PacketLineIn(c.getInputStream());
403
404
405 for (String s : pckIn.readStrings()) {
406 assertTrue(s.matches("[0-9a-f]{40} [A-Za-z/]*"));
407 }
408
409 assertEquals(200, c.getResponseCode());
410 }
411 }