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

  • Committer: Robert Collins
  • Date: 2007-04-19 02:27:44 UTC
  • mto: This revision was merged to the branch mainline in revision 2426.
  • Revision ID: robertc@robertcollins.net-20070419022744-pfdqz42kp1wizh43
``make docs`` now creates a man page at ``man1/bzr.1`` fixing bug 107388.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_revisionnamespaces.py
1
 
# Copyright (C) 2005-2012, 2016 Canonical Ltd
 
1
# Copyright (C) 2004, 2005, 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
import datetime
 
18
import os
18
19
import time
19
20
 
20
 
from breezy import (
 
21
from bzrlib import (
 
22
    branch,
 
23
    bzrdir,
21
24
    errors,
22
 
    revision as _mod_revision,
 
25
    repository,
23
26
    )
24
 
from breezy.tests import TestCaseWithTransport
25
 
from breezy.revisionspec import (
26
 
    InvalidRevisionSpec,
27
 
    RevisionInfo,
 
27
from bzrlib.builtins import merge
 
28
from bzrlib.tests import TestCase, TestCaseWithTransport
 
29
from bzrlib.revisionspec import (
28
30
    RevisionSpec,
29
 
    RevisionSpec_dwim,
 
31
    RevisionSpec_revno,
30
32
    RevisionSpec_tag,
31
33
    )
32
34
 
48
50
 
49
51
        self.tree = self.make_branch_and_tree('tree')
50
52
        self.build_tree(['tree/a'])
51
 
        self.tree.lock_write()
52
 
        self.addCleanup(self.tree.unlock)
53
53
        self.tree.add(['a'])
54
 
        self.tree.commit('a', rev_id=b'r1')
55
 
 
56
 
        self.tree2 = self.tree.controldir.sprout('tree2').open_workingtree()
57
 
        self.tree2.commit('alt', rev_id=b'alt_r2')
58
 
 
59
 
        self.tree.merge_from_branch(self.tree2.branch)
60
 
        self.tree.commit('second', rev_id=b'r2')
 
54
        self.tree.commit('a', rev_id='r1')
 
55
 
 
56
        self.tree2 = self.tree.bzrdir.sprout('tree2').open_workingtree()
 
57
        self.tree2.commit('alt', rev_id='alt_r2')
 
58
 
 
59
        self.tree.branch.repository.fetch(self.tree2.branch.repository,
 
60
                                          revision_id='alt_r2')
 
61
        self.tree.set_pending_merges(['alt_r2'])
 
62
        self.tree.commit('second', rev_id='r2')
61
63
 
62
64
    def get_in_history(self, revision_spec):
63
65
        return spec_in_history(revision_spec, self.tree.branch)
72
74
                         ' %r != %r'
73
75
                         % (revision_spec, exp_revision_id, rev_info.rev_id))
74
76
 
75
 
    def assertInvalid(self, revision_spec, extra='',
76
 
                      invalid_as_revision_id=True):
 
77
    def assertInvalid(self, revision_spec, extra=''):
77
78
        try:
78
79
            self.get_in_history(revision_spec)
79
 
        except InvalidRevisionSpec as e:
 
80
        except errors.InvalidRevisionSpec, e:
80
81
            self.assertEqual(revision_spec, e.spec)
81
82
            self.assertEqual(extra, e.extra)
82
83
        else:
83
 
            self.fail('Expected InvalidRevisionSpec to be raised for'
84
 
                      ' %r.in_history' % (revision_spec,))
85
 
        if invalid_as_revision_id:
86
 
            try:
87
 
                spec = RevisionSpec.from_string(revision_spec)
88
 
                spec.as_revision_id(self.tree.branch)
89
 
            except InvalidRevisionSpec as e:
90
 
                self.assertEqual(revision_spec, e.spec)
91
 
                self.assertEqual(extra, e.extra)
92
 
            else:
93
 
                self.fail('Expected InvalidRevisionSpec to be raised for'
94
 
                          ' %r.as_revision_id' % (revision_spec,))
95
 
 
96
 
    def assertAsRevisionId(self, revision_id, revision_spec):
97
 
        """Calling as_revision_id() should return the specified id."""
98
 
        spec = RevisionSpec.from_string(revision_spec)
99
 
        self.assertEqual(revision_id,
100
 
                         spec.as_revision_id(self.tree.branch))
101
 
 
102
 
    def get_as_tree(self, revision_spec, tree=None):
103
 
        if tree is None:
104
 
            tree = self.tree
105
 
        spec = RevisionSpec.from_string(revision_spec)
106
 
        return spec.as_tree(tree.branch)
107
 
 
108
 
 
109
 
class RevisionSpecMatchOnTrap(RevisionSpec):
110
 
 
111
 
    def _match_on(self, branch, revs):
112
 
        self.last_call = (branch, revs)
113
 
        return super(RevisionSpecMatchOnTrap, self)._match_on(branch, revs)
114
 
 
115
 
 
116
 
class TestRevisionSpecBase(TestRevisionSpec):
117
 
 
118
 
    def test_wants_no_revision_history(self):
119
 
        # If wants_revision_history = False, then _match_on should get None for
120
 
        # the branch revision history
121
 
        spec = RevisionSpecMatchOnTrap('foo', _internal=True)
122
 
        spec.in_history(self.tree.branch)
123
 
 
124
 
        self.assertEqual((self.tree.branch, None), spec.last_call)
 
84
            self.fail('Expected InvalidRevisionSpec to be raised for %s'
 
85
                      % (revision_spec,))
125
86
 
126
87
 
127
88
class TestOddRevisionSpec(TestRevisionSpec):
128
89
    """Test things that aren't normally thought of as revision specs"""
129
90
 
130
91
    def test_none(self):
131
 
        self.assertInHistoryIs(None, None, None)
 
92
        self.assertInHistoryIs(0, None, None)
132
93
 
133
94
    def test_object(self):
134
95
        self.assertRaises(TypeError, RevisionSpec.from_string, object())
135
96
 
136
 
 
137
 
class RevisionSpec_bork(RevisionSpec):
138
 
 
139
 
    prefix = 'irrelevant:'
140
 
 
141
 
    def _match_on(self, branch, revs):
142
 
        if self.spec == "bork":
143
 
            return RevisionInfo.from_revision_id(branch, b"r1")
144
 
        else:
145
 
            raise InvalidRevisionSpec(self.spec, branch)
146
 
 
147
 
 
148
 
class TestRevisionSpec_dwim(TestRevisionSpec):
149
 
 
150
 
    # Don't need to test revno's explicitly since TRS_revno already
151
 
    # covers that well for us
152
 
    def test_dwim_spec_revno(self):
153
 
        self.assertInHistoryIs(2, b'r2', '2')
154
 
        self.assertAsRevisionId(b'alt_r2', '1.1.1')
155
 
 
156
 
    def test_dwim_spec_revid(self):
157
 
        self.assertInHistoryIs(2, b'r2', 'r2')
158
 
 
159
 
    def test_dwim_spec_tag(self):
160
 
        self.tree.branch.tags.set_tag('footag', b'r1')
161
 
        self.assertAsRevisionId(b'r1', 'footag')
162
 
        self.tree.branch.tags.delete_tag('footag')
163
 
        self.assertRaises(InvalidRevisionSpec, self.get_in_history, 'footag')
164
 
 
165
 
    def test_dwim_spec_tag_that_looks_like_revno(self):
166
 
        # Test that we slip past revno with things that look like revnos,
167
 
        # but aren't.  Tags are convenient for testing this since we can
168
 
        # make them look however we want.
169
 
        self.tree.branch.tags.set_tag('3', b'r2')
170
 
        self.assertAsRevisionId(b'r2', '3')
171
 
        self.build_tree(['tree/b'])
172
 
        self.tree.add(['b'])
173
 
        self.tree.commit('b', rev_id=b'r3')
174
 
        self.assertAsRevisionId(b'r3', '3')
175
 
 
176
 
    def test_dwim_spec_date(self):
177
 
        self.assertAsRevisionId(b'r1', 'today')
178
 
 
179
 
    def test_dwim_spec_branch(self):
180
 
        self.assertInHistoryIs(None, b'alt_r2', 'tree2')
181
 
 
182
 
    def test_dwim_spec_nonexistent(self):
183
 
        self.assertInvalid('somethingrandom', invalid_as_revision_id=False)
184
 
        self.assertInvalid('-1.1', invalid_as_revision_id=False)
185
 
        self.assertInvalid('.1', invalid_as_revision_id=False)
186
 
        self.assertInvalid('1..1', invalid_as_revision_id=False)
187
 
        self.assertInvalid('1.2..1', invalid_as_revision_id=False)
188
 
        self.assertInvalid('1.', invalid_as_revision_id=False)
189
 
 
190
 
    def test_append_dwim_revspec(self):
191
 
        original_dwim_revspecs = list(RevisionSpec_dwim._possible_revspecs)
192
 
 
193
 
        def reset_dwim_revspecs():
194
 
            RevisionSpec_dwim._possible_revspecs = original_dwim_revspecs
195
 
        self.addCleanup(reset_dwim_revspecs)
196
 
        RevisionSpec_dwim.append_possible_revspec(RevisionSpec_bork)
197
 
        self.assertAsRevisionId(b'r1', 'bork')
198
 
 
199
 
    def test_append_lazy_dwim_revspec(self):
200
 
        original_dwim_revspecs = list(RevisionSpec_dwim._possible_revspecs)
201
 
 
202
 
        def reset_dwim_revspecs():
203
 
            RevisionSpec_dwim._possible_revspecs = original_dwim_revspecs
204
 
        self.addCleanup(reset_dwim_revspecs)
205
 
        RevisionSpec_dwim.append_possible_lazy_revspec(
206
 
            "breezy.tests.test_revisionspec", "RevisionSpec_bork")
207
 
        self.assertAsRevisionId(b'r1', 'bork')
 
97
    def test_unregistered_spec(self):
 
98
        self.assertRaises(errors.NoSuchRevisionSpec,
 
99
                          RevisionSpec.from_string, 'foo')
 
100
        self.assertRaises(errors.NoSuchRevisionSpec,
 
101
                          RevisionSpec.from_string, '123a')
 
102
 
 
103
 
 
104
 
 
105
class TestRevnoFromString(TestCase):
 
106
 
 
107
    def test_from_string_dotted_decimal(self):
 
108
        self.assertRaises(errors.NoSuchRevisionSpec, RevisionSpec.from_string, '-1.1')
 
109
        self.assertRaises(errors.NoSuchRevisionSpec, RevisionSpec.from_string, '.1')
 
110
        self.assertRaises(errors.NoSuchRevisionSpec, RevisionSpec.from_string, '1..1')
 
111
        self.assertRaises(errors.NoSuchRevisionSpec, RevisionSpec.from_string, '1.2..1')
 
112
        self.assertRaises(errors.NoSuchRevisionSpec, RevisionSpec.from_string, '1.')
 
113
        self.assertIsInstance(RevisionSpec.from_string('1.1'), RevisionSpec_revno)
 
114
        self.assertIsInstance(RevisionSpec.from_string('1.1.3'), RevisionSpec_revno)
208
115
 
209
116
 
210
117
class TestRevisionSpec_revno(TestRevisionSpec):
211
118
 
212
119
    def test_positive_int(self):
213
 
        self.assertInHistoryIs(0, b'null:', '0')
214
 
        self.assertInHistoryIs(1, b'r1', '1')
215
 
        self.assertInHistoryIs(2, b'r2', '2')
 
120
        self.assertInHistoryIs(0, None, '0')
 
121
        self.assertInHistoryIs(1, 'r1', '1')
 
122
        self.assertInHistoryIs(2, 'r2', '2')
216
123
        self.assertInvalid('3')
217
124
 
218
125
    def test_dotted_decimal(self):
219
 
        self.assertInHistoryIs(None, b'alt_r2', '1.1.1')
220
 
        self.assertInvalid('1.1.123')
 
126
        self.assertInHistoryIs(None, 'alt_r2', '1.1.1')
221
127
 
222
128
    def test_negative_int(self):
223
 
        self.assertInHistoryIs(2, b'r2', '-1')
224
 
        self.assertInHistoryIs(1, b'r1', '-2')
 
129
        self.assertInHistoryIs(2, 'r2', '-1')
 
130
        self.assertInHistoryIs(1, 'r1', '-2')
225
131
 
226
 
        self.assertInHistoryIs(1, b'r1', '-3')
227
 
        self.assertInHistoryIs(1, b'r1', '-4')
228
 
        self.assertInHistoryIs(1, b'r1', '-100')
 
132
        self.assertInHistoryIs(1, 'r1', '-3')
 
133
        self.assertInHistoryIs(1, 'r1', '-4')
 
134
        self.assertInHistoryIs(1, 'r1', '-100')
229
135
 
230
136
    def test_positive(self):
231
 
        self.assertInHistoryIs(0, b'null:', 'revno:0')
232
 
        self.assertInHistoryIs(1, b'r1', 'revno:1')
233
 
        self.assertInHistoryIs(2, b'r2', 'revno:2')
 
137
        self.assertInHistoryIs(0, None, 'revno:0')
 
138
        self.assertInHistoryIs(1, 'r1', 'revno:1')
 
139
        self.assertInHistoryIs(2, 'r2', 'revno:2')
234
140
 
235
141
        self.assertInvalid('revno:3')
236
142
 
237
143
    def test_negative(self):
238
 
        self.assertInHistoryIs(2, b'r2', 'revno:-1')
239
 
        self.assertInHistoryIs(1, b'r1', 'revno:-2')
 
144
        self.assertInHistoryIs(2, 'r2', 'revno:-1')
 
145
        self.assertInHistoryIs(1, 'r1', 'revno:-2')
240
146
 
241
 
        self.assertInHistoryIs(1, b'r1', 'revno:-3')
242
 
        self.assertInHistoryIs(1, b'r1', 'revno:-4')
 
147
        self.assertInHistoryIs(1, 'r1', 'revno:-3')
 
148
        self.assertInHistoryIs(1, 'r1', 'revno:-4')
243
149
 
244
150
    def test_invalid_number(self):
245
151
        # Get the right exception text
246
152
        try:
247
153
            int('X')
248
 
        except ValueError as e:
249
 
            self.assertInvalid('revno:X', extra='\n' + str(e))
250
 
        else:
251
 
            self.fail()
 
154
        except ValueError, e:
 
155
            pass
 
156
        self.assertInvalid('revno:X', extra='\n' + str(e))
252
157
 
253
158
    def test_missing_number_and_branch(self):
254
159
        self.assertInvalid('revno::',
257
162
    def test_invalid_number_with_branch(self):
258
163
        try:
259
164
            int('X')
260
 
        except ValueError as e:
261
 
            self.assertInvalid('revno:X:tree2', extra='\n' + str(e))
262
 
        else:
263
 
            self.fail()
 
165
        except ValueError, e:
 
166
            pass
 
167
        self.assertInvalid('revno:X:tree2', extra='\n' + str(e))
264
168
 
265
169
    def test_non_exact_branch(self):
266
170
        # It seems better to require an exact path to the branch
275
179
        self.assertNotEqual(self.tree.branch.base, revinfo.branch.base)
276
180
        self.assertEqual(self.tree2.branch.base, revinfo.branch.base)
277
181
        self.assertEqual(2, revinfo.revno)
278
 
        self.assertEqual(b'alt_r2', revinfo.rev_id)
 
182
        self.assertEqual('alt_r2', revinfo.rev_id)
279
183
 
280
184
    def test_int_with_branch(self):
281
185
        revinfo = self.get_in_history('2:tree2')
282
186
        self.assertNotEqual(self.tree.branch.base, revinfo.branch.base)
283
187
        self.assertEqual(self.tree2.branch.base, revinfo.branch.base)
284
188
        self.assertEqual(2, revinfo.revno)
285
 
        self.assertEqual(b'alt_r2', revinfo.rev_id)
 
189
        self.assertEqual('alt_r2', revinfo.rev_id)
286
190
 
287
191
    def test_with_url(self):
288
192
        url = self.get_url() + '/tree2'
290
194
        self.assertNotEqual(self.tree.branch.base, revinfo.branch.base)
291
195
        self.assertEqual(self.tree2.branch.base, revinfo.branch.base)
292
196
        self.assertEqual(2, revinfo.revno)
293
 
        self.assertEqual(b'alt_r2', revinfo.rev_id)
 
197
        self.assertEqual('alt_r2', revinfo.rev_id)
294
198
 
295
199
    def test_negative_with_url(self):
296
200
        url = self.get_url() + '/tree2'
298
202
        self.assertNotEqual(self.tree.branch.base, revinfo.branch.base)
299
203
        self.assertEqual(self.tree2.branch.base, revinfo.branch.base)
300
204
        self.assertEqual(2, revinfo.revno)
301
 
        self.assertEqual(b'alt_r2', revinfo.rev_id)
 
205
        self.assertEqual('alt_r2', revinfo.rev_id)
302
206
 
303
207
    def test_different_history_lengths(self):
304
208
        # Make sure we use the revisions and offsets in the supplied branch
305
209
        # not the ones in the original branch.
306
 
        self.tree2.commit('three', rev_id=b'r3')
307
 
        self.assertInHistoryIs(3, b'r3', 'revno:3:tree2')
308
 
        self.assertInHistoryIs(3, b'r3', 'revno:-1:tree2')
 
210
        self.tree2.commit('three', rev_id='r3')
 
211
        self.assertInHistoryIs(3, 'r3', 'revno:3:tree2')
 
212
        self.assertInHistoryIs(3, 'r3', 'revno:-1:tree2')
309
213
 
310
214
    def test_invalid_branch(self):
311
215
        self.assertRaises(errors.NotBranchError,
312
216
                          self.get_in_history, 'revno:-1:tree3')
313
217
 
314
218
    def test_invalid_revno_in_branch(self):
315
 
        self.tree.commit('three', rev_id=b'r3')
 
219
        self.tree.commit('three', rev_id='r3')
316
220
        self.assertInvalid('revno:3:tree2')
317
221
 
318
222
    def test_revno_n_path(self):
319
223
        """Old revno:N:path tests"""
320
224
        wta = self.make_branch_and_tree('a')
321
225
        ba = wta.branch
322
 
 
323
 
        wta.commit('Commit one', rev_id=b'a@r-0-1')
324
 
        wta.commit('Commit two', rev_id=b'a@r-0-2')
325
 
        wta.commit('Commit three', rev_id=b'a@r-0-3')
 
226
        
 
227
        wta.commit('Commit one', rev_id='a@r-0-1')
 
228
        wta.commit('Commit two', rev_id='a@r-0-2')
 
229
        wta.commit('Commit three', rev_id='a@r-0-3')
326
230
 
327
231
        wtb = self.make_branch_and_tree('b')
328
232
        bb = wtb.branch
329
233
 
330
 
        wtb.commit('Commit one', rev_id=b'b@r-0-1')
331
 
        wtb.commit('Commit two', rev_id=b'b@r-0-2')
332
 
        wtb.commit('Commit three', rev_id=b'b@r-0-3')
333
 
 
334
 
        self.assertEqual((1, b'a@r-0-1'),
 
234
        wtb.commit('Commit one', rev_id='b@r-0-1')
 
235
        wtb.commit('Commit two', rev_id='b@r-0-2')
 
236
        wtb.commit('Commit three', rev_id='b@r-0-3')
 
237
 
 
238
 
 
239
        self.assertEqual((1, 'a@r-0-1'),
335
240
                         spec_in_history('revno:1:a/', ba))
336
241
        # The argument of in_history should be ignored since it is
337
242
        # redundant with the path in the spec.
338
 
        self.assertEqual((1, b'a@r-0-1'),
 
243
        self.assertEqual((1, 'a@r-0-1'),
339
244
                         spec_in_history('revno:1:a/', None))
340
 
        self.assertEqual((1, b'a@r-0-1'),
 
245
        self.assertEqual((1, 'a@r-0-1'),
341
246
                         spec_in_history('revno:1:a/', bb))
342
 
        self.assertEqual((2, b'b@r-0-2'),
 
247
        self.assertEqual((2, 'b@r-0-2'),
343
248
                         spec_in_history('revno:2:b/', None))
344
249
 
345
 
    def test_as_revision_id(self):
346
 
        self.assertAsRevisionId(b'null:', '0')
347
 
        self.assertAsRevisionId(b'r1', '1')
348
 
        self.assertAsRevisionId(b'r2', '2')
349
 
        self.assertAsRevisionId(b'r1', '-2')
350
 
        self.assertAsRevisionId(b'r2', '-1')
351
 
        self.assertAsRevisionId(b'alt_r2', '1.1.1')
352
 
 
353
 
    def test_as_tree(self):
354
 
        tree = self.get_as_tree('0')
355
 
        self.assertEqual(_mod_revision.NULL_REVISION, tree.get_revision_id())
356
 
        tree = self.get_as_tree('1')
357
 
        self.assertEqual(b'r1', tree.get_revision_id())
358
 
        tree = self.get_as_tree('2')
359
 
        self.assertEqual(b'r2', tree.get_revision_id())
360
 
        tree = self.get_as_tree('-2')
361
 
        self.assertEqual(b'r1', tree.get_revision_id())
362
 
        tree = self.get_as_tree('-1')
363
 
        self.assertEqual(b'r2', tree.get_revision_id())
364
 
        tree = self.get_as_tree('1.1.1')
365
 
        self.assertEqual(b'alt_r2', tree.get_revision_id())
366
250
 
367
251
 
368
252
class TestRevisionSpec_revid(TestRevisionSpec):
369
 
 
 
253
    
370
254
    def test_in_history(self):
371
255
        # We should be able to access revisions that are directly
372
256
        # in the history.
373
 
        self.assertInHistoryIs(1, b'r1', 'revid:r1')
374
 
        self.assertInHistoryIs(2, b'r2', 'revid:r2')
375
 
 
 
257
        self.assertInHistoryIs(1, 'r1', 'revid:r1')
 
258
        self.assertInHistoryIs(2, 'r2', 'revid:r2')
 
259
        
376
260
    def test_missing(self):
377
 
        self.assertInvalid('revid:r3', invalid_as_revision_id=False)
 
261
        self.assertInvalid('revid:r3')
378
262
 
379
263
    def test_merged(self):
380
264
        """We can reach revisions in the ancestry"""
381
 
        self.assertInHistoryIs(None, b'alt_r2', 'revid:alt_r2')
 
265
        self.assertInHistoryIs(None, 'alt_r2', 'revid:alt_r2')
382
266
 
383
267
    def test_not_here(self):
384
 
        self.tree2.commit('alt third', rev_id=b'alt_r3')
 
268
        self.tree2.commit('alt third', rev_id='alt_r3')
385
269
        # It exists in tree2, but not in tree
386
 
        self.assertInvalid('revid:alt_r3', invalid_as_revision_id=False)
 
270
        self.assertInvalid('revid:alt_r3')
387
271
 
388
272
    def test_in_repository(self):
389
273
        """We can get any revision id in the repository"""
390
274
        # XXX: This may change in the future, but for now, it is true
391
 
        self.tree2.commit('alt third', rev_id=b'alt_r3')
392
 
        self.tree.branch.fetch(self.tree2.branch, b'alt_r3')
393
 
        self.assertInHistoryIs(None, b'alt_r3', 'revid:alt_r3')
 
275
        self.tree2.commit('alt third', rev_id='alt_r3')
 
276
        self.tree.branch.repository.fetch(self.tree2.branch.repository,
 
277
                                          revision_id='alt_r3')
 
278
        self.assertInHistoryIs(None, 'alt_r3', 'revid:alt_r3')
394
279
 
395
280
    def test_unicode(self):
396
281
        """We correctly convert a unicode ui string to an encoded revid."""
397
282
        revision_id = u'\N{SNOWMAN}'.encode('utf-8')
398
283
        self.tree.commit('unicode', rev_id=revision_id)
399
284
        self.assertInHistoryIs(3, revision_id, u'revid:\N{SNOWMAN}')
400
 
        self.assertInHistoryIs(3, revision_id, 'revid:' +
401
 
                               revision_id.decode('utf-8'))
402
 
 
403
 
    def test_as_revision_id(self):
404
 
        self.assertAsRevisionId(b'r1', 'revid:r1')
405
 
        self.assertAsRevisionId(b'r2', 'revid:r2')
406
 
        self.assertAsRevisionId(b'alt_r2', 'revid:alt_r2')
 
285
        self.assertInHistoryIs(3, revision_id, 'revid:' + revision_id)
407
286
 
408
287
 
409
288
class TestRevisionSpec_last(TestRevisionSpec):
410
289
 
411
290
    def test_positive(self):
412
 
        self.assertInHistoryIs(2, b'r2', 'last:1')
413
 
        self.assertInHistoryIs(1, b'r1', 'last:2')
414
 
        self.assertInHistoryIs(0, b'null:', 'last:3')
 
291
        self.assertInHistoryIs(2, 'r2', 'last:1')
 
292
        self.assertInHistoryIs(1, 'r1', 'last:2')
 
293
        self.assertInHistoryIs(0, None, 'last:3')
415
294
 
416
295
    def test_empty(self):
417
 
        self.assertInHistoryIs(2, b'r2', 'last:')
 
296
        self.assertInHistoryIs(2, 'r2', 'last:')
418
297
 
419
298
    def test_negative(self):
420
299
        self.assertInvalid('last:-1',
430
309
                          spec_in_history, 'last:', tree.branch)
431
310
 
432
311
    def test_not_a_number(self):
433
 
        last_e = None
434
312
        try:
435
313
            int('Y')
436
 
        except ValueError as e:
437
 
            last_e = e
438
 
        self.assertInvalid('last:Y', extra='\n' + str(last_e))
439
 
 
440
 
    def test_as_revision_id(self):
441
 
        self.assertAsRevisionId(b'r2', 'last:1')
442
 
        self.assertAsRevisionId(b'r1', 'last:2')
 
314
        except ValueError, e:
 
315
            pass
 
316
        self.assertInvalid('last:Y', extra='\n' + str(e))
443
317
 
444
318
 
445
319
class TestRevisionSpec_before(TestRevisionSpec):
446
320
 
447
321
    def test_int(self):
448
 
        self.assertInHistoryIs(1, b'r1', 'before:2')
449
 
        self.assertInHistoryIs(1, b'r1', 'before:-1')
 
322
        self.assertInHistoryIs(1, 'r1', 'before:2')
 
323
        self.assertInHistoryIs(1, 'r1', 'before:-1')
450
324
 
451
325
    def test_before_one(self):
452
 
        self.assertInHistoryIs(0, b'null:', 'before:1')
 
326
        self.assertInHistoryIs(0, None, 'before:1')
453
327
 
454
328
    def test_before_none(self):
455
329
        self.assertInvalid('before:0',
456
330
                           extra='\ncannot go before the null: revision')
457
331
 
458
332
    def test_revid(self):
459
 
        self.assertInHistoryIs(1, b'r1', 'before:revid:r2')
 
333
        self.assertInHistoryIs(1, 'r1', 'before:revid:r2')
460
334
 
461
335
    def test_last(self):
462
 
        self.assertInHistoryIs(1, b'r1', 'before:last:1')
 
336
        self.assertInHistoryIs(1, 'r1', 'before:last:1')
463
337
 
464
338
    def test_alt_revid(self):
465
339
        # This will grab the left-most ancestor for alternate histories
466
 
        self.assertInHistoryIs(1, b'r1', 'before:revid:alt_r2')
 
340
        self.assertInHistoryIs(1, 'r1', 'before:revid:alt_r2')
467
341
 
468
342
    def test_alt_no_parents(self):
469
343
        new_tree = self.make_branch_and_tree('new_tree')
470
 
        new_tree.commit('first', rev_id=b'new_r1')
471
 
        self.tree.branch.fetch(new_tree.branch, b'new_r1')
472
 
        self.assertInHistoryIs(0, b'null:', 'before:revid:new_r1')
473
 
 
474
 
    def test_as_revision_id(self):
475
 
        self.assertAsRevisionId(b'r1', 'before:revid:r2')
476
 
        self.assertAsRevisionId(b'r1', 'before:2')
477
 
        self.assertAsRevisionId(b'r1', 'before:1.1.1')
478
 
        self.assertAsRevisionId(b'r1', 'before:revid:alt_r2')
 
344
        new_tree.commit('first', rev_id='new_r1')
 
345
        self.tree.branch.repository.fetch(new_tree.branch.repository,
 
346
                                          revision_id='new_r1')
 
347
        self.assertInHistoryIs(0, None, 'before:revid:new_r1')
479
348
 
480
349
 
481
350
class TestRevisionSpec_tag(TestRevisionSpec):
482
 
 
 
351
    
483
352
    def make_branch_and_tree(self, relpath):
484
353
        # override format as the default one may not support tags
485
 
        return TestRevisionSpec.make_branch_and_tree(
486
 
            self, relpath, format='dirstate-tags')
 
354
        control = bzrdir.BzrDir.create(relpath)
 
355
        control.create_repository()
 
356
        branch.BzrBranchExperimental.initialize(control)
 
357
        return control.create_workingtree()
487
358
 
488
359
    def test_from_string_tag(self):
489
360
        spec = RevisionSpec.from_string('tag:bzr-0.14')
491
362
        self.assertEqual(spec.spec, 'bzr-0.14')
492
363
 
493
364
    def test_lookup_tag(self):
494
 
        self.tree.branch.tags.set_tag('bzr-0.14', b'r1')
495
 
        self.assertInHistoryIs(1, b'r1', 'tag:bzr-0.14')
496
 
        self.tree.branch.tags.set_tag('null_rev', b'null:')
497
 
        self.assertInHistoryIs(0, b'null:', 'tag:null_rev')
 
365
        self.tree.branch.tags.set_tag('bzr-0.14', 'r1')
 
366
        self.assertInHistoryIs(1, 'r1', 'tag:bzr-0.14')
498
367
 
499
368
    def test_failed_lookup(self):
500
369
        # tags that don't exist give a specific message: arguably we should
501
370
        # just give InvalidRevisionSpec but I think this is more helpful
502
371
        self.assertRaises(errors.NoSuchTag,
503
 
                          self.get_in_history,
504
 
                          'tag:some-random-tag')
505
 
 
506
 
    def test_as_revision_id(self):
507
 
        self.tree.branch.tags.set_tag('my-tag', b'r2')
508
 
        self.tree.branch.tags.set_tag('null_rev', b'null:')
509
 
        self.assertAsRevisionId(b'r2', 'tag:my-tag')
510
 
        self.assertAsRevisionId(b'null:', 'tag:null_rev')
511
 
        self.assertAsRevisionId(b'r1', 'before:tag:my-tag')
 
372
            self.get_in_history,
 
373
            'tag:some-random-tag')
512
374
 
513
375
 
514
376
class TestRevisionSpec_date(TestRevisionSpec):
517
379
        super(TestRevisionSpec, self).setUp()
518
380
 
519
381
        new_tree = self.make_branch_and_tree('new_tree')
520
 
        new_tree.commit('Commit one', rev_id=b'new_r1',
521
 
                        timestamp=time.time() - 60 * 60 * 24)
522
 
        new_tree.commit('Commit two', rev_id=b'new_r2')
523
 
        new_tree.commit('Commit three', rev_id=b'new_r3')
 
382
        new_tree.commit('Commit one', rev_id='new_r1',
 
383
                        timestamp=time.time() - 60*60*24)
 
384
        new_tree.commit('Commit two', rev_id='new_r2')
 
385
        new_tree.commit('Commit three', rev_id='new_r3')
524
386
 
525
387
        self.tree = new_tree
526
388
 
528
390
        self.assertInvalid('date:tomorrow')
529
391
 
530
392
    def test_today(self):
531
 
        self.assertInHistoryIs(2, b'new_r2', 'date:today')
532
 
        self.assertInHistoryIs(1, b'new_r1', 'before:date:today')
 
393
        self.assertInHistoryIs(2, 'new_r2', 'date:today')
 
394
        self.assertInHistoryIs(1, 'new_r1', 'before:date:today')
533
395
 
534
396
    def test_yesterday(self):
535
 
        self.assertInHistoryIs(1, b'new_r1', 'date:yesterday')
 
397
        self.assertInHistoryIs(1, 'new_r1', 'date:yesterday')
536
398
 
537
399
    def test_invalid(self):
538
400
        self.assertInvalid('date:foobar', extra='\ninvalid date')
543
405
 
544
406
    def test_day(self):
545
407
        now = datetime.datetime.now()
546
 
        self.assertInHistoryIs(2, b'new_r2',
547
 
                               'date:%04d-%02d-%02d' % (now.year, now.month, now.day))
548
 
 
549
 
    def test_as_revision_id(self):
550
 
        self.assertAsRevisionId(b'new_r2', 'date:today')
 
408
        self.assertInHistoryIs(2, 'new_r2',
 
409
            'date:%04d-%02d-%02d' % (now.year, now.month, now.day))
551
410
 
552
411
 
553
412
class TestRevisionSpec_ancestor(TestRevisionSpec):
554
 
 
 
413
    
555
414
    def test_non_exact_branch(self):
556
415
        # It seems better to require an exact path to the branch
557
416
        # Branch.open() rather than using Branch.open_containing()
560
419
 
561
420
    def test_simple(self):
562
421
        # Common ancestor of trees is 'alt_r2'
563
 
        self.assertInHistoryIs(None, b'alt_r2', 'ancestor:tree2')
 
422
        self.assertInHistoryIs(None, 'alt_r2', 'ancestor:tree2')
564
423
 
565
424
        # Going the other way, we get a valid revno
566
425
        tmp = self.tree
567
426
        self.tree = self.tree2
568
427
        self.tree2 = tmp
569
 
        self.assertInHistoryIs(2, b'alt_r2', 'ancestor:tree')
 
428
        self.assertInHistoryIs(2, 'alt_r2', 'ancestor:tree')
570
429
 
571
430
    def test_self(self):
572
 
        self.assertInHistoryIs(2, b'r2', 'ancestor:tree')
 
431
        self.assertInHistoryIs(2, 'r2', 'ancestor:tree')
573
432
 
574
433
    def test_unrelated(self):
575
434
        new_tree = self.make_branch_and_tree('new_tree')
576
435
 
577
 
        new_tree.commit('Commit one', rev_id=b'new_r1')
578
 
        new_tree.commit('Commit two', rev_id=b'new_r2')
579
 
        new_tree.commit('Commit three', rev_id=b'new_r3')
 
436
        new_tree.commit('Commit one', rev_id='new_r1')
 
437
        new_tree.commit('Commit two', rev_id='new_r2')
 
438
        new_tree.commit('Commit three', rev_id='new_r3')
580
439
 
581
440
        # With no common ancestor, we should raise another user error
582
441
        self.assertRaises(errors.NoCommonAncestor,
587
446
        self.assertRaises(errors.NoCommits,
588
447
                          spec_in_history, 'ancestor:new_tree',
589
448
                                           self.tree.branch)
590
 
 
 
449
                        
591
450
        self.assertRaises(errors.NoCommits,
592
451
                          spec_in_history, 'ancestor:tree',
593
452
                                           new_tree.branch)
594
453
 
595
 
    def test_as_revision_id(self):
596
 
        self.assertAsRevisionId(b'alt_r2', 'ancestor:tree2')
597
 
 
598
 
    def test_default(self):
599
 
        # We don't have a parent to default to
600
 
        self.assertRaises(errors.NotBranchError, self.get_in_history,
601
 
                          'ancestor:')
602
 
 
603
 
        # Create a branch with a parent to default to
604
 
        tree3 = self.tree.controldir.sprout('tree3').open_workingtree()
605
 
        tree3.commit('foo', rev_id=b'r3')
606
 
        self.tree = tree3
607
 
        self.assertInHistoryIs(2, b'r2', 'ancestor:')
608
 
 
609
454
 
610
455
class TestRevisionSpec_branch(TestRevisionSpec):
611
 
 
 
456
    
612
457
    def test_non_exact_branch(self):
613
458
        # It seems better to require an exact path to the branch
614
459
        # Branch.open() rather than using Branch.open_containing()
616
461
                          self.get_in_history, 'branch:tree2/a')
617
462
 
618
463
    def test_simple(self):
619
 
        self.assertInHistoryIs(None, b'alt_r2', 'branch:tree2')
 
464
        self.assertInHistoryIs(None, 'alt_r2', 'branch:tree2')
620
465
 
621
466
    def test_self(self):
622
 
        self.assertInHistoryIs(2, b'r2', 'branch:tree')
 
467
        self.assertInHistoryIs(2, 'r2', 'branch:tree')
623
468
 
624
469
    def test_unrelated(self):
625
470
        new_tree = self.make_branch_and_tree('new_tree')
626
471
 
627
 
        new_tree.commit('Commit one', rev_id=b'new_r1')
628
 
        new_tree.commit('Commit two', rev_id=b'new_r2')
629
 
        new_tree.commit('Commit three', rev_id=b'new_r3')
 
472
        new_tree.commit('Commit one', rev_id='new_r1')
 
473
        new_tree.commit('Commit two', rev_id='new_r2')
 
474
        new_tree.commit('Commit three', rev_id='new_r3')
630
475
 
631
 
        self.assertInHistoryIs(None, b'new_r3', 'branch:new_tree')
 
476
        self.assertInHistoryIs(None, 'new_r3', 'branch:new_tree')
632
477
 
633
478
        # XXX: Right now, we use fetch() to make sure the remote revisions
634
479
        # have been pulled into the local branch. We may change that
635
480
        # behavior in the future.
636
 
        self.assertTrue(self.tree.branch.repository.has_revision(b'new_r3'))
 
481
        self.failUnless(self.tree.branch.repository.has_revision('new_r3'))
637
482
 
638
483
    def test_no_commits(self):
639
 
        self.make_branch_and_tree('new_tree')
 
484
        new_tree = self.make_branch_and_tree('new_tree')
640
485
        self.assertRaises(errors.NoCommits,
641
486
                          self.get_in_history, 'branch:new_tree')
642
 
        self.assertRaises(errors.NoCommits,
643
 
                          self.get_as_tree, 'branch:new_tree')
644
 
 
645
 
    def test_as_revision_id(self):
646
 
        self.assertAsRevisionId(b'alt_r2', 'branch:tree2')
647
 
 
648
 
    def test_as_tree(self):
649
 
        tree = self.get_as_tree('branch:tree', self.tree2)
650
 
        self.assertEqual(b'r2', tree.get_revision_id())
651
 
        self.assertFalse(self.tree2.branch.repository.has_revision(b'r2'))
652
487
 
653
488
 
654
489
class TestRevisionSpec_submit(TestRevisionSpec):
658
493
        self.assertRaises(errors.NoSubmitBranch, self.get_in_history,
659
494
                          'submit:')
660
495
        self.tree.branch.set_parent('../tree2')
661
 
        self.assertInHistoryIs(None, b'alt_r2', 'submit:')
 
496
        self.assertInHistoryIs(None, 'alt_r2', 'submit:')
662
497
        self.tree.branch.set_parent('bogus')
663
498
        self.assertRaises(errors.NotBranchError, self.get_in_history,
664
 
                          'submit:')
 
499
            'submit:')
665
500
        # submit branch overrides parent branch
666
501
        self.tree.branch.set_submit_branch('tree2')
667
 
        self.assertInHistoryIs(None, b'alt_r2', 'submit:')
668
 
 
669
 
    def test_as_revision_id(self):
670
 
        self.tree.branch.set_submit_branch('tree2')
671
 
        self.assertAsRevisionId(b'alt_r2', 'branch:tree2')
672
 
 
673
 
 
674
 
class TestRevisionSpec_mainline(TestRevisionSpec):
675
 
 
676
 
    def test_as_revision_id(self):
677
 
        self.assertAsRevisionId(b'r1', 'mainline:1')
678
 
        self.assertAsRevisionId(b'r2', 'mainline:1.1.1')
679
 
        self.assertAsRevisionId(b'r2', 'mainline:revid:alt_r2')
680
 
        spec = RevisionSpec.from_string('mainline:revid:alt_r22')
681
 
        e = self.assertRaises(
682
 
            InvalidRevisionSpec, spec.as_revision_id, self.tree.branch)
683
 
        self.assertContainsRe(str(e),
684
 
                              "Requested revision: 'mainline:revid:alt_r22' does not exist in"
685
 
                              " branch: ")
686
 
 
687
 
    def test_in_history(self):
688
 
        self.assertInHistoryIs(2, b'r2', 'mainline:revid:alt_r2')
689
 
 
690
 
 
691
 
class TestRevisionSpec_annotate(TestRevisionSpec):
692
 
 
693
 
    def setUp(self):
694
 
        super(TestRevisionSpec_annotate, self).setUp()
695
 
        self.tree = self.make_branch_and_tree('annotate-tree')
696
 
        self.build_tree_contents([('annotate-tree/file1', b'1\n')])
697
 
        self.tree.add('file1')
698
 
        self.tree.commit('r1', rev_id=b'r1')
699
 
        self.build_tree_contents([('annotate-tree/file1', b'2\n1\n')])
700
 
        self.tree.commit('r2', rev_id=b'r2')
701
 
        self.build_tree_contents([('annotate-tree/file1', b'2\n1\n3\n')])
702
 
 
703
 
    def test_as_revision_id_r1(self):
704
 
        self.assertAsRevisionId(b'r1', 'annotate:annotate-tree/file1:2')
705
 
 
706
 
    def test_as_revision_id_r2(self):
707
 
        self.assertAsRevisionId(b'r2', 'annotate:annotate-tree/file1:1')
708
 
 
709
 
    def test_as_revision_id_uncommitted(self):
710
 
        spec = RevisionSpec.from_string('annotate:annotate-tree/file1:3')
711
 
        e = self.assertRaises(
712
 
            InvalidRevisionSpec, spec.as_revision_id, self.tree.branch)
713
 
        self.assertContainsRe(str(e),
714
 
                              r"Requested revision: \'annotate:annotate-tree/file1:3\' does not"
715
 
                              " exist in branch: .*\nLine 3 has not been committed.")
716
 
 
717
 
    def test_non_existent_line(self):
718
 
        spec = RevisionSpec.from_string('annotate:annotate-tree/file1:4')
719
 
        e = self.assertRaises(InvalidRevisionSpec,
720
 
                              spec.as_revision_id, self.tree.branch)
721
 
        self.assertContainsRe(str(e),
722
 
                              r"Requested revision: \'annotate:annotate-tree/file1:4\' does not"
723
 
                              " exist in branch: .*\nNo such line: 4")
724
 
 
725
 
    def test_invalid_line(self):
726
 
        spec = RevisionSpec.from_string('annotate:annotate-tree/file1:q')
727
 
        e = self.assertRaises(InvalidRevisionSpec,
728
 
                              spec.as_revision_id, self.tree.branch)
729
 
        self.assertContainsRe(str(e),
730
 
                              r"Requested revision: \'annotate:annotate-tree/file1:q\' does not"
731
 
                              " exist in branch: .*\nNo such line: q")
732
 
 
733
 
    def test_no_such_file(self):
734
 
        spec = RevisionSpec.from_string('annotate:annotate-tree/file2:1')
735
 
        e = self.assertRaises(InvalidRevisionSpec,
736
 
                              spec.as_revision_id, self.tree.branch)
737
 
        self.assertContainsRe(str(e),
738
 
                              r"Requested revision: \'annotate:annotate-tree/file2:1\' does not"
739
 
                              " exist in branch: .*\nFile 'file2' is not versioned")
740
 
 
741
 
    def test_no_such_file_with_colon(self):
742
 
        spec = RevisionSpec.from_string('annotate:annotate-tree/fi:le2:1')
743
 
        e = self.assertRaises(InvalidRevisionSpec,
744
 
                              spec.as_revision_id, self.tree.branch)
745
 
        self.assertContainsRe(str(e),
746
 
                              r"Requested revision: \'annotate:annotate-tree/fi:le2:1\' does not"
747
 
                              " exist in branch: .*\nFile 'fi:le2' is not versioned")
 
502
        self.assertInHistoryIs(None, 'alt_r2', 'submit:')