~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/testrevision.py

  • Committer: Martin Pool
  • Date: 2005-08-26 00:10:48 UTC
  • Revision ID: mbp@sourcefrog.net-20050826001048-b84148d3ef567d0d
- fix bzr.dev branch url in tutorial
  thanks to madduck

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
 
18
 
import os
19
 
 
20
 
from bzrlib.selftest import TestCaseInTempDir
21
 
from bzrlib.branch import Branch
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.trace import mutter
27
 
from bzrlib.errors import NoSuchRevision
 
17
from bzrlib.selftest import InTempDir
 
18
 
28
19
 
29
20
def make_branches():
30
 
    """Create two branches
31
 
 
32
 
    branch 1 has 6 commits, branch 2 has 3 commits
33
 
    commit 10 was a psuedo merge from branch 1
34
 
    but has been disabled until ghost support is
35
 
    implemented.
36
 
 
37
 
    the object graph is
38
 
    B:     A:
39
 
    a..0   a..0 
40
 
    a..1   a..1
41
 
    a..2   a..2
42
 
    b..3   a..3 merges b..4
43
 
    b..4   a..4
44
 
    b..5   a..5 merges b..5
45
 
    b..6 merges a4
46
 
 
47
 
    so A is missing b6 at the start
48
 
    and B is missing a3, a4, a5
49
 
    """
 
21
    from bzrlib.branch import Branch
 
22
    from bzrlib.commit import commit
 
23
    from bzrlib.revision import validate_revision_id
 
24
    import os
50
25
    os.mkdir("branch1")
51
 
    br1 = Branch.initialize("branch1")
 
26
    br1 = Branch("branch1", init=True)
52
27
    
53
28
    commit(br1, "Commit one", rev_id="a@u-0-0")
54
29
    commit(br1, "Commit two", rev_id="a@u-0-1")
55
30
    commit(br1, "Commit three", rev_id="a@u-0-2")
56
31
 
57
32
    os.mkdir("branch2")
58
 
    br2 = Branch.initialize("branch2")
 
33
    br2 = Branch("branch2", init=True)
59
34
    br2.update_revisions(br1)
60
35
    commit(br2, "Commit four", rev_id="b@u-0-3")
61
36
    commit(br2, "Commit five", rev_id="b@u-0-4")
62
37
    revisions_2 = br2.revision_history()
63
 
    
64
 
    fetch(from_branch=br2, to_branch=br1)
65
38
    br1.add_pending_merge(revisions_2[4])
66
 
    assert revisions_2[4] == 'b@u-0-4'
67
39
    commit(br1, "Commit six", rev_id="a@u-0-3")
68
40
    commit(br1, "Commit seven", rev_id="a@u-0-4")
69
41
    commit(br2, "Commit eight", rev_id="b@u-0-5")
70
 
    
71
 
    fetch(from_branch=br2, to_branch=br1)
72
42
    br1.add_pending_merge(br2.revision_history()[5])
73
43
    commit(br1, "Commit nine", rev_id="a@u-0-5")
74
 
    # DO NOT FETCH HERE - we WANT a GHOST.
75
 
    #fetch(from_branch=br1, to_branch=br2)
76
44
    br2.add_pending_merge(br1.revision_history()[4])
77
 
    commit(br2, "Commit ten - ghost merge", rev_id="b@u-0-6")
78
 
    
 
45
    commit(br2, "Commit ten", rev_id="b@u-0-6")
79
46
    return br1, br2
80
47
 
81
48
 
82
 
class TestIsAncestor(TestCaseInTempDir):
83
 
    def test_recorded_ancestry(self):
84
 
        """Test that commit records all ancestors"""
85
 
        br1, br2 = make_branches()
86
 
        d = [('a@u-0-0', ['a@u-0-0']),
87
 
             ('a@u-0-1', ['a@u-0-0', 'a@u-0-1']),
88
 
             ('a@u-0-2', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2']),
89
 
             ('b@u-0-3', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3']),
90
 
             ('b@u-0-4', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3',
91
 
                          'b@u-0-4']),
92
 
             ('a@u-0-3', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4',
93
 
                          'a@u-0-3']),
94
 
             ('a@u-0-4', ['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', 'a@u-0-4']),
96
 
             ('b@u-0-5', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4',
97
 
                          'b@u-0-5']),
98
 
             ('a@u-0-5', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4',
99
 
                          'b@u-0-3', 'b@u-0-4',
100
 
                          'b@u-0-5', 'a@u-0-5']),
101
 
             ('b@u-0-6', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2',
102
 
                          'b@u-0-3', 'b@u-0-4',
103
 
                          'b@u-0-5', 'b@u-0-6']),
104
 
             ]
105
 
        br1_only = ('a@u-0-3', 'a@u-0-4', 'a@u-0-5')
106
 
        br2_only = ('b@u-0-6',)
107
 
        for branch in br1, br2:
108
 
            for rev_id, anc in d:
109
 
                if rev_id in br1_only and not branch is br1:
110
 
                    continue
111
 
                if rev_id in br2_only and not branch is br2:
112
 
                    continue
113
 
                mutter('ancestry of {%s}: %r',
114
 
                       rev_id, branch.get_ancestry(rev_id))
115
 
                self.assertEquals(sorted(branch.get_ancestry(rev_id)),
116
 
                                  [None] + sorted(anc))
117
 
    
118
 
    
 
49
class TestIsAncestor(InTempDir):
 
50
 
119
51
    def test_is_ancestor(self):
120
52
        """Test checking whether a revision is an ancestor of another revision"""
 
53
        from bzrlib.revision import is_ancestor, MultipleRevisionSources
 
54
        from bzrlib.errors import NoSuchRevision
121
55
        br1, br2 = make_branches()
122
56
        revisions = br1.revision_history()
123
57
        revisions_2 = br2.revision_history()
124
 
        sources = br1
 
58
        sources = MultipleRevisionSources(br1, br2)
125
59
 
126
 
        assert is_ancestor(revisions[0], revisions[0], br1)
 
60
        assert is_ancestor(revisions[0], revisions[0], sources)
127
61
        assert is_ancestor(revisions[1], revisions[0], sources)
128
62
        assert not is_ancestor(revisions[0], revisions[1], sources)
129
63
        assert is_ancestor(revisions_2[3], revisions[0], sources)
130
 
        # disabled mbp 20050914, doesn't seem to happen anymore
131
 
        ## self.assertRaises(NoSuchRevision, is_ancestor, revisions_2[3],
132
 
        ##                  revisions[0], br1)        
 
64
        self.assertRaises(NoSuchRevision, is_ancestor, revisions_2[3],
 
65
                          revisions[0], br1)        
133
66
        assert is_ancestor(revisions[3], revisions_2[4], sources)
134
67
        assert is_ancestor(revisions[3], revisions_2[4], br1)
135
68
        assert is_ancestor(revisions[3], revisions_2[3], sources)
136
 
        ## assert not is_ancestor(revisions[3], revisions_2[3], br1)
137
 
 
138
 
 
139
 
class TestIntermediateRevisions(TestCaseInTempDir):
140
 
 
141
 
    def setUp(self):
142
 
        from bzrlib.commit import commit
143
 
        TestCaseInTempDir.setUp(self)
144
 
        self.br1, self.br2 = make_branches()
145
 
 
146
 
        self.br2.commit("Commit eleven", rev_id="b@u-0-7")
147
 
        self.br2.commit("Commit twelve", rev_id="b@u-0-8")
148
 
        self.br2.commit("Commit thirtteen", rev_id="b@u-0-9")
149
 
 
150
 
        fetch(from_branch=self.br2, to_branch=self.br1)
151
 
        self.br1.add_pending_merge(self.br2.revision_history()[6])
152
 
        self.br1.commit("Commit fourtten", rev_id="a@u-0-6")
153
 
 
154
 
        fetch(from_branch=self.br1, to_branch=self.br2)
155
 
        self.br2.add_pending_merge(self.br1.revision_history()[6])
156
 
        self.br2.commit("Commit fifteen", rev_id="b@u-0-10")
157
 
 
 
69
        assert not is_ancestor(revisions[3], revisions_2[3], br1)
 
70
 
 
71
 
 
72
class TestCommonAncestor(InTempDir):
 
73
    """Test checking whether a revision is an ancestor of another revision"""
 
74
    def runTest(self):
 
75
        from bzrlib.revision import find_present_ancestors, common_ancestor
158
76
        from bzrlib.revision import MultipleRevisionSources
159
 
        self.sources = MultipleRevisionSources(self.br1, self.br2)
160
 
 
161
 
    def intervene(self, ancestor, revision, revision_history=None):
162
 
        from bzrlib.revision import get_intervening_revisions
163
 
        return get_intervening_revisions(ancestor,revision, self.sources, 
164
 
                                         revision_history)
165
 
 
166
 
    def test_intervene(self):
167
 
        """Find intermediate revisions, without requiring history"""
168
 
        from bzrlib.errors import NotAncestor, NoSuchRevision
169
 
        assert len(self.intervene('a@u-0-0', 'a@u-0-0')) == 0
170
 
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-1'), ['a@u-0-1'])
171
 
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-2'), 
172
 
                         ['a@u-0-1', 'a@u-0-2'])
173
 
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-3'), 
174
 
                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3'])
175
 
        self.assertEqual(self.intervene('b@u-0-3', 'a@u-0-3'), 
176
 
                         ['b@u-0-4', 'a@u-0-3'])
177
 
        self.assertEqual(self.intervene('a@u-0-2', 'a@u-0-3', 
178
 
                                        self.br1.revision_history()), 
179
 
                         ['a@u-0-3'])
180
 
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-5', 
181
 
                                        self.br1.revision_history()), 
182
 
                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
183
 
                          'a@u-0-5'])
184
 
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-6', 
185
 
                         self.br1.revision_history()), 
186
 
                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
187
 
                          'b@u-0-6'])
188
 
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-5'), 
189
 
                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4', 
190
 
                          'b@u-0-5'])
191
 
        self.assertEqual(self.intervene('b@u-0-3', 'b@u-0-6', 
192
 
                         self.br2.revision_history()), 
193
 
                         ['b@u-0-4', 'b@u-0-5', 'b@u-0-6'])
194
 
        self.assertEqual(self.intervene('b@u-0-6', 'b@u-0-10'), 
195
 
                         ['b@u-0-7', 'b@u-0-8', 'b@u-0-9', 'b@u-0-10'])
196
 
        self.assertEqual(self.intervene('b@u-0-6', 'b@u-0-10', 
197
 
                                        self.br2.revision_history()), 
198
 
                         ['b@u-0-7', 'b@u-0-8', 'b@u-0-9', 'b@u-0-10'])
199
 
        self.assertRaises(NotAncestor, self.intervene, 'b@u-0-10', 'b@u-0-6', 
200
 
                          self.br2.revision_history())
201
 
        self.assertRaises(NoSuchRevision, self.intervene, 'c@u-0-10', 
202
 
                          'b@u-0-6', self.br2.revision_history())
203
 
        self.assertRaises(NoSuchRevision, self.intervene, 'b@u-0-10', 
204
 
                          'c@u-0-6', self.br2.revision_history())
205
 
 
206
 
 
207
 
class TestCommonAncestor(TestCaseInTempDir):
208
 
    """Test checking whether a revision is an ancestor of another revision"""
209
 
 
210
 
    def test_old_common_ancestor(self):
211
 
        """Pick a resonable merge base using the old functionality"""
212
 
        from bzrlib.revision import old_common_ancestor as common_ancestor
213
77
        br1, br2 = make_branches()
214
78
        revisions = br1.revision_history()
215
79
        revisions_2 = br2.revision_history()
216
 
        sources = br1
 
80
        sources = MultipleRevisionSources(br1, br2)
217
81
 
218
82
        expected_ancestors_list = {revisions[3]:(0, 0), 
219
83
                                   revisions[2]:(1, 1),
240
104
                          revisions_2[4])
241
105
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
242
106
                          revisions_2[4])
243
 
        fetch(from_branch=br2, to_branch=br1)
244
107
        self.assertEqual(common_ancestor(revisions[5], revisions_2[6], sources),
245
 
                          revisions[4]) # revisions_2[5] is equally valid
 
108
                          revisions[4])
246
109
        self.assertEqual(common_ancestor(revisions_2[6], revisions[5], sources),
247
110
                          revisions_2[5])
248
111
 
249
 
    def test_common_ancestor(self):
250
 
        """Pick a reasonable merge base"""
251
 
        from bzrlib.revision import common_ancestor
252
 
        br1, br2 = make_branches()
253
 
        revisions = br1.revision_history()
254
 
        revisions_2 = br2.revision_history()
255
 
        sources = MultipleRevisionSources(br1, br2)
256
 
        expected_ancestors_list = {revisions[3]:(0, 0), 
257
 
                                   revisions[2]:(1, 1),
258
 
                                   revisions_2[4]:(2, 1), 
259
 
                                   revisions[1]:(3, 2),
260
 
                                   revisions_2[3]:(4, 2),
261
 
                                   revisions[0]:(5, 3) }
262
 
        ancestors_list = find_present_ancestors(revisions[3], sources)
263
 
        assert len(expected_ancestors_list) == len(ancestors_list)
264
 
        for key, value in expected_ancestors_list.iteritems():
265
 
            self.assertEqual(ancestors_list[key], value, 
266
 
                              "key %r, %r != %r" % (key, ancestors_list[key],
267
 
                                                    value))
268
 
        self.assertEqual(common_ancestor(revisions[0], revisions[0], sources),
269
 
                          revisions[0])
270
 
        self.assertEqual(common_ancestor(revisions[1], revisions[2], sources),
271
 
                          revisions[1])
272
 
        self.assertEqual(common_ancestor(revisions[1], revisions[1], sources),
273
 
                          revisions[1])
274
 
        self.assertEqual(common_ancestor(revisions[2], revisions_2[4], sources),
275
 
                          revisions[2])
276
 
        self.assertEqual(common_ancestor(revisions[3], revisions_2[4], sources),
277
 
                          revisions_2[4])
278
 
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
279
 
                          revisions_2[4])
280
 
        self.assertEqual(common_ancestor(revisions[5], revisions_2[6], sources),
281
 
                          revisions[4]) # revisions_2[5] is equally valid
282
 
        self.assertEqual(common_ancestor(revisions_2[6], revisions[5], sources),
283
 
                          revisions[4]) # revisions_2[5] is equally valid
284
 
 
285
 
    def test_combined(self):
286
 
        """combined_graph
287
 
        Ensure it's not order-sensitive
288
 
        """
289
 
        br1, br2 = make_branches()
290
 
        source = MultipleRevisionSources(br1, br2)
291
 
        combined_1 = combined_graph(br1.last_revision(), 
292
 
                                    br2.last_revision(), source)
293
 
        combined_2 = combined_graph(br2.last_revision(),
294
 
                                    br1.last_revision(), source)
295
 
        assert combined_1[1] == combined_2[1]
296
 
        assert combined_1[2] == combined_2[2]
297
 
        assert combined_1[3] == combined_2[3]
298
 
        assert combined_1 == combined_2
 
112
TEST_CLASSES = [
 
113
    TestIsAncestor,
 
114
    TestCommonAncestor,
 
115
    ]