)
from dulwich.objects import (
hex_to_sha,
+ git_line,
)
from dulwich.file import (
GitFile,
ensure_dir_exists,
)
+from dulwich._py3_compat import (
+ iterbytes,
+ items,
+ keys,
+ )
-SYMREF = 'ref: '
-LOCAL_BRANCH_PREFIX = 'refs/heads/'
+SYMREF = b'ref: '
+LOCAL_BRANCH_PREFIX = b'refs/heads/'
+BAD_REF_CHARS = set(iterbytes(b'\177 ~^:?*['))
def check_ref_format(refname):
"""
# These could be combined into one big expression, but are listed separately
# to parallel [1].
- if '/.' in refname or refname.startswith('.'):
+ if b'/.' in refname or refname.startswith(b'.'):
return False
- if '/' not in refname:
+ if b'/' not in refname:
return False
- if '..' in refname:
+ if b'..' in refname:
return False
- for c in refname:
- if ord(c) < 0o40 or c in '\177 ~^:?*[':
+ for c in iterbytes(refname):
+ if c < 0o40 or c in BAD_REF_CHARS:
return False
- if refname[-1] in '/.':
+ if refname[-1] in b'/.':
return False
- if refname.endswith('.lock'):
+ if refname.endswith(b'.lock'):
return False
- if '@{' in refname:
+ if b'@{' in refname:
return False
- if '\\' in refname:
+ if b'\\' in refname:
return False
return True
return None
def import_refs(self, base, other):
- for name, value in other.iteritems():
- self["%s/%s" % (base, name)] = value
+ for name, value in items(other):
+ self[b'/'.join((base, name))] = value
def allkeys(self):
"""All refs present in this container."""
ret = {}
keys = self.keys(base)
if base is None:
- base = ""
+ base = b''
for key in keys:
try:
- ret[key] = self[("%s/%s" % (base, key)).strip("/")]
+ ret[key] = self[(base + b'/' + key).strip(b'/')]
except KeyError:
continue # Unable to resolve
:param name: The name of the reference.
:raises KeyError: if a refname is not HEAD or is otherwise not valid.
"""
- if name in ('HEAD', 'refs/stash'):
+ if name in (b'HEAD', b'refs/stash'):
return
- if not name.startswith('refs/') or not check_ref_format(name[5:]):
+ if not name.startswith(b'refs/') or not check_ref_format(name[5:]):
raise RefFormatError(name)
def read_ref(self, refname):
self._refs = {}
self._peeled = {}
for l in f.readlines():
- sha, name = l.rstrip("\n").split("\t")
- if name.endswith("^{}"):
+ sha, name = l.rstrip(b'\n').split(b'\t')
+ if name.endswith(b'^{}'):
name = name[:-3]
if not check_ref_format(name):
- raise ValueError("invalid ref name '%s'" % name)
+ raise ValueError("invalid ref name %r" % name)
self._peeled[name] = sha
else:
if not check_ref_format(name):
- raise ValueError("invalid ref name '%s'" % name)
+ raise ValueError("invalid ref name %r" % name)
self._refs[name] = sha
def allkeys(self):
return "%s(%r)" % (self.__class__.__name__, self.path)
def subkeys(self, base):
- keys = set()
+ subkeys = set()
path = self.refpath(base)
for root, dirs, files in os.walk(path):
dir = root[len(path):].strip(os.path.sep).replace(os.path.sep, "/")
for filename in files:
- refname = ("%s/%s" % (dir, filename)).strip("/")
+ refname = (("%s/%s" % (dir, filename))
+ .strip("/").encode('ascii'))
# check_ref_format requires at least one /, so we prepend the
# base before calling it.
- if check_ref_format("%s/%s" % (base, refname)):
- keys.add(refname)
+ if check_ref_format(base + b'/' + refname):
+ subkeys.add(refname)
for key in self.get_packed_refs():
if key.startswith(base):
- keys.add(key[len(base):].strip("/"))
- return keys
+ subkeys.add(key[len(base):].strip(b'/'))
+ return subkeys
def allkeys(self):
- keys = set()
- if os.path.exists(self.refpath("HEAD")):
- keys.add("HEAD")
- path = self.refpath("")
- for root, dirs, files in os.walk(self.refpath("refs")):
+ allkeys = set()
+ if os.path.exists(self.refpath(b'HEAD')):
+ allkeys.add(b'HEAD')
+ path = self.refpath(b'')
+ for root, dirs, files in os.walk(self.refpath(b'refs')):
dir = root[len(path):].strip(os.path.sep).replace(os.path.sep, "/")
for filename in files:
- refname = ("%s/%s" % (dir, filename)).strip("/")
+ refname = ("%s/%s" % (dir, filename)).strip("/").encode('ascii')
if check_ref_format(refname):
- keys.add(refname)
- keys.update(self.get_packed_refs())
- return keys
+ allkeys.add(refname)
+ allkeys.update(self.get_packed_refs())
+ return allkeys
def refpath(self, name):
"""Return the disk path of a ref.
"""
+ name = name.decode('ascii')
if os.path.sep != "/":
name = name.replace("/", os.path.sep)
return os.path.join(self.path, name)
raise
with f:
first_line = next(iter(f)).rstrip()
- if (first_line.startswith("# pack-refs") and " peeled" in
+ if (first_line.startswith(b'# pack-refs') and b' peeled' in
first_line):
for sha, name, peeled in read_packed_refs_with_peeled(f):
self._packed_refs[name] = sha
header = f.read(len(SYMREF))
if header == SYMREF:
# Read only the first line
- return header + next(iter(f)).rstrip("\r\n")
+ return header + next(iter(f)).rstrip(b'\r\n')
else:
# Read only the first 40 bytes
return header + f.read(40 - len(SYMREF))
try:
f = GitFile(filename, 'wb')
try:
- f.write(SYMREF + other + '\n')
+ f.write(SYMREF + other + b'\n')
except (IOError, OSError):
f.abort()
raise
f.abort()
raise
try:
- f.write(new_ref + "\n")
+ f.write(new_ref + b'\n')
except (OSError, IOError):
f.abort()
raise
f.abort()
return False
try:
- f.write(ref + "\n")
+ f.write(ref + b'\n')
except (OSError, IOError):
f.abort()
raise
def _split_ref_line(line):
"""Split a single ref line into a tuple of SHA1 and name."""
- fields = line.rstrip("\n").split(" ")
+ fields = line.rstrip(b'\n').split(b' ')
if len(fields) != 2:
- raise PackedRefsException("invalid ref line '%s'" % line)
+ raise PackedRefsException("invalid ref line %r" % line)
sha, name = fields
try:
hex_to_sha(sha)
except (AssertionError, TypeError) as e:
raise PackedRefsException(e)
if not check_ref_format(name):
- raise PackedRefsException("invalid ref name '%s'" % name)
+ raise PackedRefsException("invalid ref name %r" % name)
return (sha, name)
:return: Iterator over tuples with SHA1s and ref names.
"""
for l in f:
- if l[0] == "#":
+ if l.startswith(b'#'):
# Comment
continue
- if l[0] == "^":
+ if l.startswith(b'^'):
raise PackedRefsException(
"found peeled ref in packed-refs without peeled")
yield _split_ref_line(l)
"""
last = None
for l in f:
- if l[0] == "#":
+ if l[0] == b'#':
continue
- l = l.rstrip("\r\n")
- if l[0] == "^":
+ l = l.rstrip(b'\r\n')
+ if l.startswith(b'^'):
if not last:
raise PackedRefsException("unexpected peeled ref line")
try:
if peeled_refs is None:
peeled_refs = {}
else:
- f.write('# pack-refs with: peeled\n')
- for refname in sorted(packed_refs.iterkeys()):
- f.write('%s %s\n' % (packed_refs[refname], refname))
+ f.write(b'# pack-refs with: peeled\n')
+ for refname in sorted(keys(packed_refs)):
+ f.write(git_line(packed_refs[refname], refname))
if refname in peeled_refs:
- f.write('^%s\n' % peeled_refs[refname])
+ f.write(b'^' + peeled_refs[refname] + b'\n')
def read_info_refs(f):
for name, sha in sorted(refs.items()):
# get_refs() includes HEAD as a special case, but we don't want to
# advertise it
- if name == 'HEAD':
+ if name == b'HEAD':
continue
try:
o = store[sha]
except KeyError:
continue
peeled = store.peel_sha(sha)
- yield '%s\t%s\n' % (o.id, name)
+ yield o.id + b'\t' + name + b'\n'
if o.id != peeled.id:
- yield '%s\t%s^{}\n' % (peeled.id, name)
+ yield peeled.id + b'\t' + name + b'^{}\n'
-is_local_branch = lambda x: x.startswith("refs/heads/")
+is_local_branch = lambda x: x.startswith(b'refs/heads/')
"""
def test_valid(self):
- self.assertTrue(check_ref_format('heads/foo'))
- self.assertTrue(check_ref_format('foo/bar/baz'))
- self.assertTrue(check_ref_format('refs///heads/foo'))
- self.assertTrue(check_ref_format('foo./bar'))
- self.assertTrue(check_ref_format('heads/foo@bar'))
- self.assertTrue(check_ref_format('heads/fix.lock.error'))
+ self.assertTrue(check_ref_format(b'heads/foo'))
+ self.assertTrue(check_ref_format(b'foo/bar/baz'))
+ self.assertTrue(check_ref_format(b'refs///heads/foo'))
+ self.assertTrue(check_ref_format(b'foo./bar'))
+ self.assertTrue(check_ref_format(b'heads/foo@bar'))
+ self.assertTrue(check_ref_format(b'heads/fix.lock.error'))
def test_invalid(self):
- self.assertFalse(check_ref_format('foo'))
- self.assertFalse(check_ref_format('heads/foo/'))
- self.assertFalse(check_ref_format('./foo'))
- self.assertFalse(check_ref_format('.refs/foo'))
- self.assertFalse(check_ref_format('heads/foo..bar'))
- self.assertFalse(check_ref_format('heads/foo?bar'))
- self.assertFalse(check_ref_format('heads/foo.lock'))
- self.assertFalse(check_ref_format('heads/v@{ation'))
- self.assertFalse(check_ref_format('heads/foo\bar'))
-
-
-ONES = "1" * 40
-TWOS = "2" * 40
-THREES = "3" * 40
-FOURS = "4" * 40
-
-@skipIfPY3
+ self.assertFalse(check_ref_format(b'foo'))
+ self.assertFalse(check_ref_format(b'heads/foo/'))
+ self.assertFalse(check_ref_format(b'./foo'))
+ self.assertFalse(check_ref_format(b'.refs/foo'))
+ self.assertFalse(check_ref_format(b'heads/foo..bar'))
+ self.assertFalse(check_ref_format(b'heads/foo?bar'))
+ self.assertFalse(check_ref_format(b'heads/foo.lock'))
+ self.assertFalse(check_ref_format(b'heads/v@{ation'))
+ self.assertFalse(check_ref_format(b'heads/foo\bar'))
+
+
+ONES = b'1' * 40
+TWOS = b'2' * 40
+THREES = b'3' * 40
+FOURS = b'4' * 40
+
class PackedRefsFileTests(TestCase):
def test_split_ref_line_errors(self):
self.assertRaises(errors.PackedRefsException, _split_ref_line,
- 'singlefield')
+ b'singlefield')
self.assertRaises(errors.PackedRefsException, _split_ref_line,
- 'badsha name')
+ b'badsha name')
self.assertRaises(errors.PackedRefsException, _split_ref_line,
- '%s bad/../refname' % ONES)
+ ONES + b' bad/../refname')
def test_read_without_peeled(self):
- f = BytesIO('# comment\n%s ref/1\n%s ref/2' % (ONES, TWOS))
- self.assertEqual([(ONES, 'ref/1'), (TWOS, 'ref/2')],
+ f = BytesIO(b'\n'.join([
+ b'# comment',
+ ONES + b' ref/1',
+ TWOS + b' ref/2']))
+ self.assertEqual([(ONES, b'ref/1'), (TWOS, b'ref/2')],
list(read_packed_refs(f)))
def test_read_without_peeled_errors(self):
- f = BytesIO('%s ref/1\n^%s' % (ONES, TWOS))
+ f = BytesIO(b'\n'.join([
+ ONES + b' ref/1',
+ b'^' + TWOS]))
self.assertRaises(errors.PackedRefsException, list, read_packed_refs(f))
def test_read_with_peeled(self):
- f = BytesIO('%s ref/1\n%s ref/2\n^%s\n%s ref/4' % (
- ONES, TWOS, THREES, FOURS))
+ f = BytesIO(b'\n'.join([
+ ONES + b' ref/1',
+ TWOS + b' ref/2',
+ b'^' + THREES,
+ FOURS + b' ref/4']))
self.assertEqual([
- (ONES, 'ref/1', None),
- (TWOS, 'ref/2', THREES),
- (FOURS, 'ref/4', None),
- ], list(read_packed_refs_with_peeled(f)))
+ (ONES, b'ref/1', None),
+ (TWOS, b'ref/2', THREES),
+ (FOURS, b'ref/4', None),
+ ], list(read_packed_refs_with_peeled(f)))
def test_read_with_peeled_errors(self):
- f = BytesIO('^%s\n%s ref/1' % (TWOS, ONES))
+ f = BytesIO(b'\n'.join([
+ b'^' + TWOS,
+ ONES + b' ref/1']))
self.assertRaises(errors.PackedRefsException, list, read_packed_refs(f))
- f = BytesIO('%s ref/1\n^%s\n^%s' % (ONES, TWOS, THREES))
+ f = BytesIO(b'\n'.join([
+ ONES + b' ref/1',
+ b'^' + TWOS,
+ b'^' + THREES]))
self.assertRaises(errors.PackedRefsException, list, read_packed_refs(f))
def test_write_with_peeled(self):
f = BytesIO()
- write_packed_refs(f, {'ref/1': ONES, 'ref/2': TWOS},
- {'ref/1': THREES})
+ write_packed_refs(f, {b'ref/1': ONES, b'ref/2': TWOS},
+ {b'ref/1': THREES})
self.assertEqual(
- "# pack-refs with: peeled\n%s ref/1\n^%s\n%s ref/2\n" % (
- ONES, THREES, TWOS), f.getvalue())
+ b'\n'.join([b'# pack-refs with: peeled',
+ ONES + b' ref/1',
+ b'^' + THREES,
+ TWOS + b' ref/2']) + b'\n',
+ f.getvalue())
def test_write_without_peeled(self):
f = BytesIO()
- write_packed_refs(f, {'ref/1': ONES, 'ref/2': TWOS})
- self.assertEqual("%s ref/1\n%s ref/2\n" % (ONES, TWOS), f.getvalue())
+ write_packed_refs(f, {b'ref/1': ONES, b'ref/2': TWOS})
+ self.assertEqual(b'\n'.join([ONES + b' ref/1',
+ TWOS + b' ref/2']) + b'\n',
+ f.getvalue())
# Dict of refs that we expect all RefsContainerTests subclasses to define.
_TEST_REFS = {
- 'HEAD': '42d06bd4b77fed026b154d16493e5deab78f02ec',
- 'refs/heads/40-char-ref-aaaaaaaaaaaaaaaaaa': '42d06bd4b77fed026b154d16493e5deab78f02ec',
- 'refs/heads/master': '42d06bd4b77fed026b154d16493e5deab78f02ec',
- 'refs/heads/packed': '42d06bd4b77fed026b154d16493e5deab78f02ec',
- 'refs/tags/refs-0.1': 'df6800012397fb85c56e7418dd4eb9405dee075c',
- 'refs/tags/refs-0.2': '3ec9c43c84ff242e3ef4a9fc5bc111fd780a76a8',
- }
+ b'HEAD': b'42d06bd4b77fed026b154d16493e5deab78f02ec',
+ b'refs/heads/40-char-ref-aaaaaaaaaaaaaaaaaa': b'42d06bd4b77fed026b154d16493e5deab78f02ec',
+ b'refs/heads/master': b'42d06bd4b77fed026b154d16493e5deab78f02ec',
+ b'refs/heads/packed': b'42d06bd4b77fed026b154d16493e5deab78f02ec',
+ b'refs/tags/refs-0.1': b'df6800012397fb85c56e7418dd4eb9405dee075c',
+ b'refs/tags/refs-0.2': b'3ec9c43c84ff242e3ef4a9fc5bc111fd780a76a8',
+ }
class RefsContainerTests(object):
actual_keys = set(self._refs.keys())
self.assertEqual(set(self._refs.allkeys()), actual_keys)
# ignore the symref loop if it exists
- actual_keys.discard('refs/heads/loop')
- self.assertEqual(set(_TEST_REFS.iterkeys()), actual_keys)
+ actual_keys.discard(b'refs/heads/loop')
+ self.assertEqual(set(_TEST_REFS.keys()), actual_keys)
- actual_keys = self._refs.keys('refs/heads')
- actual_keys.discard('loop')
+ actual_keys = self._refs.keys(b'refs/heads')
+ actual_keys.discard(b'loop')
self.assertEqual(
- ['40-char-ref-aaaaaaaaaaaaaaaaaa', 'master', 'packed'],
+ [b'40-char-ref-aaaaaaaaaaaaaaaaaa', b'master', b'packed'],
sorted(actual_keys))
- self.assertEqual(['refs-0.1', 'refs-0.2'],
- sorted(self._refs.keys('refs/tags')))
+ self.assertEqual([b'refs-0.1', b'refs-0.2'],
+ sorted(self._refs.keys(b'refs/tags')))
def test_as_dict(self):
# refs/heads/loop does not show up even if it exists
self.assertEqual(_TEST_REFS, self._refs.as_dict())
def test_setitem(self):
- self._refs['refs/some/ref'] = '42d06bd4b77fed026b154d16493e5deab78f02ec'
- self.assertEqual('42d06bd4b77fed026b154d16493e5deab78f02ec',
- self._refs['refs/some/ref'])
- self.assertRaises(errors.RefFormatError, self._refs.__setitem__,
- 'notrefs/foo', '42d06bd4b77fed026b154d16493e5deab78f02ec')
+ self._refs[b'refs/some/ref'] = b'42d06bd4b77fed026b154d16493e5deab78f02ec'
+ self.assertEqual(b'42d06bd4b77fed026b154d16493e5deab78f02ec',
+ self._refs[b'refs/some/ref'])
+ self.assertRaises(
+ errors.RefFormatError, self._refs.__setitem__,
+ b'notrefs/foo', b'42d06bd4b77fed026b154d16493e5deab78f02ec')
def test_set_if_equals(self):
- nines = '9' * 40
- self.assertFalse(self._refs.set_if_equals('HEAD', 'c0ffee', nines))
- self.assertEqual('42d06bd4b77fed026b154d16493e5deab78f02ec',
- self._refs['HEAD'])
+ nines = b'9' * 40
+ self.assertFalse(self._refs.set_if_equals(b'HEAD', b'c0ffee', nines))
+ self.assertEqual(b'42d06bd4b77fed026b154d16493e5deab78f02ec',
+ self._refs[b'HEAD'])
self.assertTrue(self._refs.set_if_equals(
- 'HEAD', '42d06bd4b77fed026b154d16493e5deab78f02ec', nines))
- self.assertEqual(nines, self._refs['HEAD'])
+ b'HEAD', b'42d06bd4b77fed026b154d16493e5deab78f02ec', nines))
+ self.assertEqual(nines, self._refs[b'HEAD'])
- self.assertTrue(self._refs.set_if_equals('refs/heads/master', None,
+ self.assertTrue(self._refs.set_if_equals(b'refs/heads/master', None,
nines))
- self.assertEqual(nines, self._refs['refs/heads/master'])
+ self.assertEqual(nines, self._refs[b'refs/heads/master'])
def test_add_if_new(self):
- nines = '9' * 40
- self.assertFalse(self._refs.add_if_new('refs/heads/master', nines))
- self.assertEqual('42d06bd4b77fed026b154d16493e5deab78f02ec',
- self._refs['refs/heads/master'])
+ nines = b'9' * 40
+ self.assertFalse(self._refs.add_if_new(b'refs/heads/master', nines))
+ self.assertEqual(b'42d06bd4b77fed026b154d16493e5deab78f02ec',
+ self._refs[b'refs/heads/master'])
- self.assertTrue(self._refs.add_if_new('refs/some/ref', nines))
- self.assertEqual(nines, self._refs['refs/some/ref'])
+ self.assertTrue(self._refs.add_if_new(b'refs/some/ref', nines))
+ self.assertEqual(nines, self._refs[b'refs/some/ref'])
def test_set_symbolic_ref(self):
- self._refs.set_symbolic_ref('refs/heads/symbolic', 'refs/heads/master')
- self.assertEqual('ref: refs/heads/master',
- self._refs.read_loose_ref('refs/heads/symbolic'))
- self.assertEqual('42d06bd4b77fed026b154d16493e5deab78f02ec',
- self._refs['refs/heads/symbolic'])
+ self._refs.set_symbolic_ref(b'refs/heads/symbolic',
+ b'refs/heads/master')
+ self.assertEqual(b'ref: refs/heads/master',
+ self._refs.read_loose_ref(b'refs/heads/symbolic'))
+ self.assertEqual(b'42d06bd4b77fed026b154d16493e5deab78f02ec',
+ self._refs[b'refs/heads/symbolic'])
def test_set_symbolic_ref_overwrite(self):
- nines = '9' * 40
- self.assertFalse('refs/heads/symbolic' in self._refs)
- self._refs['refs/heads/symbolic'] = nines
- self.assertEqual(nines, self._refs.read_loose_ref('refs/heads/symbolic'))
- self._refs.set_symbolic_ref('refs/heads/symbolic', 'refs/heads/master')
- self.assertEqual('ref: refs/heads/master',
- self._refs.read_loose_ref('refs/heads/symbolic'))
- self.assertEqual('42d06bd4b77fed026b154d16493e5deab78f02ec',
- self._refs['refs/heads/symbolic'])
+ nines = b'9' * 40
+ self.assertFalse(b'refs/heads/symbolic' in self._refs)
+ self._refs[b'refs/heads/symbolic'] = nines
+ self.assertEqual(nines,
+ self._refs.read_loose_ref(b'refs/heads/symbolic'))
+ self._refs.set_symbolic_ref(b'refs/heads/symbolic',
+ b'refs/heads/master')
+ self.assertEqual(b'ref: refs/heads/master',
+ self._refs.read_loose_ref(b'refs/heads/symbolic'))
+ self.assertEqual(b'42d06bd4b77fed026b154d16493e5deab78f02ec',
+ self._refs[b'refs/heads/symbolic'])
def test_check_refname(self):
- self._refs._check_refname('HEAD')
- self._refs._check_refname('refs/stash')
- self._refs._check_refname('refs/heads/foo')
+ self._refs._check_refname(b'HEAD')
+ self._refs._check_refname(b'refs/stash')
+ self._refs._check_refname(b'refs/heads/foo')
self.assertRaises(errors.RefFormatError, self._refs._check_refname,
- 'refs')
+ b'refs')
self.assertRaises(errors.RefFormatError, self._refs._check_refname,
- 'notrefs/foo')
+ b'notrefs/foo')
def test_contains(self):
- self.assertTrue('refs/heads/master' in self._refs)
- self.assertFalse('refs/heads/bar' in self._refs)
+ self.assertTrue(b'refs/heads/master' in self._refs)
+ self.assertFalse(b'refs/heads/bar' in self._refs)
def test_delitem(self):
- self.assertEqual('42d06bd4b77fed026b154d16493e5deab78f02ec',
- self._refs['refs/heads/master'])
- del self._refs['refs/heads/master']
- self.assertRaises(KeyError, lambda: self._refs['refs/heads/master'])
+ self.assertEqual(b'42d06bd4b77fed026b154d16493e5deab78f02ec',
+ self._refs[b'refs/heads/master'])
+ del self._refs[b'refs/heads/master']
+ self.assertRaises(KeyError, lambda: self._refs[b'refs/heads/master'])
def test_remove_if_equals(self):
- self.assertFalse(self._refs.remove_if_equals('HEAD', 'c0ffee'))
- self.assertEqual('42d06bd4b77fed026b154d16493e5deab78f02ec',
- self._refs['HEAD'])
+ self.assertFalse(self._refs.remove_if_equals(b'HEAD', b'c0ffee'))
+ self.assertEqual(b'42d06bd4b77fed026b154d16493e5deab78f02ec',
+ self._refs[b'HEAD'])
self.assertTrue(self._refs.remove_if_equals(
- 'refs/tags/refs-0.2', '3ec9c43c84ff242e3ef4a9fc5bc111fd780a76a8'))
- self.assertFalse('refs/tags/refs-0.2' in self._refs)
+ b'refs/tags/refs-0.2', b'3ec9c43c84ff242e3ef4a9fc5bc111fd780a76a8'))
+ self.assertFalse(b'refs/tags/refs-0.2' in self._refs)
-@skipIfPY3
class DictRefsContainerTests(RefsContainerTests, TestCase):
def setUp(self):
def test_invalid_refname(self):
# FIXME: Move this test into RefsContainerTests, but requires
# some way of injecting invalid refs.
- self._refs._refs["refs/stash"] = "00" * 20
+ self._refs._refs[b'refs/stash'] = b'00' * 20
expected_refs = dict(_TEST_REFS)
- expected_refs["refs/stash"] = "00" * 20
+ expected_refs[b'refs/stash'] = b'00' * 20
self.assertEqual(expected_refs, self._refs.as_dict())
-@skipIfPY3
class DiskRefsContainerTests(RefsContainerTests, TestCase):
def setUp(self):
def test_get_packed_refs(self):
self.assertEqual({
- 'refs/heads/packed': '42d06bd4b77fed026b154d16493e5deab78f02ec',
- 'refs/tags/refs-0.1': 'df6800012397fb85c56e7418dd4eb9405dee075c',
- }, self._refs.get_packed_refs())
+ b'refs/heads/packed': b'42d06bd4b77fed026b154d16493e5deab78f02ec',
+ b'refs/tags/refs-0.1': b'df6800012397fb85c56e7418dd4eb9405dee075c',
+ }, self._refs.get_packed_refs())
def test_get_peeled_not_packed(self):
# not packed
- self.assertEqual(None, self._refs.get_peeled('refs/tags/refs-0.2'))
- self.assertEqual('3ec9c43c84ff242e3ef4a9fc5bc111fd780a76a8',
- self._refs['refs/tags/refs-0.2'])
+ self.assertEqual(None, self._refs.get_peeled(b'refs/tags/refs-0.2'))
+ self.assertEqual(b'3ec9c43c84ff242e3ef4a9fc5bc111fd780a76a8',
+ self._refs[b'refs/tags/refs-0.2'])
# packed, known not peelable
- self.assertEqual(self._refs['refs/heads/packed'],
- self._refs.get_peeled('refs/heads/packed'))
+ self.assertEqual(self._refs[b'refs/heads/packed'],
+ self._refs.get_peeled(b'refs/heads/packed'))
# packed, peeled
- self.assertEqual('42d06bd4b77fed026b154d16493e5deab78f02ec',
- self._refs.get_peeled('refs/tags/refs-0.1'))
+ self.assertEqual(b'42d06bd4b77fed026b154d16493e5deab78f02ec',
+ self._refs.get_peeled(b'refs/tags/refs-0.1'))
def test_setitem(self):
RefsContainerTests.test_setitem(self)
f = open(os.path.join(self._refs.path, 'refs', 'some', 'ref'), 'rb')
- self.assertEqual('42d06bd4b77fed026b154d16493e5deab78f02ec',
- f.read()[:40])
+ self.assertEqual(b'42d06bd4b77fed026b154d16493e5deab78f02ec',
+ f.read()[:40])
f.close()
def test_setitem_symbolic(self):
- ones = '1' * 40
- self._refs['HEAD'] = ones
- self.assertEqual(ones, self._refs['HEAD'])
+ ones = b'1' * 40
+ self._refs[b'HEAD'] = ones
+ self.assertEqual(ones, self._refs[b'HEAD'])
# ensure HEAD was not modified
f = open(os.path.join(self._refs.path, 'HEAD'), 'rb')
- self.assertEqual('ref: refs/heads/master', next(iter(f)).rstrip('\n'))
+ self.assertEqual(b'ref: refs/heads/master', next(iter(f)).rstrip(b'\n'))
f.close()
# ensure the symbolic link was written through
RefsContainerTests.test_set_if_equals(self)
# ensure symref was followed
- self.assertEqual('9' * 40, self._refs['refs/heads/master'])
+ self.assertEqual(b'9' * 40, self._refs[b'refs/heads/master'])
# ensure lockfile was deleted
self.assertFalse(os.path.exists(
- os.path.join(self._refs.path, 'refs', 'heads', 'master.lock')))
+ os.path.join(self._refs.path, 'refs', 'heads', 'master.lock')))
self.assertFalse(os.path.exists(
- os.path.join(self._refs.path, 'HEAD.lock')))
+ os.path.join(self._refs.path, 'HEAD.lock')))
def test_add_if_new_packed(self):
# don't overwrite packed ref
- self.assertFalse(self._refs.add_if_new('refs/tags/refs-0.1', '9' * 40))
- self.assertEqual('df6800012397fb85c56e7418dd4eb9405dee075c',
- self._refs['refs/tags/refs-0.1'])
+ self.assertFalse(self._refs.add_if_new(b'refs/tags/refs-0.1',
+ b'9' * 40))
+ self.assertEqual(b'df6800012397fb85c56e7418dd4eb9405dee075c',
+ self._refs[b'refs/tags/refs-0.1'])
+ @skipIfPY3
def test_add_if_new_symbolic(self):
# Use an empty repo instead of the default.
tear_down_repo(self._repo)
self._repo = Repo.init(repo_dir)
refs = self._repo.refs
- nines = '9' * 40
- self.assertEqual('ref: refs/heads/master', refs.read_ref('HEAD'))
- self.assertFalse('refs/heads/master' in refs)
- self.assertTrue(refs.add_if_new('HEAD', nines))
- self.assertEqual('ref: refs/heads/master', refs.read_ref('HEAD'))
- self.assertEqual(nines, refs['HEAD'])
- self.assertEqual(nines, refs['refs/heads/master'])
- self.assertFalse(refs.add_if_new('HEAD', '1' * 40))
- self.assertEqual(nines, refs['HEAD'])
- self.assertEqual(nines, refs['refs/heads/master'])
+ nines = b'9' * 40
+ self.assertEqual(b'ref: refs/heads/master', refs.read_ref(b'HEAD'))
+ self.assertFalse(b'refs/heads/master' in refs)
+ self.assertTrue(refs.add_if_new(b'HEAD', nines))
+ self.assertEqual(b'ref: refs/heads/master', refs.read_ref(b'HEAD'))
+ self.assertEqual(nines, refs[b'HEAD'])
+ self.assertEqual(nines, refs[b'refs/heads/master'])
+ self.assertFalse(refs.add_if_new(b'HEAD', b'1' * 40))
+ self.assertEqual(nines, refs[b'HEAD'])
+ self.assertEqual(nines, refs[b'refs/heads/master'])
def test_follow(self):
- self.assertEqual(
- ('refs/heads/master', '42d06bd4b77fed026b154d16493e5deab78f02ec'),
- self._refs._follow('HEAD'))
- self.assertEqual(
- ('refs/heads/master', '42d06bd4b77fed026b154d16493e5deab78f02ec'),
- self._refs._follow('refs/heads/master'))
- self.assertRaises(KeyError, self._refs._follow, 'refs/heads/loop')
+ self.assertEqual((b'refs/heads/master',
+ b'42d06bd4b77fed026b154d16493e5deab78f02ec'),
+ self._refs._follow(b'HEAD'))
+ self.assertEqual((b'refs/heads/master',
+ b'42d06bd4b77fed026b154d16493e5deab78f02ec'),
+ self._refs._follow(b'refs/heads/master'))
+ self.assertRaises(KeyError, self._refs._follow, b'refs/heads/loop')
def test_delitem(self):
RefsContainerTests.test_delitem(self)
ref_file = os.path.join(self._refs.path, 'refs', 'heads', 'master')
self.assertFalse(os.path.exists(ref_file))
- self.assertFalse('refs/heads/master' in self._refs.get_packed_refs())
+ self.assertFalse(b'refs/heads/master' in self._refs.get_packed_refs())
def test_delitem_symbolic(self):
- self.assertEqual('ref: refs/heads/master',
- self._refs.read_loose_ref('HEAD'))
- del self._refs['HEAD']
- self.assertRaises(KeyError, lambda: self._refs['HEAD'])
- self.assertEqual('42d06bd4b77fed026b154d16493e5deab78f02ec',
- self._refs['refs/heads/master'])
+ self.assertEqual(b'ref: refs/heads/master',
+ self._refs.read_loose_ref(b'HEAD'))
+ del self._refs[b'HEAD']
+ self.assertRaises(KeyError, lambda: self._refs[b'HEAD'])
+ self.assertEqual(b'42d06bd4b77fed026b154d16493e5deab78f02ec',
+ self._refs[b'refs/heads/master'])
self.assertFalse(os.path.exists(os.path.join(self._refs.path, 'HEAD')))
def test_remove_if_equals_symref(self):
# HEAD is a symref, so shouldn't equal its dereferenced value
self.assertFalse(self._refs.remove_if_equals(
- 'HEAD', '42d06bd4b77fed026b154d16493e5deab78f02ec'))
+ b'HEAD', b'42d06bd4b77fed026b154d16493e5deab78f02ec'))
self.assertTrue(self._refs.remove_if_equals(
- 'refs/heads/master', '42d06bd4b77fed026b154d16493e5deab78f02ec'))
- self.assertRaises(KeyError, lambda: self._refs['refs/heads/master'])
+ b'refs/heads/master', b'42d06bd4b77fed026b154d16493e5deab78f02ec'))
+ self.assertRaises(KeyError, lambda: self._refs[b'refs/heads/master'])
# HEAD is now a broken symref
- self.assertRaises(KeyError, lambda: self._refs['HEAD'])
- self.assertEqual('ref: refs/heads/master',
- self._refs.read_loose_ref('HEAD'))
+ self.assertRaises(KeyError, lambda: self._refs[b'HEAD'])
+ self.assertEqual(b'ref: refs/heads/master',
+ self._refs.read_loose_ref(b'HEAD'))
self.assertFalse(os.path.exists(
os.path.join(self._refs.path, 'refs', 'heads', 'master.lock')))
refs_data = f.read()
f.close()
f = GitFile(refs_file, 'wb')
- f.write('\n'.join(l for l in refs_data.split('\n')
- if not l or l[0] not in '#^'))
+ f.write(b'\n'.join(l for l in refs_data.split(b'\n')
+ if not l or l[0] not in b'#^'))
f.close()
self._repo = Repo(self._repo.path)
refs = self._repo.refs
self.assertTrue(refs.remove_if_equals(
- 'refs/heads/packed', '42d06bd4b77fed026b154d16493e5deab78f02ec'))
+ b'refs/heads/packed', b'42d06bd4b77fed026b154d16493e5deab78f02ec'))
def test_remove_if_equals_packed(self):
# test removing ref that is only packed
- self.assertEqual('df6800012397fb85c56e7418dd4eb9405dee075c',
- self._refs['refs/tags/refs-0.1'])
+ self.assertEqual(b'df6800012397fb85c56e7418dd4eb9405dee075c',
+ self._refs[b'refs/tags/refs-0.1'])
self.assertTrue(
- self._refs.remove_if_equals('refs/tags/refs-0.1',
- 'df6800012397fb85c56e7418dd4eb9405dee075c'))
- self.assertRaises(KeyError, lambda: self._refs['refs/tags/refs-0.1'])
+ self._refs.remove_if_equals(
+ b'refs/tags/refs-0.1',
+ b'df6800012397fb85c56e7418dd4eb9405dee075c'))
+ self.assertRaises(KeyError, lambda: self._refs[b'refs/tags/refs-0.1'])
def test_read_ref(self):
- self.assertEqual('ref: refs/heads/master', self._refs.read_ref("HEAD"))
- self.assertEqual('42d06bd4b77fed026b154d16493e5deab78f02ec',
- self._refs.read_ref("refs/heads/packed"))
- self.assertEqual(None,
- self._refs.read_ref("nonexistant"))
+ self.assertEqual(b'ref: refs/heads/master', self._refs.read_ref(b'HEAD'))
+ self.assertEqual(b'42d06bd4b77fed026b154d16493e5deab78f02ec',
+ self._refs.read_ref(b'refs/heads/packed'))
+ self.assertEqual(None, self._refs.read_ref(b'nonexistant'))
_TEST_REFS_SERIALIZED = (
-'42d06bd4b77fed026b154d16493e5deab78f02ec\trefs/heads/40-char-ref-aaaaaaaaaaaaaaaaaa\n'
-'42d06bd4b77fed026b154d16493e5deab78f02ec\trefs/heads/master\n'
-'42d06bd4b77fed026b154d16493e5deab78f02ec\trefs/heads/packed\n'
-'df6800012397fb85c56e7418dd4eb9405dee075c\trefs/tags/refs-0.1\n'
-'3ec9c43c84ff242e3ef4a9fc5bc111fd780a76a8\trefs/tags/refs-0.2\n')
+ b'42d06bd4b77fed026b154d16493e5deab78f02ec\trefs/heads/40-char-ref-aaaaaaaaaaaaaaaaaa\n'
+ b'42d06bd4b77fed026b154d16493e5deab78f02ec\trefs/heads/master\n'
+ b'42d06bd4b77fed026b154d16493e5deab78f02ec\trefs/heads/packed\n'
+ b'df6800012397fb85c56e7418dd4eb9405dee075c\trefs/tags/refs-0.1\n'
+ b'3ec9c43c84ff242e3ef4a9fc5bc111fd780a76a8\trefs/tags/refs-0.2\n')
-@skipIfPY3
class InfoRefsContainerTests(TestCase):
def test_invalid_refname(self):
- text = _TEST_REFS_SERIALIZED + '00' * 20 + '\trefs/stash\n'
+ text = _TEST_REFS_SERIALIZED + b'00' * 20 + b'\trefs/stash\n'
refs = InfoRefsContainer(BytesIO(text))
expected_refs = dict(_TEST_REFS)
- del expected_refs['HEAD']
- expected_refs["refs/stash"] = "00" * 20
+ del expected_refs[b'HEAD']
+ expected_refs[b'refs/stash'] = b'00' * 20
self.assertEqual(expected_refs, refs.as_dict())
def test_keys(self):
actual_keys = set(refs.keys())
self.assertEqual(set(refs.allkeys()), actual_keys)
# ignore the symref loop if it exists
- actual_keys.discard('refs/heads/loop')
+ actual_keys.discard(b'refs/heads/loop')
expected_refs = dict(_TEST_REFS)
- del expected_refs['HEAD']
- self.assertEqual(set(expected_refs.iterkeys()), actual_keys)
+ del expected_refs[b'HEAD']
+ self.assertEqual(set(expected_refs.keys()), actual_keys)
- actual_keys = refs.keys('refs/heads')
- actual_keys.discard('loop')
+ actual_keys = refs.keys(b'refs/heads')
+ actual_keys.discard(b'loop')
self.assertEqual(
- ['40-char-ref-aaaaaaaaaaaaaaaaaa', 'master', 'packed'],
+ [b'40-char-ref-aaaaaaaaaaaaaaaaaa', b'master', b'packed'],
sorted(actual_keys))
- self.assertEqual(['refs-0.1', 'refs-0.2'],
- sorted(refs.keys('refs/tags')))
+ self.assertEqual([b'refs-0.1', b'refs-0.2'],
+ sorted(refs.keys(b'refs/tags')))
def test_as_dict(self):
refs = InfoRefsContainer(BytesIO(_TEST_REFS_SERIALIZED))
# refs/heads/loop does not show up even if it exists
expected_refs = dict(_TEST_REFS)
- del expected_refs['HEAD']
+ del expected_refs[b'HEAD']
self.assertEqual(expected_refs, refs.as_dict())
def test_contains(self):
refs = InfoRefsContainer(BytesIO(_TEST_REFS_SERIALIZED))
- self.assertTrue('refs/heads/master' in refs)
- self.assertFalse('refs/heads/bar' in refs)
+ self.assertTrue(b'refs/heads/master' in refs)
+ self.assertFalse(b'refs/heads/bar' in refs)
def test_get_peeled(self):
refs = InfoRefsContainer(BytesIO(_TEST_REFS_SERIALIZED))
# refs/heads/loop does not show up even if it exists
self.assertEqual(
- _TEST_REFS['refs/heads/master'],
- refs.get_peeled('refs/heads/master'))
+ _TEST_REFS[b'refs/heads/master'],
+ refs.get_peeled(b'refs/heads/master'))
git.samba.org / jelmer / dulwich.git / commitdiff