/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: Andrew Bennetts
  • Date: 2009-10-21 11:13:40 UTC
  • mto: This revision was merged to the branch mainline in revision 4762.
  • Revision ID: andrew.bennetts@canonical.com-20091021111340-w7x4d5yf83qwjncc
Add test that WSGI glue allows request handlers to access paths above that request's. backing transport, so long as it is within the WSGI app's backing transport.

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
 
import os
23
 
 
24
 
from bzrlib import (
25
 
    knit,
26
 
    osutils,
27
 
    versionedfile,
28
 
    )
29
 
from bzrlib.bzrdir import (
30
 
    BzrDir,
31
 
    )
32
 
from bzrlib.inventory import (
33
 
    Inventory,
34
 
    )
35
 
from bzrlib.repository import (
36
 
    Repository,
37
 
    )
38
 
from bzrlib.tests import (
39
 
    TestCaseWithTransport,
40
 
    )
41
 
from bzrlib.transport import (
42
 
    get_transport,
43
 
    )
44
 
 
45
 
from bzrlib.plugins.git import (
46
 
    get_rich_root_format,
47
 
    )
48
 
from bzrlib.plugins.git.fetch import (
49
 
    BzrFetchGraphWalker,
50
 
    import_git_blob,
51
 
    import_git_tree,
52
 
    )
53
 
from bzrlib.plugins.git.mapping import (
54
 
    BzrGitMappingv1,
55
 
    default_mapping,
56
 
    )
57
 
from bzrlib.plugins.git.shamap import (
58
 
    DictGitShaMap,
59
 
    )
60
 
from bzrlib.plugins.git.tests import (
61
 
    GitBranchBuilder,
62
 
    run_git,
63
 
    )
64
 
 
65
 
 
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
 
class RepositoryFetchTests:
79
 
 
80
 
    def make_git_repo(self, path):
81
 
        os.mkdir(path)
82
 
        os.chdir(path)
83
 
        run_git("init")
84
 
        os.chdir("..")
85
 
 
86
 
    def clone_git_repo(self, from_url, to_url, revision_id=None):
87
 
        oldrepos = self.open_git_repo(from_url)
88
 
        dir = BzrDir.create(to_url, get_rich_root_format())
89
 
        newrepos = dir.create_repository()
90
 
        oldrepos.copy_content_into(newrepos, revision_id=revision_id)
91
 
        return newrepos
92
 
 
93
 
    def test_empty(self):
94
 
        self.make_git_repo("d")
95
 
        newrepos = self.clone_git_repo("d", "f")
96
 
        self.assertEquals([], newrepos.all_revision_ids())
97
 
 
98
 
    def make_onerev_branch(self):
99
 
        self.make_git_repo("d")
100
 
        os.chdir("d")
101
 
        bb = GitBranchBuilder()
102
 
        bb.set_file("foobar", "foo\nbar\n", False)
103
 
        mark = bb.commit("Somebody <somebody@someorg.org>", "mymsg")
104
 
        gitsha = bb.finish()[mark]
105
 
        os.chdir("..")
106
 
        return "d", gitsha
107
 
 
108
 
    def test_single_rev(self):
109
 
        path, gitsha = self.make_onerev_branch()
110
 
        oldrepo = self.open_git_repo(path)
111
 
        newrepo = self.clone_git_repo(path, "f")
112
 
        self.assertEquals([oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha)], newrepo.all_revision_ids())
113
 
 
114
 
    def test_single_rev_specific(self):
115
 
        path, gitsha = self.make_onerev_branch()
116
 
        oldrepo = self.open_git_repo(path)
117
 
        revid = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha)
118
 
        newrepo = self.clone_git_repo(path, "f", revision_id=revid)
119
 
        self.assertEquals([revid], newrepo.all_revision_ids())
120
 
 
121
 
    def test_incremental(self):
122
 
        self.make_git_repo("d")
123
 
        os.chdir("d")
124
 
        bb = GitBranchBuilder()
125
 
        bb.set_file("foobar", "foo\nbar\n", False)
126
 
        mark1 = bb.commit("Somebody <somebody@someorg.org>", "mymsg")
127
 
        bb.set_file("foobar", "fooll\nbar\n", False)
128
 
        mark2 = bb.commit("Somebody <somebody@someorg.org>", "nextmsg")
129
 
        marks = bb.finish()
130
 
        gitsha1 = marks[mark1]
131
 
        gitsha2 = marks[mark2]
132
 
        os.chdir("..")
133
 
        oldrepo = self.open_git_repo("d")
134
 
        revid1 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha1)
135
 
        newrepo = self.clone_git_repo("d", "f", revision_id=revid1)
136
 
        self.assertEquals([revid1], newrepo.all_revision_ids())
137
 
        revid2 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha2)
138
 
        newrepo.fetch(oldrepo, revision_id=revid2)
139
 
        self.assertEquals(set([revid1, revid2]), set(newrepo.all_revision_ids()))
140
 
 
141
 
    def test_executable(self):
142
 
        self.make_git_repo("d")
143
 
        os.chdir("d")
144
 
        bb = GitBranchBuilder()
145
 
        bb.set_file("foobar", "foo\nbar\n", True)
146
 
        bb.set_file("notexec", "foo\nbar\n", False)
147
 
        mark = bb.commit("Somebody <somebody@someorg.org>", "mymsg")
148
 
        gitsha = bb.finish()[mark]
149
 
        os.chdir("..")
150
 
        oldrepo = self.open_git_repo("d")
151
 
        newrepo = self.clone_git_repo("d", "f")
152
 
        revid = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha)
153
 
        tree = newrepo.revision_tree(revid)
154
 
        self.assertTrue(tree.has_filename("foobar"))
155
 
        self.assertEquals(True, tree.inventory[tree.path2id("foobar")].executable)
156
 
        self.assertTrue(tree.has_filename("notexec"))
157
 
        self.assertEquals(False, tree.inventory[tree.path2id("notexec")].executable)
158
 
 
159
 
    def test_non_ascii_characters(self):
160
 
        self.make_git_repo("d")
161
 
        os.chdir("d")
162
 
        bb = GitBranchBuilder()
163
 
        bb.set_file(u"foőbar", "foo\nbar\n", False)
164
 
        mark = bb.commit("Somebody <somebody@someorg.org>", "mymsg")
165
 
        gitsha = bb.finish()[mark]
166
 
        os.chdir("..")
167
 
        oldrepo = self.open_git_repo("d")
168
 
        newrepo = self.clone_git_repo("d", "f")
169
 
        revid = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha)
170
 
        tree = newrepo.revision_tree(revid)
171
 
        self.assertTrue(tree.has_filename(u"foőbar"))
172
 
 
173
 
 
174
 
class LocalRepositoryFetchTests(RepositoryFetchTests, TestCaseWithTransport):
175
 
 
176
 
    def open_git_repo(self, path):
177
 
        return Repository.open(path)
178
 
 
179
 
 
180
 
class ImportObjects(TestCaseWithTransport):
181
 
 
182
 
    def setUp(self):
183
 
        super(ImportObjects, self).setUp()
184
 
        self._map = DictGitShaMap()
185
 
        self._mapping = BzrGitMappingv1()
186
 
        factory = knit.make_file_factory(True, versionedfile.PrefixMapper())
187
 
        self._texts = factory(self.get_transport('texts'))
188
 
 
189
 
    def test_import_blob_simple(self):
190
 
        blob = Blob.from_string("bar")
191
 
        base_inv = Inventory()
192
 
        objs = { "blobname": blob}
193
 
        ret, _= import_git_blob(self._texts, self._mapping, "bla", "blobname", 
194
 
            base_inv, None, "somerevid", [], self._map, objs.__getitem__, False,
195
 
            False)
196
 
        self.assertEquals(set([('bla', 'somerevid')]), self._texts.keys())
197
 
        self.assertEquals(self._texts.get_record_stream([('bla', 'somerevid')],
198
 
            "unordered", True).next().get_bytes_as("fulltext"), "bar")
199
 
        self.assertEquals(1, len(ret)) 
200
 
        self.assertEquals(None, ret[0][0])
201
 
        self.assertEquals("bla", ret[0][1])
202
 
        ie = ret[0][3]
203
 
        self.assertEquals(False, ie.executable)
204
 
        self.assertEquals("file", ie.kind)
205
 
        self.assertEquals("somerevid", ie.revision)
206
 
        self.assertEquals(osutils.sha_strings(["bar"]), ie.text_sha1)
207
 
 
208
 
    def test_import_tree_empty_root(self):
209
 
        base_inv = Inventory(root_id=None)
210
 
        tree = Tree()
211
 
        tree.serialize()
212
 
        ret, _, _ = import_git_tree(self._texts, self._mapping, "", 
213
 
               tree.id, base_inv, 
214
 
               None, "somerevid", [], self._map, {tree.id: tree}.__getitem__)
215
 
        self.assertEquals(set([("TREE_ROOT", 'somerevid')]), self._texts.keys())
216
 
        self.assertEquals(1, len(ret))
217
 
        self.assertEquals(None, ret[0][0])
218
 
        self.assertEquals("", ret[0][1])
219
 
        ie = ret[0][3]
220
 
        self.assertEquals(False, ie.executable)
221
 
        self.assertEquals("directory", ie.kind)
222
 
        self.assertEquals({}, ie.children)
223
 
        self.assertEquals("somerevid", ie.revision)
224
 
        self.assertEquals(None, ie.text_sha1)
225
 
 
226
 
    def test_import_tree_empty(self):
227
 
        base_inv = Inventory()
228
 
        tree = Tree()
229
 
        tree.serialize()
230
 
        ret, _, _ = import_git_tree(self._texts, self._mapping, "bla", 
231
 
           tree.id, base_inv, None, "somerevid", [], 
232
 
           self._map, { tree.id: tree }.__getitem__)
233
 
        self.assertEquals(set([("bla", 'somerevid')]), self._texts.keys())
234
 
        self.assertEquals(1, len(ret))
235
 
        self.assertEquals(None, ret[0][0])
236
 
        self.assertEquals("bla", ret[0][1])
237
 
        ie = ret[0][3]
238
 
        self.assertEquals("directory", ie.kind)
239
 
        self.assertEquals(False, ie.executable)
240
 
        self.assertEquals({}, ie.children)
241
 
        self.assertEquals("somerevid", ie.revision)
242
 
        self.assertEquals(None, ie.text_sha1)
243
 
 
244
 
    def test_import_tree_with_file(self):
245
 
        base_inv = Inventory()
246
 
        blob = Blob.from_string("bar1")
247
 
        tree = Tree()
248
 
        tree.add(0100600, "foo", blob.id)
249
 
        tree.serialize()
250
 
        objects = { blob.id: blob, tree.id: tree }
251
 
        ret, _, _ = import_git_tree(self._texts, self._mapping, "bla", tree.id, 
252
 
            base_inv, None, "somerevid", [], self._map, objects.__getitem__)
253
 
        self.assertEquals(2, len(ret))
254
 
        self.assertEquals(None, ret[0][0])
255
 
        self.assertEquals("bla", ret[0][1])
256
 
        self.assertEquals(None, ret[1][0])
257
 
        self.assertEquals("bla/foo", ret[1][1])
258
 
        ie = ret[0][3]
259
 
        self.assertEquals("directory", ie.kind)
260
 
        ie = ret[1][3]
261
 
        self.assertEquals("file", ie.kind)
262
 
        self.assertEquals("bla/foo", ie.file_id)
263
 
        self.assertEquals("somerevid", ie.revision)
264
 
        self.assertEquals(osutils.sha_strings(["bar1"]), ie.text_sha1)
265
 
        self.assertEquals(False, ie.executable)
266
 
 
267
 
    def test_import_tree_with_file_exe(self):
268
 
        base_inv = Inventory(root_id=None)
269
 
        blob = Blob.from_string("bar")
270
 
        tree = Tree()
271
 
        tree.add(0100755, "foo", blob.id)
272
 
        tree.serialize()
273
 
        objects = { blob.id: blob, tree.id: tree }
274
 
        ret, _, _ = import_git_tree(self._texts, self._mapping, "", tree.id, 
275
 
            base_inv, None, "somerevid", [], self._map, objects.__getitem__)
276
 
        self.assertEquals(2, len(ret))
277
 
        self.assertEquals(None, ret[0][0])
278
 
        self.assertEquals("", ret[0][1])
279
 
        self.assertEquals(None, ret[1][0])
280
 
        self.assertEquals("foo", ret[1][1])
281
 
        ie = ret[0][3]
282
 
        self.assertEquals("directory", ie.kind)
283
 
        ie = ret[1][3]
284
 
        self.assertEquals("file", ie.kind)
285
 
        self.assertEquals(True, ie.executable)