← 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: Robert Collins
  • Date: 2007-07-15 15:40:37 UTC
  • mto: (2592.3.33 repository)
  • mto: This revision was merged to the branch mainline in revision 2624.
  • Revision ID: robertc@robertcollins.net-20070715154037-3ar8g89decddc9su
Make GraphIndex accept nodes as key, value, references, so that the method
signature is closer to what a simple key->value index delivers. Also
change the behaviour when the reference list count is zero to accept
key, value as nodes, and emit key, value to make it identical in that case
to a simple key->value index. This may not be a good idea, but for now it
seems ok.

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
    )
 
27
from bzrlib.builtins import merge
28
28
from bzrlib.tests import TestCase, TestCaseWithTransport
29
29
from bzrlib.revisionspec import (
30
30
    RevisionSpec,
50
50
 
51
51
        self.tree = self.make_branch_and_tree('tree')
52
52
        self.build_tree(['tree/a'])
53
 
        self.tree.lock_write()
54
 
        self.addCleanup(self.tree.unlock)
55
53
        self.tree.add(['a'])
56
54
        self.tree.commit('a', rev_id='r1')
57
55
 
58
56
        self.tree2 = self.tree.bzrdir.sprout('tree2').open_workingtree()
59
57
        self.tree2.commit('alt', rev_id='alt_r2')
60
58
 
61
 
        self.tree.merge_from_branch(self.tree2.branch)
 
59
        self.tree.branch.repository.fetch(self.tree2.branch.repository,
 
60
                                          revision_id='alt_r2')
 
61
        self.tree.set_pending_merges(['alt_r2'])
62
62
        self.tree.commit('second', rev_id='r2')
63
63
 
64
64
    def get_in_history(self, revision_spec):
74
74
                         ' %r != %r'
75
75
                         % (revision_spec, exp_revision_id, rev_info.rev_id))
76
76
 
77
 
    def assertInvalid(self, revision_spec, extra='',
78
 
                      invalid_as_revision_id=True):
 
77
    def assertInvalid(self, revision_spec, extra=''):
79
78
        try:
80
79
            self.get_in_history(revision_spec)
81
80
        except errors.InvalidRevisionSpec, e:
82
81
            self.assertEqual(revision_spec, e.spec)
83
82
            self.assertEqual(extra, e.extra)
84
83
        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
 
 
 
84
            self.fail('Expected InvalidRevisionSpec to be raised for %s'
 
85
                      % (revision_spec,))
138
86
 
139
87
 
140
88
class TestOddRevisionSpec(TestRevisionSpec):
141
89
    """Test things that aren't normally thought of as revision specs"""
142
90
 
143
91
    def test_none(self):
144
 
        self.assertInHistoryIs(None, None, None)
 
92
        self.assertInHistoryIs(0, None, None)
145
93
 
146
94
    def test_object(self):
147
95
        self.assertRaises(TypeError, RevisionSpec.from_string, object())
169
117
class TestRevisionSpec_revno(TestRevisionSpec):
170
118
 
171
119
    def test_positive_int(self):
172
 
        self.assertInHistoryIs(0, 'null:', '0')
 
120
        self.assertInHistoryIs(0, None, '0')
173
121
        self.assertInHistoryIs(1, 'r1', '1')
174
122
        self.assertInHistoryIs(2, 'r2', '2')
175
123
        self.assertInvalid('3')
176
124
 
177
125
    def test_dotted_decimal(self):
178
126
        self.assertInHistoryIs(None, 'alt_r2', '1.1.1')
179
 
        self.assertInvalid('1.1.123')
180
127
 
181
128
    def test_negative_int(self):
182
129
        self.assertInHistoryIs(2, 'r2', '-1')
187
134
        self.assertInHistoryIs(1, 'r1', '-100')
188
135
 
189
136
    def test_positive(self):
190
 
        self.assertInHistoryIs(0, 'null:', 'revno:0')
 
137
        self.assertInHistoryIs(0, None, 'revno:0')
191
138
        self.assertInHistoryIs(1, 'r1', 'revno:1')
192
139
        self.assertInHistoryIs(2, 'r2', 'revno:2')
193
140
 
276
223
        """Old revno:N:path tests"""
277
224
        wta = self.make_branch_and_tree('a')
278
225
        ba = wta.branch
279
 
 
 
226
        
280
227
        wta.commit('Commit one', rev_id='a@r-0-1')
281
228
        wta.commit('Commit two', rev_id='a@r-0-2')
282
229
        wta.commit('Commit three', rev_id='a@r-0-3')
300
247
        self.assertEqual((2, 'b@r-0-2'),
301
248
                         spec_in_history('revno:2:b/', None))
302
249
 
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
250
 
325
251
 
326
252
class TestRevisionSpec_revid(TestRevisionSpec):
327
 
 
 
253
    
328
254
    def test_in_history(self):
329
255
        # We should be able to access revisions that are directly
330
256
        # in the history.
331
257
        self.assertInHistoryIs(1, 'r1', 'revid:r1')
332
258
        self.assertInHistoryIs(2, 'r2', 'revid:r2')
333
 
 
 
259
        
334
260
    def test_missing(self):
335
 
        self.assertInvalid('revid:r3', invalid_as_revision_id=False)
 
261
        self.assertInvalid('revid:r3')
336
262
 
337
263
    def test_merged(self):
338
264
        """We can reach revisions in the ancestry"""
341
267
    def test_not_here(self):
342
268
        self.tree2.commit('alt third', rev_id='alt_r3')
343
269
        # It exists in tree2, but not in tree
344
 
        self.assertInvalid('revid:alt_r3', invalid_as_revision_id=False)
 
270
        self.assertInvalid('revid:alt_r3')
345
271
 
346
272
    def test_in_repository(self):
347
273
        """We can get any revision id in the repository"""
358
284
        self.assertInHistoryIs(3, revision_id, u'revid:\N{SNOWMAN}')
359
285
        self.assertInHistoryIs(3, revision_id, 'revid:' + revision_id)
360
286
 
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
287
 
367
288
class TestRevisionSpec_last(TestRevisionSpec):
368
289
 
369
290
    def test_positive(self):
370
291
        self.assertInHistoryIs(2, 'r2', 'last:1')
371
292
        self.assertInHistoryIs(1, 'r1', 'last:2')
372
 
        self.assertInHistoryIs(0, 'null:', 'last:3')
 
293
        self.assertInHistoryIs(0, None, 'last:3')
373
294
 
374
295
    def test_empty(self):
375
296
        self.assertInHistoryIs(2, 'r2', 'last:')
394
315
            pass
395
316
        self.assertInvalid('last:Y', extra='\n' + str(e))
396
317
 
397
 
    def test_as_revision_id(self):
398
 
        self.assertAsRevisionId('r2', 'last:1')
399
 
        self.assertAsRevisionId('r1', 'last:2')
400
 
 
401
318
 
402
319
class TestRevisionSpec_before(TestRevisionSpec):
403
320
 
406
323
        self.assertInHistoryIs(1, 'r1', 'before:-1')
407
324
 
408
325
    def test_before_one(self):
409
 
        self.assertInHistoryIs(0, 'null:', 'before:1')
 
326
        self.assertInHistoryIs(0, None, 'before:1')
410
327
 
411
328
    def test_before_none(self):
412
329
        self.assertInvalid('before:0',
427
344
        new_tree.commit('first', rev_id='new_r1')
428
345
        self.tree.branch.repository.fetch(new_tree.branch.repository,
429
346
                                          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')
 
347
        self.assertInHistoryIs(0, None, 'before:revid:new_r1')
437
348
 
438
349
 
439
350
class TestRevisionSpec_tag(TestRevisionSpec):
440
 
 
 
351
    
441
352
    def make_branch_and_tree(self, relpath):
442
353
        # override format as the default one may not support tags
443
 
        return TestRevisionSpec.make_branch_and_tree(
444
 
            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()
445
358
 
446
359
    def test_from_string_tag(self):
447
360
        spec = RevisionSpec.from_string('tag:bzr-0.14')
451
364
    def test_lookup_tag(self):
452
365
        self.tree.branch.tags.set_tag('bzr-0.14', 'r1')
453
366
        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
367
 
457
368
    def test_failed_lookup(self):
458
369
        # tags that don't exist give a specific message: arguably we should
461
372
            self.get_in_history,
462
373
            'tag:some-random-tag')
463
374
 
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
375
 
472
376
class TestRevisionSpec_date(TestRevisionSpec):
473
377
 
504
408
        self.assertInHistoryIs(2, 'new_r2',
505
409
            'date:%04d-%02d-%02d' % (now.year, now.month, now.day))
506
410
 
507
 
    def test_as_revision_id(self):
508
 
        self.assertAsRevisionId('new_r2', 'date:today')
509
 
 
510
411
 
511
412
class TestRevisionSpec_ancestor(TestRevisionSpec):
512
 
 
 
413
    
513
414
    def test_non_exact_branch(self):
514
415
        # It seems better to require an exact path to the branch
515
416
        # Branch.open() rather than using Branch.open_containing()
545
446
        self.assertRaises(errors.NoCommits,
546
447
                          spec_in_history, 'ancestor:new_tree',
547
448
                                           self.tree.branch)
548
 
 
 
449
                        
549
450
        self.assertRaises(errors.NoCommits,
550
451
                          spec_in_history, 'ancestor:tree',
551
452
                                           new_tree.branch)
552
453
 
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
454
 
568
455
class TestRevisionSpec_branch(TestRevisionSpec):
569
 
 
 
456
    
570
457
    def test_non_exact_branch(self):
571
458
        # It seems better to require an exact path to the branch
572
459
        # Branch.open() rather than using Branch.open_containing()
597
484
        new_tree = self.make_branch_and_tree('new_tree')
598
485
        self.assertRaises(errors.NoCommits,
599
486
                          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
487
 
611
488
 
612
489
class TestRevisionSpec_submit(TestRevisionSpec):
623
500
        # submit branch overrides parent branch
624
501
        self.tree.branch.set_submit_branch('tree2')
625
502
        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')