/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_revision.py

  • Committer: Michael Ellerman
  • Date: 2006-03-09 00:24:48 UTC
  • mto: (1610.1.8 bzr.mbp.integration)
  • mto: This revision was merged to the branch mainline in revision 1616.
  • Revision ID: michael@ellerman.id.au-20060309002448-70cce15e3d605130
Make the "ignore line" in the commit message editor the "right" width, so
that if you make your message that wide it won't wrap in bzr log output.
Just as a visual aid.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_revision.py
 
1
# (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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
import os
 
19
 
 
20
from bzrlib.branch import Branch
 
21
from bzrlib.errors import NoSuchRevision
 
22
from bzrlib.commit import commit
 
23
from bzrlib.revision import (find_present_ancestors, combined_graph,
 
24
                             is_ancestor, MultipleRevisionSources)
 
25
from bzrlib.tests import TestCaseWithTransport
 
26
from bzrlib.trace import mutter
 
27
from bzrlib.workingtree import WorkingTree
 
28
 
 
29
# XXX: Make this a method of a merge base case
 
30
def make_branches(self):
 
31
    """Create two branches
 
32
 
 
33
    branch 1 has 6 commits, branch 2 has 3 commits
 
34
    commit 10 was a psuedo merge from branch 1
 
35
    but has been disabled until ghost support is
 
36
    implemented.
 
37
 
 
38
    the object graph is
 
39
    B:     A:
 
40
    a..0   a..0 
 
41
    a..1   a..1
 
42
    a..2   a..2
 
43
    b..3   a..3 merges b..4
 
44
    b..4   a..4
 
45
    b..5   a..5 merges b..5
 
46
    b..6 merges a4
 
47
 
 
48
    so A is missing b6 at the start
 
49
    and B is missing a3, a4, a5
 
50
    """
 
51
    tree1 = self.make_branch_and_tree("branch1")
 
52
    br1 = tree1.branch
 
53
    
 
54
    tree1.commit("Commit one", rev_id="a@u-0-0")
 
55
    tree1.commit("Commit two", rev_id="a@u-0-1")
 
56
    tree1.commit("Commit three", rev_id="a@u-0-2")
 
57
 
 
58
    tree2 = self.make_branch_and_tree("branch2")
 
59
    br2 = tree2.branch
 
60
    br2.update_revisions(br1)
 
61
    tree2.commit("Commit four", rev_id="b@u-0-3")
 
62
    tree2.commit("Commit five", rev_id="b@u-0-4")
 
63
    revisions_2 = br2.revision_history()
 
64
    
 
65
    br1.fetch(br2)
 
66
    tree1.add_pending_merge(revisions_2[4])
 
67
    self.assertEquals(revisions_2[4], 'b@u-0-4')
 
68
    tree1.commit("Commit six", rev_id="a@u-0-3")
 
69
    tree1.commit("Commit seven", rev_id="a@u-0-4")
 
70
    tree2.commit("Commit eight", rev_id="b@u-0-5")
 
71
    
 
72
    br1.fetch(br2)
 
73
    tree1.add_pending_merge(br2.revision_history()[5])
 
74
    tree1.commit("Commit nine", rev_id="a@u-0-5")
 
75
    # DO NOT FETCH HERE - we WANT a GHOST.
 
76
    # br2.fetch(br1)
 
77
    tree2.add_pending_merge(br1.revision_history()[4])
 
78
    tree2.commit("Commit ten - ghost merge", rev_id="b@u-0-6")
 
79
    
 
80
    return br1, br2
 
81
 
 
82
 
 
83
class TestIsAncestor(TestCaseWithTransport):
 
84
 
 
85
    def test_recorded_ancestry(self):
 
86
        """Test that commit records all ancestors"""
 
87
        br1, br2 = make_branches(self)
 
88
        d = [('a@u-0-0', ['a@u-0-0']),
 
89
             ('a@u-0-1', ['a@u-0-0', 'a@u-0-1']),
 
90
             ('a@u-0-2', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2']),
 
91
             ('b@u-0-3', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3']),
 
92
             ('b@u-0-4', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3',
 
93
                          'b@u-0-4']),
 
94
             ('a@u-0-3', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4',
 
95
                          'a@u-0-3']),
 
96
             ('a@u-0-4', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4',
 
97
                          'a@u-0-3', 'a@u-0-4']),
 
98
             ('b@u-0-5', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4',
 
99
                          'b@u-0-5']),
 
100
             ('a@u-0-5', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4',
 
101
                          'b@u-0-3', 'b@u-0-4',
 
102
                          'b@u-0-5', 'a@u-0-5']),
 
103
             ('b@u-0-6', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2',
 
104
                          'b@u-0-3', 'b@u-0-4',
 
105
                          'b@u-0-5', 'b@u-0-6']),
 
106
             ]
 
107
        br1_only = ('a@u-0-3', 'a@u-0-4', 'a@u-0-5')
 
108
        br2_only = ('b@u-0-6',)
 
109
        for branch in br1, br2:
 
110
            for rev_id, anc in d:
 
111
                if rev_id in br1_only and not branch is br1:
 
112
                    continue
 
113
                if rev_id in br2_only and not branch is br2:
 
114
                    continue
 
115
                mutter('ancestry of {%s}: %r',
 
116
                       rev_id, branch.repository.get_ancestry(rev_id))
 
117
                result = sorted(branch.repository.get_ancestry(rev_id))
 
118
                self.assertEquals(result, [None] + sorted(anc))
 
119
    
 
120
    
 
121
    def test_is_ancestor(self):
 
122
        """Test checking whether a revision is an ancestor of another revision"""
 
123
        br1, br2 = make_branches(self)
 
124
        revisions = br1.revision_history()
 
125
        revisions_2 = br2.revision_history()
 
126
        sources = br1
 
127
 
 
128
        self.assert_(is_ancestor(revisions[0], revisions[0], br1))
 
129
        self.assert_(is_ancestor(revisions[1], revisions[0], sources))
 
130
        self.assert_(not is_ancestor(revisions[0], revisions[1], sources))
 
131
        self.assert_(is_ancestor(revisions_2[3], revisions[0], sources))
 
132
        # disabled mbp 20050914, doesn't seem to happen anymore
 
133
        ## self.assertRaises(NoSuchRevision, is_ancestor, revisions_2[3],
 
134
        ##                  revisions[0], br1)        
 
135
        self.assert_(is_ancestor(revisions[3], revisions_2[4], sources))
 
136
        self.assert_(is_ancestor(revisions[3], revisions_2[4], br1))
 
137
        self.assert_(is_ancestor(revisions[3], revisions_2[3], sources))
 
138
        ## self.assert_(not is_ancestor(revisions[3], revisions_2[3], br1))
 
139
 
 
140
 
 
141
class TestIntermediateRevisions(TestCaseWithTransport):
 
142
 
 
143
    def setUp(self):
 
144
        from bzrlib.commit import commit
 
145
        TestCaseWithTransport.setUp(self)
 
146
        self.br1, self.br2 = make_branches(self)
 
147
        wt1 = self.br1.bzrdir.open_workingtree()
 
148
        wt2 = self.br2.bzrdir.open_workingtree()
 
149
        wt2.commit("Commit eleven", rev_id="b@u-0-7")
 
150
        wt2.commit("Commit twelve", rev_id="b@u-0-8")
 
151
        wt2.commit("Commit thirtteen", rev_id="b@u-0-9")
 
152
 
 
153
        self.br1.fetch(self.br2)
 
154
        wt1.add_pending_merge(self.br2.revision_history()[6])
 
155
        wt1.commit("Commit fourtten", rev_id="a@u-0-6")
 
156
 
 
157
        self.br2.fetch(self.br1)
 
158
        wt2.add_pending_merge(self.br1.revision_history()[6])
 
159
        wt2.commit("Commit fifteen", rev_id="b@u-0-10")
 
160
 
 
161
        from bzrlib.revision import MultipleRevisionSources
 
162
        self.sources = MultipleRevisionSources(self.br1.repository,
 
163
                                               self.br2.repository)
 
164
 
 
165
    def intervene(self, ancestor, revision, revision_history=None):
 
166
        from bzrlib.revision import get_intervening_revisions
 
167
        return get_intervening_revisions(ancestor,revision, self.sources, 
 
168
                                         revision_history)
 
169
 
 
170
    def test_intervene(self):
 
171
        """Find intermediate revisions, without requiring history"""
 
172
        from bzrlib.errors import NotAncestor, NoSuchRevision
 
173
        self.assertEquals(len(self.intervene('a@u-0-0', 'a@u-0-0')), 0)
 
174
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-1'), ['a@u-0-1'])
 
175
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-2'), 
 
176
                         ['a@u-0-1', 'a@u-0-2'])
 
177
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-3'), 
 
178
                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3'])
 
179
        self.assertEqual(self.intervene('b@u-0-3', 'a@u-0-3'), 
 
180
                         ['b@u-0-4', 'a@u-0-3'])
 
181
        self.assertEqual(self.intervene('a@u-0-2', 'a@u-0-3', 
 
182
                                        self.br1.revision_history()), 
 
183
                         ['a@u-0-3'])
 
184
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-5', 
 
185
                                        self.br1.revision_history()), 
 
186
                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
 
187
                          'a@u-0-5'])
 
188
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-6', 
 
189
                         self.br1.revision_history()), 
 
190
                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
 
191
                          'b@u-0-6'])
 
192
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-5'), 
 
193
                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4', 
 
194
                          'b@u-0-5'])
 
195
        self.assertEqual(self.intervene('b@u-0-3', 'b@u-0-6', 
 
196
                         self.br2.revision_history()), 
 
197
                         ['b@u-0-4', 'b@u-0-5', 'b@u-0-6'])
 
198
        self.assertEqual(self.intervene('b@u-0-6', 'b@u-0-10'), 
 
199
                         ['b@u-0-7', 'b@u-0-8', 'b@u-0-9', 'b@u-0-10'])
 
200
        self.assertEqual(self.intervene('b@u-0-6', 'b@u-0-10', 
 
201
                                        self.br2.revision_history()), 
 
202
                         ['b@u-0-7', 'b@u-0-8', 'b@u-0-9', 'b@u-0-10'])
 
203
        self.assertRaises(NotAncestor, self.intervene, 'b@u-0-10', 'b@u-0-6', 
 
204
                          self.br2.revision_history())
 
205
        self.assertRaises(NoSuchRevision, self.intervene, 'c@u-0-10', 
 
206
                          'b@u-0-6', self.br2.revision_history())
 
207
        self.assertRaises(NoSuchRevision, self.intervene, 'b@u-0-10', 
 
208
                          'c@u-0-6', self.br2.revision_history())
 
209
 
 
210
 
 
211
class TestCommonAncestor(TestCaseWithTransport):
 
212
    """Test checking whether a revision is an ancestor of another revision"""
 
213
 
 
214
    def test_common_ancestor(self):
 
215
        """Pick a reasonable merge base"""
 
216
        from bzrlib.revision import common_ancestor
 
217
        br1, br2 = make_branches(self)
 
218
        revisions = br1.revision_history()
 
219
        revisions_2 = br2.revision_history()
 
220
        sources = MultipleRevisionSources(br1.repository, br2.repository)
 
221
        expected_ancestors_list = {revisions[3]:(0, 0), 
 
222
                                   revisions[2]:(1, 1),
 
223
                                   revisions_2[4]:(2, 1), 
 
224
                                   revisions[1]:(3, 2),
 
225
                                   revisions_2[3]:(4, 2),
 
226
                                   revisions[0]:(5, 3) }
 
227
        ancestors_list = find_present_ancestors(revisions[3], sources)
 
228
        self.assertEquals(len(expected_ancestors_list), len(ancestors_list))
 
229
        for key, value in expected_ancestors_list.iteritems():
 
230
            self.assertEqual(ancestors_list[key], value, 
 
231
                              "key %r, %r != %r" % (key, ancestors_list[key],
 
232
                                                    value))
 
233
        self.assertEqual(common_ancestor(revisions[0], revisions[0], sources),
 
234
                          revisions[0])
 
235
        self.assertEqual(common_ancestor(revisions[1], revisions[2], sources),
 
236
                          revisions[1])
 
237
        self.assertEqual(common_ancestor(revisions[1], revisions[1], sources),
 
238
                          revisions[1])
 
239
        self.assertEqual(common_ancestor(revisions[2], revisions_2[4], sources),
 
240
                          revisions[2])
 
241
        self.assertEqual(common_ancestor(revisions[3], revisions_2[4], sources),
 
242
                          revisions_2[4])
 
243
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
 
244
                          revisions_2[4])
 
245
        self.assertTrue(common_ancestor(revisions[5], revisions_2[6], sources) in
 
246
                        (revisions[4], revisions_2[5]))
 
247
        self.assertTrue(common_ancestor(revisions_2[6], revisions[5], sources),
 
248
                        (revisions[4], revisions_2[5]))
 
249
        self.assertEqual(None, common_ancestor(None, revisions[5], sources))
 
250
 
 
251
    def test_combined(self):
 
252
        """combined_graph
 
253
        Ensure it's not order-sensitive
 
254
        """
 
255
        br1, br2 = make_branches(self)
 
256
        source = MultipleRevisionSources(br1.repository, br2.repository)
 
257
        combined_1 = combined_graph(br1.last_revision(), 
 
258
                                    br2.last_revision(), source)
 
259
        combined_2 = combined_graph(br2.last_revision(),
 
260
                                    br1.last_revision(), source)
 
261
        self.assertEquals(combined_1[1], combined_2[1])
 
262
        self.assertEquals(combined_1[2], combined_2[2])
 
263
        self.assertEquals(combined_1[3], combined_2[3])
 
264
        self.assertEquals(combined_1, combined_2)
 
265
 
 
266
    def test_get_history(self):
 
267
        # TODO: test ghosts on the left hand branch's impact
 
268
        # TODO: test ghosts on all parents, we should get some
 
269
        # indicator. i.e. NULL_REVISION
 
270
        # RBC 20060608
 
271
        tree = self.make_branch_and_tree('.')
 
272
        tree.commit('1', rev_id = '1', allow_pointless=True)
 
273
        tree.commit('2', rev_id = '2', allow_pointless=True)
 
274
        tree.commit('3', rev_id = '3', allow_pointless=True)
 
275
        rev = tree.branch.repository.get_revision('1')
 
276
        history = rev.get_history(tree.branch.repository)
 
277
        self.assertEqual([None, '1'], history)
 
278
        rev = tree.branch.repository.get_revision('2')
 
279
        history = rev.get_history(tree.branch.repository)
 
280
        self.assertEqual([None, '1', '2'], history)
 
281
        rev = tree.branch.repository.get_revision('3')
 
282
        history = rev.get_history(tree.branch.repository)
 
283
        self.assertEqual([None, '1', '2' ,'3'], history)