/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to tests/test_fetch.py

Implement GitRepository.revision_graph_can_have_wrong_parents().

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_fetch.py
19
19
    Blob,
20
20
    Tree,
21
21
    )
 
22
from dulwich.repo import (
 
23
    Repo as GitRepo,
 
24
    )
22
25
import os
23
26
 
24
27
from bzrlib import (
46
49
    get_rich_root_format,
47
50
    )
48
51
from bzrlib.plugins.git.fetch import (
49
 
    BzrFetchGraphWalker,
50
52
    import_git_blob,
51
53
    import_git_tree,
52
54
    )
59
61
    )
60
62
from bzrlib.plugins.git.tests import (
61
63
    GitBranchBuilder,
62
 
    run_git,
63
64
    )
64
65
 
65
66
 
66
 
class FetchGraphWalkerTests(TestCaseWithTransport):
67
 
 
68
 
    def setUp(self):
69
 
        TestCaseWithTransport.setUp(self)
70
 
        self.mapping = default_mapping
71
 
 
72
 
    def test_empty(self):
73
 
        tree = self.make_branch_and_tree("wt")
74
 
        graphwalker = BzrFetchGraphWalker(tree.branch.repository, self.mapping)
75
 
        self.assertEquals(None, graphwalker.next())
76
 
 
77
 
 
78
67
class RepositoryFetchTests:
79
68
 
80
69
    def make_git_repo(self, path):
81
70
        os.mkdir(path)
82
 
        os.chdir(path)
83
 
        run_git("init")
84
 
        os.chdir("..")
 
71
        GitRepo.init(path)
85
72
 
86
73
    def clone_git_repo(self, from_url, to_url, revision_id=None):
87
74
        oldrepos = self.open_git_repo(from_url)
138
125
        newrepo.fetch(oldrepo, revision_id=revid2)
139
126
        self.assertEquals(set([revid1, revid2]), set(newrepo.all_revision_ids()))
140
127
 
 
128
    def test_dir_becomes_symlink(self):
 
129
        self.make_git_repo("d")
 
130
        os.chdir("d")
 
131
        bb = GitBranchBuilder()
 
132
        bb.set_file("mylink/somefile", "foo\nbar\n", False)
 
133
        mark1 = bb.commit("Somebody <somebody@someorg.org>", "mymsg1")
 
134
        bb.set_symlink("mylink", "target/")
 
135
        mark2 = bb.commit("Somebody <somebody@someorg.org>", "mymsg2")
 
136
        marks = bb.finish()
 
137
        gitsha1 = marks[mark1]
 
138
        gitsha2 = marks[mark2]
 
139
        os.chdir("..")
 
140
        oldrepo = self.open_git_repo("d")
 
141
        newrepo = self.clone_git_repo("d", "f")
 
142
        revid1 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha1)
 
143
        revid2 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha2)
 
144
        tree1 = newrepo.revision_tree(revid1)
 
145
        tree2 = newrepo.revision_tree(revid2)
 
146
        fileid = tree1.path2id("mylink")
 
147
        ie1 = tree1.inventory[fileid]
 
148
        ie2 = tree2.inventory[fileid]
 
149
        self.assertEquals(revid1, ie1.revision)
 
150
        self.assertEquals("directory", ie1.kind)
 
151
        self.assertEquals(None, ie1.symlink_target)
 
152
        self.assertEquals(revid2, ie2.revision)
 
153
        self.assertEquals("symlink", ie2.kind)
 
154
        self.assertEquals("target/", ie2.symlink_target)
 
155
 
 
156
    def test_symlink_becomes_dir(self):
 
157
        self.make_git_repo("d")
 
158
        os.chdir("d")
 
159
        bb = GitBranchBuilder()
 
160
        bb.set_symlink("mylink", "target/")
 
161
        mark1 = bb.commit("Somebody <somebody@someorg.org>", "mymsg1")
 
162
        bb.set_file("mylink/somefile", "foo\nbar\n", False)
 
163
        mark2 = bb.commit("Somebody <somebody@someorg.org>", "mymsg2")
 
164
        marks = bb.finish()
 
165
        gitsha1 = marks[mark1]
 
166
        gitsha2 = marks[mark2]
 
167
        os.chdir("..")
 
168
        oldrepo = self.open_git_repo("d")
 
169
        newrepo = self.clone_git_repo("d", "f")
 
170
        revid1 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha1)
 
171
        revid2 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha2)
 
172
        tree1 = newrepo.revision_tree(revid1)
 
173
        tree2 = newrepo.revision_tree(revid2)
 
174
        fileid = tree1.path2id("mylink")
 
175
        ie1 = tree1.inventory[fileid]
 
176
        ie2 = tree2.inventory[fileid]
 
177
        self.assertEquals(revid1, ie1.revision)
 
178
        self.assertEquals("symlink", ie1.kind)
 
179
        self.assertEquals("target/", ie1.symlink_target)
 
180
        self.assertEquals(revid2, ie2.revision)
 
181
        self.assertEquals("directory", ie2.kind)
 
182
        self.assertEquals(None, ie2.symlink_target)
 
183
 
 
184
    def test_changing_symlink(self):
 
185
        self.make_git_repo("d")
 
186
        os.chdir("d")
 
187
        bb = GitBranchBuilder()
 
188
        bb.set_symlink("mylink", "target")
 
189
        mark1 = bb.commit("Somebody <somebody@someorg.org>", "mymsg1")
 
190
        bb.set_symlink("mylink", "target/")
 
191
        mark2 = bb.commit("Somebody <somebody@someorg.org>", "mymsg2")
 
192
        marks = bb.finish()
 
193
        gitsha1 = marks[mark1]
 
194
        gitsha2 = marks[mark2]
 
195
        os.chdir("..")
 
196
        oldrepo = self.open_git_repo("d")
 
197
        newrepo = self.clone_git_repo("d", "f")
 
198
        revid1 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha1)
 
199
        revid2 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha2)
 
200
        tree1 = newrepo.revision_tree(revid1)
 
201
        tree2 = newrepo.revision_tree(revid2)
 
202
        fileid = tree1.path2id("mylink")
 
203
        ie1 = tree1.inventory[fileid]
 
204
        ie2 = tree2.inventory[fileid]
 
205
        self.assertEquals(revid1, ie1.revision)
 
206
        self.assertEquals("target", ie1.symlink_target)
 
207
        self.assertEquals(revid2, ie2.revision)
 
208
        self.assertEquals("target/", ie2.symlink_target)
 
209
 
141
210
    def test_executable(self):
142
211
        self.make_git_repo("d")
143
212
        os.chdir("d")
156
225
        self.assertTrue(tree.has_filename("notexec"))
157
226
        self.assertEquals(False, tree.inventory[tree.path2id("notexec")].executable)
158
227
 
 
228
    def test_becomes_executable(self):
 
229
        self.make_git_repo("d")
 
230
        os.chdir("d")
 
231
        bb = GitBranchBuilder()
 
232
        bb.set_file("foobar", "foo\nbar\n", False)
 
233
        mark1 = bb.commit("Somebody <somebody@someorg.org>", "mymsg")
 
234
        bb.set_file("foobar", "foo\nbar\n", True)
 
235
        mark2 = bb.commit("Somebody <somebody@someorg.org>", "mymsg")
 
236
        gitsha2 = bb.finish()[mark2]
 
237
        os.chdir("..")
 
238
        oldrepo = self.open_git_repo("d")
 
239
        newrepo = self.clone_git_repo("d", "f")
 
240
        revid = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha2)
 
241
        tree = newrepo.revision_tree(revid)
 
242
        self.assertTrue(tree.has_filename("foobar"))
 
243
        ie = tree.inventory[tree.path2id("foobar")]
 
244
        self.assertEquals(True, ie.executable)
 
245
        self.assertEquals(revid, ie.revision)
 
246
 
159
247
    def test_non_ascii_characters(self):
160
248
        self.make_git_repo("d")
161
249
        os.chdir("d")
190
278
        blob = Blob.from_string("bar")
191
279
        base_inv = Inventory()
192
280
        objs = { "blobname": blob}
193
 
        ret = import_git_blob(self._texts, self._mapping, "bla", "blobname", 
 
281
        ret, _= import_git_blob(self._texts, self._mapping, "bla", "blobname", 
194
282
            base_inv, None, "somerevid", [], self._map, objs.__getitem__, False,
195
283
            False)
196
284
        self.assertEquals(set([('bla', 'somerevid')]), self._texts.keys())
209
297
        base_inv = Inventory(root_id=None)
210
298
        tree = Tree()
211
299
        tree.serialize()
212
 
        ret = import_git_tree(self._texts, self._mapping, "", 
 
300
        ret, _, _ = import_git_tree(self._texts, self._mapping, "", 
213
301
               tree.id, base_inv, 
214
302
               None, "somerevid", [], self._map, {tree.id: tree}.__getitem__)
215
303
        self.assertEquals(set([("TREE_ROOT", 'somerevid')]), self._texts.keys())
227
315
        base_inv = Inventory()
228
316
        tree = Tree()
229
317
        tree.serialize()
230
 
        ret = import_git_tree(self._texts, self._mapping, "bla", 
 
318
        ret, _, _ = import_git_tree(self._texts, self._mapping, "bla", 
231
319
           tree.id, base_inv, None, "somerevid", [], 
232
320
           self._map, { tree.id: tree }.__getitem__)
233
321
        self.assertEquals(set([("bla", 'somerevid')]), self._texts.keys())
248
336
        tree.add(0100600, "foo", blob.id)
249
337
        tree.serialize()
250
338
        objects = { blob.id: blob, tree.id: tree }
251
 
        ret = import_git_tree(self._texts, self._mapping, "bla", tree.id, 
 
339
        ret, _, _ = import_git_tree(self._texts, self._mapping, "bla", tree.id, 
252
340
            base_inv, None, "somerevid", [], self._map, objects.__getitem__)
253
341
        self.assertEquals(2, len(ret))
254
342
        self.assertEquals(None, ret[0][0])
271
359
        tree.add(0100755, "foo", blob.id)
272
360
        tree.serialize()
273
361
        objects = { blob.id: blob, tree.id: tree }
274
 
        ret = import_git_tree(self._texts, self._mapping, "", tree.id, 
 
362
        ret, _, _ = import_git_tree(self._texts, self._mapping, "", tree.id, 
275
363
            base_inv, None, "somerevid", [], self._map, objects.__getitem__)
276
364
        self.assertEquals(2, len(ret))
277
365
        self.assertEquals(None, ret[0][0])