/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 breezy/tests/blackbox/test_info.py

  • Committer: Martin
  • Date: 2018-11-16 16:38:22 UTC
  • mto: This revision was merged to the branch mainline in revision 7172.
  • Revision ID: gzlist@googlemail.com-20181116163822-yg1h1cdng6w7w9kn
Make --profile-imports work on Python 3

Also tweak heading to line up correctly.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/blackbox/test_info.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2012, 2016 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
17
17
 
18
18
"""Tests for the info command of bzr."""
19
19
 
 
20
import shutil
20
21
import sys
21
22
 
22
 
from bzrlib import (
 
23
from breezy import (
23
24
    branch,
24
 
    bzrdir,
 
25
    controldir,
25
26
    errors,
26
27
    info,
27
28
    osutils,
29
30
    upgrade,
30
31
    urlutils,
31
32
    )
32
 
from bzrlib.transport import memory
 
33
from breezy.bzr import (
 
34
    bzrdir,
 
35
    )
 
36
from breezy.tests.matchers import ContainsNoVfsCalls
 
37
from breezy.transport import memory
33
38
 
34
39
 
35
40
class TestInfo(tests.TestCaseWithTransport):
43
48
        location = self.get_url()
44
49
        out, err = self.run_bzr('info '+location, retcode=3)
45
50
        self.assertEqual(out, '')
46
 
        self.assertEqual(err, 'bzr: ERROR: Not a branch: "%s".\n' % location)
 
51
        self.assertEqual(err, 'brz: ERROR: Not a branch: "%s".\n' % location)
 
52
 
 
53
    def test_info_empty_controldir(self):
 
54
        self.make_controldir('ctrl')
 
55
        out, err = self.run_bzr('info ctrl')
 
56
        self.assertEqual(out,
 
57
            'Empty control directory (format: 2a)\n'
 
58
            'Location:\n'
 
59
            '  control directory: ctrl\n')
 
60
        self.assertEqual(err, '')
 
61
 
 
62
    def test_info_empty_controldir_verbose(self):
 
63
        self.make_controldir('ctrl')
 
64
        out, err = self.run_bzr('info -v ctrl')
 
65
        self.assertEqualDiff(out,
 
66
            'Empty control directory (format: 2a)\n'
 
67
            'Location:\n'
 
68
            '  control directory: ctrl\n\n'
 
69
            'Format:\n'
 
70
            '       control: Meta directory format 1\n\n'
 
71
            'Control directory:\n'
 
72
            '         0 branches\n')
 
73
        self.assertEqual(err, '')
 
74
 
 
75
    def test_info_dangling_branch_reference(self):
 
76
        br = self.make_branch('target')
 
77
        br.create_checkout('from', lightweight=True)
 
78
        shutil.rmtree('target')
 
79
        out, err = self.run_bzr('info from')
 
80
        self.assertEqual(out,
 
81
            'Dangling branch reference (format: 2a)\n'
 
82
            'Location:\n'
 
83
            '   control directory: from\n'
 
84
            '  checkout of branch: target\n')
 
85
        self.assertEqual(err, '')
47
86
 
48
87
    def test_info_standalone(self):
49
88
        transport = self.get_transport()
50
89
 
51
90
        # Create initial standalone branch
52
 
        tree1 = self.make_branch_and_tree('standalone', 'weave')
 
91
        tree1 = self.make_branch_and_tree('standalone', 'knit')
53
92
        self.build_tree(['standalone/a'])
54
93
        tree1.add('a')
55
94
        branch1 = tree1.branch
56
95
 
57
96
        out, err = self.run_bzr('info standalone')
58
97
        self.assertEqualDiff(
59
 
"""Standalone tree (format: weave)
 
98
"""Standalone tree (format: knit)
60
99
Location:
61
100
  branch root: standalone
62
101
""", out)
65
104
        # Standalone branch - verbose mode
66
105
        out, err = self.run_bzr('info standalone -v')
67
106
        self.assertEqualDiff(
68
 
"""Standalone tree (format: weave)
 
107
"""Standalone tree (format: knit)
69
108
Location:
70
109
  branch root: standalone
71
110
 
72
111
Format:
73
 
       control: All-in-one format 6
74
 
  working tree: Working tree format 2
75
 
        branch: Branch format 4
76
 
    repository: Weave repository format 6
 
112
       control: Meta directory format 1
 
113
  working tree: Working tree format 3
 
114
        branch: Branch format 5
 
115
    repository: Knit repository format 1
 
116
 
 
117
Control directory:
 
118
         1 branches
77
119
 
78
120
In the working tree:
79
121
         0 unchanged
96
138
        # Standalone branch - really verbose mode
97
139
        out, err = self.run_bzr('info standalone -vv')
98
140
        self.assertEqualDiff(
99
 
"""Standalone tree (format: weave)
 
141
"""Standalone tree (format: knit)
100
142
Location:
101
143
  branch root: standalone
102
144
 
103
145
Format:
104
 
       control: All-in-one format 6
105
 
  working tree: Working tree format 2
106
 
        branch: Branch format 4
107
 
    repository: Weave repository format 6
 
146
       control: Meta directory format 1
 
147
  working tree: Working tree format 3
 
148
        branch: Branch format 5
 
149
    repository: Knit repository format 1
 
150
 
 
151
Control directory:
 
152
         1 branches
108
153
 
109
154
In the working tree:
110
155
         0 unchanged
125
170
""", out)
126
171
        self.assertEqual('', err)
127
172
        tree1.commit('commit one')
128
 
        rev = branch1.repository.get_revision(branch1.revision_history()[0])
 
173
        rev = branch1.repository.get_revision(branch1.last_revision())
129
174
        datestring_first = osutils.format_date(rev.timestamp, rev.timezone)
130
175
 
131
176
        # Branch standalone with push location
132
 
        branch2 = branch1.bzrdir.sprout('branch').open_branch()
133
 
        branch2.set_push_location(branch1.bzrdir.root_transport.base)
 
177
        branch2 = branch1.controldir.sprout('branch').open_branch()
 
178
        branch2.set_push_location(branch1.controldir.root_transport.base)
134
179
 
135
180
        out, err = self.run_bzr('info branch')
136
181
        self.assertEqualDiff(
137
 
"""Standalone tree (format: weave)
 
182
"""Standalone tree (format: knit)
138
183
Location:
139
184
  branch root: branch
140
185
 
146
191
 
147
192
        out, err = self.run_bzr('info branch --verbose')
148
193
        self.assertEqualDiff(
149
 
"""Standalone tree (format: weave)
 
194
"""Standalone tree (format: knit)
150
195
Location:
151
196
  branch root: branch
152
197
 
155
200
  parent branch: standalone
156
201
 
157
202
Format:
158
 
       control: All-in-one format 6
159
 
  working tree: Working tree format 2
160
 
        branch: Branch format 4
161
 
    repository: Weave repository format 6
 
203
       control: Meta directory format 1
 
204
  working tree: Working tree format 3
 
205
        branch: Branch format 5
 
206
    repository: Knit repository format 1
 
207
 
 
208
Control directory:
 
209
         1 branches
162
210
 
163
211
In the working tree:
164
212
         1 unchanged
184
232
 
185
233
        # Branch and bind to standalone, needs upgrade to metadir
186
234
        # (creates backup as unknown)
187
 
        branch1.bzrdir.sprout('bound')
188
 
        knit1_format = bzrdir.format_registry.make_bzrdir('knit')
 
235
        branch1.controldir.sprout('bound')
 
236
        knit1_format = controldir.format_registry.make_controldir('knit')
189
237
        upgrade.upgrade('bound', knit1_format)
190
 
        branch3 = bzrdir.BzrDir.open('bound').open_branch()
 
238
        branch3 = controldir.ControlDir.open('bound').open_branch()
191
239
        branch3.bind(branch1)
192
 
        bound_tree = branch3.bzrdir.open_workingtree()
 
240
        bound_tree = branch3.controldir.open_workingtree()
193
241
        out, err = self.run_bzr('info -v bound')
194
242
        self.assertEqualDiff(
195
243
"""Checkout (format: knit)
206
254
        branch: %s
207
255
    repository: %s
208
256
 
 
257
Control directory:
 
258
         1 branches
 
259
 
209
260
In the working tree:
210
261
         1 unchanged
211
262
         0 modified
213
264
         0 removed
214
265
         0 renamed
215
266
         0 unknown
216
 
         1 ignored
 
267
         0 ignored
217
268
         0 versioned subdirectories
218
269
 
219
270
Branch history:
232
283
        self.assertEqual('', err)
233
284
 
234
285
        # Checkout standalone (same as above, but does not have parent set)
235
 
        branch4 = bzrdir.BzrDir.create_branch_convenience('checkout',
 
286
        branch4 = controldir.ControlDir.create_branch_convenience('checkout',
236
287
            format=knit1_format)
237
288
        branch4.bind(branch1)
238
 
        branch4.bzrdir.open_workingtree().update()
 
289
        branch4.controldir.open_workingtree().update()
239
290
        out, err = self.run_bzr('info checkout --verbose')
240
291
        self.assertEqualDiff(
241
292
"""Checkout (format: knit)
249
300
        branch: Branch format 5
250
301
    repository: %s
251
302
 
 
303
Control directory:
 
304
         1 branches
 
305
 
252
306
In the working tree:
253
307
         1 unchanged
254
308
         0 modified
276
330
        tree5 = branch1.create_checkout('lightcheckout', lightweight=True)
277
331
        branch5 = tree5.branch
278
332
        out, err = self.run_bzr('info -v lightcheckout')
 
333
        if "metaweave" in controldir.format_registry:
 
334
            format_description = "knit or metaweave"
 
335
        else:
 
336
            format_description = "knit"
279
337
        self.assertEqualDiff(
280
338
"""Lightweight checkout (format: %s)
281
339
Location:
284
342
 
285
343
Format:
286
344
       control: Meta directory format 1
287
 
  working tree: Working tree format 6
288
 
        branch: Branch format 4
289
 
    repository: Weave repository format 6
 
345
  working tree: Working tree format 3
 
346
        branch: Branch format 5
 
347
    repository: Knit repository format 1
 
348
 
 
349
Control directory:
 
350
         1 branches
290
351
 
291
352
In the working tree:
292
353
         1 unchanged
306
367
 
307
368
Repository:
308
369
         1 revision
309
 
""" % (self._repo_strings, datestring_first, datestring_first,), out)
 
370
""" % (format_description, datestring_first, datestring_first,), out)
310
371
        self.assertEqual('', err)
311
372
 
312
373
        # Update initial standalone branch
313
374
        self.build_tree(['standalone/b'])
314
375
        tree1.add('b')
315
376
        tree1.commit('commit two')
316
 
        rev = branch1.repository.get_revision(branch1.revision_history()[-1])
 
377
        rev = branch1.repository.get_revision(branch1.last_revision())
317
378
        datestring_last = osutils.format_date(rev.timestamp, rev.timezone)
318
379
 
319
380
        # Out of date branched standalone branch will not be detected
320
381
        out, err = self.run_bzr('info -v branch')
321
382
        self.assertEqualDiff(
322
 
"""Standalone tree (format: weave)
 
383
"""Standalone tree (format: knit)
323
384
Location:
324
385
  branch root: branch
325
386
 
328
389
  parent branch: standalone
329
390
 
330
391
Format:
331
 
       control: All-in-one format 6
332
 
  working tree: Working tree format 2
333
 
        branch: Branch format 4
334
 
    repository: Weave repository format 6
 
392
       control: Meta directory format 1
 
393
  working tree: Working tree format 3
 
394
        branch: Branch format 5
 
395
    repository: Knit repository format 1
 
396
 
 
397
Control directory:
 
398
         1 branches
335
399
 
336
400
In the working tree:
337
401
         1 unchanged
372
436
        branch: Branch format 5
373
437
    repository: %s
374
438
 
 
439
Control directory:
 
440
         1 branches
 
441
 
375
442
Branch is out of date: missing 1 revision.
376
443
 
377
444
In the working tree:
381
448
         0 removed
382
449
         0 renamed
383
450
         0 unknown
384
 
         1 ignored
 
451
         0 ignored
385
452
         0 versioned subdirectories
386
453
 
387
454
Branch history:
411
478
        branch: Branch format 5
412
479
    repository: %s
413
480
 
 
481
Control directory:
 
482
         1 branches
 
483
 
414
484
Branch is out of date: missing 1 revision.
415
485
 
416
486
In the working tree:
446
516
 
447
517
Format:
448
518
       control: Meta directory format 1
449
 
  working tree: Working tree format 6
450
 
        branch: Branch format 4
451
 
    repository: Weave repository format 6
 
519
  working tree: Working tree format 3
 
520
        branch: Branch format 5
 
521
    repository: Knit repository format 1
 
522
 
 
523
Control directory:
 
524
         1 branches
452
525
 
453
526
Working tree is out of date: missing 1 revision.
454
527
 
470
543
 
471
544
Repository:
472
545
         2 revisions
473
 
""" % (self._repo_strings, datestring_first, datestring_last,), out)
 
546
""" % (format_description, datestring_first, datestring_last,), out)
474
547
        self.assertEqual('', err)
475
548
 
476
549
    def test_info_standalone_no_tree(self):
477
550
        # create standalone branch without a working tree
478
 
        format = bzrdir.format_registry.make_bzrdir('default')
 
551
        format = controldir.format_registry.make_controldir('default')
479
552
        branch = self.make_branch('branch')
480
553
        repo = branch.repository
481
554
        out, err = self.run_bzr('info branch -v')
489
562
        branch: %s
490
563
    repository: %s
491
564
 
 
565
Control directory:
 
566
         1 branches
 
567
 
492
568
Branch history:
493
569
         0 revisions
494
570
 
495
571
Repository:
496
572
         0 revisions
497
 
""" % (info.describe_format(repo.bzrdir, repo, branch, None),
 
573
""" % (info.describe_format(repo.controldir, repo, branch, None),
498
574
       format.get_branch_format().get_format_description(),
499
575
       format.repository_format.get_format_description(),
500
576
       ), out)
501
577
        self.assertEqual('', err)
502
578
 
503
579
    def test_info_shared_repository(self):
504
 
        format = bzrdir.format_registry.make_bzrdir('knit')
 
580
        format = controldir.format_registry.make_controldir('knit')
505
581
        transport = self.get_transport()
506
582
 
507
583
        # Create shared repository
517
593
       control: Meta directory format 1
518
594
    repository: %s
519
595
 
 
596
Control directory:
 
597
         0 branches
 
598
 
520
599
Repository:
521
600
         0 revisions
522
601
""" % ('repo', format.repository_format.get_format_description(),
524
603
        self.assertEqual('', err)
525
604
 
526
605
        # Create branch inside shared repository
527
 
        repo.bzrdir.root_transport.mkdir('branch')
528
 
        branch1 = repo.bzrdir.create_branch_convenience('repo/branch',
529
 
            format=format)
 
606
        repo.controldir.root_transport.mkdir('branch')
 
607
        branch1 = controldir.ControlDir.create_branch_convenience(
 
608
            'repo/branch', format=format)
530
609
        out, err = self.run_bzr('info -v repo/branch')
531
610
        self.assertEqualDiff(
532
611
"""Repository branch (format: dirstate or knit)
539
618
        branch: %s
540
619
    repository: %s
541
620
 
 
621
Control directory:
 
622
         1 branches
 
623
 
542
624
Branch history:
543
625
         0 revisions
544
626
 
567
649
        self.build_tree(['tree/lightcheckout/a'])
568
650
        tree2.add('a')
569
651
        tree2.commit('commit one')
570
 
        rev = repo.get_revision(branch2.revision_history()[0])
 
652
        rev = repo.get_revision(branch2.last_revision())
571
653
        datestring_first = osutils.format_date(rev.timestamp, rev.timezone)
572
654
        out, err = self.run_bzr('info tree/lightcheckout --verbose')
573
655
        self.assertEqualDiff(
583
665
        branch: %s
584
666
    repository: %s
585
667
 
 
668
Control directory:
 
669
         1 branches
 
670
 
586
671
In the working tree:
587
672
         1 unchanged
588
673
         0 modified
621
706
        branch: %s
622
707
    repository: %s
623
708
 
 
709
Control directory:
 
710
         1 branches
 
711
 
624
712
Branch is out of date: missing 1 revision.
625
713
 
626
714
In the working tree:
660
748
        branch: %s
661
749
    repository: %s
662
750
 
 
751
Control directory:
 
752
         1 branches
 
753
 
663
754
In the working tree:
664
755
         1 unchanged
665
756
         0 modified
686
777
        tree3.commit('commit two')
687
778
 
688
779
        # Out of date lightweight checkout
689
 
        rev = repo.get_revision(branch1.revision_history()[-1])
 
780
        rev = repo.get_revision(branch1.last_revision())
690
781
        datestring_last = osutils.format_date(rev.timestamp, rev.timezone)
691
782
        out, err = self.run_bzr('info tree/lightcheckout --verbose')
692
783
        self.assertEqualDiff(
702
793
        branch: %s
703
794
    repository: %s
704
795
 
 
796
Control directory:
 
797
         1 branches
 
798
 
705
799
Working tree is out of date: missing 1 revision.
706
800
 
707
801
In the working tree:
741
835
        branch: %s
742
836
    repository: %s
743
837
 
 
838
Control directory:
 
839
         1 branches
 
840
 
744
841
Branch history:
745
842
         2 revisions
746
843
         0 days old
766
863
       control: Meta directory format 1
767
864
    repository: %s
768
865
 
 
866
Control directory:
 
867
         0 branches
 
868
 
769
869
Repository:
770
870
         2 revisions
771
871
""" % (format.repository_format.get_format_description(),
773
873
        self.assertEqual('', err)
774
874
 
775
875
    def test_info_shared_repository_with_trees(self):
776
 
        format = bzrdir.format_registry.make_bzrdir('knit')
 
876
        format = controldir.format_registry.make_controldir('knit')
777
877
        transport = self.get_transport()
778
878
 
779
879
        # Create shared repository with working trees
789
889
       control: Meta directory format 1
790
890
    repository: %s
791
891
 
 
892
Control directory:
 
893
         0 branches
 
894
 
792
895
Create working tree for new branches inside the repository.
793
896
 
794
897
Repository:
798
901
        self.assertEqual('', err)
799
902
 
800
903
        # Create two branches
801
 
        repo.bzrdir.root_transport.mkdir('branch1')
802
 
        branch1 = repo.bzrdir.create_branch_convenience('repo/branch1',
 
904
        repo.controldir.root_transport.mkdir('branch1')
 
905
        branch1 = controldir.ControlDir.create_branch_convenience('repo/branch1',
803
906
            format=format)
804
 
        branch2 = branch1.bzrdir.sprout('repo/branch2').open_branch()
 
907
        branch2 = branch1.controldir.sprout('repo/branch2').open_branch()
805
908
 
806
909
        # Empty first branch
807
910
        out, err = self.run_bzr('info repo/branch1 --verbose')
817
920
        branch: %s
818
921
    repository: %s
819
922
 
 
923
Control directory:
 
924
         1 branches
 
925
 
820
926
In the working tree:
821
927
         0 unchanged
822
928
         0 modified
839
945
 
840
946
        # Update first branch
841
947
        self.build_tree(['repo/branch1/a'])
842
 
        tree1 = branch1.bzrdir.open_workingtree()
 
948
        tree1 = branch1.controldir.open_workingtree()
843
949
        tree1.add('a')
844
950
        tree1.commit('commit one')
845
 
        rev = repo.get_revision(branch1.revision_history()[0])
 
951
        rev = repo.get_revision(branch1.last_revision())
846
952
        datestring_first = osutils.format_date(rev.timestamp, rev.timezone)
847
953
        out, err = self.run_bzr('info -v repo/branch1')
848
954
        self.assertEqualDiff(
857
963
        branch: %s
858
964
    repository: %s
859
965
 
 
966
Control directory:
 
967
         1 branches
 
968
 
860
969
In the working tree:
861
970
         1 unchanged
862
971
         0 modified
898
1007
        branch: %s
899
1008
    repository: %s
900
1009
 
 
1010
Control directory:
 
1011
         1 branches
 
1012
 
901
1013
In the working tree:
902
1014
         0 unchanged
903
1015
         0 modified
919
1031
        self.assertEqual('', err)
920
1032
 
921
1033
        # Update second branch
922
 
        tree2 = branch2.bzrdir.open_workingtree()
 
1034
        tree2 = branch2.controldir.open_workingtree()
923
1035
        tree2.pull(branch1)
924
1036
        out, err = self.run_bzr('info -v repo/branch2')
925
1037
        self.assertEqualDiff(
937
1049
        branch: %s
938
1050
    repository: %s
939
1051
 
 
1052
Control directory:
 
1053
         1 branches
 
1054
 
940
1055
In the working tree:
941
1056
         1 unchanged
942
1057
         0 modified
972
1087
       control: Meta directory format 1
973
1088
    repository: %s
974
1089
 
 
1090
Control directory:
 
1091
         0 branches
 
1092
 
975
1093
Create working tree for new branches inside the repository.
976
1094
 
977
1095
Repository:
982
1100
        self.assertEqual('', err)
983
1101
 
984
1102
    def test_info_shared_repository_with_tree_in_root(self):
985
 
        format = bzrdir.format_registry.make_bzrdir('knit')
 
1103
        format = controldir.format_registry.make_controldir('knit')
986
1104
        transport = self.get_transport()
987
1105
 
988
1106
        # Create shared repository with working trees
998
1116
       control: Meta directory format 1
999
1117
    repository: %s
1000
1118
 
 
1119
Control directory:
 
1120
         0 branches
 
1121
 
1001
1122
Create working tree for new branches inside the repository.
1002
1123
 
1003
1124
Repository:
1007
1128
        self.assertEqual('', err)
1008
1129
 
1009
1130
        # Create branch in root of repository
1010
 
        control = repo.bzrdir
 
1131
        control = repo.controldir
1011
1132
        branch = control.create_branch()
1012
1133
        control.create_workingtree()
1013
1134
        out, err = self.run_bzr('info -v repo')
1023
1144
        branch: %s
1024
1145
    repository: %s
1025
1146
 
 
1147
Control directory:
 
1148
         1 branches
 
1149
 
1026
1150
In the working tree:
1027
1151
         0 unchanged
1028
1152
         0 modified
1044
1168
        self.assertEqual('', err)
1045
1169
 
1046
1170
    def test_info_repository_hook(self):
1047
 
        format = bzrdir.format_registry.make_bzrdir('knit')
 
1171
        format = controldir.format_registry.make_controldir('knit')
1048
1172
        def repo_info(repo, stats, outf):
1049
 
            outf.write("more info\n")
 
1173
            outf.write(u"more info\n")
1050
1174
        info.hooks.install_named_hook('repository', repo_info, None)
1051
1175
        # Create shared repository with working trees
1052
1176
        repo = self.make_repository('repo', shared=True, format=format)
1060
1184
       control: Meta directory format 1
1061
1185
    repository: %s
1062
1186
 
 
1187
Control directory:
 
1188
         0 branches
 
1189
 
1063
1190
Create working tree for new branches inside the repository.
1064
1191
 
1065
1192
Repository:
1069
1196
       ), out)
1070
1197
        self.assertEqual('', err)
1071
1198
 
 
1199
    def test_info_unshared_repository_with_colocated_branches(self):
 
1200
        format = controldir.format_registry.make_controldir('development-colo')
 
1201
        transport = self.get_transport()
 
1202
 
 
1203
        # Create unshared repository
 
1204
        repo = self.make_repository('repo', shared=False, format=format)
 
1205
        repo.set_make_working_trees(True)
 
1206
        repo.controldir.create_branch(name='foo')
 
1207
        out, err = self.run_bzr('info repo')
 
1208
        self.assertEqualDiff(
 
1209
"""Unshared repository with trees and colocated branches (format: development-colo)
 
1210
Location:
 
1211
  repository: repo
 
1212
""", out)
 
1213
        self.assertEqual('', err)
 
1214
 
1072
1215
    def assertCheckoutStatusOutput(self,
1073
1216
        command_string, lco_tree, shared_repo=None,
1074
1217
        repo_branch=None,
1148
1291
        extra_space = ''
1149
1292
        if light_checkout:
1150
1293
            tree_data = ("  light checkout root: %s\n" %
1151
 
                friendly_location(lco_tree.bzrdir.root_transport.base))
 
1294
                friendly_location(lco_tree.controldir.root_transport.base))
1152
1295
            extra_space = ' '
1153
1296
        if lco_tree.branch.get_bound_location() is not None:
1154
1297
            tree_data += ("%s       checkout root: %s\n" % (extra_space,
1155
 
                friendly_location(lco_tree.branch.bzrdir.root_transport.base)))
 
1298
                friendly_location(lco_tree.branch.controldir.root_transport.base)))
1156
1299
        if shared_repo is not None:
1157
1300
            branch_data = (
1158
1301
                "   checkout of branch: %s\n"
1159
1302
                "    shared repository: %s\n" %
1160
 
                (friendly_location(repo_branch.bzrdir.root_transport.base),
1161
 
                 friendly_location(shared_repo.bzrdir.root_transport.base)))
 
1303
                (friendly_location(repo_branch.controldir.root_transport.base),
 
1304
                 friendly_location(shared_repo.controldir.root_transport.base)))
1162
1305
        elif repo_branch is not None:
1163
1306
            branch_data = (
1164
1307
                "%s  checkout of branch: %s\n" %
1165
1308
                (extra_space,
1166
 
                 friendly_location(repo_branch.bzrdir.root_transport.base)))
 
1309
                 friendly_location(repo_branch.controldir.root_transport.base)))
1167
1310
        else:
1168
1311
            branch_data = ("   checkout of branch: %s\n" %
1169
 
                lco_tree.branch.bzrdir.root_transport.base)
 
1312
                lco_tree.branch.controldir.root_transport.base)
1170
1313
 
1171
1314
        if verbose >= 2:
1172
1315
            verbose_info = '         0 committers\n'
1183
1326
        branch: %s
1184
1327
    repository: %s
1185
1328
%s
 
1329
Control directory:
 
1330
         1 branches
 
1331
 
1186
1332
In the working tree:
1187
1333
         0 unchanged
1188
1334
         0 modified
1216
1362
        repo = self.make_repository('repo', shared=True,
1217
1363
                                    format=bzrdir.BzrDirMetaFormat1())
1218
1364
        repo.set_make_working_trees(False)
1219
 
        repo.bzrdir.root_transport.mkdir('branch')
1220
 
        repo_branch = repo.bzrdir.create_branch_convenience('repo/branch',
1221
 
                                    format=bzrdir.BzrDirMetaFormat1())
 
1365
        repo.controldir.root_transport.mkdir('branch')
 
1366
        repo_branch = controldir.ControlDir.create_branch_convenience(
 
1367
            'repo/branch', format=bzrdir.BzrDirMetaFormat1())
1222
1368
        # Do a heavy checkout
1223
1369
        transport.mkdir('tree')
1224
1370
        transport.mkdir('tree/checkout')
1225
 
        co_branch = bzrdir.BzrDir.create_branch_convenience('tree/checkout',
1226
 
            format=bzrdir.BzrDirMetaFormat1())
 
1371
        co_branch = controldir.ControlDir.create_branch_convenience(
 
1372
            'tree/checkout', format=bzrdir.BzrDirMetaFormat1())
1227
1373
        co_branch.bind(repo_branch)
1228
1374
        # Do a light checkout of the heavy one
1229
1375
        transport.mkdir('tree/lightcheckout')
1230
1376
        lco_dir = bzrdir.BzrDirMetaFormat1().initialize('tree/lightcheckout')
1231
 
        branch.BranchReferenceFormat().initialize(lco_dir,
1232
 
            target_branch=co_branch)
 
1377
        lco_dir.set_branch_reference(co_branch)
1233
1378
        lco_dir.create_workingtree()
1234
1379
        lco_tree = lco_dir.open_workingtree()
1235
1380
 
1320
1465
            lco_tree.branch.unlock()
1321
1466
 
1322
1467
        if sys.platform == 'win32':
1323
 
            self.knownFailure('Win32 cannot run "bzr info"'
 
1468
            self.knownFailure('Win32 cannot run "brz info"'
1324
1469
                              ' when the tree is locked.')
1325
1470
 
1326
 
    def test_info_locking_oslocks(self):
1327
 
        if sys.platform == "win32":
1328
 
            self.skip("don't use oslocks on win32 in unix manner")
1329
 
        # This test tests old (all-in-one, OS lock using) behaviour which
1330
 
        # simply cannot work on windows (and is indeed why we changed our
1331
 
        # design. As such, don't try to remove the thisFailsStrictLockCheck
1332
 
        # call here.
1333
 
        self.thisFailsStrictLockCheck()
1334
 
 
1335
 
        tree = self.make_branch_and_tree('branch',
1336
 
                                         format=bzrdir.BzrDirFormat6())
1337
 
 
1338
 
        # Test all permutations of locking the working tree, branch and repository
1339
 
        # XXX: Well not yet, as we can't query oslocks yet. Currently, it's
1340
 
        # implemented by raising NotImplementedError and get_physical_lock_status()
1341
 
        # always returns false. This makes bzr info hide the lock status.  (Olaf)
1342
 
        # W B R
1343
 
 
1344
 
        # U U U
1345
 
        out, err = self.run_bzr('info -v branch')
1346
 
        self.assertEqualDiff(
1347
 
"""Standalone tree (format: weave)
1348
 
Location:
1349
 
  branch root: %s
1350
 
 
1351
 
Format:
1352
 
       control: All-in-one format 6
1353
 
  working tree: Working tree format 2
1354
 
        branch: Branch format 4
1355
 
    repository: %s
1356
 
 
1357
 
In the working tree:
1358
 
         0 unchanged
1359
 
         0 modified
1360
 
         0 added
1361
 
         0 removed
1362
 
         0 renamed
1363
 
         0 unknown
1364
 
         0 ignored
1365
 
         0 versioned subdirectories
1366
 
 
1367
 
Branch history:
1368
 
         0 revisions
1369
 
 
1370
 
Repository:
1371
 
         0 revisions
1372
 
""" % ('branch', tree.branch.repository._format.get_format_description(),
1373
 
       ), out)
1374
 
        self.assertEqual('', err)
1375
 
        # L L L
1376
 
        tree.lock_write()
1377
 
        out, err = self.run_bzr('info -v branch')
1378
 
        self.assertEqualDiff(
1379
 
"""Standalone tree (format: weave)
1380
 
Location:
1381
 
  branch root: %s
1382
 
 
1383
 
Format:
1384
 
       control: All-in-one format 6
1385
 
  working tree: Working tree format 2
1386
 
        branch: Branch format 4
1387
 
    repository: %s
1388
 
 
1389
 
In the working tree:
1390
 
         0 unchanged
1391
 
         0 modified
1392
 
         0 added
1393
 
         0 removed
1394
 
         0 renamed
1395
 
         0 unknown
1396
 
         0 ignored
1397
 
         0 versioned subdirectories
1398
 
 
1399
 
Branch history:
1400
 
         0 revisions
1401
 
 
1402
 
Repository:
1403
 
         0 revisions
1404
 
""" % ('branch', tree.branch.repository._format.get_format_description(),
1405
 
       ), out)
1406
 
        self.assertEqual('', err)
1407
 
        tree.unlock()
1408
 
 
1409
1471
    def test_info_stacked(self):
1410
1472
        # We have a mainline
1411
1473
        trunk_tree = self.make_branch_and_tree('mainline',
1412
1474
            format='1.6')
1413
1475
        trunk_tree.commit('mainline')
1414
1476
        # and a branch from it which is stacked
1415
 
        new_dir = trunk_tree.bzrdir.sprout('newbranch', stacked=True)
 
1477
        new_dir = trunk_tree.controldir.sprout('newbranch', stacked=True)
1416
1478
        out, err = self.run_bzr('info newbranch')
1417
1479
        self.assertEqual(
1418
1480
"""Standalone tree (format: 1.6)
1424
1486
     stacked on: mainline
1425
1487
""", out)
1426
1488
        self.assertEqual("", err)
 
1489
 
 
1490
    def test_info_revinfo_optional(self):
 
1491
        tree = self.make_branch_and_tree('.')
 
1492
        def last_revision_info(self):
 
1493
            raise errors.UnsupportedOperation(last_revision_info, self)
 
1494
        self.overrideAttr(
 
1495
            branch.Branch, "last_revision_info", last_revision_info)
 
1496
        out, err = self.run_bzr('info -v .')
 
1497
        self.assertEqual(
 
1498
"""Standalone tree (format: 2a)
 
1499
Location:
 
1500
  branch root: .
 
1501
 
 
1502
Format:
 
1503
       control: Meta directory format 1
 
1504
  working tree: Working tree format 6
 
1505
        branch: Branch format 7
 
1506
    repository: Repository format 2a - rich roots, group compression and chk inventories
 
1507
 
 
1508
Control directory:
 
1509
         1 branches
 
1510
 
 
1511
In the working tree:
 
1512
         0 unchanged
 
1513
         0 modified
 
1514
         0 added
 
1515
         0 removed
 
1516
         0 renamed
 
1517
         0 unknown
 
1518
         0 ignored
 
1519
         0 versioned subdirectories
 
1520
""", out)
 
1521
        self.assertEqual("", err)
 
1522
 
 
1523
    def test_info_shows_colocated_branches(self):
 
1524
        bzrdir = self.make_branch('.', format='development-colo').controldir
 
1525
        bzrdir.create_branch(name="colo1")
 
1526
        bzrdir.create_branch(name="colo2")
 
1527
        bzrdir.create_branch(name="colo3")
 
1528
        out, err = self.run_bzr('info -v .')
 
1529
        self.assertEqualDiff(
 
1530
"""Standalone branch (format: development-colo)
 
1531
Location:
 
1532
  branch root: .
 
1533
 
 
1534
Format:
 
1535
       control: Meta directory format 1 with support for colocated branches
 
1536
        branch: Branch format 7
 
1537
    repository: Repository format 2a - rich roots, group compression and chk inventories
 
1538
 
 
1539
Control directory:
 
1540
         4 branches
 
1541
 
 
1542
Branch history:
 
1543
         0 revisions
 
1544
 
 
1545
Repository:
 
1546
         0 revisions
 
1547
""", out)
 
1548
        self.assertEqual("", err)
 
1549
 
 
1550
 
 
1551
class TestSmartServerInfo(tests.TestCaseWithTransport):
 
1552
 
 
1553
    def test_simple_branch_info(self):
 
1554
        self.setup_smart_server_with_call_log()
 
1555
        t = self.make_branch_and_tree('branch')
 
1556
        self.build_tree_contents([('branch/foo', b'thecontents')])
 
1557
        t.add("foo")
 
1558
        t.commit("message")
 
1559
        self.reset_smart_call_log()
 
1560
        out, err = self.run_bzr(['info', self.get_url('branch')])
 
1561
        # This figure represent the amount of work to perform this use case. It
 
1562
        # is entirely ok to reduce this number if a test fails due to rpc_count
 
1563
        # being too low. If rpc_count increases, more network roundtrips have
 
1564
        # become necessary for this use case. Please do not adjust this number
 
1565
        # upwards without agreement from bzr's network support maintainers.
 
1566
        self.assertLength(10, self.hpss_calls)
 
1567
        self.assertLength(1, self.hpss_connections)
 
1568
        self.assertThat(self.hpss_calls, ContainsNoVfsCalls)
 
1569
 
 
1570
    def test_verbose_branch_info(self):
 
1571
        self.setup_smart_server_with_call_log()
 
1572
        t = self.make_branch_and_tree('branch')
 
1573
        self.build_tree_contents([('branch/foo', b'thecontents')])
 
1574
        t.add("foo")
 
1575
        t.commit("message")
 
1576
        self.reset_smart_call_log()
 
1577
        out, err = self.run_bzr(['info', '-v', self.get_url('branch')])
 
1578
        # This figure represent the amount of work to perform this use case. It
 
1579
        # is entirely ok to reduce this number if a test fails due to rpc_count
 
1580
        # being too low. If rpc_count increases, more network roundtrips have
 
1581
        # become necessary for this use case. Please do not adjust this number
 
1582
        # upwards without agreement from bzr's network support maintainers.
 
1583
        self.assertLength(14, self.hpss_calls)
 
1584
        self.assertLength(1, self.hpss_connections)
 
1585
        self.assertThat(self.hpss_calls, ContainsNoVfsCalls)