/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

Reduce number of round trips when fetching from Git.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_fetch.py
49
49
    get_rich_root_format,
50
50
    )
51
51
from bzrlib.plugins.git.fetch import (
 
52
    BzrFetchGraphWalker,
52
53
    import_git_blob,
53
54
    import_git_tree,
54
55
    )
64
65
    )
65
66
 
66
67
 
 
68
class FetchGraphWalkerTests(TestCaseWithTransport):
 
69
 
 
70
    def setUp(self):
 
71
        TestCaseWithTransport.setUp(self)
 
72
        self.mapping = default_mapping
 
73
 
 
74
    def test_empty(self):
 
75
        tree = self.make_branch_and_tree("wt")
 
76
        graphwalker = BzrFetchGraphWalker(tree.branch.repository, self.mapping)
 
77
        self.assertEquals(None, graphwalker.next())
 
78
 
 
79
 
67
80
class RepositoryFetchTests:
68
81
 
69
82
    def make_git_repo(self, path):
125
138
        newrepo.fetch(oldrepo, revision_id=revid2)
126
139
        self.assertEquals(set([revid1, revid2]), set(newrepo.all_revision_ids()))
127
140
 
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
 
 
210
141
    def test_executable(self):
211
142
        self.make_git_repo("d")
212
143
        os.chdir("d")
225
156
        self.assertTrue(tree.has_filename("notexec"))
226
157
        self.assertEquals(False, tree.inventory[tree.path2id("notexec")].executable)
227
158
 
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
 
 
247
159
    def test_non_ascii_characters(self):
248
160
        self.make_git_repo("d")
249
161
        os.chdir("d")
279
191
        base_inv = Inventory()
280
192
        objs = { "blobname": blob}
281
193
        ret, _= import_git_blob(self._texts, self._mapping, "bla", "blobname", 
282
 
            base_inv, None, None, "somerevid", [], self._map, objs.__getitem__, False,
 
194
            base_inv, None, "somerevid", [], self._map, objs.__getitem__, False,
283
195
            False)
284
196
        self.assertEquals(set([('bla', 'somerevid')]), self._texts.keys())
285
197
        self.assertEquals(self._texts.get_record_stream([('bla', 'somerevid')],
298
210
        tree = Tree()
299
211
        tree.serialize()
300
212
        ret, _, _ = import_git_tree(self._texts, self._mapping, "", 
301
 
               tree.id, base_inv, None,
 
213
               tree.id, base_inv, 
302
214
               None, "somerevid", [], self._map, {tree.id: tree}.__getitem__)
303
215
        self.assertEquals(set([("TREE_ROOT", 'somerevid')]), self._texts.keys())
304
216
        self.assertEquals(1, len(ret))
316
228
        tree = Tree()
317
229
        tree.serialize()
318
230
        ret, _, _ = import_git_tree(self._texts, self._mapping, "bla", 
319
 
           tree.id, base_inv, None, None, "somerevid", [], 
 
231
           tree.id, base_inv, None, "somerevid", [], 
320
232
           self._map, { tree.id: tree }.__getitem__)
321
233
        self.assertEquals(set([("bla", 'somerevid')]), self._texts.keys())
322
234
        self.assertEquals(1, len(ret))
337
249
        tree.serialize()
338
250
        objects = { blob.id: blob, tree.id: tree }
339
251
        ret, _, _ = import_git_tree(self._texts, self._mapping, "bla", tree.id, 
340
 
            base_inv, None, None, "somerevid", [], self._map, objects.__getitem__)
 
252
            base_inv, None, "somerevid", [], self._map, objects.__getitem__)
341
253
        self.assertEquals(2, len(ret))
342
254
        self.assertEquals(None, ret[0][0])
343
255
        self.assertEquals("bla", ret[0][1])
360
272
        tree.serialize()
361
273
        objects = { blob.id: blob, tree.id: tree }
362
274
        ret, _, _ = import_git_tree(self._texts, self._mapping, "", tree.id, 
363
 
            base_inv, None, None, "somerevid", [], self._map, objects.__getitem__)
 
275
            base_inv, None, "somerevid", [], self._map, objects.__getitem__)
364
276
        self.assertEquals(2, len(ret))
365
277
        self.assertEquals(None, ret[0][0])
366
278
        self.assertEquals("", ret[0][1])