← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_revisionnamespaces.py

  • Committer: Ian Clatworthy
  • Date: 2007-08-13 14:16:53 UTC
  • mto: (2733.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 2734.
  • Revision ID: ian.clatworthy@internode.on.net-20070813141653-3cbrp00xowq58zv1
Added mini tutorial

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_revisionnamespaces.py
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
18
import os
23
23
    bzrdir,
24
24
    errors,
25
25
    repository,
26
 
    revision as _mod_revision,
27
26
    )
28
27
from bzrlib.tests import TestCase, TestCaseWithTransport
29
28
from bzrlib.revisionspec import (
50
49
 
51
50
        self.tree = self.make_branch_and_tree('tree')
52
51
        self.build_tree(['tree/a'])
53
 
        self.tree.lock_write()
54
 
        self.addCleanup(self.tree.unlock)
55
52
        self.tree.add(['a'])
56
53
        self.tree.commit('a', rev_id='r1')
57
54
 
58
55
        self.tree2 = self.tree.bzrdir.sprout('tree2').open_workingtree()
59
56
        self.tree2.commit('alt', rev_id='alt_r2')
60
57
 
61
 
        self.tree.merge_from_branch(self.tree2.branch)
 
58
        self.tree.branch.repository.fetch(self.tree2.branch.repository,
 
59
                                          revision_id='alt_r2')
 
60
        self.tree.set_pending_merges(['alt_r2'])
62
61
        self.tree.commit('second', rev_id='r2')
63
62
 
64
63
    def get_in_history(self, revision_spec):
74
73
                         ' %r != %r'
75
74
                         % (revision_spec, exp_revision_id, rev_info.rev_id))
76
75
 
77
 
    def assertInvalid(self, revision_spec, extra='',
78
 
                      invalid_as_revision_id=True):
 
76
    def assertInvalid(self, revision_spec, extra=''):
79
77
        try:
80
78
            self.get_in_history(revision_spec)
81
79
        except errors.InvalidRevisionSpec, e:
82
80
            self.assertEqual(revision_spec, e.spec)
83
81
            self.assertEqual(extra, e.extra)
84
82
        else:
85
 
            self.fail('Expected InvalidRevisionSpec to be raised for'
86
 
                      ' %r.in_history' % (revision_spec,))
87
 
        if invalid_as_revision_id:
88
 
            try:
89
 
                spec = RevisionSpec.from_string(revision_spec)
90
 
                spec.as_revision_id(self.tree.branch)
91
 
            except errors.InvalidRevisionSpec, e:
92
 
                self.assertEqual(revision_spec, e.spec)
93
 
                self.assertEqual(extra, e.extra)
94
 
            else:
95
 
                self.fail('Expected InvalidRevisionSpec to be raised for'
96
 
                          ' %r.as_revision_id' % (revision_spec,))
97
 
 
98
 
    def assertAsRevisionId(self, revision_id, revision_spec):
99
 
        """Calling as_revision_id() should return the specified id."""
100
 
        spec = RevisionSpec.from_string(revision_spec)
101
 
        self.assertEqual(revision_id,
102
 
                         spec.as_revision_id(self.tree.branch))
103
 
 
104
 
    def get_as_tree(self, revision_spec, tree=None):
105
 
        if tree is None:
106
 
            tree = self.tree
107
 
        spec = RevisionSpec.from_string(revision_spec)
108
 
        return spec.as_tree(tree.branch)
109
 
 
110
 
 
111
 
class RevisionSpecMatchOnTrap(RevisionSpec):
112
 
 
113
 
    def _match_on(self, branch, revs):
114
 
        self.last_call = (branch, revs)
115
 
        return super(RevisionSpecMatchOnTrap, self)._match_on(branch, revs)
116
 
 
117
 
 
118
 
class TestRevisionSpecBase(TestRevisionSpec):
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
 
 
129
 
    def test_wants_no_revision_history(self):
130
 
        # If wants_revision_history = False, then _match_on should get None for
131
 
        # the branch revision history
132
 
        spec = RevisionSpecMatchOnTrap('foo', _internal=True)
133
 
        spec.wants_revision_history = False
134
 
        spec.in_history(self.tree.branch)
135
 
 
136
 
        self.assertEqual((self.tree.branch, None), spec.last_call)
137
 
 
 
83
            self.fail('Expected InvalidRevisionSpec to be raised for %s'
 
84
                      % (revision_spec,))
138
85
 
139
86
 
140
87
class TestOddRevisionSpec(TestRevisionSpec):
141
88
    """Test things that aren't normally thought of as revision specs"""
142
89
 
143
90
    def test_none(self):
144
 
        self.assertInHistoryIs(None, None, None)
 
91
        self.assertInHistoryIs(0, None, None)
145
92
 
146
93
    def test_object(self):
147
94
        self.assertRaises(TypeError, RevisionSpec.from_string, object())
169
116
class TestRevisionSpec_revno(TestRevisionSpec):
170
117
 
171
118
    def test_positive_int(self):
172
 
        self.assertInHistoryIs(0, 'null:', '0')
 
119
        self.assertInHistoryIs(0, None, '0')
173
120
        self.assertInHistoryIs(1, 'r1', '1')
174
121
        self.assertInHistoryIs(2, 'r2', '2')
175
122
        self.assertInvalid('3')
176
123
 
177
124
    def test_dotted_decimal(self):
178
125
        self.assertInHistoryIs(None, 'alt_r2', '1.1.1')
179
 
        self.assertInvalid('1.1.123')
180
126
 
181
127
    def test_negative_int(self):
182
128
        self.assertInHistoryIs(2, 'r2', '-1')
187
133
        self.assertInHistoryIs(1, 'r1', '-100')
188
134
 
189
135
    def test_positive(self):
190
 
        self.assertInHistoryIs(0, 'null:', 'revno:0')
 
136
        self.assertInHistoryIs(0, None, 'revno:0')
191
137
        self.assertInHistoryIs(1, 'r1', 'revno:1')
192
138
        self.assertInHistoryIs(2, 'r2', 'revno:2')
193
139
 
276
222
        """Old revno:N:path tests"""
277
223
        wta = self.make_branch_and_tree('a')
278
224
        ba = wta.branch
279
 
 
 
225
        
280
226
        wta.commit('Commit one', rev_id='a@r-0-1')
281
227
        wta.commit('Commit two', rev_id='a@r-0-2')
282
228
        wta.commit('Commit three', rev_id='a@r-0-3')
300
246
        self.assertEqual((2, 'b@r-0-2'),
301
247
                         spec_in_history('revno:2:b/', None))
302
248
 
303
 
    def test_as_revision_id(self):
304
 
        self.assertAsRevisionId('null:', '0')
305
 
        self.assertAsRevisionId('r1', '1')
306
 
        self.assertAsRevisionId('r2', '2')
307
 
        self.assertAsRevisionId('r1', '-2')
308
 
        self.assertAsRevisionId('r2', '-1')
309
 
        self.assertAsRevisionId('alt_r2', '1.1.1')
310
 
 
311
 
    def test_as_tree(self):
312
 
        tree = self.get_as_tree('0')
313
 
        self.assertEquals(_mod_revision.NULL_REVISION, tree.get_revision_id())
314
 
        tree = self.get_as_tree('1')
315
 
        self.assertEquals('r1', tree.get_revision_id())
316
 
        tree = self.get_as_tree('2')
317
 
        self.assertEquals('r2', tree.get_revision_id())
318
 
        tree = self.get_as_tree('-2')
319
 
        self.assertEquals('r1', tree.get_revision_id())
320
 
        tree = self.get_as_tree('-1')
321
 
        self.assertEquals('r2', tree.get_revision_id())
322
 
        tree = self.get_as_tree('1.1.1')
323
 
        self.assertEquals('alt_r2', tree.get_revision_id())
324
249
 
325
250
 
326
251
class TestRevisionSpec_revid(TestRevisionSpec):
327
 
 
 
252
    
328
253
    def test_in_history(self):
329
254
        # We should be able to access revisions that are directly
330
255
        # in the history.
331
256
        self.assertInHistoryIs(1, 'r1', 'revid:r1')
332
257
        self.assertInHistoryIs(2, 'r2', 'revid:r2')
333
 
 
 
258
        
334
259
    def test_missing(self):
335
 
        self.assertInvalid('revid:r3', invalid_as_revision_id=False)
 
260
        self.assertInvalid('revid:r3')
336
261
 
337
262
    def test_merged(self):
338
263
        """We can reach revisions in the ancestry"""
341
266
    def test_not_here(self):
342
267
        self.tree2.commit('alt third', rev_id='alt_r3')
343
268
        # It exists in tree2, but not in tree
344
 
        self.assertInvalid('revid:alt_r3', invalid_as_revision_id=False)
 
269
        self.assertInvalid('revid:alt_r3')
345
270
 
346
271
    def test_in_repository(self):
347
272
        """We can get any revision id in the repository"""
358
283
        self.assertInHistoryIs(3, revision_id, u'revid:\N{SNOWMAN}')
359
284
        self.assertInHistoryIs(3, revision_id, 'revid:' + revision_id)
360
285
 
361
 
    def test_as_revision_id(self):
362
 
        self.assertAsRevisionId('r1', 'revid:r1')
363
 
        self.assertAsRevisionId('r2', 'revid:r2')
364
 
        self.assertAsRevisionId('alt_r2', 'revid:alt_r2')
365
 
 
366
286
 
367
287
class TestRevisionSpec_last(TestRevisionSpec):
368
288
 
369
289
    def test_positive(self):
370
290
        self.assertInHistoryIs(2, 'r2', 'last:1')
371
291
        self.assertInHistoryIs(1, 'r1', 'last:2')
372
 
        self.assertInHistoryIs(0, 'null:', 'last:3')
 
292
        self.assertInHistoryIs(0, None, 'last:3')
373
293
 
374
294
    def test_empty(self):
375
295
        self.assertInHistoryIs(2, 'r2', 'last:')
394
314
            pass
395
315
        self.assertInvalid('last:Y', extra='\n' + str(e))
396
316
 
397
 
    def test_as_revision_id(self):
398
 
        self.assertAsRevisionId('r2', 'last:1')
399
 
        self.assertAsRevisionId('r1', 'last:2')
400
 
 
401
317
 
402
318
class TestRevisionSpec_before(TestRevisionSpec):
403
319
 
406
322
        self.assertInHistoryIs(1, 'r1', 'before:-1')
407
323
 
408
324
    def test_before_one(self):
409
 
        self.assertInHistoryIs(0, 'null:', 'before:1')
 
325
        self.assertInHistoryIs(0, None, 'before:1')
410
326
 
411
327
    def test_before_none(self):
412
328
        self.assertInvalid('before:0',
427
343
        new_tree.commit('first', rev_id='new_r1')
428
344
        self.tree.branch.repository.fetch(new_tree.branch.repository,
429
345
                                          revision_id='new_r1')
430
 
        self.assertInHistoryIs(0, 'null:', 'before:revid:new_r1')
431
 
 
432
 
    def test_as_revision_id(self):
433
 
        self.assertAsRevisionId('r1', 'before:revid:r2')
434
 
        self.assertAsRevisionId('r1', 'before:2')
435
 
        self.assertAsRevisionId('r1', 'before:1.1.1')
436
 
        self.assertAsRevisionId('r1', 'before:revid:alt_r2')
 
346
        self.assertInHistoryIs(0, None, 'before:revid:new_r1')
437
347
 
438
348
 
439
349
class TestRevisionSpec_tag(TestRevisionSpec):
440
 
 
 
350
    
441
351
    def make_branch_and_tree(self, relpath):
442
352
        # override format as the default one may not support tags
443
 
        return TestRevisionSpec.make_branch_and_tree(
444
 
            self, relpath, format='dirstate-tags')
 
353
        control = bzrdir.BzrDir.create(relpath)
 
354
        control.create_repository()
 
355
        branch.BzrBranchExperimental.initialize(control)
 
356
        return control.create_workingtree()
445
357
 
446
358
    def test_from_string_tag(self):
447
359
        spec = RevisionSpec.from_string('tag:bzr-0.14')
451
363
    def test_lookup_tag(self):
452
364
        self.tree.branch.tags.set_tag('bzr-0.14', 'r1')
453
365
        self.assertInHistoryIs(1, 'r1', 'tag:bzr-0.14')
454
 
        self.tree.branch.tags.set_tag('null_rev', 'null:')
455
 
        self.assertInHistoryIs(0, 'null:', 'tag:null_rev')
456
366
 
457
367
    def test_failed_lookup(self):
458
368
        # tags that don't exist give a specific message: arguably we should
461
371
            self.get_in_history,
462
372
            'tag:some-random-tag')
463
373
 
464
 
    def test_as_revision_id(self):
465
 
        self.tree.branch.tags.set_tag('my-tag', 'r2')
466
 
        self.tree.branch.tags.set_tag('null_rev', 'null:')
467
 
        self.assertAsRevisionId('r2', 'tag:my-tag')
468
 
        self.assertAsRevisionId('null:', 'tag:null_rev')
469
 
        self.assertAsRevisionId('r1', 'before:tag:my-tag')
470
 
 
471
374
 
472
375
class TestRevisionSpec_date(TestRevisionSpec):
473
376
 
504
407
        self.assertInHistoryIs(2, 'new_r2',
505
408
            'date:%04d-%02d-%02d' % (now.year, now.month, now.day))
506
409
 
507
 
    def test_as_revision_id(self):
508
 
        self.assertAsRevisionId('new_r2', 'date:today')
509
 
 
510
410
 
511
411
class TestRevisionSpec_ancestor(TestRevisionSpec):
512
 
 
 
412
    
513
413
    def test_non_exact_branch(self):
514
414
        # It seems better to require an exact path to the branch
515
415
        # Branch.open() rather than using Branch.open_containing()
545
445
        self.assertRaises(errors.NoCommits,
546
446
                          spec_in_history, 'ancestor:new_tree',
547
447
                                           self.tree.branch)
548
 
 
 
448
                        
549
449
        self.assertRaises(errors.NoCommits,
550
450
                          spec_in_history, 'ancestor:tree',
551
451
                                           new_tree.branch)
552
452
 
553
 
    def test_as_revision_id(self):
554
 
        self.assertAsRevisionId('alt_r2', 'ancestor:tree2')
555
 
 
556
 
    def test_default(self):
557
 
        # We don't have a parent to default to
558
 
        self.assertRaises(errors.NotBranchError, self.get_in_history,
559
 
                          'ancestor:')
560
 
 
561
 
        # Create a branch with a parent to default to
562
 
        tree3 = self.tree.bzrdir.sprout('tree3').open_workingtree()
563
 
        tree3.commit('foo', rev_id='r3')
564
 
        self.tree = tree3
565
 
        self.assertInHistoryIs(2, 'r2', 'ancestor:')
566
 
 
567
453
 
568
454
class TestRevisionSpec_branch(TestRevisionSpec):
569
 
 
 
455
    
570
456
    def test_non_exact_branch(self):
571
457
        # It seems better to require an exact path to the branch
572
458
        # Branch.open() rather than using Branch.open_containing()
597
483
        new_tree = self.make_branch_and_tree('new_tree')
598
484
        self.assertRaises(errors.NoCommits,
599
485
                          self.get_in_history, 'branch:new_tree')
600
 
        self.assertRaises(errors.NoCommits,
601
 
                          self.get_as_tree, 'branch:new_tree')
602
 
 
603
 
    def test_as_revision_id(self):
604
 
        self.assertAsRevisionId('alt_r2', 'branch:tree2')
605
 
 
606
 
    def test_as_tree(self):
607
 
        tree = self.get_as_tree('branch:tree', self.tree2)
608
 
        self.assertEquals('r2', tree.get_revision_id())
609
 
        self.assertFalse(self.tree2.branch.repository.has_revision('r2'))
610
486
 
611
487
 
612
488
class TestRevisionSpec_submit(TestRevisionSpec):
623
499
        # submit branch overrides parent branch
624
500
        self.tree.branch.set_submit_branch('tree2')
625
501
        self.assertInHistoryIs(None, 'alt_r2', 'submit:')
626
 
 
627
 
    def test_as_revision_id(self):
628
 
        self.tree.branch.set_submit_branch('tree2')
629
 
        self.assertAsRevisionId('alt_r2', 'branch:tree2')