def test_get_info_refs(self):
self._environ['QUERY_STRING'] = ''
blob1 = make_object(Blob, data=b'1')
blob2 = make_object(Blob, data=b'2')
blob3 = make_object(Blob, data=b'3')
tag1 = make_tag(blob2, name=b'tag-tag')
objects = [blob1, blob2, blob3, tag1]
refs = {
b'HEAD': b'000',
b'refs/heads/master': blob1.id,
b'refs/tags/tag-tag': tag1.id,
b'refs/tags/blob-tag': blob3.id,
}
backend = _test_backend(objects, refs=refs)
mat = re.search('.*', '//info/refs')
self.assertEqual([
blob1.id + b'\trefs/heads/master\n', blob3.id +
b'\trefs/tags/blob-tag\n', tag1.id + b'\trefs/tags/tag-tag\n',
blob2.id + b'\trefs/tags/tag-tag^{}\n'
], list(get_info_refs(self._req, backend, mat)))
self.assertEqual(HTTP_OK, self._status)
self.assertContentTypeEquals('text/plain')
self.assertFalse(self._req.cached)
def test_get_info_refs(self):
self._environ['QUERY_STRING'] = ''
blob1 = make_object(Blob, data='1')
blob2 = make_object(Blob, data='2')
blob3 = make_object(Blob, data='3')
tag1 = make_object(Tag, name='tag-tag',
tagger='Test <*****@*****.**>',
tag_time=12345,
tag_timezone=0,
message='message',
object=(Blob, blob2.id))
objects = [blob1, blob2, blob3, tag1]
refs = {
'HEAD': '000',
'refs/heads/master': blob1.id,
'refs/tags/tag-tag': tag1.id,
'refs/tags/blob-tag': blob3.id,
}
backend = _test_backend(objects, refs=refs)
mat = re.search('.*', '//info/refs')
self.assertEquals(['%s\trefs/heads/master\n' % blob1.id,
'%s\trefs/tags/blob-tag\n' % blob3.id,
'%s\trefs/tags/tag-tag\n' % tag1.id,
'%s\trefs/tags/tag-tag^{}\n' % blob2.id],
list(get_info_refs(self._req, backend, mat)))
self.assertEquals(HTTP_OK, self._status)
self.assertContentTypeEquals('text/plain')
self.assertFalse(self._req.cached)
def test_get_info_refs(self):
self._environ['QUERY_STRING'] = ''
blob1 = make_object(Blob, data=b'1')
blob2 = make_object(Blob, data=b'2')
blob3 = make_object(Blob, data=b'3')
tag1 = make_tag(blob2, name=b'tag-tag')
objects = [blob1, blob2, blob3, tag1]
refs = {
b'HEAD': b'000',
b'refs/heads/master': blob1.id,
b'refs/tags/tag-tag': tag1.id,
b'refs/tags/blob-tag': blob3.id,
}
backend = _test_backend(objects, refs=refs)
mat = re.search('.*', '//info/refs')
self.assertEqual([blob1.id + b'\trefs/heads/master\n',
blob3.id + b'\trefs/tags/blob-tag\n',
tag1.id + b'\trefs/tags/tag-tag\n',
blob2.id + b'\trefs/tags/tag-tag^{}\n'],
list(get_info_refs(self._req, backend, mat)))
self.assertEqual(HTTP_OK, self._status)
self.assertContentTypeEquals('text/plain')
self.assertFalse(self._req.cached)
def test_get_info_refs(self):
self._environ["QUERY_STRING"] = ""
blob1 = make_object(Blob, data=b"1")
blob2 = make_object(Blob, data=b"2")
blob3 = make_object(Blob, data=b"3")
tag1 = make_tag(blob2, name=b"tag-tag")
objects = [blob1, blob2, blob3, tag1]
refs = {
b"HEAD": b"000",
b"refs/heads/master": blob1.id,
b"refs/tags/tag-tag": tag1.id,
b"refs/tags/blob-tag": blob3.id,
}
backend = _test_backend(objects, refs=refs)
mat = re.search(".*", "//info/refs")
self.assertEqual(
[
blob1.id + b"\trefs/heads/master\n",
blob3.id + b"\trefs/tags/blob-tag\n",
tag1.id + b"\trefs/tags/tag-tag\n",
blob2.id + b"\trefs/tags/tag-tag^{}\n",
],
list(get_info_refs(self._req, backend, mat)),
)
self.assertEqual(HTTP_OK, self._status)
self.assertContentTypeEquals("text/plain")
self.assertFalse(self._req.cached)
def test_get_info_refs(self):
self._environ["wsgi.input"] = BytesIO(b"foo")
self._environ["QUERY_STRING"] = "service=git-upload-pack"
class Backend(object):
def open_repository(self, url):
return None
mat = re.search(".*", "/git-upload-pack")
handler_output = b"".join(get_info_refs(self._req, Backend(), mat))
write_output = self._output.getvalue()
self.assertEqual(
(
b"001e# service=git-upload-pack\n"
b"0000"
# input is ignored by the handler
b"handled input: "
),
write_output,
)
# Ensure all output was written via the write callback.
self.assertEqual(b"", handler_output)
self.assertTrue(self._handler.advertise_refs)
self.assertTrue(self._handler.stateless_rpc)
self.assertFalse(self._req.cached)
def test_get_info_refs(self):
self._environ['QUERY_STRING'] = ''
blob1 = make_object(Blob, data='1')
blob2 = make_object(Blob, data='2')
blob3 = make_object(Blob, data='3')
tag1 = make_object(Tag, name='tag-tag',
tagger='Test <*****@*****.**>',
tag_time=12345,
tag_timezone=0,
message='message',
object=(Blob, blob2.id))
objects = [blob1, blob2, blob3, tag1]
refs = {
'HEAD': '000',
'refs/heads/master': blob1.id,
'refs/tags/tag-tag': tag1.id,
'refs/tags/blob-tag': blob3.id,
}
backend = _test_backend(objects, refs=refs)
mat = re.search('.*', '//info/refs')
self.assertEquals(['%s\trefs/heads/master\n' % blob1.id,
'%s\trefs/tags/blob-tag\n' % blob3.id,
'%s\trefs/tags/tag-tag\n' % tag1.id,
'%s\trefs/tags/tag-tag^{}\n' % blob2.id],
list(get_info_refs(self._req, backend, mat)))
self.assertEquals(HTTP_OK, self._status)
self.assertContentTypeEquals('text/plain')
self.assertFalse(self._req.cached)
def test_get_info_refs(self):
self._environ['QUERY_STRING'] = ''
class TestTag(object):
def __init__(self, sha, obj_class, obj_sha):
self.sha = lambda: sha
self.object = (obj_class, obj_sha)
class TestBlob(object):
def __init__(self, sha):
self.sha = lambda: sha
blob1 = TestBlob('111')
blob2 = TestBlob('222')
blob3 = TestBlob('333')
tag1 = TestTag('aaa', Blob, '222')
class TestRepo(object):
def __init__(self, objects, peeled):
self._objects = dict((o.sha(), o) for o in objects)
self._peeled = peeled
def get_peeled(self, sha):
return self._peeled[sha]
def __getitem__(self, sha):
return self._objects[sha]
def get_refs(self):
return {
'HEAD': '000',
'refs/heads/master': blob1.sha(),
'refs/tags/tag-tag': tag1.sha(),
'refs/tags/blob-tag': blob3.sha(),
}
class TestBackend(object):
def __init__(self):
objects = [blob1, blob2, blob3, tag1]
self.repo = TestRepo(objects, {
'HEAD': '000',
'refs/heads/master': blob1.sha(),
'refs/tags/tag-tag': blob2.sha(),
'refs/tags/blob-tag': blob3.sha(),
})
def open_repository(self, path):
assert path == '/'
return self.repo
mat = re.search('.*', '//info/refs')
self.assertEquals(['111\trefs/heads/master\n',
'333\trefs/tags/blob-tag\n',
'aaa\trefs/tags/tag-tag\n',
'222\trefs/tags/tag-tag^{}\n'],
list(get_info_refs(self._req, TestBackend(), mat)))
def test_get_info_refs_unknown(self):
self._environ['QUERY_STRING'] = 'service=git-evil-handler'
class Backend(object):
def open_repository(self, url):
return None
mat = re.search('.*', '/git-evil-pack')
content = list(get_info_refs(self._req, Backend(), mat))
self.assertFalse(b'git-evil-handler' in b"".join(content))
self.assertEqual(HTTP_FORBIDDEN, self._status)
self.assertFalse(self._req.cached)
def test_get_info_refs_unknown(self):
self._environ["QUERY_STRING"] = "service=git-evil-handler"
class Backend(object):
def open_repository(self, url):
return None
mat = re.search(".*", "/git-evil-pack")
content = list(get_info_refs(self._req, Backend(), mat))
self.assertNotIn(b"git-evil-handler", b"".join(content))
self.assertEqual(HTTP_FORBIDDEN, self._status)
self.assertFalse(self._req.cached)
def test_get_info_refs_unknown(self):
self._environ['QUERY_STRING'] = 'service=git-evil-handler'
class Backend(object):
def open_repository(self, url):
return None
mat = re.search('.*', '/git-evil-pack')
content = list(get_info_refs(self._req, Backend(), mat))
self.assertFalse(b'git-evil-handler' in b"".join(content))
self.assertEqual(HTTP_FORBIDDEN, self._status)
self.assertFalse(self._req.cached)
def test_get_info_refs(self):
self._environ['wsgi.input'] = StringIO('foo')
self._environ['QUERY_STRING'] = 'service=git-upload-pack'
output = ''.join(get_info_refs(self._req, 'backend', None,
services=self.services()))
self.assertEquals(('pkt-line: # service=git-upload-pack\n'
'flush-pkt\n'
# input is ignored by the handler
'handled input: '), output)
self.assertTrue(self._handler.advertise_refs)
self.assertTrue(self._handler.stateless_rpc)
def test_get_info_refs_not_found(self):
self._environ['QUERY_STRING'] = ''
objects = []
refs = {}
backend = _test_backend(objects, refs=refs)
mat = re.search('info/refs', '/foo/info/refs')
self.assertEqual([b'No git repository was found at /foo'],
list(get_info_refs(self._req, backend, mat)))
self.assertEqual(HTTP_NOT_FOUND, self._status)
self.assertContentTypeEquals('text/plain')
def test_get_info_refs(self):
self._environ['wsgi.input'] = StringIO('foo')
self._environ['QUERY_STRING'] = 'service=git-upload-pack'
mat = re.search('.*', '/git-upload-pack')
output = ''.join(get_info_refs(self._req, 'backend', mat,
services=self.services()))
self.assertEquals(('001e# service=git-upload-pack\n'
'0000'
# input is ignored by the handler
'handled input: '), output)
self.assertTrue(self._handler.advertise_refs)
self.assertTrue(self._handler.stateless_rpc)
def test_get_info_refs_not_found(self):
self._environ['QUERY_STRING'] = ''
objects = []
refs = {}
backend = _test_backend(objects, refs=refs)
mat = re.search('info/refs', '/foo/info/refs')
self.assertEqual(
[b'No git repository was found at /foo'],
list(get_info_refs(self._req, backend, mat)))
self.assertEqual(HTTP_NOT_FOUND, self._status)
self.assertContentTypeEquals('text/plain')
def test_get_info_refs_not_found(self):
self._environ["QUERY_STRING"] = ""
objects = []
refs = {}
backend = _test_backend(objects, refs=refs)
mat = re.search("info/refs", "/foo/info/refs")
self.assertEqual(
[b"No git repository was found at /foo"],
list(get_info_refs(self._req, backend, mat)),
)
self.assertEqual(HTTP_NOT_FOUND, self._status)
self.assertContentTypeEquals("text/plain")
def test_get_info_refs(self):
self._environ['wsgi.input'] = StringIO('foo')
self._environ['QUERY_STRING'] = 'service=git-upload-pack'
mat = re.search('.*', '/git-upload-pack')
handler_output = ''.join(get_info_refs(self._req, 'backend', mat))
write_output = self._output.getvalue()
self.assertEquals(('001e# service=git-upload-pack\n'
'0000'
# input is ignored by the handler
'handled input: '), write_output)
# Ensure all output was written via the write callback.
self.assertEquals('', handler_output)
self.assertTrue(self._handler.advertise_refs)
self.assertTrue(self._handler.http_req)
self.assertFalse(self._req.cached)
def test_get_info_refs(self):
self._environ['wsgi.input'] = StringIO('foo')
self._environ['QUERY_STRING'] = 'service=git-upload-pack'
mat = re.search('.*', '/git-upload-pack')
handler_output = ''.join(get_info_refs(self._req, 'backend', mat))
write_output = self._output.getvalue()
self.assertEquals(('001e# service=git-upload-pack\n'
'0000'
# input is ignored by the handler
'handled input: '), write_output)
# Ensure all output was written via the write callback.
self.assertEquals('', handler_output)
self.assertTrue(self._handler.advertise_refs)
self.assertTrue(self._handler.http_req)
self.assertFalse(self._req.cached)
def test_get_info_refs(self):
self._environ['QUERY_STRING'] = ''
class TestTag(object):
type = Tag().type
def __init__(self, sha, obj_type, obj_sha):
self.sha = lambda: sha
self.object = (obj_type, obj_sha)
class TestBlob(object):
type = Blob().type
def __init__(self, sha):
self.sha = lambda: sha
blob1 = TestBlob('111')
blob2 = TestBlob('222')
blob3 = TestBlob('333')
tag1 = TestTag('aaa', TestTag.type, 'bbb')
tag2 = TestTag('bbb', TestBlob.type, '222')
class TestBackend(object):
def __init__(self):
objects = [blob1, blob2, blob3, tag1, tag2]
self.repo = dict((o.sha(), o) for o in objects)
def get_refs(self):
return {
'HEAD': '000',
'refs/heads/master': blob1.sha(),
'refs/tags/tag-tag': tag1.sha(),
'refs/tags/blob-tag': blob3.sha(),
}
self.assertEquals(['111\trefs/heads/master\n',
'333\trefs/tags/blob-tag\n',
'aaa\trefs/tags/tag-tag\n',
'222\trefs/tags/tag-tag^{}\n'],
list(get_info_refs(self._req, TestBackend(), None)))
def test_get_info_refs(self):
self._environ['wsgi.input'] = BytesIO(b'foo')
self._environ['QUERY_STRING'] = 'service=git-upload-pack'
class Backend(object):
def open_repository(self, url):
return None
mat = re.search('.*', '/git-upload-pack')
handler_output = b''.join(get_info_refs(self._req, Backend(), mat))
write_output = self._output.getvalue()
self.assertEqual((b'001e# service=git-upload-pack\n'
b'0000'
# input is ignored by the handler
b'handled input: '), write_output)
# Ensure all output was written via the write callback.
self.assertEqual(b'', handler_output)
self.assertTrue(self._handler.advertise_refs)
self.assertTrue(self._handler.http_req)
self.assertFalse(self._req.cached)
def test_get_info_refs(self):
self._environ["wsgi.input"] = StringIO("foo")
self._environ["QUERY_STRING"] = "service=git-upload-pack"
mat = re.search(".*", "/git-upload-pack")
handler_output = "".join(get_info_refs(self._req, "backend", mat))
write_output = self._output.getvalue()
self.assertEquals(
(
"001e# service=git-upload-pack\n"
"0000"
# input is ignored by the handler
"handled input: "
),
write_output,
)
# Ensure all output was written via the write callback.
self.assertEquals("", handler_output)
self.assertTrue(self._handler.advertise_refs)
self.assertTrue(self._handler.http_req)
self.assertFalse(self._req.cached)
def test_get_info_refs(self):
self._environ["QUERY_STRING"] = ""
blob1 = make_object(Blob, data="1")
blob2 = make_object(Blob, data="2")
blob3 = make_object(Blob, data="3")
tag1 = make_object(
Tag,
name="tag-tag",
tagger="Test <*****@*****.**>",
tag_time=12345,
tag_timezone=0,
message="message",
object=(Blob, blob2.id),
)
objects = [blob1, blob2, blob3, tag1]
refs = {
"HEAD": "000",
"refs/heads/master": blob1.id,
"refs/tags/tag-tag": tag1.id,
"refs/tags/blob-tag": blob3.id,
}
backend = _test_backend(objects, refs=refs)
mat = re.search(".*", "//info/refs")
self.assertEquals(
[
"%s\trefs/heads/master\n" % blob1.id,
"%s\trefs/tags/blob-tag\n" % blob3.id,
"%s\trefs/tags/tag-tag\n" % tag1.id,
"%s\trefs/tags/tag-tag^{}\n" % blob2.id,
],
list(get_info_refs(self._req, backend, mat)),
)
self.assertEquals(HTTP_OK, self._status)
self.assertContentTypeEquals("text/plain")
self.assertFalse(self._req.cached)
def test_get_info_refs(self):
self._environ['wsgi.input'] = BytesIO(b'foo')
self._environ['QUERY_STRING'] = 'service=git-upload-pack'
class Backend(object):
def open_repository(self, url):
return None
mat = re.search('.*', '/git-upload-pack')
handler_output = b''.join(get_info_refs(self._req, Backend(), mat))
write_output = self._output.getvalue()
self.assertEqual(
(
b'001e# service=git-upload-pack\n'
b'0000'
# input is ignored by the handler
b'handled input: '),
write_output)
# Ensure all output was written via the write callback.
self.assertEqual(b'', handler_output)
self.assertTrue(self._handler.advertise_refs)
self.assertTrue(self._handler.stateless_rpc)
self.assertFalse(self._req.cached)
def test_get_info_refs_unknown(self):
self._environ['QUERY_STRING'] = 'service=git-evil-handler'
list(get_info_refs(self._req, 'backend', None))
self.assertEquals(HTTP_FORBIDDEN, self._status)
self.assertFalse(self._req.cached)
def test_get_info_refs_unknown(self):
self._environ['QUERY_STRING'] = 'service=git-evil-handler'
list(get_info_refs(self._req, 'backend', None))
self.assertEquals(HTTP_FORBIDDEN, self._status)
self.assertFalse(self._req.cached)
