/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: John Arbash Meinel
  • Date: 2009-06-18 18:18:36 UTC
  • mto: This revision was merged to the branch mainline in revision 4461.
  • Revision ID: john@arbash-meinel.com-20090618181836-biodfkat9a8eyzjz
The new add_inventory_by_delta is returning a CHKInventory when mapping from NULL
Which is completely valid, but 'broke' one of the tests.
So to fix it, changed the test to use CHKInventories on both sides, and add an __eq__
member. The nice thing is that CHKInventory.__eq__ is fairly cheap, since it only
has to check the root keys.

Show diffs side-by-side

added added

removed removed

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