def test_object_diff_kind_change(self):
f = BytesIO()
b1 = Blob.from_string(b"new\nsame\n")
store = MemoryObjectStore()
store.add_object(b1)
write_object_diff(
f,
store,
(b"bar.txt", 0o644, b1.id),
(
b"bar.txt",
0o160000,
b"06d0bdd9e2e20377b3180e4986b14c8549b393e4",
),
)
self.assertEqual(
[
b"diff --git a/bar.txt b/bar.txt",
b"old file mode 644",
b"new file mode 160000",
b"index a116b51..06d0bdd 160000",
b"--- a/bar.txt",
b"+++ b/bar.txt",
b"@@ -1,2 +1 @@",
b"-new",
b"-same",
b"+Subproject commit 06d0bdd9e2e20377b3180e4986b14c8549b393e4",
],
f.getvalue().splitlines(),
)
def test_add_thin_pack_empty(self):
o = MemoryObjectStore()
f = BytesIO()
entries = build_pack(f, [], store=o)
self.assertEqual([], entries)
o.add_thin_pack(f.read, None)
def test_object_diff_bin_blob_force(self):
f = BytesIO()
# Prepare two slightly different PNG headers
b1 = Blob.from_string(
b"\x89\x50\x4e\x47\x0d\x0a\x1a\x0a"
b"\x00\x00\x00\x0d\x49\x48\x44\x52"
b"\x00\x00\x01\xd5\x00\x00\x00\x9f"
b"\x08\x04\x00\x00\x00\x05\x04\x8b")
b2 = Blob.from_string(
b"\x89\x50\x4e\x47\x0d\x0a\x1a\x0a"
b"\x00\x00\x00\x0d\x49\x48\x44\x52"
b"\x00\x00\x01\xd5\x00\x00\x00\x9f"
b"\x08\x03\x00\x00\x00\x98\xd3\xb3")
store = MemoryObjectStore()
store.add_objects([(b1, None), (b2, None)])
write_object_diff(
f, store, (b'foo.png', 0o644, b1.id),
(b'bar.png', 0o644, b2.id), diff_binary=True)
self.assertEqual([
b'diff --git a/foo.png b/bar.png',
b'index f73e47d..06364b7 644',
b'--- a/foo.png',
b'+++ b/bar.png',
b'@@ -1,4 +1,4 @@',
b' \x89PNG',
b' \x1a',
b' \x00\x00\x00',
b'-IHDR\x00\x00\x01\xd5\x00\x00\x00'
b'\x9f\x08\x04\x00\x00\x00\x05\x04\x8b',
b'\\ No newline at end of file',
b'+IHDR\x00\x00\x01\xd5\x00\x00\x00\x9f'
b'\x08\x03\x00\x00\x00\x98\xd3\xb3',
b'\\ No newline at end of file'
], f.getvalue().splitlines())
def setUp(self):
super(TestThinPack, self).setUp()
self.store = MemoryObjectStore()
self.blobs = {}
for blob in (b"foo", b"bar", b"foo1234", b"bar2468"):
self.blobs[blob] = make_object(Blob, data=blob)
self.store.add_object(self.blobs[b"foo"])
self.store.add_object(self.blobs[b"bar"])
# Build a thin pack. 'foo' is as an external reference, 'bar' an
# internal reference.
self.pack_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, self.pack_dir)
self.pack_prefix = os.path.join(self.pack_dir, "pack")
with open(self.pack_prefix + ".pack", "wb") as f:
build_pack(
f,
[
(REF_DELTA, (self.blobs[b"foo"].id, b"foo1234")),
(Blob.type_num, b"bar"),
(REF_DELTA, (self.blobs[b"bar"].id, b"bar2468")),
],
store=self.store,
)
# Index the new pack.
with self.make_pack(True) as pack:
with PackData(pack._data_path) as data:
data.pack = pack
data.create_index(self.pack_prefix + ".idx")
del self.store[self.blobs[b"bar"].id]
def test_object_diff_bin_blob_force(self):
f = BytesIO()
# Prepare two slightly different PNG headers
b1 = Blob.from_string(
b"\x89\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52"
b"\x00\x00\x01\xd5\x00\x00\x00\x9f\x08\x04\x00\x00\x00\x05\x04\x8b"
)
b2 = Blob.from_string(
b"\x89\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52"
b"\x00\x00\x01\xd5\x00\x00\x00\x9f\x08\x03\x00\x00\x00\x98\xd3\xb3"
)
store = MemoryObjectStore()
store.add_objects([(b1, None), (b2, None)])
write_object_diff(f, store, (b"foo.png", 0o644, b1.id), (b"bar.png", 0o644, b2.id), diff_binary=True)
self.assertEqual(
[
b"diff --git a/foo.png b/bar.png",
b"index f73e47d..06364b7 644",
b"--- a/foo.png",
b"+++ b/bar.png",
b"@@ -1,4 +1,4 @@",
b" \x89PNG",
b" \x1a",
b" \x00\x00\x00",
b"-IHDR\x00\x00\x01\xd5\x00\x00\x00\x9f\x08\x04\x00\x00\x00\x05\x04\x8b",
b"\\ No newline at end of file",
b"+IHDR\x00\x00\x01\xd5\x00\x00\x00\x9f\x08\x03\x00\x00\x00\x98\xd3\xb3",
b"\\ No newline at end of file",
],
f.getvalue().splitlines(),
)
def test_tree_diff_submodule(self):
f = BytesIO()
store = MemoryObjectStore()
tree1 = Tree()
tree1.add(
b"asubmodule",
S_IFGITLINK,
b"06d0bdd9e2e20377b3180e4986b14c8549b393e4",
)
tree2 = Tree()
tree2.add(
b"asubmodule",
S_IFGITLINK,
b"cc975646af69f279396d4d5e1379ac6af80ee637",
)
store.add_objects([(o, None) for o in [tree1, tree2]])
write_tree_diff(f, store, tree1.id, tree2.id)
self.assertEqual(
[
b"diff --git a/asubmodule b/asubmodule",
b"index 06d0bdd..cc97564 160000",
b"--- a/asubmodule",
b"+++ b/asubmodule",
b"@@ -1 +1 @@",
b"-Subproject commit 06d0bdd9e2e20377b3180e4986b14c8549b393e4",
b"+Subproject commit cc975646af69f279396d4d5e1379ac6af80ee637",
],
f.getvalue().splitlines(),
)
def test_add_thin_pack_empty(self):
o = MemoryObjectStore()
f = BytesIO()
entries = build_pack(f, [], store=o)
self.assertEqual([], entries)
o.add_thin_pack(f.read, None)
def setUp(self):
super(TestThinPack, self).setUp()
self.store = MemoryObjectStore()
self.blobs = {}
for blob in ('foo', 'bar', 'foo1234', 'bar2468'):
self.blobs[blob] = make_object(Blob, data=blob)
self.store.add_object(self.blobs['foo'])
self.store.add_object(self.blobs['bar'])
# Build a thin pack. 'foo' is as an external reference, 'bar' an
# internal reference.
self.pack_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, self.pack_dir)
self.pack_prefix = os.path.join(self.pack_dir, 'pack')
f = open(self.pack_prefix + '.pack', 'wb')
try:
build_pack(f, [
(REF_DELTA, (self.blobs['foo'].id, 'foo1234')),
(Blob.type_num, 'bar'),
(REF_DELTA, (self.blobs['bar'].id, 'bar2468'))],
store=self.store)
finally:
f.close()
# Index the new pack.
with self.make_pack(True) as pack:
with PackData(pack._data_path) as data:
data.pack = pack
data.create_index(self.pack_prefix + '.idx')
del self.store[self.blobs['bar'].id]
def test_object_diff_bin_blob_force(self):
f = StringIO()
# Prepare two slightly different PNG headers
b1 = Blob.from_string(
"\x89\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52"
"\x00\x00\x01\xd5\x00\x00\x00\x9f\x08\x04\x00\x00\x00\x05\x04\x8b")
b2 = Blob.from_string(
"\x89\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52"
"\x00\x00\x01\xd5\x00\x00\x00\x9f\x08\x03\x00\x00\x00\x98\xd3\xb3")
store = MemoryObjectStore()
store.add_objects([(b1, None), (b2, None)])
write_object_diff(f, store, ('foo.png', 0644, b1.id),
('bar.png', 0644, b2.id), diff_binary=True)
self.assertEqual([
'diff --git a/foo.png b/bar.png',
'index f73e47d..06364b7 644',
'--- a/foo.png',
'+++ b/bar.png',
'@@ -1,4 +1,4 @@',
' \x89PNG',
' \x1a',
' \x00\x00\x00',
'-IHDR\x00\x00\x01\xd5\x00\x00\x00\x9f\x08\x04\x00\x00\x00\x05\x04\x8b',
'\\ No newline at end of file',
'+IHDR\x00\x00\x01\xd5\x00\x00\x00\x9f\x08\x03\x00\x00\x00\x98\xd3\xb3',
'\\ No newline at end of file'
], f.getvalue().splitlines())
def setUp(self):
super(TestThinPack, self).setUp()
self.store = MemoryObjectStore()
self.blobs = {}
for blob in (b'foo', b'bar', b'foo1234', b'bar2468'):
self.blobs[blob] = make_object(Blob, data=blob)
self.store.add_object(self.blobs[b'foo'])
self.store.add_object(self.blobs[b'bar'])
# Build a thin pack. 'foo' is as an external reference, 'bar' an
# internal reference.
self.pack_dir = tempfile.mkdtemp()
if not isinstance(self.pack_dir, bytes):
self.pack_dir = self.pack_dir.encode(sys.getfilesystemencoding())
self.addCleanup(shutil.rmtree, self.pack_dir)
self.pack_prefix = os.path.join(self.pack_dir, b'pack')
with open(self.pack_prefix + b'.pack', 'wb') as f:
build_pack(f, [
(REF_DELTA, (self.blobs[b'foo'].id, b'foo1234')),
(Blob.type_num, b'bar'),
(REF_DELTA, (self.blobs[b'bar'].id, b'bar2468'))],
store=self.store)
# Index the new pack.
with self.make_pack(True) as pack:
with PackData(pack._data_path) as data:
data.pack = pack
data.create_index(self.pack_prefix + b'.idx')
del self.store[self.blobs[b'bar'].id]
class CommitTreeTests(TestCase):
def setUp(self):
super(CommitTreeTests, self).setUp()
self.store = MemoryObjectStore()
def test_single_blob(self):
blob = Blob()
blob.data = b"foo"
self.store.add_object(blob)
blobs = [(b"bla", blob.id, stat.S_IFREG)]
rootid = commit_tree(self.store, blobs)
self.assertEqual(rootid, b"1a1e80437220f9312e855c37ac4398b68e5c1d50")
self.assertEqual((stat.S_IFREG, blob.id), self.store[rootid][b"bla"])
self.assertEqual(set([rootid, blob.id]), set(self.store._data.keys()))
def test_nested(self):
blob = Blob()
blob.data = b"foo"
self.store.add_object(blob)
blobs = [(b"bla/bar", blob.id, stat.S_IFREG)]
rootid = commit_tree(self.store, blobs)
self.assertEqual(rootid, b"d92b959b216ad0d044671981196781b3258fa537")
dirid = self.store[rootid][b"bla"][1]
self.assertEqual(dirid, b"c1a1deb9788150829579a8b4efa6311e7b638650")
self.assertEqual((stat.S_IFDIR, dirid), self.store[rootid][b"bla"])
self.assertEqual((stat.S_IFREG, blob.id), self.store[dirid][b"bar"])
self.assertEqual(set([rootid, dirid, blob.id]),
set(self.store._data.keys()))
class CommitTreeTests(TestCase):
def setUp(self):
super(CommitTreeTests, self).setUp()
self.store = MemoryObjectStore()
def test_single_blob(self):
blob = Blob()
blob.data = b"foo"
self.store.add_object(blob)
blobs = [(b"bla", blob.id, stat.S_IFREG)]
rootid = commit_tree(self.store, blobs)
self.assertEqual(rootid, b"1a1e80437220f9312e855c37ac4398b68e5c1d50")
self.assertEqual((stat.S_IFREG, blob.id), self.store[rootid][b"bla"])
self.assertEqual(set([rootid, blob.id]), set(self.store._data.keys()))
def test_nested(self):
blob = Blob()
blob.data = b"foo"
self.store.add_object(blob)
blobs = [(b"bla/bar", blob.id, stat.S_IFREG)]
rootid = commit_tree(self.store, blobs)
self.assertEqual(rootid, b"d92b959b216ad0d044671981196781b3258fa537")
dirid = self.store[rootid][b"bla"][1]
self.assertEqual(dirid, b"c1a1deb9788150829579a8b4efa6311e7b638650")
self.assertEqual((stat.S_IFDIR, dirid), self.store[rootid][b"bla"])
self.assertEqual((stat.S_IFREG, blob.id), self.store[dirid][b"bar"])
self.assertEqual(set([rootid, dirid, blob.id]),
set(self.store._data.keys()))
class TestThinPack(PackTests):
def setUp(self):
super(TestThinPack, self).setUp()
self.store = MemoryObjectStore()
self.blobs = {}
for blob in ('foo', 'bar', 'foo1234', 'bar2468'):
self.blobs[blob] = make_object(Blob, data=blob)
self.store.add_object(self.blobs['foo'])
self.store.add_object(self.blobs['bar'])
# Build a thin pack. 'foo' is as an external reference, 'bar' an
# internal reference.
self.pack_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, self.pack_dir)
self.pack_prefix = os.path.join(self.pack_dir, 'pack')
f = open(self.pack_prefix + '.pack', 'wb')
try:
build_pack(f, [
(REF_DELTA, (self.blobs['foo'].id, 'foo1234')),
(Blob.type_num, 'bar'),
(REF_DELTA, (self.blobs['bar'].id, 'bar2468'))],
store=self.store)
finally:
f.close()
# Index the new pack.
with self.make_pack(True) as pack:
with PackData(pack._data_path) as data:
data.pack = pack
data.create_index(self.pack_prefix + '.idx')
del self.store[self.blobs['bar'].id]
def make_pack(self, resolve_ext_ref):
return Pack(
self.pack_prefix,
resolve_ext_ref=self.store.get_raw if resolve_ext_ref else None)
def test_get_raw(self):
with self.make_pack(False) as p:
self.assertRaises(
KeyError, p.get_raw, self.blobs['foo1234'].id)
with self.make_pack(True) as p:
self.assertEqual(
(3, 'foo1234'),
p.get_raw(self.blobs['foo1234'].id))
def test_iterobjects(self):
with self.make_pack(False) as p:
self.assertRaises(KeyError, list, p.iterobjects())
with self.make_pack(True) as p:
self.assertEqual(
sorted([self.blobs['foo1234'].id, self.blobs[b'bar'].id,
self.blobs['bar2468'].id]),
sorted(o.id for o in p.iterobjects()))
def setUp(self):
super(GitFastExporterTests, self).setUp()
self.store = MemoryObjectStore()
self.stream = BytesIO()
try:
from dulwich.fastexport import GitFastExporter
except ImportError:
raise SkipTest("python-fastimport not available")
self.fastexporter = GitFastExporter(self.stream, self.store)
def test_ff(self):
store = MemoryObjectStore()
base = make_commit()
c1 = make_commit(parents=[base.id])
c2 = make_commit(parents=[c1.id])
store.add_objects([(base, None), (c1, None), (c2, None)])
self.assertTrue(can_fast_forward(store, c1.id, c1.id))
self.assertTrue(can_fast_forward(store, base.id, c1.id))
self.assertTrue(can_fast_forward(store, c1.id, c2.id))
self.assertFalse(can_fast_forward(store, c2.id, c1.id))
def _get_example_tar_stream(self, *tar_stream_args, **tar_stream_kwargs):
store = MemoryObjectStore()
b1 = Blob.from_string(b"somedata")
store.add_object(b1)
t1 = Tree()
t1.add(b"somename", 0o100644, b1.id)
store.add_object(t1)
stream = b''.join(
tar_stream(store, t1, *tar_stream_args, **tar_stream_kwargs))
return BytesIO(stream)
def test_add_pack(self):
o = MemoryObjectStore()
f, commit, abort = o.add_pack()
try:
b = make_object(Blob, data=b"more yummy data")
write_pack_objects(f, [(b, None)])
except:
abort()
raise
else:
commit()
def test_add_pack(self):
o = MemoryObjectStore()
f, commit, abort = o.add_pack()
try:
b = make_object(Blob, data=b"more yummy data")
write_pack_objects(f, [(b, None)])
except BaseException:
abort()
raise
else:
commit()
def test_diverged(self):
store = MemoryObjectStore()
base = make_commit()
c1 = make_commit(parents=[base.id])
c2a = make_commit(parents=[c1.id], message=b'2a')
c2b = make_commit(parents=[c1.id], message=b'2b')
store.add_objects([(base, None), (c1, None), (c2a, None), (c2b, None)])
self.assertTrue(can_fast_forward(store, c1.id, c2a.id))
self.assertTrue(can_fast_forward(store, c1.id, c2b.id))
self.assertFalse(can_fast_forward(store, c2a.id, c2b.id))
self.assertFalse(can_fast_forward(store, c2b.id, c2a.id))
def test_simple(self):
store = MemoryObjectStore()
b1 = Blob.from_string(b"somedata")
store.add_object(b1)
t1 = Tree()
t1.add(b"somename", 0o100644, b1.id)
store.add_object(t1)
stream = b''.join(tar_stream(store, t1, 10))
out = BytesIO(stream)
tf = tarfile.TarFile(fileobj=out)
self.addCleanup(tf.close)
self.assertEqual(["somename"], tf.getnames())
def test_tree_diff(self):
f = BytesIO()
store = MemoryObjectStore()
added = Blob.from_string(b"add\n")
removed = Blob.from_string(b"removed\n")
changed1 = Blob.from_string(b"unchanged\nremoved\n")
changed2 = Blob.from_string(b"unchanged\nadded\n")
unchanged = Blob.from_string(b"unchanged\n")
tree1 = Tree()
tree1.add(b"removed.txt", 0o644, removed.id)
tree1.add(b"changed.txt", 0o644, changed1.id)
tree1.add(b"unchanged.txt", 0o644, changed1.id)
tree2 = Tree()
tree2.add(b"added.txt", 0o644, added.id)
tree2.add(b"changed.txt", 0o644, changed2.id)
tree2.add(b"unchanged.txt", 0o644, changed1.id)
store.add_objects([(o, None) for o in [
tree1,
tree2,
added,
removed,
changed1,
changed2,
unchanged,
]])
write_tree_diff(f, store, tree1.id, tree2.id)
self.assertEqual(
[
b"diff --git a/added.txt b/added.txt",
b"new file mode 644",
b"index 0000000..76d4bb8",
b"--- /dev/null",
b"+++ b/added.txt",
b"@@ -0,0 +1 @@",
b"+add",
b"diff --git a/changed.txt b/changed.txt",
b"index bf84e48..1be2436 644",
b"--- a/changed.txt",
b"+++ b/changed.txt",
b"@@ -1,2 +1,2 @@",
b" unchanged",
b"-removed",
b"+added",
b"diff --git a/removed.txt b/removed.txt",
b"deleted file mode 644",
b"index 2c3f0b3..0000000",
b"--- a/removed.txt",
b"+++ /dev/null",
b"@@ -1 +0,0 @@",
b"-removed",
],
f.getvalue().splitlines(),
)
class TreeLookupPathTests(TestCase):
def setUp(self):
TestCase.setUp(self)
self.store = MemoryObjectStore()
blob_a = make_object(Blob, data=b"a")
blob_b = make_object(Blob, data=b"b")
blob_c = make_object(Blob, data=b"c")
for blob in [blob_a, blob_b, blob_c]:
self.store.add_object(blob)
blobs = [
(b"a", blob_a.id, 0o100644),
(b"ad/b", blob_b.id, 0o100644),
(b"ad/bd/c", blob_c.id, 0o100755),
(b"ad/c", blob_c.id, 0o100644),
(b"c", blob_c.id, 0o100644),
(b"d", blob_c.id, S_IFGITLINK),
]
self.tree_id = commit_tree(self.store, blobs)
def get_object(self, sha):
return self.store[sha]
def test_lookup_blob(self):
o_id = tree_lookup_path(self.get_object, self.tree_id, b"a")[1]
self.assertIsInstance(self.store[o_id], Blob)
def test_lookup_tree(self):
o_id = tree_lookup_path(self.get_object, self.tree_id, b"ad")[1]
self.assertIsInstance(self.store[o_id], Tree)
o_id = tree_lookup_path(self.get_object, self.tree_id, b"ad/bd")[1]
self.assertIsInstance(self.store[o_id], Tree)
o_id = tree_lookup_path(self.get_object, self.tree_id, b"ad/bd/")[1]
self.assertIsInstance(self.store[o_id], Tree)
def test_lookup_submodule(self):
tree_lookup_path(self.get_object, self.tree_id, b"d")[1]
self.assertRaises(SubmoduleEncountered, tree_lookup_path,
self.get_object, self.tree_id, b"d/a")
def test_lookup_nonexistent(self):
self.assertRaises(KeyError, tree_lookup_path, self.get_object,
self.tree_id, b"j")
def test_lookup_not_tree(self):
self.assertRaises(
NotTreeError,
tree_lookup_path,
self.get_object,
self.tree_id,
b"ad/b/j",
)
def test_object_diff_add_blob(self):
f = BytesIO()
store = MemoryObjectStore()
b2 = Blob.from_string(b"new\nsame\n")
store.add_object(b2)
write_object_diff(f, store, (None, None, None),
(b"bar.txt", 0o644, b2.id))
self.assertEqual([
b'diff --git /dev/null b/bar.txt', b'new mode 644',
b'index 0000000..a116b51 644', b'--- /dev/null', b'+++ b/bar.txt',
b'@@ -1,0 +1,2 @@', b'+new', b'+same'
],
f.getvalue().splitlines())
def test_object_diff_remove_blob(self):
f = BytesIO()
b1 = Blob.from_string(b"new\nsame\n")
store = MemoryObjectStore()
store.add_object(b1)
write_object_diff(f, store, (b"bar.txt", 0o644, b1.id),
(None, None, None))
self.assertEqual([
b'diff --git a/bar.txt /dev/null', b'deleted mode 644',
b'index a116b51..0000000', b'--- a/bar.txt', b'+++ /dev/null',
b'@@ -1,2 +1,0 @@', b'-new', b'-same'
],
f.getvalue().splitlines())
def test_tree_diff(self):
f = StringIO()
store = MemoryObjectStore()
added = Blob.from_string("add\n")
removed = Blob.from_string("removed\n")
changed1 = Blob.from_string("unchanged\nremoved\n")
changed2 = Blob.from_string("unchanged\nadded\n")
unchanged = Blob.from_string("unchanged\n")
tree1 = Tree()
tree1.add(0644, "removed.txt", removed.id)
tree1.add(0644, "changed.txt", changed1.id)
tree1.add(0644, "unchanged.txt", changed1.id)
tree2 = Tree()
tree2.add(0644, "added.txt", added.id)
tree2.add(0644, "changed.txt", changed2.id)
tree1.add(0644, "unchanged.txt", changed1.id)
store.add_objects([(o, None) for o in [
tree1, tree2, added, removed, changed1, changed2, unchanged]])
write_tree_diff(f, store, tree1.id, tree2.id)
self.assertEquals([
'diff --git a/changed.txt b/changed.txt',
'index bf84e48..1be2436 644',
'--- a/changed.txt',
'+++ b/changed.txt',
'@@ -1,2 +1,2 @@',
' unchanged',
'-removed',
'+added',
'diff --git a/removed.txt /dev/null',
'deleted mode 644',
'index 2c3f0b3..e69de29',
'--- a/removed.txt',
'+++ /dev/null',
'@@ -1,1 +1,0 @@',
'-removed',
'diff --git a/unchanged.txt /dev/null',
'deleted mode 644',
'index bf84e48..e69de29',
'--- a/unchanged.txt',
'+++ /dev/null',
'@@ -1,2 +1,0 @@',
'-unchanged',
'-removed',
'diff --git /dev/null b/added.txt',
'new mode 644',
'index e69de29..76d4bb8 644',
'--- /dev/null',
'+++ b/added.txt',
'@@ -1,0 +1,1 @@',
'+add'
], f.getvalue().splitlines())
def test_object_diff_blob(self):
f = BytesIO()
b1 = Blob.from_string(b"old\nsame\n")
b2 = Blob.from_string(b"new\nsame\n")
store = MemoryObjectStore()
store.add_objects([(b1, None), (b2, None)])
write_object_diff(f, store, (b"foo.txt", 0o644, b1.id),
(b"bar.txt", 0o644, b2.id))
self.assertEqual([
b"diff --git a/foo.txt b/bar.txt", b"index 3b0f961..a116b51 644",
b"--- a/foo.txt", b"+++ b/bar.txt", b"@@ -1,2 +1,2 @@", b"-old",
b"+new", b" same"
],
f.getvalue().splitlines())
def test_object_diff_remove_bin_blob(self):
f = BytesIO()
b1 = Blob.from_string(
'\x89\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52'
'\x00\x00\x01\xd5\x00\x00\x00\x9f\x08\x04\x00\x00\x00\x05\x04\x8b')
store = MemoryObjectStore()
store.add_object(b1)
write_object_diff(f, store, ('foo.png', 0o644, b1.id),
(None, None, None))
self.assertEqual([
'diff --git a/foo.png /dev/null',
'deleted mode 644',
'index f73e47d..0000000',
'Binary files a/foo.png and /dev/null differ'
], f.getvalue().splitlines())
def test_object_diff_add_bin_blob(self):
f = BytesIO()
b2 = Blob.from_string(
'\x89\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52'
'\x00\x00\x01\xd5\x00\x00\x00\x9f\x08\x03\x00\x00\x00\x98\xd3\xb3')
store = MemoryObjectStore()
store.add_object(b2)
write_object_diff(f, store, (None, None, None),
('bar.png', 0o644, b2.id))
self.assertEqual([
'diff --git /dev/null b/bar.png', 'new mode 644',
'index 0000000..06364b7 644',
'Binary files /dev/null and b/bar.png differ'
],
f.getvalue().splitlines())
def test_object_diff_remove_bin_blob(self):
f = BytesIO()
b1 = Blob.from_string(
'\x89\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52'
'\x00\x00\x01\xd5\x00\x00\x00\x9f\x08\x04\x00\x00\x00\x05\x04\x8b')
store = MemoryObjectStore()
store.add_object(b1)
write_object_diff(f, store, ('foo.png', 0o644, b1.id),
(None, None, None))
self.assertEqual([
'diff --git a/foo.png /dev/null', 'deleted mode 644',
'index f73e47d..0000000',
'Binary files a/foo.png and /dev/null differ'
],
f.getvalue().splitlines())
def test_object_diff_add_bin_blob(self):
f = BytesIO()
b2 = Blob.from_string(
'\x89\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52'
'\x00\x00\x01\xd5\x00\x00\x00\x9f\x08\x03\x00\x00\x00\x98\xd3\xb3')
store = MemoryObjectStore()
store.add_object(b2)
write_object_diff(f, store, (None, None, None),
('bar.png', 0o644, b2.id))
self.assertEqual([
'diff --git /dev/null b/bar.png',
'new mode 644',
'index 0000000..06364b7 644',
'Binary files /dev/null and b/bar.png differ'
], f.getvalue().splitlines())
def setUp(self):
super(TestThinPack, self).setUp()
self.store = MemoryObjectStore()
self.blobs = {}
for blob in ('foo', 'bar', 'foo1234', 'bar2468'):
self.blobs[blob] = make_object(Blob, data=blob)
self.store.add_object(self.blobs['foo'])
self.store.add_object(self.blobs['bar'])
# Build a thin pack. 'foo' is as an external reference, 'bar' an
# internal reference.
self.pack_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, self.pack_dir)
self.pack_prefix = os.path.join(self.pack_dir, 'pack')
f = open(self.pack_prefix + '.pack', 'wb')
try:
build_pack(f, [
(REF_DELTA, (self.blobs['foo'].id, 'foo1234')),
(Blob.type_num, 'bar'),
(REF_DELTA, (self.blobs['bar'].id, 'bar2468'))],
store=self.store)
finally:
f.close()
# Index the new pack.
pack = self.make_pack(True)
data = PackData(pack._data_path)
data.pack = pack
data.create_index(self.pack_prefix + '.idx')
del self.store[self.blobs['bar'].id]
def __init__(self):
from dulwich.config import ConfigFile
BaseRepo.__init__(self, MemoryObjectStore(), DictRefsContainer({}))
self._named_files = {}
self.bare = True
self._config = ConfigFile()
self._description = None
def test_against_empty_tree(self):
i = self.get_simple_index("index")
changes = list(i.changes_from_tree(MemoryObjectStore(), None))
self.assertEqual(1, len(changes))
(oldname, newname), (oldmode, newmode), (oldsha, newsha) = changes[0]
self.assertEqual(b'bla', newname)
self.assertEqual(b'e69de29bb2d1d6434b8b29ae775ad8c2e48c5391', newsha)
class GitFastExporterTests(TestCase):
"""Tests for the GitFastExporter tests."""
def setUp(self):
super(GitFastExporterTests, self).setUp()
self.store = MemoryObjectStore()
self.stream = BytesIO()
try:
from dulwich.fastexport import GitFastExporter
except ImportError:
raise SkipTest("python-fastimport not available")
self.fastexporter = GitFastExporter(self.stream, self.store)
def test_emit_blob(self):
b = Blob()
b.data = b"fooBAR"
self.fastexporter.emit_blob(b)
self.assertEqual(b"blob\nmark :1\ndata 6\nfooBAR\n", self.stream.getvalue())
def test_emit_commit(self):
b = Blob()
b.data = b"FOO"
t = Tree()
t.add(b"foo", stat.S_IFREG | 0o644, b.id)
c = Commit()
c.committer = c.author = b"Jelmer <jelmer@host>"
c.author_time = c.commit_time = 1271345553
c.author_timezone = c.commit_timezone = 0
c.message = b"msg"
c.tree = t.id
self.store.add_objects([(b, None), (t, None), (c, None)])
self.fastexporter.emit_commit(c, b"refs/heads/master")
self.assertEqual(
b"""blob
mark :1
data 3
FOO
commit refs/heads/master
mark :2
author Jelmer <jelmer@host> 1271345553 +0000
committer Jelmer <jelmer@host> 1271345553 +0000
data 3
msg
M 644 :1 foo
""",
self.stream.getvalue(),
)
def test_tree_diff(self):
f = BytesIO()
store = MemoryObjectStore()
added = Blob.from_string(b"add\n")
removed = Blob.from_string(b"removed\n")
changed1 = Blob.from_string(b"unchanged\nremoved\n")
changed2 = Blob.from_string(b"unchanged\nadded\n")
unchanged = Blob.from_string(b"unchanged\n")
tree1 = Tree()
tree1.add(b"removed.txt", 0o644, removed.id)
tree1.add(b"changed.txt", 0o644, changed1.id)
tree1.add(b"unchanged.txt", 0o644, changed1.id)
tree2 = Tree()
tree2.add(b"added.txt", 0o644, added.id)
tree2.add(b"changed.txt", 0o644, changed2.id)
tree2.add(b"unchanged.txt", 0o644, changed1.id)
store.add_objects([
(o, None) for o in
[tree1, tree2, added, removed, changed1, changed2, unchanged]
])
write_tree_diff(f, store, tree1.id, tree2.id)
self.assertEqual([
b'diff --git /dev/null b/added.txt',
b'new mode 644',
b'index 0000000..76d4bb8 644',
b'--- /dev/null',
b'+++ b/added.txt',
b'@@ -1,0 +1,1 @@',
b'+add',
b'diff --git a/changed.txt b/changed.txt',
b'index bf84e48..1be2436 644',
b'--- a/changed.txt',
b'+++ b/changed.txt',
b'@@ -1,2 +1,2 @@',
b' unchanged',
b'-removed',
b'+added',
b'diff --git a/removed.txt /dev/null',
b'deleted mode 644',
b'index 2c3f0b3..0000000',
b'--- a/removed.txt',
b'+++ /dev/null',
b'@@ -1,1 +1,0 @@',
b'-removed',
],
f.getvalue().splitlines())
def test_object_diff_remove_blob(self):
f = BytesIO()
b1 = Blob.from_string(b"new\nsame\n")
store = MemoryObjectStore()
store.add_object(b1)
write_object_diff(f, store, ("bar.txt", 0o644, b1.id),
(None, None, None))
self.assertEqual([
b'diff --git a/bar.txt /dev/null',
b'deleted mode 644',
b'index a116b51..0000000',
b'--- a/bar.txt',
b'+++ /dev/null',
b'@@ -1,2 +1,0 @@',
b'-new',
b'-same'
], f.getvalue().splitlines())
def setUp(self):
TestCase.setUp(self)
self.store = MemoryObjectStore()
blob_a = make_object(Blob, data=b'a')
blob_b = make_object(Blob, data=b'b')
blob_c = make_object(Blob, data=b'c')
for blob in [blob_a, blob_b, blob_c]:
self.store.add_object(blob)
blobs = [
(b'a', blob_a.id, 0o100644),
(b'ad/b', blob_b.id, 0o100644),
(b'ad/bd/c', blob_c.id, 0o100755),
(b'ad/c', blob_c.id, 0o100644),
(b'c', blob_c.id, 0o100644),
]
self.tree_id = commit_tree(self.store, blobs)
def setUp(self):
super(CommitTreeChangesTests, self).setUp()
self.store = MemoryObjectStore()
self.blob_a = make_object(Blob, data=b"a")
self.blob_b = make_object(Blob, data=b"b")
self.blob_c = make_object(Blob, data=b"c")
for blob in [self.blob_a, self.blob_b, self.blob_c]:
self.store.add_object(blob)
blobs = [
(b"a", self.blob_a.id, 0o100644),
(b"ad/b", self.blob_b.id, 0o100644),
(b"ad/bd/c", self.blob_c.id, 0o100755),
(b"ad/c", self.blob_c.id, 0o100644),
(b"c", self.blob_c.id, 0o100644),
]
self.tree_id = commit_tree(self.store, blobs)
def test_object_diff_add_blob(self):
f = BytesIO()
store = MemoryObjectStore()
b2 = Blob.from_string(b"new\nsame\n")
store.add_object(b2)
write_object_diff(f, store, (None, None, None),
("bar.txt", 0o644, b2.id))
self.assertEqual([
b'diff --git /dev/null b/bar.txt',
b'new mode 644',
b'index 0000000..a116b51 644',
b'--- /dev/null',
b'+++ b/bar.txt',
b'@@ -1,0 +1,2 @@',
b'+new',
b'+same'
], f.getvalue().splitlines())
class GitFastExporterTests(TestCase):
"""Tests for the GitFastExporter tests."""
def setUp(self):
super(GitFastExporterTests, self).setUp()
self.store = MemoryObjectStore()
self.stream = StringIO()
try:
from dulwich.fastexport import GitFastExporter
except ImportError:
raise TestSkipped("python-fastimport not available")
self.fastexporter = GitFastExporter(self.stream, self.store)
def test_emit_blob(self):
b = Blob()
b.data = "fooBAR"
self.fastexporter.emit_blob(b)
self.assertEquals('blob\nmark :1\ndata 6\nfooBAR\n',
self.stream.getvalue())
def test_emit_commit(self):
b = Blob()
b.data = "FOO"
t = Tree()
t.add(stat.S_IFREG | 0644, "foo", b.id)
c = Commit()
c.committer = c.author = "Jelmer <jelmer@host>"
c.author_time = c.commit_time = 1271345553
c.author_timezone = c.commit_timezone = 0
c.message = "msg"
c.tree = t.id
self.store.add_objects([(b, None), (t, None), (c, None)])
self.fastexporter.emit_commit(c, "refs/heads/master")
self.assertEquals("""blob
mark :1
data 3
FOO
commit refs/heads/master
mark :2
author Jelmer <jelmer@host> 1271345553 +0000
committer Jelmer <jelmer@host> 1271345553 +0000
data 3
msg
M 644 1 foo
""", self.stream.getvalue())
def test_tree_diff(self):
f = BytesIO()
store = MemoryObjectStore()
added = Blob.from_string(b"add\n")
removed = Blob.from_string(b"removed\n")
changed1 = Blob.from_string(b"unchanged\nremoved\n")
changed2 = Blob.from_string(b"unchanged\nadded\n")
unchanged = Blob.from_string(b"unchanged\n")
tree1 = Tree()
tree1.add(b"removed.txt", 0o644, removed.id)
tree1.add(b"changed.txt", 0o644, changed1.id)
tree1.add(b"unchanged.txt", 0o644, changed1.id)
tree2 = Tree()
tree2.add(b"added.txt", 0o644, added.id)
tree2.add(b"changed.txt", 0o644, changed2.id)
tree2.add(b"unchanged.txt", 0o644, changed1.id)
store.add_objects([(o, None) for o in [tree1, tree2, added, removed, changed1, changed2, unchanged]])
write_tree_diff(f, store, tree1.id, tree2.id)
self.assertEqual(
[
b"diff --git /dev/null b/added.txt",
b"new mode 644",
b"index 0000000..76d4bb8 644",
b"--- /dev/null",
b"+++ b/added.txt",
b"@@ -1,0 +1,1 @@",
b"+add",
b"diff --git a/changed.txt b/changed.txt",
b"index bf84e48..1be2436 644",
b"--- a/changed.txt",
b"+++ b/changed.txt",
b"@@ -1,2 +1,2 @@",
b" unchanged",
b"-removed",
b"+added",
b"diff --git a/removed.txt /dev/null",
b"deleted mode 644",
b"index 2c3f0b3..0000000",
b"--- a/removed.txt",
b"+++ /dev/null",
b"@@ -1,1 +1,0 @@",
b"-removed",
],
f.getvalue().splitlines(),
)
def test_object_diff_blob(self):
f = BytesIO()
b1 = Blob.from_string(b"old\nsame\n")
b2 = Blob.from_string(b"new\nsame\n")
store = MemoryObjectStore()
store.add_objects([(b1, None), (b2, None)])
write_object_diff(f, store, ("foo.txt", 0o644, b1.id),
("bar.txt", 0o644, b2.id))
self.assertEqual([
b"diff --git a/foo.txt b/bar.txt",
b"index 3b0f961..a116b51 644",
b"--- a/foo.txt",
b"+++ b/bar.txt",
b"@@ -1,2 +1,2 @@",
b"-old",
b"+new",
b" same"
], f.getvalue().splitlines())
def test_object_diff_bin_blob(self):
f = BytesIO()
# Prepare two slightly different PNG headers
b1 = Blob.from_string(
"\x89\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52"
"\x00\x00\x01\xd5\x00\x00\x00\x9f\x08\x04\x00\x00\x00\x05\x04\x8b")
b2 = Blob.from_string(
"\x89\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52"
"\x00\x00\x01\xd5\x00\x00\x00\x9f\x08\x03\x00\x00\x00\x98\xd3\xb3")
store = MemoryObjectStore()
store.add_objects([(b1, None), (b2, None)])
write_object_diff(f, store, ('foo.png', 0o644, b1.id),
('bar.png', 0o644, b2.id))
self.assertEqual([
'diff --git a/foo.png b/bar.png', 'index f73e47d..06364b7 644',
'Binary files a/foo.png and b/bar.png differ'
],
f.getvalue().splitlines())
def test_object_diff_bin_blob(self):
f = BytesIO()
# Prepare two slightly different PNG headers
b1 = Blob.from_string(
"\x89\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52"
"\x00\x00\x01\xd5\x00\x00\x00\x9f\x08\x04\x00\x00\x00\x05\x04\x8b")
b2 = Blob.from_string(
"\x89\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52"
"\x00\x00\x01\xd5\x00\x00\x00\x9f\x08\x03\x00\x00\x00\x98\xd3\xb3")
store = MemoryObjectStore()
store.add_objects([(b1, None), (b2, None)])
write_object_diff(f, store, ('foo.png', 0o644, b1.id),
('bar.png', 0o644, b2.id))
self.assertEqual([
'diff --git a/foo.png b/bar.png',
'index f73e47d..06364b7 644',
'Binary files a/foo.png and b/bar.png differ'
], f.getvalue().splitlines())
def setUp(self):
TestCase.setUp(self)
self.store = MemoryObjectStore()
blob_a = make_object(Blob, data=b"a")
blob_b = make_object(Blob, data=b"b")
blob_c = make_object(Blob, data=b"c")
for blob in [blob_a, blob_b, blob_c]:
self.store.add_object(blob)
blobs = [
(b"a", blob_a.id, 0o100644),
(b"ad/b", blob_b.id, 0o100644),
(b"ad/bd/c", blob_c.id, 0o100755),
(b"ad/c", blob_c.id, 0o100644),
(b"c", blob_c.id, 0o100644),
(b"d", blob_c.id, S_IFGITLINK),
]
self.tree_id = commit_tree(self.store, blobs)
def setUp(self):
super(GitFastExporterTests, self).setUp()
self.store = MemoryObjectStore()
self.stream = StringIO()
try:
from dulwich.fastexport import GitFastExporter
except ImportError:
raise TestSkipped("python-fastimport not available")
self.fastexporter = GitFastExporter(self.stream, self.store)
def __init__(self):
from dulwich.config import ConfigFile
self._reflog = []
refs_container = DictRefsContainer({}, logger=self._append_reflog)
BaseRepo.__init__(self, MemoryObjectStore(), refs_container)
self._named_files = {}
self.bare = True
self._config = ConfigFile()
self._description = None
def test_empty(self):
store = MemoryObjectStore()
c1, c2, c3 = build_commit_graph(store, [[1], [2, 1], [3, 1, 2]])
tree = store[c3.tree]
stream = b''.join(tar_stream(store, tree, 10))
out = BytesIO(stream)
tf = tarfile.TarFile(fileobj=out)
self.addCleanup(tf.close)
self.assertEqual([], tf.getnames())
def test_tree_diff(self):
f = BytesIO()
store = MemoryObjectStore()
added = Blob.from_string(b"add\n")
removed = Blob.from_string(b"removed\n")
changed1 = Blob.from_string(b"unchanged\nremoved\n")
changed2 = Blob.from_string(b"unchanged\nadded\n")
unchanged = Blob.from_string(b"unchanged\n")
tree1 = Tree()
tree1.add(b"removed.txt", 0o644, removed.id)
tree1.add(b"changed.txt", 0o644, changed1.id)
tree1.add(b"unchanged.txt", 0o644, changed1.id)
tree2 = Tree()
tree2.add(b"added.txt", 0o644, added.id)
tree2.add(b"changed.txt", 0o644, changed2.id)
tree2.add(b"unchanged.txt", 0o644, changed1.id)
store.add_objects([(o, None) for o in [
tree1, tree2, added, removed, changed1, changed2, unchanged]])
write_tree_diff(f, store, tree1.id, tree2.id)
self.assertEqual([
b'diff --git a/added.txt b/added.txt',
b'new file mode 644',
b'index 0000000..76d4bb8',
b'--- /dev/null',
b'+++ b/added.txt',
b'@@ -0,0 +1 @@',
b'+add',
b'diff --git a/changed.txt b/changed.txt',
b'index bf84e48..1be2436 644',
b'--- a/changed.txt',
b'+++ b/changed.txt',
b'@@ -1,2 +1,2 @@',
b' unchanged',
b'-removed',
b'+added',
b'diff --git a/removed.txt b/removed.txt',
b'deleted file mode 644',
b'index 2c3f0b3..0000000',
b'--- a/removed.txt',
b'+++ /dev/null',
b'@@ -1 +0,0 @@',
b'-removed',
], f.getvalue().splitlines())
class TreeLookupPathTests(TestCase):
def setUp(self):
TestCase.setUp(self)
self.store = MemoryObjectStore()
blob_a = make_object(Blob, data=b'a')
blob_b = make_object(Blob, data=b'b')
blob_c = make_object(Blob, data=b'c')
for blob in [blob_a, blob_b, blob_c]:
self.store.add_object(blob)
blobs = [
(b'a', blob_a.id, 0o100644),
(b'ad/b', blob_b.id, 0o100644),
(b'ad/bd/c', blob_c.id, 0o100755),
(b'ad/c', blob_c.id, 0o100644),
(b'c', blob_c.id, 0o100644),
]
self.tree_id = commit_tree(self.store, blobs)
def get_object(self, sha):
return self.store[sha]
def test_lookup_blob(self):
o_id = tree_lookup_path(self.get_object, self.tree_id, b'a')[1]
self.assertTrue(isinstance(self.store[o_id], Blob))
def test_lookup_tree(self):
o_id = tree_lookup_path(self.get_object, self.tree_id, b'ad')[1]
self.assertTrue(isinstance(self.store[o_id], Tree))
o_id = tree_lookup_path(self.get_object, self.tree_id, b'ad/bd')[1]
self.assertTrue(isinstance(self.store[o_id], Tree))
o_id = tree_lookup_path(self.get_object, self.tree_id, b'ad/bd/')[1]
self.assertTrue(isinstance(self.store[o_id], Tree))
def test_lookup_nonexistent(self):
self.assertRaises(
KeyError, tree_lookup_path, self.get_object, self.tree_id, b'j')
def test_lookup_not_tree(self):
self.assertRaises(
NotTreeError, tree_lookup_path, self.get_object, self.tree_id,
b'ad/b/j')
def test_object_diff_remove_blob(self):
f = BytesIO()
b1 = Blob.from_string(b"new\nsame\n")
store = MemoryObjectStore()
store.add_object(b1)
write_object_diff(f, store, (b"bar.txt", 0o644, b1.id), (None, None, None))
self.assertEqual(
[
b"diff --git a/bar.txt /dev/null",
b"deleted mode 644",
b"index a116b51..0000000",
b"--- a/bar.txt",
b"+++ /dev/null",
b"@@ -1,2 +1,0 @@",
b"-new",
b"-same",
],
f.getvalue().splitlines(),
)
def test_object_diff_add_blob(self):
f = BytesIO()
store = MemoryObjectStore()
b2 = Blob.from_string(b"new\nsame\n")
store.add_object(b2)
write_object_diff(f, store, (None, None, None), (b"bar.txt", 0o644, b2.id))
self.assertEqual(
[
b"diff --git /dev/null b/bar.txt",
b"new mode 644",
b"index 0000000..a116b51 644",
b"--- /dev/null",
b"+++ b/bar.txt",
b"@@ -1,0 +1,2 @@",
b"+new",
b"+same",
],
f.getvalue().splitlines(),
)
def test_object_diff_kind_change(self):
f = BytesIO()
b1 = Blob.from_string(b"new\nsame\n")
store = MemoryObjectStore()
store.add_object(b1)
write_object_diff(f, store, ("bar.txt", 0o644, b1.id),
("bar.txt", 0o160000, "06d0bdd9e2e20377b3180e4986b14c8549b393e4"))
self.assertEqual([
b'diff --git a/bar.txt b/bar.txt',
b'old mode 644',
b'new mode 160000',
b'index a116b51..06d0bdd 160000',
b'--- a/bar.txt',
b'+++ b/bar.txt',
b'@@ -1,2 +1,1 @@',
b'-new',
b'-same',
b'+Submodule commit 06d0bdd9e2e20377b3180e4986b14c8549b393e4',
], f.getvalue().splitlines())
class FastExporterTests(TestCase):
def setUp(self):
super(FastExporterTests, self).setUp()
self.store = MemoryObjectStore()
self.stream = StringIO()
self.fastexporter = FastExporter(self.stream, self.store)
def test_export_blob(self):
b = Blob()
b.data = "fooBAR"
self.assertEquals(1, self.fastexporter.export_blob(b))
self.assertEquals('blob\nmark :1\ndata 6\nfooBAR\n',
self.stream.getvalue())
def test_export_commit(self):
b = Blob()
b.data = "FOO"
t = Tree()
t.add(stat.S_IFREG | 0644, "foo", b.id)
c = Commit()
c.committer = c.author = "Jelmer <jelmer@host>"
c.author_time = c.commit_time = 1271345553.47
c.author_timezone = c.commit_timezone = 0
c.message = "msg"
c.tree = t.id
self.store.add_objects([(b, None), (t, None), (c, None)])
self.assertEquals(2,
self.fastexporter.export_commit(c, "refs/heads/master"))
self.assertEquals("""blob
mark :1
data 3
FOO
commit refs/heads/master
mark :2
author Jelmer <jelmer@host> 1271345553.47 +0000
committer Jelmer <jelmer@host> 1271345553.47 +0000
data 3
msg
M 100644 :1 foo
""", self.stream.getvalue())
def test_tree_diff_submodule(self):
f = BytesIO()
store = MemoryObjectStore()
tree1 = Tree()
tree1.add(b"asubmodule", S_IFGITLINK,
Sha1Sum("06d0bdd9e2e20377b3180e4986b14c8549b393e4"))
tree2 = Tree()
tree2.add(b"asubmodule", S_IFGITLINK,
Sha1Sum("cc975646af69f279396d4d5e1379ac6af80ee637"))
store.add_objects([(o, None) for o in [tree1, tree2]])
write_tree_diff(f, store, tree1.id, tree2.id)
self.assertEqual([
b'diff --git a/asubmodule b/asubmodule',
b'index 06d0bdd..cc97564 160000',
b'--- a/asubmodule',
b'+++ b/asubmodule',
b'@@ -1,1 +1,1 @@',
b'-Submodule commit 06d0bdd9e2e20377b3180e4986b14c8549b393e4',
b'+Submodule commit cc975646af69f279396d4d5e1379ac6af80ee637',
], f.getvalue().splitlines())
class DiffTestCase(TestCase):
def setUp(self):
super(DiffTestCase, self).setUp()
self.store = MemoryObjectStore()
self.empty_tree = self.commit_tree([])
def commit_tree(self, entries):
commit_blobs = []
for entry in entries:
if len(entry) == 2:
path, obj = entry
mode = F
else:
path, obj, mode = entry
if isinstance(obj, Blob):
self.store.add_object(obj)
sha = obj.id
else:
sha = obj
commit_blobs.append((path, sha, mode))
return self.store[commit_tree(self.store, commit_blobs)]
class MissingObjectFinderTest(TestCase):
def setUp(self):
super(MissingObjectFinderTest, self).setUp()
self.store = MemoryObjectStore()
self.commits = []
def cmt(self, n):
return self.commits[n - 1]
def assertMissingMatch(self, haves, wants, expected):
for sha, path in self.store.find_missing_objects(haves, wants):
self.assertTrue(sha in expected, "(%s,%s) erroneously reported as missing" % (sha, path))
expected.remove(sha)
self.assertEqual(len(expected), 0, "some objects are not reported as missing: %s" % (expected,))
def setUp(self):
TestCase.setUp(self)
self.store = MemoryObjectStore()
blob_a = make_object(Blob, data='a')
blob_b = make_object(Blob, data='b')
blob_c = make_object(Blob, data='c')
for blob in [blob_a, blob_b, blob_c]:
self.store.add_object(blob)
blobs = [
('a', blob_a.id, 0100644),
('ad/b', blob_b.id, 0100644),
('ad/bd/c', blob_c.id, 0100755),
('ad/c', blob_c.id, 0100644),
('c', blob_c.id, 0100644),
]
self.tree_id = commit_tree(self.store, blobs)
