/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

First attempt to merge .dev and resolve the conflicts (but tests are 
failing)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_revisionspec.py
1
 
# Copyright (C) 2004, 2005, 2006 by 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
19
19
import time
20
20
 
21
21
from bzrlib import (
 
22
    branch,
 
23
    bzrdir,
22
24
    errors,
23
 
    )
24
 
from bzrlib.builtins import merge
25
 
from bzrlib.tests import TestCaseWithTransport
26
 
from bzrlib.revisionspec import RevisionSpec
 
25
    repository,
 
26
    )
 
27
from bzrlib.tests import TestCase, TestCaseWithTransport
 
28
from bzrlib.revisionspec import (
 
29
    RevisionSpec,
 
30
    RevisionSpec_revno,
 
31
    RevisionSpec_tag,
 
32
    )
27
33
 
28
34
 
29
35
def spec_in_history(spec, branch):
36
42
 
37
43
    def setUp(self):
38
44
        super(TestRevisionSpec, self).setUp()
 
45
        # this sets up a revision graph:
 
46
        # r1: []             1
 
47
        # alt_r2: [r1]       1.1.1
 
48
        # r2: [r1, alt_r2]   2
39
49
 
40
50
        self.tree = self.make_branch_and_tree('tree')
41
51
        self.build_tree(['tree/a'])
 
52
        self.tree.lock_write()
 
53
        self.addCleanup(self.tree.unlock)
42
54
        self.tree.add(['a'])
43
55
        self.tree.commit('a', rev_id='r1')
44
56
 
45
57
        self.tree2 = self.tree.bzrdir.sprout('tree2').open_workingtree()
46
58
        self.tree2.commit('alt', rev_id='alt_r2')
47
59
 
48
 
        self.tree.branch.repository.fetch(self.tree2.branch.repository,
49
 
                                          revision_id='alt_r2')
50
 
        self.tree.set_pending_merges(['alt_r2'])
 
60
        self.tree.merge_from_branch(self.tree2.branch)
51
61
        self.tree.commit('second', rev_id='r2')
52
62
 
53
63
    def get_in_history(self, revision_spec):
56
66
    def assertInHistoryIs(self, exp_revno, exp_revision_id, revision_spec):
57
67
        rev_info = self.get_in_history(revision_spec)
58
68
        self.assertEqual(exp_revno, rev_info.revno,
59
 
                         'Revision spec: %s returned wrong revno: %s != %s'
 
69
                         'Revision spec: %r returned wrong revno: %r != %r'
60
70
                         % (revision_spec, exp_revno, rev_info.revno))
61
71
        self.assertEqual(exp_revision_id, rev_info.rev_id,
62
 
                         'Revision spec: %s returned wrong revision id:'
63
 
                         ' %s != %s'
 
72
                         'Revision spec: %r returned wrong revision id:'
 
73
                         ' %r != %r'
64
74
                         % (revision_spec, exp_revision_id, rev_info.rev_id))
65
75
 
66
 
    def assertInvalid(self, revision_spec, extra=''):
 
76
    def assertInvalid(self, revision_spec, extra='',
 
77
                      invalid_as_revision_id=True):
67
78
        try:
68
79
            self.get_in_history(revision_spec)
69
80
        except errors.InvalidRevisionSpec, e:
70
81
            self.assertEqual(revision_spec, e.spec)
71
82
            self.assertEqual(extra, e.extra)
72
83
        else:
73
 
            self.fail('Expected InvalidRevisionSpec to be raised for %s'
74
 
                      % (revision_spec,))
 
84
            self.fail('Expected InvalidRevisionSpec to be raised for'
 
85
                      ' %r.in_history' % (revision_spec,))
 
86
        if invalid_as_revision_id:
 
87
            try:
 
88
                spec = RevisionSpec.from_string(revision_spec)
 
89
                spec.as_revision_id(self.tree.branch)
 
90
            except errors.InvalidRevisionSpec, e:
 
91
                self.assertEqual(revision_spec, e.spec)
 
92
                self.assertEqual(extra, e.extra)
 
93
            else:
 
94
                self.fail('Expected InvalidRevisionSpec to be raised for'
 
95
                          ' %r.as_revision_id' % (revision_spec,))
 
96
 
 
97
    def assertAsRevisionId(self, revision_id, revision_spec):
 
98
        """Calling as_revision_id() should return the specified id."""
 
99
        spec = RevisionSpec.from_string(revision_spec)
 
100
        self.assertEqual(revision_id,
 
101
                         spec.as_revision_id(self.tree.branch))
 
102
 
 
103
 
 
104
class RevisionSpecMatchOnTrap(RevisionSpec):
 
105
 
 
106
    def _match_on(self, branch, revs):
 
107
        self.last_call = (branch, revs)
 
108
        return super(RevisionSpecMatchOnTrap, self)._match_on(branch, revs)
 
109
 
 
110
 
 
111
class TestRevisionSpecBase(TestRevisionSpec):
 
112
 
 
113
    def test_wants_revision_history(self):
 
114
        # If wants_revision_history = True, then _match_on should get the
 
115
        # branch revision history
 
116
        spec = RevisionSpecMatchOnTrap('foo', _internal=True)
 
117
        spec.in_history(self.tree.branch)
 
118
 
 
119
        self.assertEqual((self.tree.branch, ['r1' ,'r2']),
 
120
                         spec.last_call)
 
121
 
 
122
    def test_wants_no_revision_history(self):
 
123
        # If wants_revision_history = False, then _match_on should get None for
 
124
        # the branch revision history
 
125
        spec = RevisionSpecMatchOnTrap('foo', _internal=True)
 
126
        spec.wants_revision_history = False
 
127
        spec.in_history(self.tree.branch)
 
128
 
 
129
        self.assertEqual((self.tree.branch, None), spec.last_call)
 
130
 
75
131
 
76
132
 
77
133
class TestOddRevisionSpec(TestRevisionSpec):
78
134
    """Test things that aren't normally thought of as revision specs"""
79
135
 
80
136
    def test_none(self):
81
 
        self.assertInHistoryIs(0, None, None)
 
137
        self.assertInHistoryIs(None, None, None)
82
138
 
83
139
    def test_object(self):
84
140
        self.assertRaises(TypeError, RevisionSpec.from_string, object())
90
146
                          RevisionSpec.from_string, '123a')
91
147
 
92
148
 
 
149
 
 
150
class TestRevnoFromString(TestCase):
 
151
 
 
152
    def test_from_string_dotted_decimal(self):
 
153
        self.assertRaises(errors.NoSuchRevisionSpec, RevisionSpec.from_string, '-1.1')
 
154
        self.assertRaises(errors.NoSuchRevisionSpec, RevisionSpec.from_string, '.1')
 
155
        self.assertRaises(errors.NoSuchRevisionSpec, RevisionSpec.from_string, '1..1')
 
156
        self.assertRaises(errors.NoSuchRevisionSpec, RevisionSpec.from_string, '1.2..1')
 
157
        self.assertRaises(errors.NoSuchRevisionSpec, RevisionSpec.from_string, '1.')
 
158
        self.assertIsInstance(RevisionSpec.from_string('1.1'), RevisionSpec_revno)
 
159
        self.assertIsInstance(RevisionSpec.from_string('1.1.3'), RevisionSpec_revno)
 
160
 
 
161
 
93
162
class TestRevisionSpec_revno(TestRevisionSpec):
94
163
 
95
164
    def test_positive_int(self):
96
 
        self.assertInHistoryIs(0, None, '0')
 
165
        self.assertInHistoryIs(0, 'null:', '0')
97
166
        self.assertInHistoryIs(1, 'r1', '1')
98
167
        self.assertInHistoryIs(2, 'r2', '2')
99
 
 
100
168
        self.assertInvalid('3')
101
169
 
 
170
    def test_dotted_decimal(self):
 
171
        self.assertInHistoryIs(None, 'alt_r2', '1.1.1')
 
172
 
102
173
    def test_negative_int(self):
103
174
        self.assertInHistoryIs(2, 'r2', '-1')
104
175
        self.assertInHistoryIs(1, 'r1', '-2')
108
179
        self.assertInHistoryIs(1, 'r1', '-100')
109
180
 
110
181
    def test_positive(self):
111
 
        self.assertInHistoryIs(0, None, 'revno:0')
 
182
        self.assertInHistoryIs(0, 'null:', 'revno:0')
112
183
        self.assertInHistoryIs(1, 'r1', 'revno:1')
113
184
        self.assertInHistoryIs(2, 'r2', 'revno:2')
114
185
 
221
292
        self.assertEqual((2, 'b@r-0-2'),
222
293
                         spec_in_history('revno:2:b/', None))
223
294
 
 
295
    def test_as_revision_id(self):
 
296
        self.assertAsRevisionId('null:', '0')
 
297
        self.assertAsRevisionId('r1', '1')
 
298
        self.assertAsRevisionId('r2', '2')
 
299
        self.assertAsRevisionId('r1', '-2')
 
300
        self.assertAsRevisionId('r2', '-1')
 
301
        self.assertAsRevisionId('alt_r2', '1.1.1')
224
302
 
225
303
 
226
304
class TestRevisionSpec_revid(TestRevisionSpec):
232
310
        self.assertInHistoryIs(2, 'r2', 'revid:r2')
233
311
        
234
312
    def test_missing(self):
235
 
        self.assertInvalid('revid:r3')
 
313
        self.assertInvalid('revid:r3', invalid_as_revision_id=False)
236
314
 
237
315
    def test_merged(self):
238
316
        """We can reach revisions in the ancestry"""
241
319
    def test_not_here(self):
242
320
        self.tree2.commit('alt third', rev_id='alt_r3')
243
321
        # It exists in tree2, but not in tree
244
 
        self.assertInvalid('revid:alt_r3')
 
322
        self.assertInvalid('revid:alt_r3', invalid_as_revision_id=False)
245
323
 
246
324
    def test_in_repository(self):
247
325
        """We can get any revision id in the repository"""
251
329
                                          revision_id='alt_r3')
252
330
        self.assertInHistoryIs(None, 'alt_r3', 'revid:alt_r3')
253
331
 
 
332
    def test_unicode(self):
 
333
        """We correctly convert a unicode ui string to an encoded revid."""
 
334
        revision_id = u'\N{SNOWMAN}'.encode('utf-8')
 
335
        self.tree.commit('unicode', rev_id=revision_id)
 
336
        self.assertInHistoryIs(3, revision_id, u'revid:\N{SNOWMAN}')
 
337
        self.assertInHistoryIs(3, revision_id, 'revid:' + revision_id)
 
338
 
 
339
    def test_as_revision_id(self):
 
340
        self.assertAsRevisionId('r1', 'revid:r1')
 
341
        self.assertAsRevisionId('r2', 'revid:r2')
 
342
        self.assertAsRevisionId('alt_r2', 'revid:alt_r2')
 
343
 
254
344
 
255
345
class TestRevisionSpec_last(TestRevisionSpec):
256
346
 
257
347
    def test_positive(self):
258
348
        self.assertInHistoryIs(2, 'r2', 'last:1')
259
349
        self.assertInHistoryIs(1, 'r1', 'last:2')
260
 
        self.assertInHistoryIs(0, None, 'last:3')
 
350
        self.assertInHistoryIs(0, 'null:', 'last:3')
261
351
 
262
352
    def test_empty(self):
263
353
        self.assertInHistoryIs(2, 'r2', 'last:')
282
372
            pass
283
373
        self.assertInvalid('last:Y', extra='\n' + str(e))
284
374
 
 
375
    def test_as_revision_id(self):
 
376
        self.assertAsRevisionId('r2', 'last:1')
 
377
        self.assertAsRevisionId('r1', 'last:2')
 
378
 
285
379
 
286
380
class TestRevisionSpec_before(TestRevisionSpec):
287
381
 
290
384
        self.assertInHistoryIs(1, 'r1', 'before:-1')
291
385
 
292
386
    def test_before_one(self):
293
 
        self.assertInHistoryIs(0, None, 'before:1')
 
387
        self.assertInHistoryIs(0, 'null:', 'before:1')
294
388
 
295
389
    def test_before_none(self):
296
390
        self.assertInvalid('before:0',
311
405
        new_tree.commit('first', rev_id='new_r1')
312
406
        self.tree.branch.repository.fetch(new_tree.branch.repository,
313
407
                                          revision_id='new_r1')
314
 
        self.assertInHistoryIs(0, None, 'before:revid:new_r1')
 
408
        self.assertInHistoryIs(0, 'null:', 'before:revid:new_r1')
 
409
 
 
410
    def test_as_revision_id(self):
 
411
        self.assertAsRevisionId('r1', 'before:revid:r2')
 
412
        self.assertAsRevisionId('r1', 'before:2')
 
413
        self.assertAsRevisionId('r1', 'before:1.1.1')
 
414
        self.assertAsRevisionId('r1', 'before:revid:alt_r2')
315
415
 
316
416
 
317
417
class TestRevisionSpec_tag(TestRevisionSpec):
318
418
    
319
 
    def test_invalid(self):
320
 
        self.assertInvalid('tag:foo', extra='\ntag: namespace registered,'
321
 
                                            ' but not implemented')
 
419
    def make_branch_and_tree(self, relpath):
 
420
        # override format as the default one may not support tags
 
421
        return TestRevisionSpec.make_branch_and_tree(
 
422
            self, relpath, format='dirstate-tags')
 
423
 
 
424
    def test_from_string_tag(self):
 
425
        spec = RevisionSpec.from_string('tag:bzr-0.14')
 
426
        self.assertIsInstance(spec, RevisionSpec_tag)
 
427
        self.assertEqual(spec.spec, 'bzr-0.14')
 
428
 
 
429
    def test_lookup_tag(self):
 
430
        self.tree.branch.tags.set_tag('bzr-0.14', 'r1')
 
431
        self.assertInHistoryIs(1, 'r1', 'tag:bzr-0.14')
 
432
        self.tree.branch.tags.set_tag('null_rev', 'null:')
 
433
        self.assertInHistoryIs(0, 'null:', 'tag:null_rev')
 
434
 
 
435
    def test_failed_lookup(self):
 
436
        # tags that don't exist give a specific message: arguably we should
 
437
        # just give InvalidRevisionSpec but I think this is more helpful
 
438
        self.assertRaises(errors.NoSuchTag,
 
439
            self.get_in_history,
 
440
            'tag:some-random-tag')
 
441
 
 
442
    def test_as_revision_id(self):
 
443
        self.tree.branch.tags.set_tag('my-tag', 'r2')
 
444
        self.tree.branch.tags.set_tag('null_rev', 'null:')
 
445
        self.assertAsRevisionId('r2', 'tag:my-tag')
 
446
        self.assertAsRevisionId('null:', 'tag:null_rev')
 
447
        self.assertAsRevisionId('r1', 'before:tag:my-tag')
322
448
 
323
449
 
324
450
class TestRevisionSpec_date(TestRevisionSpec):
356
482
        self.assertInHistoryIs(2, 'new_r2',
357
483
            'date:%04d-%02d-%02d' % (now.year, now.month, now.day))
358
484
 
 
485
    def test_as_revision_id(self):
 
486
        self.assertAsRevisionId('new_r2', 'date:today')
 
487
 
359
488
 
360
489
class TestRevisionSpec_ancestor(TestRevisionSpec):
361
490
    
399
528
                          spec_in_history, 'ancestor:tree',
400
529
                                           new_tree.branch)
401
530
 
 
531
    def test_as_revision_id(self):
 
532
        self.assertAsRevisionId('alt_r2', 'ancestor:tree2')
 
533
 
402
534
 
403
535
class TestRevisionSpec_branch(TestRevisionSpec):
404
536
    
432
564
        new_tree = self.make_branch_and_tree('new_tree')
433
565
        self.assertRaises(errors.NoCommits,
434
566
                          self.get_in_history, 'branch:new_tree')
 
567
 
 
568
    def test_as_revision_id(self):
 
569
        self.assertAsRevisionId('alt_r2', 'branch:tree2')
 
570
 
 
571
 
 
572
class TestRevisionSpec_submit(TestRevisionSpec):
 
573
 
 
574
    def test_submit_branch(self):
 
575
        # Common ancestor of trees is 'alt_r2'
 
576
        self.assertRaises(errors.NoSubmitBranch, self.get_in_history,
 
577
                          'submit:')
 
578
        self.tree.branch.set_parent('../tree2')
 
579
        self.assertInHistoryIs(None, 'alt_r2', 'submit:')
 
580
        self.tree.branch.set_parent('bogus')
 
581
        self.assertRaises(errors.NotBranchError, self.get_in_history,
 
582
            'submit:')
 
583
        # submit branch overrides parent branch
 
584
        self.tree.branch.set_submit_branch('tree2')
 
585
        self.assertInHistoryIs(None, 'alt_r2', 'submit:')
 
586
 
 
587
    def test_as_revision_id(self):
 
588
        self.tree.branch.set_submit_branch('tree2')
 
589
        self.assertAsRevisionId('alt_r2', 'branch:tree2')