/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 bzrlib/tests/test_missing.py

  • Committer: Vincent Ladeuil
  • Date: 2012-01-18 14:09:19 UTC
  • mto: This revision was merged to the branch mainline in revision 6468.
  • Revision ID: v.ladeuil+lp@free.fr-20120118140919-rlvdrhpc0nq1lbwi
Change set/remove to require a lock for the branch config files.

This means that tests (or any plugin for that matter) do not requires an
explicit lock on the branch anymore to change a single option. This also
means the optimisation becomes "opt-in" and as such won't be as
spectacular as it may be and/or harder to get right (nothing fails
anymore).

This reduces the diff by ~300 lines.

Code/tests that were updating more than one config option is still taking
a lock to at least avoid some IOs and demonstrate the benefits through
the decreased number of hpss calls.

The duplication between BranchStack and BranchOnlyStack will be removed
once the same sharing is in place for local config files, at which point
the Stack class itself may be able to host the changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_missing.py
 
1
# Copyright (C) 2005-2009, 2011 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
from bzrlib import (
 
18
    missing,
 
19
    tests,
 
20
    )
 
21
from bzrlib.missing import (
 
22
    iter_log_revisions,
 
23
    )
 
24
from bzrlib.tests import TestCaseWithTransport
 
25
 
 
26
 
 
27
class TestMissing(TestCaseWithTransport):
 
28
 
 
29
    def assertUnmerged(self, expected, source, target, restrict='all',
 
30
                       backward=False):
 
31
        unmerged = missing.find_unmerged(source, target, restrict=restrict,
 
32
                                         backward=backward)
 
33
        self.assertEqual(expected, unmerged)
 
34
 
 
35
    def test_find_unmerged(self):
 
36
        original_tree = self.make_branch_and_tree('original')
 
37
        original = original_tree.branch
 
38
        puller_tree = self.make_branch_and_tree('puller')
 
39
        puller = puller_tree.branch
 
40
        merger_tree = self.make_branch_and_tree('merger')
 
41
        merger = merger_tree.branch
 
42
        self.assertUnmerged(([], []), original, puller)
 
43
        original_tree.commit('a', rev_id='a')
 
44
        self.assertUnmerged(([('1', 'a')], []), original, puller)
 
45
        puller_tree.pull(original)
 
46
        self.assertUnmerged(([], []), original, puller)
 
47
        merger_tree.pull(original)
 
48
        original_tree.commit('b', rev_id='b')
 
49
        original_tree.commit('c', rev_id='c')
 
50
        self.assertUnmerged(([('2', 'b'), ('3', 'c')], []),
 
51
                            original, puller)
 
52
        self.assertUnmerged(([('3', 'c'), ('2', 'b')], []),
 
53
                            original, puller, backward=True)
 
54
 
 
55
        puller_tree.pull(original)
 
56
        self.assertUnmerged(([], []), original, puller)
 
57
        self.assertUnmerged(([('2', 'b'), ('3', 'c')], []),
 
58
                            original, merger)
 
59
        merger_tree.merge_from_branch(original)
 
60
        self.assertUnmerged(([('2', 'b'), ('3', 'c')], []),
 
61
                            original, merger)
 
62
        merger_tree.commit('d', rev_id='d')
 
63
        self.assertUnmerged(([], [('2', 'd')]), original, merger)
 
64
 
 
65
    def test_iter_log_revisions(self):
 
66
        base_tree = self.make_branch_and_tree('base')
 
67
        self.build_tree(['base/a'])
 
68
        base_tree.add(['a'], ['a-id'])
 
69
        base_tree.commit('add a', rev_id='b-1')
 
70
 
 
71
        child_tree = base_tree.bzrdir.sprout('child').open_workingtree()
 
72
 
 
73
        self.build_tree(['child/b'])
 
74
        child_tree.add(['b'], ['b-id'])
 
75
        child_tree.commit('adding b', rev_id='c-2')
 
76
 
 
77
        child_tree.remove(['a'])
 
78
        child_tree.commit('removing a', rev_id='c-3')
 
79
 
 
80
        self.build_tree_contents([('child/b', 'new contents for b\n')])
 
81
        child_tree.commit('modifying b', rev_id='c-4')
 
82
 
 
83
        child_tree.rename_one('b', 'c')
 
84
        child_tree.commit('rename b=>c', rev_id='c-5')
 
85
 
 
86
        base_extra, child_extra = missing.find_unmerged(base_tree.branch,
 
87
                                                        child_tree.branch)
 
88
        results = list(iter_log_revisions(base_extra,
 
89
                            base_tree.branch.repository,
 
90
                            verbose=True))
 
91
        self.assertEqual([], results)
 
92
 
 
93
        results = list(iter_log_revisions(child_extra,
 
94
                            child_tree.branch.repository,
 
95
                            verbose=True))
 
96
        self.assertEqual(4, len(results))
 
97
 
 
98
        r0,r1,r2,r3 = results
 
99
 
 
100
        self.assertEqual([('2', 'c-2'), ('3', 'c-3'),
 
101
                          ('4', 'c-4'), ('5', 'c-5'),],
 
102
                         [(r.revno, r.rev.revision_id) for r in results])
 
103
 
 
104
        delta0 = r0.delta
 
105
        self.assertNotEqual(None, delta0)
 
106
        self.assertEqual([('b', 'b-id', 'file')], delta0.added)
 
107
        self.assertEqual([], delta0.removed)
 
108
        self.assertEqual([], delta0.renamed)
 
109
        self.assertEqual([], delta0.modified)
 
110
 
 
111
        delta1 = r1.delta
 
112
        self.assertNotEqual(None, delta1)
 
113
        self.assertEqual([], delta1.added)
 
114
        self.assertEqual([('a', 'a-id', 'file')], delta1.removed)
 
115
        self.assertEqual([], delta1.renamed)
 
116
        self.assertEqual([], delta1.modified)
 
117
 
 
118
        delta2 = r2.delta
 
119
        self.assertNotEqual(None, delta2)
 
120
        self.assertEqual([], delta2.added)
 
121
        self.assertEqual([], delta2.removed)
 
122
        self.assertEqual([], delta2.renamed)
 
123
        self.assertEqual([('b', 'b-id', 'file', True, False)], delta2.modified)
 
124
 
 
125
        delta3 = r3.delta
 
126
        self.assertNotEqual(None, delta3)
 
127
        self.assertEqual([], delta3.added)
 
128
        self.assertEqual([], delta3.removed)
 
129
        self.assertEqual([('b', 'c', 'b-id', 'file', False, False)],
 
130
                         delta3.renamed)
 
131
        self.assertEqual([], delta3.modified)
 
132
 
 
133
 
 
134
class TestFindUnmerged(tests.TestCaseWithTransport):
 
135
 
 
136
    def assertUnmerged(self, local, remote, local_branch, remote_branch,
 
137
            restrict='all', include_merged=False, backward=False,
 
138
            local_revid_range=None, remote_revid_range=None):
 
139
        """Check the output of find_unmerged_mainline_revisions"""
 
140
        local_extra, remote_extra = missing.find_unmerged(
 
141
            local_branch, remote_branch, restrict,
 
142
            include_merged=include_merged, backward=backward,
 
143
            local_revid_range=local_revid_range,
 
144
            remote_revid_range=remote_revid_range)
 
145
        self.assertEqual(local, local_extra)
 
146
        self.assertEqual(remote, remote_extra)
 
147
 
 
148
    def test_same_branch(self):
 
149
        tree = self.make_branch_and_tree('tree')
 
150
        rev1 = tree.commit('one')
 
151
        tree.lock_read()
 
152
        self.addCleanup(tree.unlock)
 
153
        self.assertUnmerged([], [], tree.branch, tree.branch)
 
154
        self.assertUnmerged([], [], tree.branch, tree.branch,
 
155
            local_revid_range=(rev1, rev1))
 
156
 
 
157
    def test_one_ahead(self):
 
158
        tree = self.make_branch_and_tree('tree')
 
159
        rev1 = tree.commit('one')
 
160
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
 
161
        rev2 = tree2.commit('two')
 
162
        self.assertUnmerged([], [('2', rev2)], tree.branch, tree2.branch)
 
163
        self.assertUnmerged([('2', rev2)], [], tree2.branch, tree.branch)
 
164
 
 
165
    def test_restrict(self):
 
166
        tree = self.make_branch_and_tree('tree')
 
167
        rev1 = tree.commit('one')
 
168
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
 
169
        rev2 = tree2.commit('two')
 
170
        self.assertUnmerged([], [('2', rev2)], tree.branch, tree2.branch)
 
171
        self.assertUnmerged([], None, tree.branch, tree2.branch, 'local')
 
172
        self.assertUnmerged(None, [('2', rev2)], tree.branch, tree2.branch,
 
173
                                               'remote')
 
174
 
 
175
    def test_merged(self):
 
176
        tree = self.make_branch_and_tree('tree')
 
177
        rev1 = tree.commit('one')
 
178
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
 
179
        rev2 = tree2.commit('two')
 
180
        rev3 = tree2.commit('three')
 
181
        tree.merge_from_branch(tree2.branch)
 
182
        rev4 = tree.commit('four')
 
183
 
 
184
        self.assertUnmerged([('2', rev4)], [], tree.branch, tree2.branch)
 
185
        self.assertUnmerged([('2', rev4)], [], tree.branch, tree2.branch,
 
186
            local_revid_range=(rev4, rev4))
 
187
        self.assertUnmerged([], [], tree.branch, tree2.branch,
 
188
            local_revid_range=(rev1, rev1))
 
189
 
 
190
    def test_include_merged(self):
 
191
        tree = self.make_branch_and_tree('tree')
 
192
        rev1 = tree.commit('one', rev_id='rev1')
 
193
 
 
194
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
 
195
        rev2 = tree2.commit('two', rev_id='rev2')
 
196
        rev3 = tree2.commit('three', rev_id='rev3')
 
197
 
 
198
        tree3 = tree2.bzrdir.sprout('tree3').open_workingtree()
 
199
        rev4 = tree3.commit('four', rev_id='rev4')
 
200
        rev5 = tree3.commit('five', rev_id='rev5')
 
201
 
 
202
        tree2.merge_from_branch(tree3.branch)
 
203
        rev6 = tree2.commit('six', rev_id='rev6')
 
204
 
 
205
        self.assertUnmerged([], [('2', 'rev2', 0), ('3', 'rev3', 0),
 
206
                                 ('4', 'rev6', 0),
 
207
                                 ('3.1.1', 'rev4', 1), ('3.1.2', 'rev5', 1),
 
208
                                 ],
 
209
                            tree.branch, tree2.branch,
 
210
                            include_merged=True)
 
211
 
 
212
        self.assertUnmerged([], [('4', 'rev6', 0),
 
213
                                 ('3.1.2', 'rev5', 1), ('3.1.1', 'rev4', 1),
 
214
                                 ('3', 'rev3', 0), ('2', 'rev2', 0),
 
215
                                 ],
 
216
                            tree.branch, tree2.branch,
 
217
                            include_merged=True,
 
218
                            backward=True)
 
219
 
 
220
        self.assertUnmerged([], [('4', 'rev6', 0)],
 
221
            tree.branch, tree2.branch,
 
222
            include_merged=True, remote_revid_range=(rev6, rev6))
 
223
 
 
224
        self.assertUnmerged([], [('3', 'rev3', 0), ('3.1.1', 'rev4', 1)],
 
225
                    tree.branch, tree2.branch,
 
226
                    include_merged=True, remote_revid_range=(rev3, rev4))
 
227
 
 
228
        self.assertUnmerged([], [('4', 'rev6', 0), ('3.1.2', 'rev5', 1)],
 
229
                    tree.branch, tree2.branch,
 
230
                    include_merged=True, remote_revid_range=(rev5, rev6))
 
231
 
 
232
    def test_revision_range(self):
 
233
        local = self.make_branch_and_tree('local')
 
234
        lrevid1 = local.commit('one')
 
235
        remote = local.bzrdir.sprout('remote').open_workingtree()
 
236
        rrevid2 = remote.commit('two')
 
237
        rrevid3 = remote.commit('three')
 
238
        rrevid4 = remote.commit('four')
 
239
        lrevid2 = local.commit('two')
 
240
        lrevid3 = local.commit('three')
 
241
        lrevid4 = local.commit('four')
 
242
        local_extra = [('2', lrevid2), ('3', lrevid3), ('4', lrevid4)]
 
243
        remote_extra = [('2', rrevid2), ('3', rrevid3), ('4', rrevid4)]
 
244
 
 
245
        # control
 
246
        self.assertUnmerged(local_extra, remote_extra,
 
247
            local.branch, remote.branch)
 
248
        self.assertUnmerged(local_extra, remote_extra,
 
249
            local.branch, remote.branch, local_revid_range=(None, None),
 
250
            remote_revid_range=(None, None))
 
251
 
 
252
        # exclude local revisions
 
253
        self.assertUnmerged([('2', lrevid2)], remote_extra,
 
254
            local.branch, remote.branch, local_revid_range=(lrevid2, lrevid2))
 
255
        self.assertUnmerged([('2', lrevid2), ('3', lrevid3)], remote_extra,
 
256
            local.branch, remote.branch, local_revid_range=(lrevid2, lrevid3))
 
257
        self.assertUnmerged([('2', lrevid2), ('3', lrevid3)], None,
 
258
            local.branch, remote.branch, 'local',
 
259
            local_revid_range=(lrevid2, lrevid3))
 
260
 
 
261
        # exclude remote revisions
 
262
        self.assertUnmerged(local_extra, [('2', rrevid2)],
 
263
            local.branch, remote.branch, remote_revid_range=(None, rrevid2))
 
264
        self.assertUnmerged(local_extra, [('2', rrevid2)],
 
265
            local.branch, remote.branch, remote_revid_range=(lrevid1, rrevid2))
 
266
        self.assertUnmerged(local_extra, [('2', rrevid2)],
 
267
            local.branch, remote.branch, remote_revid_range=(rrevid2, rrevid2))
 
268
        self.assertUnmerged(local_extra, [('2', rrevid2), ('3', rrevid3)],
 
269
            local.branch, remote.branch, remote_revid_range=(None, rrevid3))
 
270
        self.assertUnmerged(local_extra, [('2', rrevid2), ('3', rrevid3)],
 
271
            local.branch, remote.branch, remote_revid_range=(rrevid2, rrevid3))
 
272
        self.assertUnmerged(local_extra, [('3', rrevid3)],
 
273
            local.branch, remote.branch, remote_revid_range=(rrevid3, rrevid3))
 
274
        self.assertUnmerged(None, [('2', rrevid2), ('3', rrevid3)],
 
275
            local.branch, remote.branch, 'remote',
 
276
            remote_revid_range=(rrevid2, rrevid3))
 
277
 
 
278
        # exclude local and remote revisions
 
279
        self.assertUnmerged([('3', lrevid3)], [('3', rrevid3)],
 
280
            local.branch, remote.branch, local_revid_range=(lrevid3, lrevid3),
 
281
            remote_revid_range=(rrevid3, rrevid3))