1
# Copyright (C) 2009 Jelmer Vernooij <jelmer@samba.org>
2
# -*- coding: utf-8 -*-
4
# This program is free software; you can redistribute it and/or modify
5
# it under the terms of the GNU General Public License as published by
6
# the Free Software Foundation; either version 2 of the License, or
7
# (at your option) any later version.
9
# This program is distributed in the hope that it will be useful,
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12
# GNU General Public License for more details.
14
# You should have received a copy of the GNU General Public License
15
# along with this program; if not, write to the Free Software
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
from dulwich.objects import (
22
from dulwich.repo import (
33
from bzrlib.bzrdir import (
36
from bzrlib.inventory import (
39
from bzrlib.repository import (
42
from bzrlib.tests import (
43
TestCaseWithTransport,
46
from bzrlib.plugins.git.fetch import (
50
from bzrlib.plugins.git.mapping import (
54
from bzrlib.plugins.git.tests import (
59
class RepositoryFetchTests:
61
def make_git_repo(self, path):
65
def clone_git_repo(self, from_url, to_url, revision_id=None):
66
oldrepos = self.open_git_repo(from_url)
67
dir = BzrDir.create(to_url)
68
newrepos = dir.create_repository()
69
oldrepos.copy_content_into(newrepos, revision_id=revision_id)
73
self.make_git_repo("d")
74
newrepos = self.clone_git_repo("d", "f")
75
self.assertEquals([], newrepos.all_revision_ids())
77
def make_onerev_branch(self):
78
self.make_git_repo("d")
80
bb = GitBranchBuilder()
81
bb.set_file("foobar", "foo\nbar\n", False)
82
mark = bb.commit("Somebody <somebody@someorg.org>", "mymsg")
83
gitsha = bb.finish()[mark]
87
def test_single_rev(self):
88
path, gitsha = self.make_onerev_branch()
89
oldrepo = self.open_git_repo(path)
90
newrepo = self.clone_git_repo(path, "f")
91
self.assertEquals([oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha)], newrepo.all_revision_ids())
93
def test_single_rev_specific(self):
94
path, gitsha = self.make_onerev_branch()
95
oldrepo = self.open_git_repo(path)
96
revid = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha)
97
newrepo = self.clone_git_repo(path, "f", revision_id=revid)
98
self.assertEquals([revid], newrepo.all_revision_ids())
100
def test_incremental(self):
101
self.make_git_repo("d")
103
bb = GitBranchBuilder()
104
bb.set_file("foobar", "foo\nbar\n", False)
105
mark1 = bb.commit("Somebody <somebody@someorg.org>", "mymsg")
106
bb.set_file("foobar", "fooll\nbar\n", False)
107
mark2 = bb.commit("Somebody <somebody@someorg.org>", "nextmsg")
109
gitsha1 = marks[mark1]
110
gitsha2 = marks[mark2]
112
oldrepo = self.open_git_repo("d")
113
revid1 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha1)
114
newrepo = self.clone_git_repo("d", "f", revision_id=revid1)
115
self.assertEquals([revid1], newrepo.all_revision_ids())
116
revid2 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha2)
117
newrepo.fetch(oldrepo, revision_id=revid2)
118
self.assertEquals(set([revid1, revid2]), set(newrepo.all_revision_ids()))
120
def test_dir_becomes_symlink(self):
121
self.make_git_repo("d")
123
bb = GitBranchBuilder()
124
bb.set_file("mylink/somefile", "foo\nbar\n", False)
125
mark1 = bb.commit("Somebody <somebody@someorg.org>", "mymsg1")
126
bb.set_symlink("mylink", "target/")
127
mark2 = bb.commit("Somebody <somebody@someorg.org>", "mymsg2")
129
gitsha1 = marks[mark1]
130
gitsha2 = marks[mark2]
132
oldrepo = self.open_git_repo("d")
133
newrepo = self.clone_git_repo("d", "f")
134
revid1 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha1)
135
revid2 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha2)
136
tree1 = newrepo.revision_tree(revid1)
137
tree2 = newrepo.revision_tree(revid2)
138
fileid = tree1.path2id("mylink")
139
ie1 = tree1.inventory[fileid]
140
ie2 = tree2.inventory[fileid]
141
self.assertEquals(revid1, ie1.revision)
142
self.assertEquals("directory", ie1.kind)
143
self.assertEquals(None, ie1.symlink_target)
144
self.assertEquals(revid2, ie2.revision)
145
self.assertEquals("symlink", ie2.kind)
146
self.assertEquals("target/", ie2.symlink_target)
148
def test_symlink_becomes_dir(self):
149
self.make_git_repo("d")
151
bb = GitBranchBuilder()
152
bb.set_symlink("mylink", "target/")
153
mark1 = bb.commit("Somebody <somebody@someorg.org>", "mymsg1")
154
bb.set_file("mylink/somefile", "foo\nbar\n", False)
155
mark2 = bb.commit("Somebody <somebody@someorg.org>", "mymsg2")
157
gitsha1 = marks[mark1]
158
gitsha2 = marks[mark2]
160
oldrepo = self.open_git_repo("d")
161
newrepo = self.clone_git_repo("d", "f")
162
revid1 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha1)
163
revid2 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha2)
164
tree1 = newrepo.revision_tree(revid1)
165
tree2 = newrepo.revision_tree(revid2)
166
fileid = tree1.path2id("mylink")
167
ie1 = tree1.inventory[fileid]
168
ie2 = tree2.inventory[fileid]
169
self.assertEquals(revid1, ie1.revision)
170
self.assertEquals("symlink", ie1.kind)
171
self.assertEquals("target/", ie1.symlink_target)
172
self.assertEquals(revid2, ie2.revision)
173
self.assertEquals("directory", ie2.kind)
174
self.assertEquals(None, ie2.symlink_target)
176
def test_changing_symlink(self):
177
self.make_git_repo("d")
179
bb = GitBranchBuilder()
180
bb.set_symlink("mylink", "target")
181
mark1 = bb.commit("Somebody <somebody@someorg.org>", "mymsg1")
182
bb.set_symlink("mylink", "target/")
183
mark2 = bb.commit("Somebody <somebody@someorg.org>", "mymsg2")
185
gitsha1 = marks[mark1]
186
gitsha2 = marks[mark2]
188
oldrepo = self.open_git_repo("d")
189
newrepo = self.clone_git_repo("d", "f")
190
revid1 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha1)
191
revid2 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha2)
192
tree1 = newrepo.revision_tree(revid1)
193
tree2 = newrepo.revision_tree(revid2)
194
fileid = tree1.path2id("mylink")
195
ie1 = tree1.inventory[fileid]
196
ie2 = tree2.inventory[fileid]
197
self.assertEquals(revid1, ie1.revision)
198
self.assertEquals("target", ie1.symlink_target)
199
self.assertEquals(revid2, ie2.revision)
200
self.assertEquals("target/", ie2.symlink_target)
202
def test_executable(self):
203
self.make_git_repo("d")
205
bb = GitBranchBuilder()
206
bb.set_file("foobar", "foo\nbar\n", True)
207
bb.set_file("notexec", "foo\nbar\n", False)
208
mark = bb.commit("Somebody <somebody@someorg.org>", "mymsg")
209
gitsha = bb.finish()[mark]
211
oldrepo = self.open_git_repo("d")
212
newrepo = self.clone_git_repo("d", "f")
213
revid = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha)
214
tree = newrepo.revision_tree(revid)
215
self.assertTrue(tree.has_filename("foobar"))
216
self.assertEquals(True, tree.inventory[tree.path2id("foobar")].executable)
217
self.assertTrue(tree.has_filename("notexec"))
218
self.assertEquals(False, tree.inventory[tree.path2id("notexec")].executable)
220
def test_becomes_executable(self):
221
self.make_git_repo("d")
223
bb = GitBranchBuilder()
224
bb.set_file("foobar", "foo\nbar\n", False)
225
mark1 = bb.commit("Somebody <somebody@someorg.org>", "mymsg")
226
bb.set_file("foobar", "foo\nbar\n", True)
227
mark2 = bb.commit("Somebody <somebody@someorg.org>", "mymsg")
228
gitsha2 = bb.finish()[mark2]
230
oldrepo = self.open_git_repo("d")
231
newrepo = self.clone_git_repo("d", "f")
232
revid = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha2)
233
tree = newrepo.revision_tree(revid)
234
self.assertTrue(tree.has_filename("foobar"))
235
ie = tree.inventory[tree.path2id("foobar")]
236
self.assertEquals(True, ie.executable)
237
self.assertEquals(revid, ie.revision)
239
def test_non_ascii_characters(self):
240
self.make_git_repo("d")
242
bb = GitBranchBuilder()
243
bb.set_file(u"foőbar", "foo\nbar\n", False)
244
mark = bb.commit("Somebody <somebody@someorg.org>", "mymsg")
245
gitsha = bb.finish()[mark]
247
oldrepo = self.open_git_repo("d")
248
newrepo = self.clone_git_repo("d", "f")
249
revid = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha)
250
tree = newrepo.revision_tree(revid)
251
self.assertTrue(tree.has_filename(u"foőbar"))
254
class LocalRepositoryFetchTests(RepositoryFetchTests, TestCaseWithTransport):
256
def open_git_repo(self, path):
257
return Repository.open(path)
260
class DummyStoreUpdater(object):
262
def add_object(self, obj, ie, path):
269
class ImportObjects(TestCaseWithTransport):
272
super(ImportObjects, self).setUp()
273
self._mapping = BzrGitMappingv1()
274
factory = knit.make_file_factory(True, versionedfile.PrefixMapper())
275
self._texts = factory(self.get_transport('texts'))
277
def test_import_blob_simple(self):
278
blob = Blob.from_string("bar")
279
base_inv = Inventory()
280
objs = { "blobname": blob}
281
ret = import_git_blob(self._texts, self._mapping, "bla", "bla",
283
base_inv, None, "somerevid", [], objs.__getitem__,
284
(None, DEFAULT_FILE_MODE), DummyStoreUpdater(),
285
self._mapping.generate_file_id)
286
self.assertEquals(set([('bla', 'somerevid')]), self._texts.keys())
287
self.assertEquals(self._texts.get_record_stream([('bla', 'somerevid')],
288
"unordered", True).next().get_bytes_as("fulltext"), "bar")
289
self.assertEquals(1, len(ret))
290
self.assertEquals(None, ret[0][0])
291
self.assertEquals("bla", ret[0][1])
293
self.assertEquals(False, ie.executable)
294
self.assertEquals("file", ie.kind)
295
self.assertEquals("somerevid", ie.revision)
296
self.assertEquals(osutils.sha_strings(["bar"]), ie.text_sha1)
298
def test_import_tree_empty_root(self):
299
base_inv = Inventory(root_id=None)
301
ret, child_modes = import_git_tree(self._texts, self._mapping, "", "",
302
(None, tree.id), base_inv,
303
None, "somerevid", [], {tree.id: tree}.__getitem__,
304
(None, stat.S_IFDIR), DummyStoreUpdater(),
305
self._mapping.generate_file_id)
306
self.assertEquals(child_modes, {})
307
self.assertEquals(set([("TREE_ROOT", 'somerevid')]), self._texts.keys())
308
self.assertEquals(1, len(ret))
309
self.assertEquals(None, ret[0][0])
310
self.assertEquals("", ret[0][1])
312
self.assertEquals(False, ie.executable)
313
self.assertEquals("directory", ie.kind)
314
self.assertEquals({}, ie.children)
315
self.assertEquals("somerevid", ie.revision)
316
self.assertEquals(None, ie.text_sha1)
318
def test_import_tree_empty(self):
319
base_inv = Inventory()
321
ret, child_modes = import_git_tree(self._texts, self._mapping, "bla", "bla",
322
(None, tree.id), base_inv, None, "somerevid", [],
323
{ tree.id: tree }.__getitem__,
324
(None, stat.S_IFDIR), DummyStoreUpdater(),
325
self._mapping.generate_file_id)
326
self.assertEquals(child_modes, {})
327
self.assertEquals(set([("bla", 'somerevid')]), self._texts.keys())
328
self.assertEquals(1, len(ret))
329
self.assertEquals(None, ret[0][0])
330
self.assertEquals("bla", ret[0][1])
332
self.assertEquals("directory", ie.kind)
333
self.assertEquals(False, ie.executable)
334
self.assertEquals({}, ie.children)
335
self.assertEquals("somerevid", ie.revision)
336
self.assertEquals(None, ie.text_sha1)
338
def test_import_tree_with_file(self):
339
base_inv = Inventory()
340
blob = Blob.from_string("bar1")
342
tree.add(stat.S_IFREG | 0644, "foo", blob.id)
343
objects = { blob.id: blob, tree.id: tree }
344
ret, child_modes = import_git_tree(self._texts, self._mapping, "bla", "bla",
345
(None, tree.id), base_inv, None, "somerevid", [],
346
objects.__getitem__, (None, stat.S_IFDIR), DummyStoreUpdater(),
347
self._mapping.generate_file_id)
348
self.assertEquals(child_modes, {})
349
self.assertEquals(2, len(ret))
350
self.assertEquals(None, ret[0][0])
351
self.assertEquals("bla", ret[0][1])
352
self.assertEquals(None, ret[1][0])
353
self.assertEquals("bla/foo", ret[1][1])
355
self.assertEquals("directory", ie.kind)
357
self.assertEquals("file", ie.kind)
358
self.assertEquals("bla/foo", ie.file_id)
359
self.assertEquals("somerevid", ie.revision)
360
self.assertEquals(osutils.sha_strings(["bar1"]), ie.text_sha1)
361
self.assertEquals(False, ie.executable)
363
def test_import_tree_with_unusual_mode_file(self):
364
base_inv = Inventory()
365
blob = Blob.from_string("bar1")
367
tree.add(stat.S_IFREG | 0664, "foo", blob.id)
368
objects = { blob.id: blob, tree.id: tree }
369
ret, child_modes = import_git_tree(self._texts, self._mapping, "bla", "bla",
370
(None, tree.id), base_inv, None, "somerevid", [],
371
objects.__getitem__, (None, stat.S_IFDIR), DummyStoreUpdater(),
372
self._mapping.generate_file_id)
373
self.assertEquals(child_modes, { "bla/foo": stat.S_IFREG | 0664 })
375
def test_import_tree_with_file_exe(self):
376
base_inv = Inventory(root_id=None)
377
blob = Blob.from_string("bar")
379
tree.add(0100755, "foo", blob.id)
380
objects = { blob.id: blob, tree.id: tree }
381
ret, child_modes = import_git_tree(self._texts, self._mapping, "", "",
382
(None, tree.id), base_inv, None, "somerevid", [],
383
objects.__getitem__, (None, stat.S_IFDIR), DummyStoreUpdater(),
384
self._mapping.generate_file_id)
385
self.assertEquals(child_modes, {})
386
self.assertEquals(2, len(ret))
387
self.assertEquals(None, ret[0][0])
388
self.assertEquals("", ret[0][1])
389
self.assertEquals(None, ret[1][0])
390
self.assertEquals("foo", ret[1][1])
392
self.assertEquals("directory", ie.kind)
394
self.assertEquals("file", ie.kind)
395
self.assertEquals(True, ie.executable)
added
removed
tests/test_fetch.py
