← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_info.py

  • Committer: Robert Collins
  • Date: 2007-07-04 08:08:13 UTC
  • mfrom: (2572 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2587.
  • Revision ID: robertc@robertcollins.net-20070704080813-wzebx0r88fvwj5rq
Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_info.py
1
 
# Copyright (C) 2006 by Canonical Ltd
2
 
# -*- coding: utf-8 -*-
 
1
# Copyright (C) 2006, 2007 Canonical Ltd
3
2
#
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
21
20
import sys
22
21
 
23
22
import bzrlib
24
 
from bzrlib import repository
 
23
from bzrlib import (
 
24
    bzrdir,
 
25
    repository,
 
26
    )
25
27
from bzrlib.osutils import format_date
26
28
from bzrlib.tests import TestSkipped
27
29
from bzrlib.tests.blackbox import ExternalBase
34
36
            location = "C:/i/do/not/exist/"
35
37
        else:
36
38
            location = "/i/do/not/exist/"
37
 
        out, err = self.runbzr('info '+location, retcode=3)
 
39
        out, err = self.run_bzr('info '+location, retcode=3)
38
40
        self.assertEqual(out, '')
39
41
        self.assertEqual(err, 'bzr: ERROR: Not a branch: %s\n' % location)
40
42
 
42
44
        transport = self.get_transport()
43
45
 
44
46
        # Create initial standalone branch
45
 
        old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
46
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(bzrlib.bzrdir.BzrDirFormat6())
47
 
        tree1 = self.make_branch_and_tree('standalone')
48
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
 
47
        tree1 = self.make_branch_and_tree('standalone', 'weave')
49
48
        self.build_tree(['standalone/a'])
50
49
        tree1.add('a')
51
50
        branch1 = tree1.branch
52
 
        out, err = self.runbzr('info standalone')
 
51
        out, err = self.run_bzr('info standalone -v')
53
52
        self.assertEqualDiff(
54
 
"""Location:
 
53
"""Standalone tree (format: weave)
 
54
Location:
55
55
  branch root: %s
56
56
 
57
57
Format:
72
72
 
73
73
Branch history:
74
74
         0 revisions
 
75
         0 committers
75
76
 
76
 
Revision store:
 
77
Repository:
77
78
         0 revisions
78
79
         0 KiB
79
80
""" % branch1.bzrdir.root_transport.base, out)
85
86
        # Branch standalone with push location
86
87
        branch2 = branch1.bzrdir.sprout('branch').open_branch()
87
88
        branch2.set_push_location(branch1.bzrdir.root_transport.base)
88
 
        out, err = self.runbzr('info branch --verbose')
 
89
        out, err = self.run_bzr('info branch --verbose')
89
90
        self.assertEqualDiff(
90
 
"""Location:
 
91
"""Standalone tree (format: weave)
 
92
Location:
91
93
  branch root: %s
92
94
 
93
95
Related branches:
117
119
   first revision: %s
118
120
  latest revision: %s
119
121
 
120
 
Revision store:
 
122
Repository:
121
123
         1 revision
122
124
         %d KiB
123
125
""" % (branch2.bzrdir.root_transport.base,
134
136
        # Branch and bind to standalone, needs upgrade to metadir
135
137
        # (creates backup as unknown)
136
138
        branch1.bzrdir.sprout('bound')
137
 
        knit1_format = bzrlib.bzrdir.BzrDirMetaFormat1()
138
 
        knit1_format.repository_format = repository.RepositoryFormatKnit1()
 
139
        knit1_format = bzrdir.format_registry.make_bzrdir('knit')
139
140
        bzrlib.upgrade.upgrade('bound', knit1_format)
140
141
        branch3 = bzrlib.bzrdir.BzrDir.open('bound').open_branch()
141
142
        branch3.bind(branch1)
142
143
        bound_tree = branch3.bzrdir.open_workingtree()
143
 
        out, err = self.runbzr('info bound')
 
144
        out, err = self.run_bzr('info -v bound')
144
145
        self.assertEqualDiff(
145
 
"""Location:
 
146
"""Checkout (format: knit)
 
147
Location:
146
148
       checkout root: %s
147
149
  checkout of branch: %s
148
150
 
152
154
Format:
153
155
       control: Meta directory format 1
154
156
  working tree: %s
155
 
        branch: Branch format 5
 
157
        branch: %s
156
158
    repository: %s
157
159
 
158
160
In the working tree:
167
169
 
168
170
Branch history:
169
171
         1 revision
 
172
         1 committer
170
173
         0 days old
171
174
   first revision: %s
172
175
  latest revision: %s
173
176
 
174
 
Revision store:
 
177
Repository:
175
178
         1 revision
176
179
         %d KiB
177
180
""" % (branch3.bzrdir.root_transport.base,
178
181
       branch1.bzrdir.root_transport.base,
179
182
       branch1.bzrdir.root_transport.base,
180
183
       bound_tree._format.get_format_description(),      
 
184
       branch3._format.get_format_description(),
181
185
       branch3.repository._format.get_format_description(),
182
186
       datestring_first, datestring_first,
183
187
       # poking at _revision_store isn't all that clean, but neither is
188
192
        self.assertEqual('', err)
189
193
 
190
194
        # Checkout standalone (same as above, but does not have parent set)
191
 
        old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
192
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(knit1_format)
193
 
        branch4 = bzrlib.bzrdir.BzrDir.create_branch_convenience('checkout')
194
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
 
195
        branch4 = bzrlib.bzrdir.BzrDir.create_branch_convenience('checkout',
 
196
            format=knit1_format)
195
197
        branch4.bind(branch1)
196
198
        branch4.bzrdir.open_workingtree().update()
197
 
        out, err = self.runbzr('info checkout --verbose')
 
199
        out, err = self.run_bzr('info checkout --verbose')
198
200
        self.assertEqualDiff(
199
 
"""Location:
 
201
"""Checkout (format: knit)
 
202
Location:
200
203
       checkout root: %s
201
204
  checkout of branch: %s
202
205
 
223
226
   first revision: %s
224
227
  latest revision: %s
225
228
 
226
 
Revision store:
 
229
Repository:
227
230
         1 revision
228
231
         %d KiB
229
232
""" % (branch4.bzrdir.root_transport.base,
238
241
        self.assertEqual('', err)
239
242
 
240
243
        # Lightweight checkout (same as above, different branch and repository)
241
 
        old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
242
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(bzrlib.bzrdir.BzrDirMetaFormat1())
243
 
        transport.mkdir('lightcheckout')
244
 
        dir5 = bzrlib.bzrdir.BzrDirMetaFormat1().initialize('lightcheckout')
245
 
        bzrlib.branch.BranchReferenceFormat().initialize(dir5, branch1)
246
 
        dir5.create_workingtree()
247
 
        tree5 = dir5.open_workingtree()
248
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
 
244
        tree5 = branch1.create_checkout('lightcheckout', lightweight=True)
249
245
        branch5 = tree5.branch
250
 
        out, err = self.runbzr('info lightcheckout')
 
246
        out, err = self.run_bzr('info -v lightcheckout')
251
247
        self.assertEqualDiff(
252
 
"""Location:
253
 
 light checkout root: %s
254
 
  checkout of branch: %s
 
248
"""Lightweight checkout (format: dirstate or dirstate-tags)
 
249
Location:
 
250
  light checkout root: %s
 
251
   checkout of branch: %s
255
252
 
256
253
Format:
257
254
       control: Meta directory format 1
258
 
  working tree: Working tree format 3
 
255
  working tree: Working tree format 4
259
256
        branch: Branch format 4
260
257
    repository: Weave repository format 6
261
258
 
271
268
 
272
269
Branch history:
273
270
         1 revision
 
271
         1 committer
274
272
         0 days old
275
273
   first revision: %s
276
274
  latest revision: %s
277
275
 
278
 
Revision store:
 
276
Repository:
279
277
         1 revision
280
278
         0 KiB
281
279
""" % (tree5.bzrdir.root_transport.base,
292
290
        datestring_last = format_date(rev.timestamp, rev.timezone)
293
291
 
294
292
        # Out of date branched standalone branch will not be detected
295
 
        out, err = self.runbzr('info branch')
 
293
        out, err = self.run_bzr('info -v branch')
296
294
        self.assertEqualDiff(
297
 
"""Location:
 
295
"""Standalone tree (format: weave)
 
296
Location:
298
297
  branch root: %s
299
298
 
300
299
Related branches:
319
318
 
320
319
Branch history:
321
320
         1 revision
 
321
         1 committer
322
322
         0 days old
323
323
   first revision: %s
324
324
  latest revision: %s
325
325
 
326
 
Revision store:
 
326
Repository:
327
327
         1 revision
328
328
         0 KiB
329
329
""" % (branch2.bzrdir.root_transport.base,
334
334
        self.assertEqual('', err)
335
335
 
336
336
        # Out of date bound branch
337
 
        out, err = self.runbzr('info bound')
 
337
        out, err = self.run_bzr('info -v bound')
338
338
        self.assertEqualDiff(
339
 
"""Location:
 
339
"""Checkout (format: knit)
 
340
Location:
340
341
       checkout root: %s
341
342
  checkout of branch: %s
342
343
 
363
364
 
364
365
Branch history:
365
366
         1 revision
 
367
         1 committer
366
368
         0 days old
367
369
   first revision: %s
368
370
  latest revision: %s
369
371
 
370
 
Revision store:
 
372
Repository:
371
373
         1 revision
372
374
         %d KiB
373
375
""" % (branch3.bzrdir.root_transport.base,
383
385
        self.assertEqual('', err)
384
386
 
385
387
        # Out of date checkout
386
 
        out, err = self.runbzr('info checkout')
 
388
        out, err = self.run_bzr('info -v checkout')
387
389
        self.assertEqualDiff(
388
 
"""Location:
 
390
"""Checkout (format: knit)
 
391
Location:
389
392
       checkout root: %s
390
393
  checkout of branch: %s
391
394
 
409
412
 
410
413
Branch history:
411
414
         1 revision
 
415
         1 committer
412
416
         0 days old
413
417
   first revision: %s
414
418
  latest revision: %s
415
419
 
416
 
Revision store:
 
420
Repository:
417
421
         1 revision
418
422
         %d KiB
419
423
""" % (branch4.bzrdir.root_transport.base,
428
432
        self.assertEqual('', err)
429
433
 
430
434
        # Out of date lightweight checkout
431
 
        out, err = self.runbzr('info lightcheckout --verbose')
 
435
        out, err = self.run_bzr('info lightcheckout --verbose')
432
436
        self.assertEqualDiff(
433
 
"""Location:
434
 
 light checkout root: %s
435
 
  checkout of branch: %s
 
437
"""Lightweight checkout (format: dirstate or dirstate-tags)
 
438
Location:
 
439
  light checkout root: %s
 
440
   checkout of branch: %s
436
441
 
437
442
Format:
438
443
       control: Meta directory format 1
439
 
  working tree: Working tree format 3
 
444
  working tree: Working tree format 4
440
445
        branch: Branch format 4
441
446
    repository: Weave repository format 6
442
447
 
459
464
   first revision: %s
460
465
  latest revision: %s
461
466
 
462
 
Revision store:
 
467
Repository:
463
468
         2 revisions
464
469
         0 KiB
465
470
""" % (tree5.bzrdir.root_transport.base,
470
475
 
471
476
    def test_info_standalone_no_tree(self):
472
477
        # create standalone branch without a working tree
 
478
        format = bzrdir.format_registry.make_bzrdir('default')
473
479
        branch = self.make_branch('branch')
474
480
        repo = branch.repository
475
 
        out, err = self.runbzr('info branch')
 
481
        out, err = self.run_bzr('info branch -v')
476
482
        self.assertEqualDiff(
477
 
"""Location:
 
483
"""Standalone branch (format: dirstate or knit)
 
484
Location:
478
485
  branch root: %s
479
486
 
480
487
Format:
481
488
       control: Meta directory format 1
482
 
        branch: Branch format 5
 
489
        branch: %s
483
490
    repository: %s
484
491
 
485
492
Branch history:
486
493
         0 revisions
 
494
         0 committers
487
495
 
488
 
Revision store:
 
496
Repository:
489
497
         0 revisions
490
498
         0 KiB
491
499
""" % (branch.bzrdir.root_transport.base,
492
 
       repo._format.get_format_description(),
 
500
       format.get_branch_format().get_format_description(),
 
501
       format.repository_format.get_format_description(),
493
502
       ), out)
494
503
        self.assertEqual('', err)
495
504
 
496
505
    def test_info_shared_repository(self):
497
 
        old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
498
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(bzrlib.bzrdir.BzrDirMetaFormat1())
 
506
        format = bzrdir.format_registry.make_bzrdir('knit')
499
507
        transport = self.get_transport()
500
508
 
501
509
        # Create shared repository
502
 
        repo = self.make_repository('repo', shared=True)
 
510
        repo = self.make_repository('repo', shared=True, format=format)
503
511
        repo.set_make_working_trees(False)
504
 
        out, err = self.runbzr('info repo')
 
512
        out, err = self.run_bzr('info -v repo')
505
513
        self.assertEqualDiff(
506
 
"""Location:
 
514
"""Shared repository (format: dirstate or dirstate-tags or knit)
 
515
Location:
507
516
  shared repository: %s
508
517
 
509
518
Format:
510
519
       control: Meta directory format 1
511
520
    repository: %s
512
521
 
513
 
Revision store:
 
522
Repository:
514
523
         0 revisions
515
524
         0 KiB
516
525
""" % (repo.bzrdir.root_transport.base,
517
 
       repo._format.get_format_description(),
 
526
       format.repository_format.get_format_description(),
518
527
       ), out)
519
528
        self.assertEqual('', err)
520
529
 
521
530
        # Create branch inside shared repository
522
531
        repo.bzrdir.root_transport.mkdir('branch')
523
 
        branch1 = repo.bzrdir.create_branch_convenience('repo/branch')
524
 
        out, err = self.runbzr('info repo/branch')
 
532
        branch1 = repo.bzrdir.create_branch_convenience('repo/branch',
 
533
            format=format)
 
534
        out, err = self.run_bzr('info -v repo/branch')
525
535
        self.assertEqualDiff(
526
 
"""Location:
 
536
"""Repository branch (format: dirstate or knit)
 
537
Location:
527
538
  shared repository: %s
528
539
  repository branch: branch
529
540
 
530
541
Format:
531
542
       control: Meta directory format 1
532
 
        branch: Branch format 5
 
543
        branch: %s
533
544
    repository: %s
534
545
 
535
546
Branch history:
536
547
         0 revisions
 
548
         0 committers
537
549
 
538
 
Revision store:
 
550
Repository:
539
551
         0 revisions
540
552
         0 KiB
541
553
""" % (repo.bzrdir.root_transport.base,
542
 
       repo._format.get_format_description(),
 
554
       format.get_branch_format().get_format_description(),
 
555
       format.repository_format.get_format_description(),
543
556
       ), out)
544
557
        self.assertEqual('', err)
545
558
 
546
559
        # Create lightweight checkout
547
560
        transport.mkdir('tree')
548
561
        transport.mkdir('tree/lightcheckout')
549
 
        dir2 = bzrlib.bzrdir.BzrDirMetaFormat1().initialize('tree/lightcheckout')
550
 
        bzrlib.branch.BranchReferenceFormat().initialize(dir2, branch1)
551
 
        dir2.create_workingtree()
552
 
        tree2 = dir2.open_workingtree()
 
562
        tree2 = branch1.create_checkout('tree/lightcheckout', 
 
563
            lightweight=True)
553
564
        branch2 = tree2.branch
554
 
        self.assertCheckoutStatusOutput('tree/lightcheckout', tree2, shared_repo=repo)
 
565
        self.assertCheckoutStatusOutput('-v tree/lightcheckout', tree2,
 
566
                   shared_repo=repo, repo_branch=branch1, verbose=True)
555
567
 
556
568
        # Create normal checkout
557
569
        tree3 = branch1.create_checkout('tree/checkout')
564
576
        tree2.commit('commit one')
565
577
        rev = repo.get_revision(branch2.revision_history()[0])
566
578
        datestring_first = format_date(rev.timestamp, rev.timezone)
567
 
        out, err = self.runbzr('info tree/lightcheckout --verbose')
 
579
        out, err = self.run_bzr('info tree/lightcheckout --verbose')
568
580
        self.assertEqualDiff(
569
 
"""Location:
570
 
 light checkout root: %s
571
 
   shared repository: %s
572
 
   repository branch: branch
 
581
"""Lightweight checkout (format: dirstate or dirstate-tags)
 
582
Location:
 
583
  light checkout root: %s
 
584
   checkout of branch: %s
 
585
    shared repository: %s
573
586
 
574
587
Format:
575
588
       control: Meta directory format 1
576
 
  working tree: Working tree format 3
577
 
        branch: Branch format 5
 
589
  working tree: Working tree format 4
 
590
        branch: %s
578
591
    repository: %s
579
592
 
580
593
In the working tree:
594
607
   first revision: %s
595
608
  latest revision: %s
596
609
 
597
 
Revision store:
 
610
Repository:
598
611
         1 revision
599
612
         %d KiB
600
613
""" % (tree2.bzrdir.root_transport.base,
 
614
       tree2.branch.bzrdir.root_transport.base,
601
615
       repo.bzrdir.root_transport.base,
602
 
       repo._format.get_format_description(),
 
616
       format.get_branch_format().get_format_description(),
 
617
       format.repository_format.get_format_description(),
603
618
       datestring_first, datestring_first,
604
619
       # poking at _revision_store isn't all that clean, but neither is
605
620
       # having the ui test dependent on the exact overhead of a given store.
608
623
        self.assertEqual('', err)
609
624
 
610
625
        # Out of date checkout
611
 
        out, err = self.runbzr('info tree/checkout')
 
626
        out, err = self.run_bzr('info -v tree/checkout')
612
627
        self.assertEqualDiff(
613
 
"""Location:
 
628
"""Checkout (format: dirstate)
 
629
Location:
614
630
       checkout root: %s
615
631
  checkout of branch: %s
616
632
 
617
633
Format:
618
634
       control: Meta directory format 1
619
 
  working tree: Working tree format 3
620
 
        branch: Branch format 5
 
635
  working tree: Working tree format 4
 
636
        branch: %s
621
637
    repository: %s
622
638
 
623
639
Branch is out of date: missing 1 revision.
634
650
 
635
651
Branch history:
636
652
         0 revisions
 
653
         0 committers
637
654
 
638
 
Revision store:
 
655
Repository:
639
656
         0 revisions
640
657
         0 KiB
641
658
""" % (tree3.bzrdir.root_transport.base,
642
659
       branch1.bzrdir.root_transport.base,
643
 
       repo._format.get_format_description(),
 
660
       format.get_branch_format().get_format_description(),
 
661
       format.repository_format.get_format_description(),
644
662
       ), out)
645
663
        self.assertEqual('', err)
646
664
 
648
666
        tree3.update()
649
667
        self.build_tree(['tree/checkout/b'])
650
668
        tree3.add('b')
651
 
        out, err = self.runbzr('info tree/checkout --verbose')
 
669
        out, err = self.run_bzr('info tree/checkout --verbose')
652
670
        self.assertEqualDiff(
653
 
"""Location:
 
671
"""Checkout (format: dirstate)
 
672
Location:
654
673
       checkout root: %s
655
674
  checkout of branch: %s
656
675
 
657
676
Format:
658
677
       control: Meta directory format 1
659
 
  working tree: Working tree format 3
660
 
        branch: Branch format 5
 
678
  working tree: Working tree format 4
 
679
        branch: %s
661
680
    repository: %s
662
681
 
663
682
In the working tree:
677
696
   first revision: %s
678
697
  latest revision: %s
679
698
 
680
 
Revision store:
 
699
Repository:
681
700
         1 revision
682
701
         %d KiB
683
702
""" % (tree3.bzrdir.root_transport.base, branch1.bzrdir.root_transport.base,
684
 
       repo._format.get_format_description(),
 
703
       format.get_branch_format().get_format_description(),
 
704
       format.repository_format.get_format_description(),
685
705
       datestring_first, datestring_first,
686
706
       # poking at _revision_store isn't all that clean, but neither is
687
707
       # having the ui test dependent on the exact overhead of a given store.
693
713
        # Out of date lightweight checkout
694
714
        rev = repo.get_revision(branch1.revision_history()[-1])
695
715
        datestring_last = format_date(rev.timestamp, rev.timezone)
696
 
        out, err = self.runbzr('info tree/lightcheckout --verbose')
 
716
        out, err = self.run_bzr('info tree/lightcheckout --verbose')
697
717
        self.assertEqualDiff(
698
 
"""Location:
699
 
 light checkout root: %s
700
 
   shared repository: %s
701
 
   repository branch: branch
 
718
"""Lightweight checkout (format: dirstate or dirstate-tags)
 
719
Location:
 
720
  light checkout root: %s
 
721
   checkout of branch: %s
 
722
    shared repository: %s
702
723
 
703
724
Format:
704
725
       control: Meta directory format 1
705
 
  working tree: Working tree format 3
706
 
        branch: Branch format 5
 
726
  working tree: Working tree format 4
 
727
        branch: %s
707
728
    repository: %s
708
729
 
709
730
Working tree is out of date: missing 1 revision.
725
746
   first revision: %s
726
747
  latest revision: %s
727
748
 
728
 
Revision store:
 
749
Repository:
729
750
         2 revisions
730
751
         %d KiB
731
752
""" % (tree2.bzrdir.root_transport.base,
 
753
       tree2.branch.bzrdir.root_transport.base,
732
754
       repo.bzrdir.root_transport.base,
733
 
       repo._format.get_format_description(),
 
755
       format.get_branch_format().get_format_description(),
 
756
       format.repository_format.get_format_description(),
734
757
       datestring_first, datestring_last,
735
758
       # poking at _revision_store isn't all that clean, but neither is
736
759
       # having the ui test dependent on the exact overhead of a given store.
739
762
        self.assertEqual('', err)
740
763
 
741
764
        # Show info about shared branch
742
 
        out, err = self.runbzr('info repo/branch --verbose')
 
765
        out, err = self.run_bzr('info repo/branch --verbose')
743
766
        self.assertEqualDiff(
744
 
"""Location:
 
767
"""Repository branch (format: dirstate or knit)
 
768
Location:
745
769
  shared repository: %s
746
770
  repository branch: branch
747
771
 
748
772
Format:
749
773
       control: Meta directory format 1
750
 
        branch: Branch format 5
 
774
        branch: %s
751
775
    repository: %s
752
776
 
753
777
Branch history:
757
781
   first revision: %s
758
782
  latest revision: %s
759
783
 
760
 
Revision store:
 
784
Repository:
761
785
         2 revisions
762
786
         %d KiB
763
787
""" % (repo.bzrdir.root_transport.base,
764
 
       repo._format.get_format_description(),
 
788
       format.get_branch_format().get_format_description(),
 
789
       format.repository_format.get_format_description(),
765
790
       datestring_first, datestring_last,
766
791
       # poking at _revision_store isn't all that clean, but neither is
767
792
       # having the ui test dependent on the exact overhead of a given store.
770
795
        self.assertEqual('', err)
771
796
 
772
797
        # Show info about repository with revisions
773
 
        out, err = self.runbzr('info repo')
 
798
        out, err = self.run_bzr('info -v repo')
774
799
        self.assertEqualDiff(
775
 
"""Location:
 
800
"""Shared repository (format: dirstate or dirstate-tags or knit)
 
801
Location:
776
802
  shared repository: %s
777
803
 
778
804
Format:
779
805
       control: Meta directory format 1
780
806
    repository: %s
781
807
 
782
 
Revision store:
 
808
Repository:
783
809
         2 revisions
784
810
         %d KiB
785
811
""" % (repo.bzrdir.root_transport.base,
786
 
       repo._format.get_format_description(),
 
812
       format.repository_format.get_format_description(),
787
813
       # poking at _revision_store isn't all that clean, but neither is
788
814
       # having the ui test dependent on the exact overhead of a given store.
789
815
       repo._revision_store.total_size(repo.get_transaction())[1] / 1024,
790
816
       ), out)
791
817
        self.assertEqual('', err)
792
818
 
793
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
794
 
 
795
819
    def test_info_shared_repository_with_trees(self):
796
 
        old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
797
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(bzrlib.bzrdir.BzrDirMetaFormat1())
 
820
        format = bzrdir.format_registry.make_bzrdir('knit')
798
821
        transport = self.get_transport()
799
822
 
800
823
        # Create shared repository with working trees
801
 
        repo = self.make_repository('repo', shared=True)
 
824
        repo = self.make_repository('repo', shared=True, format=format)
802
825
        repo.set_make_working_trees(True)
803
 
        out, err = self.runbzr('info repo')
 
826
        out, err = self.run_bzr('info -v repo')
804
827
        self.assertEqualDiff(
805
 
"""Location:
 
828
"""Shared repository with trees (format: dirstate or dirstate-tags or knit)
 
829
Location:
806
830
  shared repository: %s
807
831
 
808
832
Format:
811
835
 
812
836
Create working tree for new branches inside the repository.
813
837
 
814
 
Revision store:
 
838
Repository:
815
839
         0 revisions
816
840
         0 KiB
817
841
""" % (repo.bzrdir.root_transport.base,
818
 
       repo._format.get_format_description(),
 
842
       format.repository_format.get_format_description(),
819
843
       ), out)
820
844
        self.assertEqual('', err)
821
845
 
822
846
        # Create two branches
823
847
        repo.bzrdir.root_transport.mkdir('branch1')
824
 
        branch1 = repo.bzrdir.create_branch_convenience('repo/branch1')
 
848
        branch1 = repo.bzrdir.create_branch_convenience('repo/branch1',
 
849
            format=format)
825
850
        branch2 = branch1.bzrdir.sprout('repo/branch2').open_branch()
826
851
 
827
852
        # Empty first branch
828
 
        out, err = self.runbzr('info repo/branch1 --verbose')
 
853
        out, err = self.run_bzr('info repo/branch1 --verbose')
829
854
        self.assertEqualDiff(
830
 
"""Location:
831
 
    shared repository: %s
832
 
  repository checkout: branch1
 
855
"""Repository tree (format: knit)
 
856
Location:
 
857
  shared repository: %s
 
858
  repository branch: branch1
833
859
 
834
860
Format:
835
861
       control: Meta directory format 1
836
862
  working tree: Working tree format 3
837
 
        branch: Branch format 5
 
863
        branch: %s
838
864
    repository: %s
839
865
 
840
866
In the working tree:
851
877
         0 revisions
852
878
         0 committers
853
879
 
854
 
Revision store:
 
880
Repository:
855
881
         0 revisions
856
882
         0 KiB
857
883
""" % (repo.bzrdir.root_transport.base,
858
 
       repo._format.get_format_description(),
 
884
       format.get_branch_format().get_format_description(),
 
885
       format.repository_format.get_format_description(),
859
886
       ), out)
860
887
        self.assertEqual('', err)
861
888
 
866
893
        tree1.commit('commit one')
867
894
        rev = repo.get_revision(branch1.revision_history()[0])
868
895
        datestring_first = format_date(rev.timestamp, rev.timezone)
869
 
        out, err = self.runbzr('info repo/branch1')
 
896
        out, err = self.run_bzr('info -v repo/branch1')
870
897
        self.assertEqualDiff(
871
 
"""Location:
872
 
    shared repository: %s
873
 
  repository checkout: branch1
 
898
"""Repository tree (format: knit)
 
899
Location:
 
900
  shared repository: %s
 
901
  repository branch: branch1
874
902
 
875
903
Format:
876
904
       control: Meta directory format 1
877
905
  working tree: Working tree format 3
878
 
        branch: Branch format 5
 
906
        branch: %s
879
907
    repository: %s
880
908
 
881
909
In the working tree:
890
918
 
891
919
Branch history:
892
920
         1 revision
 
921
         1 committer
893
922
         0 days old
894
923
   first revision: %s
895
924
  latest revision: %s
896
925
 
897
 
Revision store:
 
926
Repository:
898
927
         1 revision
899
928
         %d KiB
900
929
""" % (repo.bzrdir.root_transport.base,
901
 
       repo._format.get_format_description(),
 
930
       format.get_branch_format().get_format_description(),
 
931
       format.repository_format.get_format_description(),
902
932
       datestring_first, datestring_first,
903
933
       # poking at _revision_store isn't all that clean, but neither is
904
934
       # having the ui test dependent on the exact overhead of a given store.
907
937
        self.assertEqual('', err)
908
938
 
909
939
        # Out of date second branch
910
 
        out, err = self.runbzr('info repo/branch2 --verbose')
 
940
        out, err = self.run_bzr('info repo/branch2 --verbose')
911
941
        self.assertEqualDiff(
912
 
"""Location:
913
 
    shared repository: %s
914
 
  repository checkout: branch2
 
942
"""Repository tree (format: knit)
 
943
Location:
 
944
  shared repository: %s
 
945
  repository branch: branch2
915
946
 
916
947
Related branches:
917
948
  parent branch: %s
919
950
Format:
920
951
       control: Meta directory format 1
921
952
  working tree: Working tree format 3
922
 
        branch: Branch format 5
 
953
        branch: %s
923
954
    repository: %s
924
955
 
925
956
In the working tree:
936
967
         0 revisions
937
968
         0 committers
938
969
 
939
 
Revision store:
 
970
Repository:
940
971
         1 revision
941
972
         %d KiB
942
973
""" % (repo.bzrdir.root_transport.base,
943
974
       branch1.bzrdir.root_transport.base,
944
 
       repo._format.get_format_description(),
 
975
       format.get_branch_format().get_format_description(),
 
976
       format.repository_format.get_format_description(),
945
977
       # poking at _revision_store isn't all that clean, but neither is
946
978
       # having the ui test dependent on the exact overhead of a given store.
947
979
       repo._revision_store.total_size(repo.get_transaction())[1] / 1024,
951
983
        # Update second branch
952
984
        tree2 = branch2.bzrdir.open_workingtree()
953
985
        tree2.pull(branch1)
954
 
        out, err = self.runbzr('info repo/branch2')
 
986
        out, err = self.run_bzr('info -v repo/branch2')
955
987
        self.assertEqualDiff(
956
 
"""Location:
957
 
    shared repository: %s
958
 
  repository checkout: branch2
 
988
"""Repository tree (format: knit)
 
989
Location:
 
990
  shared repository: %s
 
991
  repository branch: branch2
959
992
 
960
993
Related branches:
961
994
  parent branch: %s
963
996
Format:
964
997
       control: Meta directory format 1
965
998
  working tree: Working tree format 3
966
 
        branch: Branch format 5
 
999
        branch: %s
967
1000
    repository: %s
968
1001
 
969
1002
In the working tree:
978
1011
 
979
1012
Branch history:
980
1013
         1 revision
 
1014
         1 committer
981
1015
         0 days old
982
1016
   first revision: %s
983
1017
  latest revision: %s
984
1018
 
985
 
Revision store:
 
1019
Repository:
986
1020
         1 revision
987
1021
         %d KiB
988
1022
""" % (repo.bzrdir.root_transport.base,
989
1023
       branch1.bzrdir.root_transport.base,
990
 
       repo._format.get_format_description(),
 
1024
       format.get_branch_format().get_format_description(),
 
1025
       format.repository_format.get_format_description(),
991
1026
       datestring_first, datestring_first,
992
1027
       # poking at _revision_store isn't all that clean, but neither is
993
1028
       # having the ui test dependent on the exact overhead of a given store.
996
1031
        self.assertEqual('', err)
997
1032
 
998
1033
        # Show info about repository with revisions
999
 
        out, err = self.runbzr('info repo')
 
1034
        out, err = self.run_bzr('info -v repo')
1000
1035
        self.assertEqualDiff(
1001
 
"""Location:
 
1036
"""Shared repository with trees (format: dirstate or dirstate-tags or knit)
 
1037
Location:
1002
1038
  shared repository: %s
1003
1039
 
1004
1040
Format:
1007
1043
 
1008
1044
Create working tree for new branches inside the repository.
1009
1045
 
1010
 
Revision store:
 
1046
Repository:
1011
1047
         1 revision
1012
1048
         %d KiB
1013
1049
""" % (repo.bzrdir.root_transport.base,
1014
 
       repo._format.get_format_description(),
 
1050
       format.repository_format.get_format_description(),
1015
1051
       # poking at _revision_store isn't all that clean, but neither is
1016
1052
       # having the ui test dependent on the exact overhead of a given store.
1017
1053
       repo._revision_store.total_size(repo.get_transaction())[1] / 1024,
1018
1054
       ),
1019
1055
       out)
1020
1056
        self.assertEqual('', err)
1021
 
 
1022
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
1023
1057
    
1024
1058
    def test_info_shared_repository_with_tree_in_root(self):
1025
 
        old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
1026
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(bzrlib.bzrdir.BzrDirMetaFormat1())
 
1059
        format = bzrdir.format_registry.make_bzrdir('knit')
1027
1060
        transport = self.get_transport()
1028
1061
 
1029
1062
        # Create shared repository with working trees
1030
 
        repo = self.make_repository('repo', shared=True)
 
1063
        repo = self.make_repository('repo', shared=True, format=format)
1031
1064
        repo.set_make_working_trees(True)
1032
 
        out, err = self.runbzr('info repo')
 
1065
        out, err = self.run_bzr('info -v repo')
1033
1066
        self.assertEqualDiff(
1034
 
"""Location:
 
1067
"""Shared repository with trees (format: dirstate or dirstate-tags or knit)
 
1068
Location:
1035
1069
  shared repository: %s
1036
1070
 
1037
1071
Format:
1040
1074
 
1041
1075
Create working tree for new branches inside the repository.
1042
1076
 
1043
 
Revision store:
 
1077
Repository:
1044
1078
         0 revisions
1045
1079
         0 KiB
1046
1080
""" % (repo.bzrdir.root_transport.base,
1047
 
       repo._format.get_format_description(),
 
1081
       format.repository_format.get_format_description(),
1048
1082
       ), out)
1049
1083
        self.assertEqual('', err)
1050
1084
 
1052
1086
        control = repo.bzrdir
1053
1087
        branch = control.create_branch()
1054
1088
        control.create_workingtree()
1055
 
        out, err = self.runbzr('info repo')
 
1089
        out, err = self.run_bzr('info -v repo')
1056
1090
        self.assertEqualDiff(
1057
 
"""Location:
1058
 
    shared repository: %s
1059
 
  repository checkout: .
 
1091
"""Repository tree (format: knit)
 
1092
Location:
 
1093
  shared repository: %s
 
1094
  repository branch: .
1060
1095
 
1061
1096
Format:
1062
1097
       control: Meta directory format 1
1063
1098
  working tree: Working tree format 3
1064
 
        branch: Branch format 5
 
1099
        branch: %s
1065
1100
    repository: %s
1066
1101
 
1067
1102
In the working tree:
1076
1111
 
1077
1112
Branch history:
1078
1113
         0 revisions
 
1114
         0 committers
1079
1115
 
1080
 
Revision store:
 
1116
Repository:
1081
1117
         0 revisions
1082
1118
         0 KiB
1083
1119
""" % (repo.bzrdir.root_transport.base,
1084
 
       repo._format.get_format_description(),
 
1120
       format.get_branch_format().get_format_description(),
 
1121
       format.repository_format.get_format_description(),
1085
1122
       ), out)
1086
1123
        self.assertEqual('', err)
1087
1124
 
1088
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
1089
 
 
1090
1125
    def assertCheckoutStatusOutput(self, 
1091
1126
        command_string, lco_tree, shared_repo=None,
1092
1127
        repo_branch=None,
1093
1128
        tree_locked=False,
1094
1129
        branch_locked=False, repo_locked=False,
1095
1130
        verbose=False,
1096
 
        light_checkout=True):
1097
 
        """Check the output of info in a light checkout tree.
 
1131
        light_checkout=True,
 
1132
        checkout_root=None):
 
1133
        """Check the output of info in a checkout.
1098
1134
 
1099
1135
        This is not quite a mirror of the info code: rather than using the
1100
1136
        tree being examined to predict output, it uses a bunch of flags which
1113
1149
        :param repo_locked: If true, expect the repository to be locked.
1114
1150
        :param verbose: If true, expect verbose output
1115
1151
        """
1116
 
        out, err = self.runbzr('info %s' % command_string)
 
1152
        if tree_locked and sys.platform == 'win32':
 
1153
            # We expect this to fail because of locking errors. (A write-locked
 
1154
            # file cannot be read-locked in the same process).
 
1155
            # This should be removed when the locking errors are fixed.
 
1156
            args = command_string.split(' ')
 
1157
            self.run_bzr_error([], 'info', *args)
 
1158
            return
 
1159
        out, err = self.run_bzr('info %s' % command_string)
 
1160
        description = {
 
1161
            (True, True): 'Lightweight checkout',
 
1162
            (True, False): 'Repository checkout',
 
1163
            (False, True): 'Lightweight checkout',
 
1164
            (False, False): 'Checkout',
 
1165
            }[(shared_repo is not None, light_checkout)]
 
1166
        format = {True: 'dirstate or dirstate-tags',
 
1167
                  False: 'dirstate'}[light_checkout]
1117
1168
        if repo_locked or branch_locked or tree_locked:
1118
1169
            def locked_message(a_bool):
1119
1170
                if a_bool:
1131
1182
                    locked_message(repo_locked)))
1132
1183
        else:
1133
1184
            expected_lock_output = ''
 
1185
        tree_data = ''
 
1186
        extra_space = ''
1134
1187
        if light_checkout:
1135
 
            tree_data = (" light checkout root: %s" %
1136
 
                lco_tree.bzrdir.root_transport.base)
1137
 
        else:
1138
 
            tree_data = ("       checkout root: %s" %
1139
 
                lco_tree.bzrdir.root_transport.base)
 
1188
            tree_data = ("  light checkout root: %s\n" %
 
1189
                lco_tree.bzrdir.root_transport.base)
 
1190
            extra_space = ' '
 
1191
        if lco_tree.branch.get_bound_location() is not None:
 
1192
            tree_data += ("%s       checkout root: %s\n" % (extra_space,
 
1193
                lco_tree.branch.bzrdir.root_transport.base))
1140
1194
        if shared_repo is not None:
1141
1195
            branch_data = (
1142
 
                "   shared repository: %s\n"
1143
 
                "   repository branch: branch\n" %
1144
 
                shared_repo.bzrdir.root_transport.base)
 
1196
                "   checkout of branch: %s\n"
 
1197
                "    shared repository: %s\n" %
 
1198
                (repo_branch.bzrdir.root_transport.base,
 
1199
                 shared_repo.bzrdir.root_transport.base))
1145
1200
        elif repo_branch is not None:
1146
1201
            branch_data = (
1147
 
                "  checkout of branch: %s\n" % 
1148
 
                repo_branch.bzrdir.root_transport.base)
 
1202
                "%s  checkout of branch: %s\n" %
 
1203
                (extra_space,
 
1204
                 repo_branch.bzrdir.root_transport.base))
1149
1205
        else:
1150
 
            branch_data = ("  checkout of branch: %s\n" % 
 
1206
            branch_data = ("   checkout of branch: %s\n" %
1151
1207
                lco_tree.branch.bzrdir.root_transport.base)
1152
1208
        
1153
1209
        if verbose:
1156
1212
            verbose_info = ''
1157
1213
            
1158
1214
        self.assertEqualDiff(
1159
 
"""Location:
1160
 
%s
1161
 
%s
 
1215
"""%s (format: %s)
 
1216
Location:
 
1217
%s%s
1162
1218
Format:
1163
1219
       control: Meta directory format 1
1164
1220
  working tree: %s
1165
 
        branch: Branch format 5
 
1221
        branch: %s
1166
1222
    repository: %s
1167
1223
%s
1168
1224
In the working tree:
1178
1234
Branch history:
1179
1235
         0 revisions
1180
1236
%s
1181
 
Revision store:
 
1237
Repository:
1182
1238
         0 revisions
1183
1239
         0 KiB
1184
 
""" %  (tree_data,
 
1240
""" %  (description,
 
1241
        format,
 
1242
        tree_data,
1185
1243
        branch_data,
1186
1244
        lco_tree._format.get_format_description(),
 
1245
        lco_tree.branch._format.get_format_description(),
1187
1246
        lco_tree.branch.repository._format.get_format_description(),
1188
1247
        expected_lock_output,
1189
1248
        verbose_info,
1216
1275
        # W B R
1217
1276
 
1218
1277
        # U U U
1219
 
        self.assertCheckoutStatusOutput('tree/lightcheckout', lco_tree)
 
1278
        self.assertCheckoutStatusOutput('-v tree/lightcheckout', lco_tree,
 
1279
                                        repo_branch=repo_branch,
 
1280
                                        verbose=True, light_checkout=True)
1220
1281
        # U U L
1221
1282
        lco_tree.branch.repository.lock_write()
1222
1283
        try:
1223
 
            self.assertCheckoutStatusOutput('tree/lightcheckout',
1224
 
            lco_tree,
1225
 
            repo_locked=True)
 
1284
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
 
1285
            lco_tree, repo_branch=repo_branch,
 
1286
            repo_locked=True, verbose=True, light_checkout=True)
1226
1287
        finally:
1227
1288
            lco_tree.branch.repository.unlock()
1228
1289
        # U L L
1229
1290
        lco_tree.branch.lock_write()
1230
1291
        try:
1231
 
            self.assertCheckoutStatusOutput('tree/lightcheckout',
 
1292
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
1232
1293
            lco_tree,
1233
1294
            branch_locked=True,
1234
 
            repo_locked=True)
 
1295
            repo_locked=True,
 
1296
            repo_branch=repo_branch,
 
1297
            verbose=True)
1235
1298
        finally:
1236
1299
            lco_tree.branch.unlock()
1237
1300
        # L L L
1238
1301
        lco_tree.lock_write()
1239
1302
        try:
1240
 
            self.assertCheckoutStatusOutput('tree/lightcheckout',
1241
 
            lco_tree,
 
1303
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
 
1304
            lco_tree, repo_branch=repo_branch,
1242
1305
            tree_locked=True,
1243
1306
            branch_locked=True,
1244
 
            repo_locked=True)
 
1307
            repo_locked=True,
 
1308
            verbose=True)
1245
1309
        finally:
1246
1310
            lco_tree.unlock()
1247
1311
        # L L U
1248
1312
        lco_tree.lock_write()
1249
1313
        lco_tree.branch.repository.unlock()
1250
1314
        try:
1251
 
            self.assertCheckoutStatusOutput('tree/lightcheckout',
1252
 
            lco_tree,
 
1315
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
 
1316
            lco_tree, repo_branch=repo_branch,
1253
1317
            tree_locked=True,
1254
 
            branch_locked=True)
 
1318
            branch_locked=True,
 
1319
            verbose=True)
1255
1320
        finally:
1256
1321
            lco_tree.branch.repository.lock_write()
1257
1322
            lco_tree.unlock()
1259
1324
        lco_tree.lock_write()
1260
1325
        lco_tree.branch.unlock()
1261
1326
        try:
1262
 
            self.assertCheckoutStatusOutput('tree/lightcheckout',
1263
 
            lco_tree,
1264
 
            tree_locked=True)
 
1327
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
 
1328
            lco_tree, repo_branch=repo_branch,
 
1329
            tree_locked=True,
 
1330
            verbose=True)
1265
1331
        finally:
1266
1332
            lco_tree.branch.lock_write()
1267
1333
            lco_tree.unlock()
1270
1336
        lco_tree.branch.unlock()
1271
1337
        lco_tree.branch.repository.lock_write()
1272
1338
        try:
1273
 
            self.assertCheckoutStatusOutput('tree/lightcheckout',
1274
 
            lco_tree,
 
1339
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
 
1340
            lco_tree, repo_branch=repo_branch,
1275
1341
            tree_locked=True,
1276
 
            repo_locked=True)
 
1342
            repo_locked=True,
 
1343
            verbose=True)
1277
1344
        finally:
1278
1345
            lco_tree.branch.repository.unlock()
1279
1346
            lco_tree.branch.lock_write()
1282
1349
        lco_tree.branch.lock_write()
1283
1350
        lco_tree.branch.repository.unlock()
1284
1351
        try:
1285
 
            self.assertCheckoutStatusOutput('tree/lightcheckout',
1286
 
            lco_tree,
1287
 
            branch_locked=True)
 
1352
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
 
1353
            lco_tree, repo_branch=repo_branch,
 
1354
            branch_locked=True,
 
1355
            verbose=True)
1288
1356
        finally:
1289
1357
            lco_tree.branch.repository.lock_write()
1290
1358
            lco_tree.branch.unlock()
1291
1359
 
 
1360
        if sys.platform == 'win32':
 
1361
            self.knownFailure('Win32 cannot run "bzr info"'
 
1362
                              ' when the tree is locked.')
 
1363
 
1292
1364
    def test_info_locking_oslocks(self):
1293
1365
        if sys.platform == "win32":
1294
1366
            raise TestSkipped("don't use oslocks on win32 in unix manner")
1303
1375
        # W B R
1304
1376
 
1305
1377
        # U U U
1306
 
        out, err = self.runbzr('info branch')
 
1378
        out, err = self.run_bzr('info -v branch')
1307
1379
        self.assertEqualDiff(
1308
 
"""Location:
 
1380
"""Standalone tree (format: weave)
 
1381
Location:
1309
1382
  branch root: %s
1310
1383
 
1311
1384
Format:
1326
1399
 
1327
1400
Branch history:
1328
1401
         0 revisions
 
1402
         0 committers
1329
1403
 
1330
 
Revision store:
 
1404
Repository:
1331
1405
         0 revisions
1332
1406
         0 KiB
1333
1407
""" % (tree.bzrdir.root_transport.base,
1336
1410
        self.assertEqual('', err)
1337
1411
        # L L L
1338
1412
        tree.lock_write()
1339
 
        out, err = self.runbzr('info branch')
 
1413
        out, err = self.run_bzr('info -v branch')
1340
1414
        self.assertEqualDiff(
1341
 
"""Location:
 
1415
"""Standalone tree (format: weave)
 
1416
Location:
1342
1417
  branch root: %s
1343
1418
 
1344
1419
Format:
1359
1434
 
1360
1435
Branch history:
1361
1436
         0 revisions
 
1437
         0 committers
1362
1438
 
1363
 
Revision store:
 
1439
Repository:
1364
1440
         0 revisions
1365
1441
         0 KiB
1366
1442
""" % (tree.bzrdir.root_transport.base,