Kiln » Dependencies » Dulwich Read More
Clone URL:  
Pushed to one repository · View In Graph Contained in master

fix http test on osx

Signed-off-by: Jelmer Vernooij <jelmer@samba.org>

Changeset 99274d9ddb15…

Parent c51c99834cc1…

committed by Jelmer Vernooij

authored by Yifan Zhang

Changes to one file · Browse files at 99274d9ddb15 Showing diff from parent c51c99834cc1 Diff from another changeset...

Change 1 of 2 Show Changes Only dulwich/​tests/​compat/​test_client.py Stacked
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
 
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
 # test_client.py -- Compatibilty tests for git client.  # Copyright (C) 2010 Google, Inc.  #  # This program is free software; you can redistribute it and/or  # modify it under the terms of the GNU General Public License  # as published by the Free Software Foundation; version 2  # of the License or (at your option) any later version of  # the License.  #  # This program is distributed in the hope that it will be useful,  # but WITHOUT ANY WARRANTY; without even the implied warranty of  # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the  # GNU General Public License for more details.  #  # You should have received a copy of the GNU General Public License  # along with this program; if not, write to the Free Software  # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,  # MA 02110-1301, USA.    """Compatibilty tests between the Dulwich client and the cgit server."""    from cStringIO import StringIO  import BaseHTTPServer  import SimpleHTTPServer  import copy  import os  import select  import shutil  import signal  import subprocess  import tarfile  import tempfile  import threading  import urllib +from socket import gethostname    from dulwich import (   client,   errors,   file,   index,   protocol,   objects,   repo,   )  from dulwich.tests import (   get_safe_env,   SkipTest,   )    from dulwich.tests.compat.utils import (   CompatTestCase,   check_for_daemon,   import_repo_to_dir,   run_git_or_fail,   )  from dulwich.tests.compat.server_utils import (   ShutdownServerMixIn,   )      class DulwichClientTestBase(object):   """Tests for client/server compatibility."""     def setUp(self):   self.gitroot = os.path.dirname(import_repo_to_dir('server_new.export'))   self.dest = os.path.join(self.gitroot, 'dest')   file.ensure_dir_exists(self.dest)   run_git_or_fail(['init', '--quiet', '--bare'], cwd=self.dest)     def tearDown(self):   shutil.rmtree(self.gitroot)     def assertDestEqualsSrc(self):   src = repo.Repo(os.path.join(self.gitroot, 'server_new.export'))   dest = repo.Repo(os.path.join(self.gitroot, 'dest'))   self.assertReposEqual(src, dest)     def _client(self):   raise NotImplementedError()     def _build_path(self):   raise NotImplementedError()     def _do_send_pack(self):   c = self._client()   srcpath = os.path.join(self.gitroot, 'server_new.export')   src = repo.Repo(srcpath)   sendrefs = dict(src.get_refs())   del sendrefs['HEAD']   c.send_pack(self._build_path('/dest'), lambda _: sendrefs,   src.object_store.generate_pack_contents)     def test_send_pack(self):   self._do_send_pack()   self.assertDestEqualsSrc()     def test_send_pack_nothing_to_send(self):   self._do_send_pack()   self.assertDestEqualsSrc()   # nothing to send, but shouldn't raise either.   self._do_send_pack()     def test_send_without_report_status(self):   c = self._client()   c._send_capabilities.remove('report-status')   srcpath = os.path.join(self.gitroot, 'server_new.export')   src = repo.Repo(srcpath)   sendrefs = dict(src.get_refs())   del sendrefs['HEAD']   c.send_pack(self._build_path('/dest'), lambda _: sendrefs,   src.object_store.generate_pack_contents)   self.assertDestEqualsSrc()     def make_dummy_commit(self, dest):   b = objects.Blob.from_string('hi')   dest.object_store.add_object(b)   t = index.commit_tree(dest.object_store, [('hi', b.id, 0100644)])   c = objects.Commit()   c.author = c.committer = 'Foo Bar <foo@example.com>'   c.author_time = c.commit_time = 0   c.author_timezone = c.commit_timezone = 0   c.message = 'hi'   c.tree = t   dest.object_store.add_object(c)   return c.id     def disable_ff_and_make_dummy_commit(self):   # disable non-fast-forward pushes to the server   dest = repo.Repo(os.path.join(self.gitroot, 'dest'))   run_git_or_fail(['config', 'receive.denyNonFastForwards', 'true'],   cwd=dest.path)   commit_id = self.make_dummy_commit(dest)   return dest, commit_id     def compute_send(self):   srcpath = os.path.join(self.gitroot, 'server_new.export')   src = repo.Repo(srcpath)   sendrefs = dict(src.get_refs())   del sendrefs['HEAD']   return sendrefs, src.object_store.generate_pack_contents     def test_send_pack_one_error(self):   dest, dummy_commit = self.disable_ff_and_make_dummy_commit()   dest.refs['refs/heads/master'] = dummy_commit   sendrefs, gen_pack = self.compute_send()   c = self._client()   try:   c.send_pack(self._build_path('/dest'), lambda _: sendrefs, gen_pack)   except errors.UpdateRefsError, e:   self.assertEqual('refs/heads/master failed to update', str(e))   self.assertEqual({'refs/heads/branch': 'ok',   'refs/heads/master': 'non-fast-forward'},   e.ref_status)     def test_send_pack_multiple_errors(self):   dest, dummy = self.disable_ff_and_make_dummy_commit()   # set up for two non-ff errors   dest.refs['refs/heads/branch'] = dest.refs['refs/heads/master'] = dummy   sendrefs, gen_pack = self.compute_send()   c = self._client()   try:   c.send_pack(self._build_path('/dest'), lambda _: sendrefs, gen_pack)   except errors.UpdateRefsError, e:   self.assertEqual('refs/heads/branch, refs/heads/master failed to '   'update', str(e))   self.assertEqual({'refs/heads/branch': 'non-fast-forward',   'refs/heads/master': 'non-fast-forward'},   e.ref_status)     def test_archive(self):   c = self._client()   f = StringIO()   c.archive(self._build_path('/server_new.export'), 'HEAD', f.write)   f.seek(0)   tf = tarfile.open(fileobj=f)   self.assertEqual(['baz', 'foo'], tf.getnames())     def test_fetch_pack(self):   c = self._client()   dest = repo.Repo(os.path.join(self.gitroot, 'dest'))   refs = c.fetch(self._build_path('/server_new.export'), dest)   map(lambda r: dest.refs.set_if_equals(r[0], None, r[1]), refs.items())   self.assertDestEqualsSrc()     def test_incremental_fetch_pack(self):   self.test_fetch_pack()   dest, dummy = self.disable_ff_and_make_dummy_commit()   dest.refs['refs/heads/master'] = dummy   c = self._client()   dest = repo.Repo(os.path.join(self.gitroot, 'server_new.export'))   refs = c.fetch(self._build_path('/dest'), dest)   map(lambda r: dest.refs.set_if_equals(r[0], None, r[1]), refs.items())   self.assertDestEqualsSrc()     def test_fetch_pack_zero_sha(self):   # zero sha1s are already present on the client, and should   # be ignored   c = self._client()   dest = repo.Repo(os.path.join(self.gitroot, 'dest'))   refs = c.fetch(self._build_path('/server_new.export'), dest,   lambda refs: [protocol.ZERO_SHA])   map(lambda r: dest.refs.set_if_equals(r[0], None, r[1]), refs.items())     def test_send_remove_branch(self):   dest = repo.Repo(os.path.join(self.gitroot, 'dest'))   dummy_commit = self.make_dummy_commit(dest)   dest.refs['refs/heads/master'] = dummy_commit   dest.refs['refs/heads/abranch'] = dummy_commit   sendrefs = dict(dest.refs)   sendrefs['refs/heads/abranch'] = "00" * 20   del sendrefs['HEAD']   gen_pack = lambda have, want: []   c = self._client()   self.assertEqual(dest.refs["refs/heads/abranch"], dummy_commit)   c.send_pack(self._build_path('/dest'), lambda _: sendrefs, gen_pack)   self.assertFalse("refs/heads/abranch" in dest.refs)      class DulwichTCPClientTest(CompatTestCase, DulwichClientTestBase):     def setUp(self):   CompatTestCase.setUp(self)   DulwichClientTestBase.setUp(self)   if check_for_daemon(limit=1):   raise SkipTest('git-daemon was already running on port %s' %   protocol.TCP_GIT_PORT)   fd, self.pidfile = tempfile.mkstemp(prefix='dulwich-test-git-client',   suffix=".pid")   os.fdopen(fd).close()   run_git_or_fail(   ['daemon', '--verbose', '--export-all',   '--pid-file=%s' % self.pidfile, '--base-path=%s' % self.gitroot,   '--detach', '--reuseaddr', '--enable=receive-pack',   '--enable=upload-archive', '--listen=localhost', self.gitroot], cwd=self.gitroot)   if not check_for_daemon():   raise SkipTest('git-daemon failed to start')     def tearDown(self):   try:   os.kill(int(open(self.pidfile).read().strip()), signal.SIGKILL)   os.unlink(self.pidfile)   except (OSError, IOError):   pass   DulwichClientTestBase.tearDown(self)   CompatTestCase.tearDown(self)     def _client(self):   return client.TCPGitClient('localhost')     def _build_path(self, path):   return path      class TestSSHVendor(object):   @staticmethod   def connect_ssh(host, command, username=None, port=None):   cmd, path = command[0].replace("'", '').split(' ')   cmd = cmd.split('-', 1)   p = subprocess.Popen(cmd + [path], env=get_safe_env(), stdin=subprocess.PIPE,   stdout=subprocess.PIPE, stderr=subprocess.PIPE)   return client.SubprocessWrapper(p)      class DulwichMockSSHClientTest(CompatTestCase, DulwichClientTestBase):     def setUp(self):   CompatTestCase.setUp(self)   DulwichClientTestBase.setUp(self)   self.real_vendor = client.get_ssh_vendor   client.get_ssh_vendor = TestSSHVendor     def tearDown(self):   DulwichClientTestBase.tearDown(self)   CompatTestCase.tearDown(self)   client.get_ssh_vendor = self.real_vendor     def _client(self):   return client.SSHGitClient('localhost')     def _build_path(self, path):   return self.gitroot + path      class DulwichSubprocessClientTest(CompatTestCase, DulwichClientTestBase):     def setUp(self):   CompatTestCase.setUp(self)   DulwichClientTestBase.setUp(self)     def tearDown(self):   DulwichClientTestBase.tearDown(self)   CompatTestCase.tearDown(self)     def _client(self):   return client.SubprocessGitClient(stderr=subprocess.PIPE)     def _build_path(self, path):   return self.gitroot + path      class GitHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):   """HTTP Request handler that calls out to 'git http-backend'."""     # Make rfile unbuffered -- we need to read one line and then pass   # the rest to a subprocess, so we can't use buffered input.   rbufsize = 0     def do_POST(self):   self.run_backend()     def do_GET(self):   self.run_backend()     def send_head(self):   return self.run_backend()     def log_request(self, code='-', size='-'):   # Let's be quiet, the test suite is noisy enough already   pass     def run_backend(self):   """Call out to git http-backend."""   # Based on CGIHTTPServer.CGIHTTPRequestHandler.run_cgi:   # Copyright (c) 2001-2010 Python Software Foundation; All Rights Reserved   # Licensed under the Python Software Foundation License.   rest = self.path   # find an explicit query string, if present.   i = rest.rfind('?')   if i >= 0:   rest, query = rest[:i], rest[i+1:]   else:   query = ''     env = copy.deepcopy(os.environ)   env['SERVER_SOFTWARE'] = self.version_string()   env['SERVER_NAME'] = self.server.server_name   env['GATEWAY_INTERFACE'] = 'CGI/1.1'   env['SERVER_PROTOCOL'] = self.protocol_version   env['SERVER_PORT'] = str(self.server.server_port)   env['GIT_PROJECT_ROOT'] = self.server.root_path   env["GIT_HTTP_EXPORT_ALL"] = "1"   env['REQUEST_METHOD'] = self.command   uqrest = urllib.unquote(rest)   env['PATH_INFO'] = uqrest   env['SCRIPT_NAME'] = "/"   if query:   env['QUERY_STRING'] = query   host = self.address_string()   if host != self.client_address[0]:   env['REMOTE_HOST'] = host   env['REMOTE_ADDR'] = self.client_address[0]   authorization = self.headers.getheader("authorization")   if authorization:   authorization = authorization.split()   if len(authorization) == 2:   import base64, binascii   env['AUTH_TYPE'] = authorization[0]   if authorization[0].lower() == "basic":   try:   authorization = base64.decodestring(authorization[1])   except binascii.Error:   pass   else:   authorization = authorization.split(':')   if len(authorization) == 2:   env['REMOTE_USER'] = authorization[0]   # XXX REMOTE_IDENT   if self.headers.typeheader is None:   env['CONTENT_TYPE'] = self.headers.type   else:   env['CONTENT_TYPE'] = self.headers.typeheader   length = self.headers.getheader('content-length')   if length:   env['CONTENT_LENGTH'] = length   referer = self.headers.getheader('referer')   if referer:   env['HTTP_REFERER'] = referer   accept = []   for line in self.headers.getallmatchingheaders('accept'):   if line[:1] in "\t\n\r ":   accept.append(line.strip())   else:   accept = accept + line[7:].split(',')   env['HTTP_ACCEPT'] = ','.join(accept)   ua = self.headers.getheader('user-agent')   if ua:   env['HTTP_USER_AGENT'] = ua   co = filter(None, self.headers.getheaders('cookie'))   if co:   env['HTTP_COOKIE'] = ', '.join(co)   # XXX Other HTTP_* headers   # Since we're setting the env in the parent, provide empty   # values to override previously set values   for k in ('QUERY_STRING', 'REMOTE_HOST', 'CONTENT_LENGTH',   'HTTP_USER_AGENT', 'HTTP_COOKIE', 'HTTP_REFERER'):   env.setdefault(k, "")     self.send_response(200, "Script output follows")     decoded_query = query.replace('+', ' ')     try:   nbytes = int(length)   except (TypeError, ValueError):   nbytes = 0   if self.command.lower() == "post" and nbytes > 0:   data = self.rfile.read(nbytes)   else:   data = None   # throw away additional data [see bug #427345]   while select.select([self.rfile._sock], [], [], 0)[0]:   if not self.rfile._sock.recv(1):   break   args = ['http-backend']   if '=' not in decoded_query:   args.append(decoded_query)   stdout = run_git_or_fail(args, input=data, env=env, stderr=subprocess.PIPE)   self.wfile.write(stdout)      class HTTPGitServer(BaseHTTPServer.HTTPServer):     allow_reuse_address = True     def __init__(self, server_address, root_path):   BaseHTTPServer.HTTPServer.__init__(self, server_address, GitHTTPRequestHandler)   self.root_path = root_path + self.server_name = "localhost"     def get_url(self):   return 'http://%s:%s/' % (self.server_name, self.server_port)      if not getattr(HTTPGitServer, 'shutdown', None):   _HTTPGitServer = HTTPGitServer     class TCPGitServer(ShutdownServerMixIn, HTTPGitServer):   """Subclass of HTTPGitServer that can be shut down."""     def __init__(self, *args, **kwargs):   # BaseServer is old-style so we have to call both __init__s   ShutdownServerMixIn.__init__(self)   _HTTPGitServer.__init__(self, *args, **kwargs)      class DulwichHttpClientTest(CompatTestCase, DulwichClientTestBase):     min_git_version = (1, 7, 0, 2)     def setUp(self):   CompatTestCase.setUp(self)   DulwichClientTestBase.setUp(self)   self._httpd = HTTPGitServer(("localhost", 0), self.gitroot)   self.addCleanup(self._httpd.shutdown)   threading.Thread(target=self._httpd.serve_forever).start()   run_git_or_fail(['config', 'http.uploadpack', 'true'],   cwd=self.dest)   run_git_or_fail(['config', 'http.receivepack', 'true'],   cwd=self.dest)     def tearDown(self):   DulwichClientTestBase.tearDown(self)   CompatTestCase.tearDown(self)     def _client(self):   return client.HttpGitClient(self._httpd.get_url())     def _build_path(self, path):   return path     def test_archive(self):   raise SkipTest("exporting archives not supported over http")