/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

  • Committer: Vincent Ladeuil
  • Date: 2010-01-25 15:55:48 UTC
  • mto: (4985.1.4 add-attr-cleanup)
  • mto: This revision was merged to the branch mainline in revision 4988.
  • Revision ID: v.ladeuil+lp@free.fr-20100125155548-0l352pujvt5bzl5e
Deploy addAttrCleanup on the whole test suite.

Several use case worth mentioning:

- setting a module or any other object attribute is the majority
by far. In some cases the setting itself is deferred but most of
the time we want to set at the same time we add the cleanup.

- there multiple occurrences of protecting hooks or ui factory
which are now useless (the test framework takes care of that now),

- there was some lambda uses that can now be avoided.

That first cleanup already simplifies things a lot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_fetch.py
1
 
# Copyright (C) 2009 Jelmer Vernooij <jelmer@samba.org>
2
 
# -*- coding: utf-8 -*-
3
 
#
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.
8
 
#
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.
13
 
#
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
17
 
 
18
 
from dulwich.objects import (
19
 
    Blob,
20
 
    Tree,
21
 
    )
22
 
from dulwich.repo import (
23
 
    Repo as GitRepo,
24
 
    )
25
 
import os
26
 
import stat
27
 
 
28
 
from bzrlib import (
29
 
    knit,
30
 
    osutils,
31
 
    versionedfile,
32
 
    )
33
 
from bzrlib.bzrdir import (
34
 
    BzrDir,
35
 
    )
36
 
from bzrlib.inventory import (
37
 
    Inventory,
38
 
    )
39
 
from bzrlib.repository import (
40
 
    Repository,
41
 
    )
42
 
from bzrlib.tests import (
43
 
    TestCaseWithTransport,
44
 
    )
45
 
 
46
 
from bzrlib.plugins.git.fetch import (
47
 
    import_git_blob,
48
 
    import_git_tree,
49
 
    )
50
 
from bzrlib.plugins.git.mapping import (
51
 
    BzrGitMappingv1,
52
 
    DEFAULT_FILE_MODE,
53
 
    )
54
 
from bzrlib.plugins.git.tests import (
55
 
    GitBranchBuilder,
56
 
    )
57
 
 
58
 
 
59
 
class RepositoryFetchTests:
60
 
 
61
 
    def make_git_repo(self, path):
62
 
        os.mkdir(path)
63
 
        GitRepo.init(path)
64
 
 
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)
70
 
        return newrepos
71
 
 
72
 
    def test_empty(self):
73
 
        self.make_git_repo("d")
74
 
        newrepos = self.clone_git_repo("d", "f")
75
 
        self.assertEquals([], newrepos.all_revision_ids())
76
 
 
77
 
    def make_onerev_branch(self):
78
 
        self.make_git_repo("d")
79
 
        os.chdir("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]
84
 
        os.chdir("..")
85
 
        return "d", gitsha
86
 
 
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())
92
 
 
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())
99
 
 
100
 
    def test_incremental(self):
101
 
        self.make_git_repo("d")
102
 
        os.chdir("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")
108
 
        marks = bb.finish()
109
 
        gitsha1 = marks[mark1]
110
 
        gitsha2 = marks[mark2]
111
 
        os.chdir("..")
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()))
119
 
 
120
 
    def test_dir_becomes_symlink(self):
121
 
        self.make_git_repo("d")
122
 
        os.chdir("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")
128
 
        marks = bb.finish()
129
 
        gitsha1 = marks[mark1]
130
 
        gitsha2 = marks[mark2]
131
 
        os.chdir("..")
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)
147
 
 
148
 
    def test_symlink_becomes_dir(self):
149
 
        self.make_git_repo("d")
150
 
        os.chdir("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")
156
 
        marks = bb.finish()
157
 
        gitsha1 = marks[mark1]
158
 
        gitsha2 = marks[mark2]
159
 
        os.chdir("..")
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)
175
 
 
176
 
    def test_changing_symlink(self):
177
 
        self.make_git_repo("d")
178
 
        os.chdir("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")
184
 
        marks = bb.finish()
185
 
        gitsha1 = marks[mark1]
186
 
        gitsha2 = marks[mark2]
187
 
        os.chdir("..")
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)
201
 
 
202
 
    def test_executable(self):
203
 
        self.make_git_repo("d")
204
 
        os.chdir("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]
210
 
        os.chdir("..")
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)
219
 
 
220
 
    def test_becomes_executable(self):
221
 
        self.make_git_repo("d")
222
 
        os.chdir("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]
229
 
        os.chdir("..")
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)
238
 
 
239
 
    def test_non_ascii_characters(self):
240
 
        self.make_git_repo("d")
241
 
        os.chdir("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]
246
 
        os.chdir("..")
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"))
252
 
 
253
 
 
254
 
class LocalRepositoryFetchTests(RepositoryFetchTests, TestCaseWithTransport):
255
 
 
256
 
    def open_git_repo(self, path):
257
 
        return Repository.open(path)
258
 
 
259
 
 
260
 
class DummyStoreUpdater(object):
261
 
 
262
 
    def add_object(self, obj, ie, path):
263
 
        pass
264
 
 
265
 
    def finish(self):
266
 
        pass
267
 
 
268
 
 
269
 
class ImportObjects(TestCaseWithTransport):
270
 
 
271
 
    def setUp(self):
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'))
276
 
 
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",
282
 
            (None, "blobname"), 
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])
292
 
        ie = ret[0][3]
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)
297
 
 
298
 
    def test_import_tree_empty_root(self):
299
 
        base_inv = Inventory(root_id=None)
300
 
        tree = Tree()
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])
311
 
        ie = ret[0][3]
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)
317
 
 
318
 
    def test_import_tree_empty(self):
319
 
        base_inv = Inventory()
320
 
        tree = Tree()
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])
331
 
        ie = ret[0][3]
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)
337
 
 
338
 
    def test_import_tree_with_file(self):
339
 
        base_inv = Inventory()
340
 
        blob = Blob.from_string("bar1")
341
 
        tree = Tree()
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])
354
 
        ie = ret[0][3]
355
 
        self.assertEquals("directory", ie.kind)
356
 
        ie = ret[1][3]
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)
362
 
 
363
 
    def test_import_tree_with_unusual_mode_file(self):
364
 
        base_inv = Inventory()
365
 
        blob = Blob.from_string("bar1")
366
 
        tree = Tree()
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 })
374
 
 
375
 
    def test_import_tree_with_file_exe(self):
376
 
        base_inv = Inventory(root_id=None)
377
 
        blob = Blob.from_string("bar")
378
 
        tree = Tree()
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])
391
 
        ie = ret[0][3]
392
 
        self.assertEquals("directory", ie.kind)
393
 
        ie = ret[1][3]
394
 
        self.assertEquals("file", ie.kind)
395
 
        self.assertEquals(True, ie.executable)