/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_branch.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_branch.py
1
 
# Copyright (C) 2007 Canonical Ltd
2
 
#
3
 
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License as published by
5
 
# the Free Software Foundation; either version 2 of the License, or
6
 
# (at your option) any later version.
7
 
#
8
 
# This program is distributed in the hope that it will be useful,
9
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
# GNU General Public License for more details.
12
 
#
13
 
# You should have received a copy of the GNU General Public License
14
 
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 
 
17
 
 
18
 
"""Tests for interfacing with a Git Branch"""
19
 
 
20
 
 
21
 
import dulwich
22
 
from dulwich.objects import (
23
 
    Commit,
24
 
    Tag,
25
 
    )
26
 
from dulwich.repo import (
27
 
    Repo as GitRepo,
28
 
    )
29
 
 
30
 
import os
31
 
 
32
 
from bzrlib import (
33
 
    errors,
34
 
    revision,
35
 
    )
36
 
from bzrlib.branch import (
37
 
    Branch,
38
 
    InterBranch,
39
 
    )
40
 
from bzrlib.bzrdir import (
41
 
    BzrDir,
42
 
    )
43
 
from bzrlib.repository import (
44
 
    Repository,
45
 
    )
46
 
 
47
 
from bzrlib.plugins.git import (
48
 
    LocalGitControlDirFormat,
49
 
    branch,
50
 
    tests,
51
 
    )
52
 
from bzrlib.plugins.git.mapping import (
53
 
    default_mapping,
54
 
    )
55
 
 
56
 
 
57
 
class TestGitBranch(tests.TestCaseInTempDir):
58
 
 
59
 
    def test_open_existing(self):
60
 
        GitRepo.init('.')
61
 
        d = BzrDir.open('.')
62
 
        thebranch = d.create_branch()
63
 
        self.assertIsInstance(thebranch, branch.GitBranch)
64
 
 
65
 
    def test_repr(self):
66
 
        GitRepo.init('.')
67
 
        d = BzrDir.open('.')
68
 
        thebranch = d.create_branch()
69
 
        self.assertEquals("<LocalGitBranch('file://%s/', 'HEAD')>" % self.test_dir, repr(thebranch))
70
 
 
71
 
    def test_last_revision_is_null(self):
72
 
        GitRepo.init('.')
73
 
        thedir = BzrDir.open('.')
74
 
        thebranch = thedir.create_branch()
75
 
        self.assertEqual(revision.NULL_REVISION, thebranch.last_revision())
76
 
        self.assertEqual((0, revision.NULL_REVISION),
77
 
                         thebranch.last_revision_info())
78
 
 
79
 
    def simple_commit_a(self):
80
 
        r = GitRepo.init('.')
81
 
        self.build_tree(['a'])
82
 
        r.stage(["a"])
83
 
        return r.do_commit("a", committer="Somebody <foo@example.com>")
84
 
 
85
 
    def test_last_revision_is_valid(self):
86
 
        head = self.simple_commit_a()
87
 
        thebranch = Branch.open('.')
88
 
        self.assertEqual(default_mapping.revision_id_foreign_to_bzr(head),
89
 
                         thebranch.last_revision())
90
 
 
91
 
    def test_revision_history(self):
92
 
        reva = self.simple_commit_a()
93
 
        self.build_tree(['b'])
94
 
        r = GitRepo(".")
95
 
        r.stage("b")
96
 
        revb = r.do_commit("b", committer="Somebody <foo@example.com>")
97
 
 
98
 
        thebranch = Branch.open('.')
99
 
        self.assertEqual([default_mapping.revision_id_foreign_to_bzr(r) for r in (reva, revb)],
100
 
                         thebranch.revision_history())
101
 
 
102
 
    def test_tag_annotated(self):
103
 
        reva = self.simple_commit_a()
104
 
        o = Tag()
105
 
        o.name = "foo"
106
 
        o.tagger = "Jelmer <foo@example.com>"
107
 
        o.message = "add tag"
108
 
        o.object = (Commit, reva)
109
 
        o.tag_timezone = 0
110
 
        o.tag_time = 42
111
 
        r = GitRepo(".")
112
 
        r.object_store.add_object(o)
113
 
        r['refs/tags/foo'] = o.id
114
 
        thebranch = Branch.open('.')
115
 
        self.assertEquals({"foo": default_mapping.revision_id_foreign_to_bzr(reva)},
116
 
                          thebranch.tags.get_tag_dict())
117
 
 
118
 
    def test_tag(self):
119
 
        reva = self.simple_commit_a()
120
 
        r = GitRepo(".")
121
 
        r.refs["refs/tags/foo"] = reva
122
 
        thebranch = Branch.open('.')
123
 
        self.assertEquals({"foo": default_mapping.revision_id_foreign_to_bzr(reva)},
124
 
                          thebranch.tags.get_tag_dict())
125
 
 
126
 
 
127
 
 
128
 
class TestWithGitBranch(tests.TestCaseWithTransport):
129
 
 
130
 
    def setUp(self):
131
 
        tests.TestCaseWithTransport.setUp(self)
132
 
        dulwich.repo.Repo.create(self.test_dir)
133
 
        d = BzrDir.open(self.test_dir)
134
 
        self.git_branch = d.create_branch()
135
 
 
136
 
    def test_get_parent(self):
137
 
        self.assertIs(None, self.git_branch.get_parent())
138
 
 
139
 
    def test_get_stacked_on_url(self):
140
 
        self.assertRaises(errors.UnstackableBranchFormat,
141
 
            self.git_branch.get_stacked_on_url)
142
 
 
143
 
    def test_get_physical_lock_status(self):
144
 
        self.assertFalse(self.git_branch.get_physical_lock_status())
145
 
 
146
 
 
147
 
class TestGitBranchFormat(tests.TestCase):
148
 
 
149
 
    def setUp(self):
150
 
        super(TestGitBranchFormat, self).setUp()
151
 
        self.format = branch.GitBranchFormat()
152
 
 
153
 
    def test_get_format_description(self):
154
 
        self.assertEquals("Git Branch", self.format.get_format_description())
155
 
 
156
 
    def test_get_network_name(self):
157
 
        self.assertEquals("git", self.format.network_name())
158
 
 
159
 
    def test_supports_tags(self):
160
 
        self.assertTrue(self.format.supports_tags())
161
 
 
162
 
 
163
 
class BranchTests(tests.TestCaseInTempDir):
164
 
 
165
 
    def make_onerev_branch(self):
166
 
        os.mkdir("d")
167
 
        os.chdir("d")
168
 
        GitRepo.init('.')
169
 
        bb = tests.GitBranchBuilder()
170
 
        bb.set_file("foobar", "foo\nbar\n", False)
171
 
        mark = bb.commit("Somebody <somebody@someorg.org>", "mymsg")
172
 
        gitsha = bb.finish()[mark]
173
 
        os.chdir("..")
174
 
        return "d", gitsha
175
 
 
176
 
    def make_tworev_branch(self):
177
 
        os.mkdir("d")
178
 
        os.chdir("d")
179
 
        GitRepo.init('.')
180
 
        bb = tests.GitBranchBuilder()
181
 
        bb.set_file("foobar", "foo\nbar\n", False)
182
 
        mark1 = bb.commit("Somebody <somebody@someorg.org>", "mymsg")
183
 
        mark2 = bb.commit("Somebody <somebody@someorg.org>", "mymsg")
184
 
        marks = bb.finish()
185
 
        os.chdir("..")
186
 
        return "d", (marks[mark1], marks[mark2])
187
 
 
188
 
    def clone_git_branch(self, from_url, to_url):
189
 
        from_dir = BzrDir.open(from_url)
190
 
        to_dir = from_dir.sprout(to_url)
191
 
        return to_dir.open_branch()
192
 
 
193
 
    def test_single_rev(self):
194
 
        path, gitsha = self.make_onerev_branch()
195
 
        oldrepo = Repository.open(path)
196
 
        revid = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha)
197
 
        newbranch = self.clone_git_branch(path, "f")
198
 
        self.assertEquals([revid], newbranch.repository.all_revision_ids())
199
 
 
200
 
    def test_sprouted_tags(self):
201
 
        path, gitsha = self.make_onerev_branch()
202
 
        r = GitRepo(path)
203
 
        r.refs["refs/tags/lala"] = r.head()
204
 
        oldrepo = Repository.open(path)
205
 
        revid = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha)
206
 
        newbranch = self.clone_git_branch(path, "f")
207
 
        self.assertEquals({"lala": revid}, newbranch.tags.get_tag_dict())
208
 
        self.assertEquals([revid], newbranch.repository.all_revision_ids())
209
 
 
210
 
    def test_interbranch_pull(self):
211
 
        path, (gitsha1, gitsha2) = self.make_tworev_branch()
212
 
        oldrepo = Repository.open(path)
213
 
        revid2 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha2)
214
 
        newbranch = self.make_branch('g')
215
 
        inter_branch = InterBranch.get(Branch.open(path), newbranch)
216
 
        inter_branch.pull()
217
 
        self.assertEquals(revid2, newbranch.last_revision())
218
 
 
219
 
    def test_interbranch_pull_noop(self):
220
 
        path, (gitsha1, gitsha2) = self.make_tworev_branch()
221
 
        oldrepo = Repository.open(path)
222
 
        revid2 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha2)
223
 
        newbranch = self.make_branch('g')
224
 
        inter_branch = InterBranch.get(Branch.open(path), newbranch)
225
 
        inter_branch.pull()
226
 
        # This is basically "assertNotRaises"
227
 
        inter_branch.pull()
228
 
        self.assertEquals(revid2, newbranch.last_revision())
229
 
 
230
 
    def test_interbranch_pull_stop_revision(self):
231
 
        path, (gitsha1, gitsha2) = self.make_tworev_branch()
232
 
        oldrepo = Repository.open(path)
233
 
        revid1 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha1)
234
 
        newbranch = self.make_branch('g')
235
 
        inter_branch = InterBranch.get(Branch.open(path), newbranch)
236
 
        inter_branch.pull(stop_revision=revid1)
237
 
        self.assertEquals(revid1, newbranch.last_revision())
238
 
 
239
 
    def test_interbranch_limited_pull(self):
240
 
        path, (gitsha1, gitsha2) = self.make_tworev_branch()
241
 
        oldrepo = Repository.open(path)
242
 
        revid1 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha1)
243
 
        revid2 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha2)
244
 
        newbranch = self.make_branch('g')
245
 
        inter_branch = InterBranch.get(Branch.open(path), newbranch)
246
 
        inter_branch.pull(limit=1)
247
 
        self.assertEquals(revid1, newbranch.last_revision())
248
 
        inter_branch.pull(limit=1)
249
 
        self.assertEquals(revid2, newbranch.last_revision())
250
 
 
251
 
 
252
 
class ForeignTestsBranchFactory(object):
253
 
 
254
 
    def make_empty_branch(self, transport):
255
 
        d = LocalGitControlDirFormat().initialize_on_transport(transport)
256
 
        return d.create_branch()
257
 
 
258
 
    make_branch = make_empty_branch
259
 
 
260
 
 
261