← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_revision.py

 * Two new commands 'bzr checkout' and 'bzr update' allow for CVS/SVN-alike
   behaviour. They use the existing serverless-mode and store no data
   locally. As such they are not suitable for use except in high bandwidth
   low latency environments like LAN's or local disk. (Robert Collins)

Show diffs side-by-side

added added

removed removed

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