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

  • Committer: Marius Kruger
  • Date: 2010-07-10 21:28:56 UTC
  • mto: (5384.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5385.
  • Revision ID: marius.kruger@enerweb.co.za-20100710212856-uq4ji3go0u5se7hx
* Update documentation
* add NEWS

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_revisionspec.py
1
 
# Copyright (C) 2005-2012, 2016 Canonical Ltd
 
1
# Copyright (C) 2005-2010 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
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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,
 
25
    repository,
22
26
    revision as _mod_revision,
23
27
    )
24
 
from breezy.tests import TestCaseWithTransport
25
 
from breezy.revisionspec import (
26
 
    RevisionInfo,
 
28
from bzrlib.tests import TestCase, TestCaseWithTransport
 
29
from bzrlib.revisionspec import (
27
30
    RevisionSpec,
28
 
    RevisionSpec_dwim,
 
31
    RevisionSpec_revno,
29
32
    RevisionSpec_tag,
30
33
    )
31
34
 
50
53
        self.tree.lock_write()
51
54
        self.addCleanup(self.tree.unlock)
52
55
        self.tree.add(['a'])
53
 
        self.tree.commit('a', rev_id=b'r1')
 
56
        self.tree.commit('a', rev_id='r1')
54
57
 
55
 
        self.tree2 = self.tree.controldir.sprout('tree2').open_workingtree()
56
 
        self.tree2.commit('alt', rev_id=b'alt_r2')
 
58
        self.tree2 = self.tree.bzrdir.sprout('tree2').open_workingtree()
 
59
        self.tree2.commit('alt', rev_id='alt_r2')
57
60
 
58
61
        self.tree.merge_from_branch(self.tree2.branch)
59
 
        self.tree.commit('second', rev_id=b'r2')
 
62
        self.tree.commit('second', rev_id='r2')
60
63
 
61
64
    def get_in_history(self, revision_spec):
62
65
        return spec_in_history(revision_spec, self.tree.branch)
75
78
                      invalid_as_revision_id=True):
76
79
        try:
77
80
            self.get_in_history(revision_spec)
78
 
        except errors.InvalidRevisionSpec as e:
 
81
        except errors.InvalidRevisionSpec, e:
79
82
            self.assertEqual(revision_spec, e.spec)
80
83
            self.assertEqual(extra, e.extra)
81
84
        else:
85
88
            try:
86
89
                spec = RevisionSpec.from_string(revision_spec)
87
90
                spec.as_revision_id(self.tree.branch)
88
 
            except errors.InvalidRevisionSpec as e:
 
91
            except errors.InvalidRevisionSpec, e:
89
92
                self.assertEqual(revision_spec, e.spec)
90
93
                self.assertEqual(extra, e.extra)
91
94
            else:
114
117
 
115
118
class TestRevisionSpecBase(TestRevisionSpec):
116
119
 
 
120
    def test_wants_revision_history(self):
 
121
        # If wants_revision_history = True, then _match_on should get the
 
122
        # branch revision history
 
123
        spec = RevisionSpecMatchOnTrap('foo', _internal=True)
 
124
        spec.in_history(self.tree.branch)
 
125
 
 
126
        self.assertEqual((self.tree.branch, ['r1' ,'r2']),
 
127
                         spec.last_call)
 
128
 
117
129
    def test_wants_no_revision_history(self):
118
130
        # If wants_revision_history = False, then _match_on should get None for
119
131
        # the branch revision history
120
132
        spec = RevisionSpecMatchOnTrap('foo', _internal=True)
 
133
        spec.wants_revision_history = False
121
134
        spec.in_history(self.tree.branch)
122
135
 
123
136
        self.assertEqual((self.tree.branch, None), spec.last_call)
124
137
 
125
138
 
 
139
 
126
140
class TestOddRevisionSpec(TestRevisionSpec):
127
141
    """Test things that aren't normally thought of as revision specs"""
128
142
 
133
147
        self.assertRaises(TypeError, RevisionSpec.from_string, object())
134
148
 
135
149
 
136
 
class RevisionSpec_bork(RevisionSpec):
137
 
 
138
 
    prefix = 'irrelevant:'
139
 
 
140
 
    def _match_on(self, branch, revs):
141
 
        if self.spec == "bork":
142
 
            return RevisionInfo.from_revision_id(branch, b"r1")
143
 
        else:
144
 
            raise errors.InvalidRevisionSpec(self.spec, branch)
145
 
 
146
 
 
147
150
class TestRevisionSpec_dwim(TestRevisionSpec):
148
151
 
149
152
    # Don't need to test revno's explicitly since TRS_revno already
150
153
    # covers that well for us
151
154
    def test_dwim_spec_revno(self):
152
 
        self.assertInHistoryIs(2, b'r2', '2')
153
 
        self.assertAsRevisionId(b'alt_r2', '1.1.1')
 
155
        self.assertInHistoryIs(2, 'r2', '2')
 
156
        self.assertAsRevisionId('alt_r2', '1.1.1')
154
157
 
155
158
    def test_dwim_spec_revid(self):
156
 
        self.assertInHistoryIs(2, b'r2', 'r2')
 
159
        self.assertInHistoryIs(2, 'r2', 'r2')
157
160
 
158
161
    def test_dwim_spec_tag(self):
159
 
        self.tree.branch.tags.set_tag('footag', b'r1')
160
 
        self.assertAsRevisionId(b'r1', 'footag')
 
162
        self.tree.branch.tags.set_tag('footag', 'r1')
 
163
        self.assertAsRevisionId('r1', 'footag')
161
164
        self.tree.branch.tags.delete_tag('footag')
162
165
        self.assertRaises(errors.InvalidRevisionSpec,
163
166
                          self.get_in_history, 'footag')
166
169
        # Test that we slip past revno with things that look like revnos,
167
170
        # but aren't.  Tags are convenient for testing this since we can
168
171
        # make them look however we want.
169
 
        self.tree.branch.tags.set_tag('3', b'r2')
170
 
        self.assertAsRevisionId(b'r2', '3')
 
172
        self.tree.branch.tags.set_tag('3', 'r2')
 
173
        self.assertAsRevisionId('r2', '3')
171
174
        self.build_tree(['tree/b'])
172
175
        self.tree.add(['b'])
173
 
        self.tree.commit('b', rev_id=b'r3')
174
 
        self.assertAsRevisionId(b'r3', '3')
 
176
        self.tree.commit('b', rev_id='r3')
 
177
        self.assertAsRevisionId('r3', '3')
175
178
 
176
179
    def test_dwim_spec_date(self):
177
 
        self.assertAsRevisionId(b'r1', 'today')
 
180
        self.assertAsRevisionId('r1', 'today')
178
181
 
179
182
    def test_dwim_spec_branch(self):
180
 
        self.assertInHistoryIs(None, b'alt_r2', 'tree2')
 
183
        self.assertInHistoryIs(None, 'alt_r2', 'tree2')
181
184
 
182
185
    def test_dwim_spec_nonexistent(self):
183
186
        self.assertInvalid('somethingrandom', invalid_as_revision_id=False)
187
190
        self.assertInvalid('1.2..1', invalid_as_revision_id=False)
188
191
        self.assertInvalid('1.', invalid_as_revision_id=False)
189
192
 
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')
208
 
 
209
193
 
210
194
class TestRevisionSpec_revno(TestRevisionSpec):
211
195
 
212
196
    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')
 
197
        self.assertInHistoryIs(0, 'null:', '0')
 
198
        self.assertInHistoryIs(1, 'r1', '1')
 
199
        self.assertInHistoryIs(2, 'r2', '2')
216
200
        self.assertInvalid('3')
217
201
 
218
202
    def test_dotted_decimal(self):
219
 
        self.assertInHistoryIs(None, b'alt_r2', '1.1.1')
 
203
        self.assertInHistoryIs(None, 'alt_r2', '1.1.1')
220
204
        self.assertInvalid('1.1.123')
221
205
 
222
206
    def test_negative_int(self):
223
 
        self.assertInHistoryIs(2, b'r2', '-1')
224
 
        self.assertInHistoryIs(1, b'r1', '-2')
 
207
        self.assertInHistoryIs(2, 'r2', '-1')
 
208
        self.assertInHistoryIs(1, 'r1', '-2')
225
209
 
226
 
        self.assertInHistoryIs(1, b'r1', '-3')
227
 
        self.assertInHistoryIs(1, b'r1', '-4')
228
 
        self.assertInHistoryIs(1, b'r1', '-100')
 
210
        self.assertInHistoryIs(1, 'r1', '-3')
 
211
        self.assertInHistoryIs(1, 'r1', '-4')
 
212
        self.assertInHistoryIs(1, 'r1', '-100')
229
213
 
230
214
    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')
 
215
        self.assertInHistoryIs(0, 'null:', 'revno:0')
 
216
        self.assertInHistoryIs(1, 'r1', 'revno:1')
 
217
        self.assertInHistoryIs(2, 'r2', 'revno:2')
234
218
 
235
219
        self.assertInvalid('revno:3')
236
220
 
237
221
    def test_negative(self):
238
 
        self.assertInHistoryIs(2, b'r2', 'revno:-1')
239
 
        self.assertInHistoryIs(1, b'r1', 'revno:-2')
 
222
        self.assertInHistoryIs(2, 'r2', 'revno:-1')
 
223
        self.assertInHistoryIs(1, 'r1', 'revno:-2')
240
224
 
241
 
        self.assertInHistoryIs(1, b'r1', 'revno:-3')
242
 
        self.assertInHistoryIs(1, b'r1', 'revno:-4')
 
225
        self.assertInHistoryIs(1, 'r1', 'revno:-3')
 
226
        self.assertInHistoryIs(1, 'r1', 'revno:-4')
243
227
 
244
228
    def test_invalid_number(self):
245
229
        # Get the right exception text
246
230
        try:
247
231
            int('X')
248
 
        except ValueError as e:
249
 
            self.assertInvalid('revno:X', extra='\n' + str(e))
250
 
        else:
251
 
            self.fail()
 
232
        except ValueError, e:
 
233
            pass
 
234
        self.assertInvalid('revno:X', extra='\n' + str(e))
252
235
 
253
236
    def test_missing_number_and_branch(self):
254
237
        self.assertInvalid('revno::',
257
240
    def test_invalid_number_with_branch(self):
258
241
        try:
259
242
            int('X')
260
 
        except ValueError as e:
261
 
            self.assertInvalid('revno:X:tree2', extra='\n' + str(e))
262
 
        else:
263
 
            self.fail()
 
243
        except ValueError, e:
 
244
            pass
 
245
        self.assertInvalid('revno:X:tree2', extra='\n' + str(e))
264
246
 
265
247
    def test_non_exact_branch(self):
266
248
        # It seems better to require an exact path to the branch
275
257
        self.assertNotEqual(self.tree.branch.base, revinfo.branch.base)
276
258
        self.assertEqual(self.tree2.branch.base, revinfo.branch.base)
277
259
        self.assertEqual(2, revinfo.revno)
278
 
        self.assertEqual(b'alt_r2', revinfo.rev_id)
 
260
        self.assertEqual('alt_r2', revinfo.rev_id)
279
261
 
280
262
    def test_int_with_branch(self):
281
263
        revinfo = self.get_in_history('2:tree2')
282
264
        self.assertNotEqual(self.tree.branch.base, revinfo.branch.base)
283
265
        self.assertEqual(self.tree2.branch.base, revinfo.branch.base)
284
266
        self.assertEqual(2, revinfo.revno)
285
 
        self.assertEqual(b'alt_r2', revinfo.rev_id)
 
267
        self.assertEqual('alt_r2', revinfo.rev_id)
286
268
 
287
269
    def test_with_url(self):
288
270
        url = self.get_url() + '/tree2'
290
272
        self.assertNotEqual(self.tree.branch.base, revinfo.branch.base)
291
273
        self.assertEqual(self.tree2.branch.base, revinfo.branch.base)
292
274
        self.assertEqual(2, revinfo.revno)
293
 
        self.assertEqual(b'alt_r2', revinfo.rev_id)
 
275
        self.assertEqual('alt_r2', revinfo.rev_id)
294
276
 
295
277
    def test_negative_with_url(self):
296
278
        url = self.get_url() + '/tree2'
298
280
        self.assertNotEqual(self.tree.branch.base, revinfo.branch.base)
299
281
        self.assertEqual(self.tree2.branch.base, revinfo.branch.base)
300
282
        self.assertEqual(2, revinfo.revno)
301
 
        self.assertEqual(b'alt_r2', revinfo.rev_id)
 
283
        self.assertEqual('alt_r2', revinfo.rev_id)
302
284
 
303
285
    def test_different_history_lengths(self):
304
286
        # Make sure we use the revisions and offsets in the supplied branch
305
287
        # 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')
 
288
        self.tree2.commit('three', rev_id='r3')
 
289
        self.assertInHistoryIs(3, 'r3', 'revno:3:tree2')
 
290
        self.assertInHistoryIs(3, 'r3', 'revno:-1:tree2')
309
291
 
310
292
    def test_invalid_branch(self):
311
293
        self.assertRaises(errors.NotBranchError,
312
294
                          self.get_in_history, 'revno:-1:tree3')
313
295
 
314
296
    def test_invalid_revno_in_branch(self):
315
 
        self.tree.commit('three', rev_id=b'r3')
 
297
        self.tree.commit('three', rev_id='r3')
316
298
        self.assertInvalid('revno:3:tree2')
317
299
 
318
300
    def test_revno_n_path(self):
320
302
        wta = self.make_branch_and_tree('a')
321
303
        ba = wta.branch
322
304
 
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')
 
305
        wta.commit('Commit one', rev_id='a@r-0-1')
 
306
        wta.commit('Commit two', rev_id='a@r-0-2')
 
307
        wta.commit('Commit three', rev_id='a@r-0-3')
326
308
 
327
309
        wtb = self.make_branch_and_tree('b')
328
310
        bb = wtb.branch
329
311
 
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'),
 
312
        wtb.commit('Commit one', rev_id='b@r-0-1')
 
313
        wtb.commit('Commit two', rev_id='b@r-0-2')
 
314
        wtb.commit('Commit three', rev_id='b@r-0-3')
 
315
 
 
316
 
 
317
        self.assertEqual((1, 'a@r-0-1'),
335
318
                         spec_in_history('revno:1:a/', ba))
336
319
        # The argument of in_history should be ignored since it is
337
320
        # redundant with the path in the spec.
338
 
        self.assertEqual((1, b'a@r-0-1'),
 
321
        self.assertEqual((1, 'a@r-0-1'),
339
322
                         spec_in_history('revno:1:a/', None))
340
 
        self.assertEqual((1, b'a@r-0-1'),
 
323
        self.assertEqual((1, 'a@r-0-1'),
341
324
                         spec_in_history('revno:1:a/', bb))
342
 
        self.assertEqual((2, b'b@r-0-2'),
 
325
        self.assertEqual((2, 'b@r-0-2'),
343
326
                         spec_in_history('revno:2:b/', None))
344
327
 
345
328
    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')
 
329
        self.assertAsRevisionId('null:', '0')
 
330
        self.assertAsRevisionId('r1', '1')
 
331
        self.assertAsRevisionId('r2', '2')
 
332
        self.assertAsRevisionId('r1', '-2')
 
333
        self.assertAsRevisionId('r2', '-1')
 
334
        self.assertAsRevisionId('alt_r2', '1.1.1')
352
335
 
353
336
    def test_as_tree(self):
354
337
        tree = self.get_as_tree('0')
355
 
        self.assertEqual(_mod_revision.NULL_REVISION, tree.get_revision_id())
 
338
        self.assertEquals(_mod_revision.NULL_REVISION, tree.get_revision_id())
356
339
        tree = self.get_as_tree('1')
357
 
        self.assertEqual(b'r1', tree.get_revision_id())
 
340
        self.assertEquals('r1', tree.get_revision_id())
358
341
        tree = self.get_as_tree('2')
359
 
        self.assertEqual(b'r2', tree.get_revision_id())
 
342
        self.assertEquals('r2', tree.get_revision_id())
360
343
        tree = self.get_as_tree('-2')
361
 
        self.assertEqual(b'r1', tree.get_revision_id())
 
344
        self.assertEquals('r1', tree.get_revision_id())
362
345
        tree = self.get_as_tree('-1')
363
 
        self.assertEqual(b'r2', tree.get_revision_id())
 
346
        self.assertEquals('r2', tree.get_revision_id())
364
347
        tree = self.get_as_tree('1.1.1')
365
 
        self.assertEqual(b'alt_r2', tree.get_revision_id())
 
348
        self.assertEquals('alt_r2', tree.get_revision_id())
366
349
 
367
350
 
368
351
class TestRevisionSpec_revid(TestRevisionSpec):
370
353
    def test_in_history(self):
371
354
        # We should be able to access revisions that are directly
372
355
        # in the history.
373
 
        self.assertInHistoryIs(1, b'r1', 'revid:r1')
374
 
        self.assertInHistoryIs(2, b'r2', 'revid:r2')
 
356
        self.assertInHistoryIs(1, 'r1', 'revid:r1')
 
357
        self.assertInHistoryIs(2, 'r2', 'revid:r2')
375
358
 
376
359
    def test_missing(self):
377
360
        self.assertInvalid('revid:r3', invalid_as_revision_id=False)
378
361
 
379
362
    def test_merged(self):
380
363
        """We can reach revisions in the ancestry"""
381
 
        self.assertInHistoryIs(None, b'alt_r2', 'revid:alt_r2')
 
364
        self.assertInHistoryIs(None, 'alt_r2', 'revid:alt_r2')
382
365
 
383
366
    def test_not_here(self):
384
 
        self.tree2.commit('alt third', rev_id=b'alt_r3')
 
367
        self.tree2.commit('alt third', rev_id='alt_r3')
385
368
        # It exists in tree2, but not in tree
386
369
        self.assertInvalid('revid:alt_r3', invalid_as_revision_id=False)
387
370
 
388
371
    def test_in_repository(self):
389
372
        """We can get any revision id in the repository"""
390
373
        # 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')
 
374
        self.tree2.commit('alt third', rev_id='alt_r3')
 
375
        self.tree.branch.repository.fetch(self.tree2.branch.repository,
 
376
                                          revision_id='alt_r3')
 
377
        self.assertInHistoryIs(None, 'alt_r3', 'revid:alt_r3')
394
378
 
395
379
    def test_unicode(self):
396
380
        """We correctly convert a unicode ui string to an encoded revid."""
397
381
        revision_id = u'\N{SNOWMAN}'.encode('utf-8')
398
382
        self.tree.commit('unicode', rev_id=revision_id)
399
383
        self.assertInHistoryIs(3, revision_id, u'revid:\N{SNOWMAN}')
400
 
        self.assertInHistoryIs(3, revision_id, 'revid:' +
401
 
                               revision_id.decode('utf-8'))
 
384
        self.assertInHistoryIs(3, revision_id, 'revid:' + revision_id)
402
385
 
403
386
    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')
 
387
        self.assertAsRevisionId('r1', 'revid:r1')
 
388
        self.assertAsRevisionId('r2', 'revid:r2')
 
389
        self.assertAsRevisionId('alt_r2', 'revid:alt_r2')
407
390
 
408
391
 
409
392
class TestRevisionSpec_last(TestRevisionSpec):
410
393
 
411
394
    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')
 
395
        self.assertInHistoryIs(2, 'r2', 'last:1')
 
396
        self.assertInHistoryIs(1, 'r1', 'last:2')
 
397
        self.assertInHistoryIs(0, 'null:', 'last:3')
415
398
 
416
399
    def test_empty(self):
417
 
        self.assertInHistoryIs(2, b'r2', 'last:')
 
400
        self.assertInHistoryIs(2, 'r2', 'last:')
418
401
 
419
402
    def test_negative(self):
420
403
        self.assertInvalid('last:-1',
430
413
                          spec_in_history, 'last:', tree.branch)
431
414
 
432
415
    def test_not_a_number(self):
433
 
        last_e = None
434
416
        try:
435
417
            int('Y')
436
 
        except ValueError as e:
437
 
            last_e = e
438
 
        self.assertInvalid('last:Y', extra='\n' + str(last_e))
 
418
        except ValueError, e:
 
419
            pass
 
420
        self.assertInvalid('last:Y', extra='\n' + str(e))
439
421
 
440
422
    def test_as_revision_id(self):
441
 
        self.assertAsRevisionId(b'r2', 'last:1')
442
 
        self.assertAsRevisionId(b'r1', 'last:2')
 
423
        self.assertAsRevisionId('r2', 'last:1')
 
424
        self.assertAsRevisionId('r1', 'last:2')
443
425
 
444
426
 
445
427
class TestRevisionSpec_before(TestRevisionSpec):
446
428
 
447
429
    def test_int(self):
448
 
        self.assertInHistoryIs(1, b'r1', 'before:2')
449
 
        self.assertInHistoryIs(1, b'r1', 'before:-1')
 
430
        self.assertInHistoryIs(1, 'r1', 'before:2')
 
431
        self.assertInHistoryIs(1, 'r1', 'before:-1')
450
432
 
451
433
    def test_before_one(self):
452
 
        self.assertInHistoryIs(0, b'null:', 'before:1')
 
434
        self.assertInHistoryIs(0, 'null:', 'before:1')
453
435
 
454
436
    def test_before_none(self):
455
437
        self.assertInvalid('before:0',
456
438
                           extra='\ncannot go before the null: revision')
457
439
 
458
440
    def test_revid(self):
459
 
        self.assertInHistoryIs(1, b'r1', 'before:revid:r2')
 
441
        self.assertInHistoryIs(1, 'r1', 'before:revid:r2')
460
442
 
461
443
    def test_last(self):
462
 
        self.assertInHistoryIs(1, b'r1', 'before:last:1')
 
444
        self.assertInHistoryIs(1, 'r1', 'before:last:1')
463
445
 
464
446
    def test_alt_revid(self):
465
447
        # This will grab the left-most ancestor for alternate histories
466
 
        self.assertInHistoryIs(1, b'r1', 'before:revid:alt_r2')
 
448
        self.assertInHistoryIs(1, 'r1', 'before:revid:alt_r2')
467
449
 
468
450
    def test_alt_no_parents(self):
469
451
        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')
 
452
        new_tree.commit('first', rev_id='new_r1')
 
453
        self.tree.branch.repository.fetch(new_tree.branch.repository,
 
454
                                          revision_id='new_r1')
 
455
        self.assertInHistoryIs(0, 'null:', 'before:revid:new_r1')
473
456
 
474
457
    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')
 
458
        self.assertAsRevisionId('r1', 'before:revid:r2')
 
459
        self.assertAsRevisionId('r1', 'before:2')
 
460
        self.assertAsRevisionId('r1', 'before:1.1.1')
 
461
        self.assertAsRevisionId('r1', 'before:revid:alt_r2')
479
462
 
480
463
 
481
464
class TestRevisionSpec_tag(TestRevisionSpec):
491
474
        self.assertEqual(spec.spec, 'bzr-0.14')
492
475
 
493
476
    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')
 
477
        self.tree.branch.tags.set_tag('bzr-0.14', 'r1')
 
478
        self.assertInHistoryIs(1, 'r1', 'tag:bzr-0.14')
 
479
        self.tree.branch.tags.set_tag('null_rev', 'null:')
 
480
        self.assertInHistoryIs(0, 'null:', 'tag:null_rev')
498
481
 
499
482
    def test_failed_lookup(self):
500
483
        # tags that don't exist give a specific message: arguably we should
501
484
        # just give InvalidRevisionSpec but I think this is more helpful
502
485
        self.assertRaises(errors.NoSuchTag,
503
 
                          self.get_in_history,
504
 
                          'tag:some-random-tag')
 
486
            self.get_in_history,
 
487
            'tag:some-random-tag')
505
488
 
506
489
    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')
 
490
        self.tree.branch.tags.set_tag('my-tag', 'r2')
 
491
        self.tree.branch.tags.set_tag('null_rev', 'null:')
 
492
        self.assertAsRevisionId('r2', 'tag:my-tag')
 
493
        self.assertAsRevisionId('null:', 'tag:null_rev')
 
494
        self.assertAsRevisionId('r1', 'before:tag:my-tag')
512
495
 
513
496
 
514
497
class TestRevisionSpec_date(TestRevisionSpec):
517
500
        super(TestRevisionSpec, self).setUp()
518
501
 
519
502
        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')
 
503
        new_tree.commit('Commit one', rev_id='new_r1',
 
504
                        timestamp=time.time() - 60*60*24)
 
505
        new_tree.commit('Commit two', rev_id='new_r2')
 
506
        new_tree.commit('Commit three', rev_id='new_r3')
524
507
 
525
508
        self.tree = new_tree
526
509
 
528
511
        self.assertInvalid('date:tomorrow')
529
512
 
530
513
    def test_today(self):
531
 
        self.assertInHistoryIs(2, b'new_r2', 'date:today')
532
 
        self.assertInHistoryIs(1, b'new_r1', 'before:date:today')
 
514
        self.assertInHistoryIs(2, 'new_r2', 'date:today')
 
515
        self.assertInHistoryIs(1, 'new_r1', 'before:date:today')
533
516
 
534
517
    def test_yesterday(self):
535
 
        self.assertInHistoryIs(1, b'new_r1', 'date:yesterday')
 
518
        self.assertInHistoryIs(1, 'new_r1', 'date:yesterday')
536
519
 
537
520
    def test_invalid(self):
538
521
        self.assertInvalid('date:foobar', extra='\ninvalid date')
543
526
 
544
527
    def test_day(self):
545
528
        now = datetime.datetime.now()
546
 
        self.assertInHistoryIs(2, b'new_r2',
547
 
                               'date:%04d-%02d-%02d' % (now.year, now.month, now.day))
 
529
        self.assertInHistoryIs(2, 'new_r2',
 
530
            'date:%04d-%02d-%02d' % (now.year, now.month, now.day))
548
531
 
549
532
    def test_as_revision_id(self):
550
 
        self.assertAsRevisionId(b'new_r2', 'date:today')
 
533
        self.assertAsRevisionId('new_r2', 'date:today')
551
534
 
552
535
 
553
536
class TestRevisionSpec_ancestor(TestRevisionSpec):
560
543
 
561
544
    def test_simple(self):
562
545
        # Common ancestor of trees is 'alt_r2'
563
 
        self.assertInHistoryIs(None, b'alt_r2', 'ancestor:tree2')
 
546
        self.assertInHistoryIs(None, 'alt_r2', 'ancestor:tree2')
564
547
 
565
548
        # Going the other way, we get a valid revno
566
549
        tmp = self.tree
567
550
        self.tree = self.tree2
568
551
        self.tree2 = tmp
569
 
        self.assertInHistoryIs(2, b'alt_r2', 'ancestor:tree')
 
552
        self.assertInHistoryIs(2, 'alt_r2', 'ancestor:tree')
570
553
 
571
554
    def test_self(self):
572
 
        self.assertInHistoryIs(2, b'r2', 'ancestor:tree')
 
555
        self.assertInHistoryIs(2, 'r2', 'ancestor:tree')
573
556
 
574
557
    def test_unrelated(self):
575
558
        new_tree = self.make_branch_and_tree('new_tree')
576
559
 
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')
 
560
        new_tree.commit('Commit one', rev_id='new_r1')
 
561
        new_tree.commit('Commit two', rev_id='new_r2')
 
562
        new_tree.commit('Commit three', rev_id='new_r3')
580
563
 
581
564
        # With no common ancestor, we should raise another user error
582
565
        self.assertRaises(errors.NoCommonAncestor,
593
576
                                           new_tree.branch)
594
577
 
595
578
    def test_as_revision_id(self):
596
 
        self.assertAsRevisionId(b'alt_r2', 'ancestor:tree2')
 
579
        self.assertAsRevisionId('alt_r2', 'ancestor:tree2')
597
580
 
598
581
    def test_default(self):
599
582
        # We don't have a parent to default to
601
584
                          'ancestor:')
602
585
 
603
586
        # 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')
 
587
        tree3 = self.tree.bzrdir.sprout('tree3').open_workingtree()
 
588
        tree3.commit('foo', rev_id='r3')
606
589
        self.tree = tree3
607
 
        self.assertInHistoryIs(2, b'r2', 'ancestor:')
 
590
        self.assertInHistoryIs(2, 'r2', 'ancestor:')
608
591
 
609
592
 
610
593
class TestRevisionSpec_branch(TestRevisionSpec):
616
599
                          self.get_in_history, 'branch:tree2/a')
617
600
 
618
601
    def test_simple(self):
619
 
        self.assertInHistoryIs(None, b'alt_r2', 'branch:tree2')
 
602
        self.assertInHistoryIs(None, 'alt_r2', 'branch:tree2')
620
603
 
621
604
    def test_self(self):
622
 
        self.assertInHistoryIs(2, b'r2', 'branch:tree')
 
605
        self.assertInHistoryIs(2, 'r2', 'branch:tree')
623
606
 
624
607
    def test_unrelated(self):
625
608
        new_tree = self.make_branch_and_tree('new_tree')
626
609
 
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')
 
610
        new_tree.commit('Commit one', rev_id='new_r1')
 
611
        new_tree.commit('Commit two', rev_id='new_r2')
 
612
        new_tree.commit('Commit three', rev_id='new_r3')
630
613
 
631
 
        self.assertInHistoryIs(None, b'new_r3', 'branch:new_tree')
 
614
        self.assertInHistoryIs(None, 'new_r3', 'branch:new_tree')
632
615
 
633
616
        # XXX: Right now, we use fetch() to make sure the remote revisions
634
617
        # have been pulled into the local branch. We may change that
635
618
        # behavior in the future.
636
 
        self.assertTrue(self.tree.branch.repository.has_revision(b'new_r3'))
 
619
        self.failUnless(self.tree.branch.repository.has_revision('new_r3'))
637
620
 
638
621
    def test_no_commits(self):
639
 
        self.make_branch_and_tree('new_tree')
 
622
        new_tree = self.make_branch_and_tree('new_tree')
640
623
        self.assertRaises(errors.NoCommits,
641
624
                          self.get_in_history, 'branch:new_tree')
642
625
        self.assertRaises(errors.NoCommits,
643
626
                          self.get_as_tree, 'branch:new_tree')
644
627
 
645
628
    def test_as_revision_id(self):
646
 
        self.assertAsRevisionId(b'alt_r2', 'branch:tree2')
 
629
        self.assertAsRevisionId('alt_r2', 'branch:tree2')
647
630
 
648
631
    def test_as_tree(self):
649
632
        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'))
 
633
        self.assertEquals('r2', tree.get_revision_id())
 
634
        self.assertFalse(self.tree2.branch.repository.has_revision('r2'))
652
635
 
653
636
 
654
637
class TestRevisionSpec_submit(TestRevisionSpec):
658
641
        self.assertRaises(errors.NoSubmitBranch, self.get_in_history,
659
642
                          'submit:')
660
643
        self.tree.branch.set_parent('../tree2')
661
 
        self.assertInHistoryIs(None, b'alt_r2', 'submit:')
 
644
        self.assertInHistoryIs(None, 'alt_r2', 'submit:')
662
645
        self.tree.branch.set_parent('bogus')
663
646
        self.assertRaises(errors.NotBranchError, self.get_in_history,
664
 
                          'submit:')
 
647
            'submit:')
665
648
        # submit branch overrides parent branch
666
649
        self.tree.branch.set_submit_branch('tree2')
667
 
        self.assertInHistoryIs(None, b'alt_r2', 'submit:')
 
650
        self.assertInHistoryIs(None, 'alt_r2', 'submit:')
668
651
 
669
652
    def test_as_revision_id(self):
670
653
        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(errors.InvalidRevisionSpec,
682
 
                              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(errors.InvalidRevisionSpec,
712
 
                              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(errors.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(errors.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(errors.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(errors.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")
 
654
        self.assertAsRevisionId('alt_r2', 'branch:tree2')