← 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: Patch Queue Manager
  • Date: 2016-04-21 05:06:57 UTC
  • mfrom: (6603.4.1 bzr)
  • Revision ID: pqm@pqm.ubuntu.com-20160421050657-ygnzfybewvudf1j9
(richard-wilbur) Use initial_comment as commit_message for lp_propose.(Shawn
 Wang) (Shawn Wang)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/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
23
from bzrlib import (
23
24
    branch,
24
25
    bzrdir,
 
26
    controldir,
25
27
    errors,
26
28
    info,
27
29
    osutils,
29
31
    upgrade,
30
32
    urlutils,
31
33
    )
 
34
from bzrlib.tests.matchers import ContainsNoVfsCalls
32
35
from bzrlib.transport import memory
33
36
 
34
37
 
45
48
        self.assertEqual(out, '')
46
49
        self.assertEqual(err, 'bzr: ERROR: Not a branch: "%s".\n' % location)
47
50
 
 
51
    def test_info_empty_controldir(self):
 
52
        self.make_bzrdir('ctrl')
 
53
        out, err = self.run_bzr('info ctrl')
 
54
        self.assertEqual(out,
 
55
            'Empty control directory (format: 2a or pack-0.92)\n'
 
56
            'Location:\n'
 
57
            '  control directory: ctrl\n')
 
58
        self.assertEqual(err, '')
 
59
 
 
60
    def test_info_empty_controldir_verbose(self):
 
61
        self.make_bzrdir('ctrl')
 
62
        out, err = self.run_bzr('info -v ctrl')
 
63
        self.assertEqualDiff(out,
 
64
            'Empty control directory (format: 2a or pack-0.92)\n'
 
65
            'Location:\n'
 
66
            '  control directory: ctrl\n\n'
 
67
            'Format:\n'
 
68
            '       control: Meta directory format 1\n\n'
 
69
            'Control directory:\n'
 
70
            '         0 branches\n')
 
71
        self.assertEqual(err, '')
 
72
 
 
73
    def test_info_dangling_branch_reference(self):
 
74
        br = self.make_branch('target')
 
75
        br.create_checkout('from', lightweight=True)
 
76
        shutil.rmtree('target')
 
77
        out, err = self.run_bzr('info from')
 
78
        self.assertEqual(out,
 
79
            'Dangling branch reference (format: 2a or pack-0.92)\n'
 
80
            'Location:\n'
 
81
            '   control directory: from\n'
 
82
            '  checkout of branch: target\n')
 
83
        self.assertEqual(err, '')
 
84
 
48
85
    def test_info_standalone(self):
49
86
        transport = self.get_transport()
50
87
 
51
88
        # Create initial standalone branch
52
 
        tree1 = self.make_branch_and_tree('standalone', 'weave')
 
89
        tree1 = self.make_branch_and_tree('standalone', 'knit')
53
90
        self.build_tree(['standalone/a'])
54
91
        tree1.add('a')
55
92
        branch1 = tree1.branch
56
93
 
57
94
        out, err = self.run_bzr('info standalone')
58
95
        self.assertEqualDiff(
59
 
"""Standalone tree (format: weave)
 
96
"""Standalone tree (format: knit)
60
97
Location:
61
98
  branch root: standalone
62
99
""", out)
65
102
        # Standalone branch - verbose mode
66
103
        out, err = self.run_bzr('info standalone -v')
67
104
        self.assertEqualDiff(
68
 
"""Standalone tree (format: weave)
 
105
"""Standalone tree (format: knit)
69
106
Location:
70
107
  branch root: standalone
71
108
 
72
109
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
 
110
       control: Meta directory format 1
 
111
  working tree: Working tree format 3
 
112
        branch: Branch format 5
 
113
    repository: Knit repository format 1
 
114
 
 
115
Control directory:
 
116
         1 branches
77
117
 
78
118
In the working tree:
79
119
         0 unchanged
96
136
        # Standalone branch - really verbose mode
97
137
        out, err = self.run_bzr('info standalone -vv')
98
138
        self.assertEqualDiff(
99
 
"""Standalone tree (format: weave)
 
139
"""Standalone tree (format: knit)
100
140
Location:
101
141
  branch root: standalone
102
142
 
103
143
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
 
144
       control: Meta directory format 1
 
145
  working tree: Working tree format 3
 
146
        branch: Branch format 5
 
147
    repository: Knit repository format 1
 
148
 
 
149
Control directory:
 
150
         1 branches
108
151
 
109
152
In the working tree:
110
153
         0 unchanged
125
168
""", out)
126
169
        self.assertEqual('', err)
127
170
        tree1.commit('commit one')
128
 
        rev = branch1.repository.get_revision(branch1.revision_history()[0])
 
171
        rev = branch1.repository.get_revision(branch1.last_revision())
129
172
        datestring_first = osutils.format_date(rev.timestamp, rev.timezone)
130
173
 
131
174
        # Branch standalone with push location
134
177
 
135
178
        out, err = self.run_bzr('info branch')
136
179
        self.assertEqualDiff(
137
 
"""Standalone tree (format: weave)
 
180
"""Standalone tree (format: knit)
138
181
Location:
139
182
  branch root: branch
140
183
 
146
189
 
147
190
        out, err = self.run_bzr('info branch --verbose')
148
191
        self.assertEqualDiff(
149
 
"""Standalone tree (format: weave)
 
192
"""Standalone tree (format: knit)
150
193
Location:
151
194
  branch root: branch
152
195
 
155
198
  parent branch: standalone
156
199
 
157
200
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
 
201
       control: Meta directory format 1
 
202
  working tree: Working tree format 3
 
203
        branch: Branch format 5
 
204
    repository: Knit repository format 1
 
205
 
 
206
Control directory:
 
207
         1 branches
162
208
 
163
209
In the working tree:
164
210
         1 unchanged
185
231
        # Branch and bind to standalone, needs upgrade to metadir
186
232
        # (creates backup as unknown)
187
233
        branch1.bzrdir.sprout('bound')
188
 
        knit1_format = bzrdir.format_registry.make_bzrdir('knit')
 
234
        knit1_format = controldir.format_registry.make_bzrdir('knit')
189
235
        upgrade.upgrade('bound', knit1_format)
190
 
        branch3 = bzrdir.BzrDir.open('bound').open_branch()
 
236
        branch3 = controldir.ControlDir.open('bound').open_branch()
191
237
        branch3.bind(branch1)
192
238
        bound_tree = branch3.bzrdir.open_workingtree()
193
239
        out, err = self.run_bzr('info -v bound')
206
252
        branch: %s
207
253
    repository: %s
208
254
 
 
255
Control directory:
 
256
         1 branches
 
257
 
209
258
In the working tree:
210
259
         1 unchanged
211
260
         0 modified
213
262
         0 removed
214
263
         0 renamed
215
264
         0 unknown
216
 
         1 ignored
 
265
         0 ignored
217
266
         0 versioned subdirectories
218
267
 
219
268
Branch history:
232
281
        self.assertEqual('', err)
233
282
 
234
283
        # Checkout standalone (same as above, but does not have parent set)
235
 
        branch4 = bzrdir.BzrDir.create_branch_convenience('checkout',
 
284
        branch4 = controldir.ControlDir.create_branch_convenience('checkout',
236
285
            format=knit1_format)
237
286
        branch4.bind(branch1)
238
287
        branch4.bzrdir.open_workingtree().update()
249
298
        branch: Branch format 5
250
299
    repository: %s
251
300
 
 
301
Control directory:
 
302
         1 branches
 
303
 
252
304
In the working tree:
253
305
         1 unchanged
254
306
         0 modified
276
328
        tree5 = branch1.create_checkout('lightcheckout', lightweight=True)
277
329
        branch5 = tree5.branch
278
330
        out, err = self.run_bzr('info -v lightcheckout')
 
331
        if "metaweave" in controldir.format_registry:
 
332
            format_description = "knit or metaweave"
 
333
        else:
 
334
            format_description = "knit"
279
335
        self.assertEqualDiff(
280
336
"""Lightweight checkout (format: %s)
281
337
Location:
284
340
 
285
341
Format:
286
342
       control: Meta directory format 1
287
 
  working tree: Working tree format 6
288
 
        branch: Branch format 4
289
 
    repository: Weave repository format 6
 
343
  working tree: Working tree format 3
 
344
        branch: Branch format 5
 
345
    repository: Knit repository format 1
 
346
 
 
347
Control directory:
 
348
         1 branches
290
349
 
291
350
In the working tree:
292
351
         1 unchanged
306
365
 
307
366
Repository:
308
367
         1 revision
309
 
""" % (self._repo_strings, datestring_first, datestring_first,), out)
 
368
""" % (format_description, datestring_first, datestring_first,), out)
310
369
        self.assertEqual('', err)
311
370
 
312
371
        # Update initial standalone branch
313
372
        self.build_tree(['standalone/b'])
314
373
        tree1.add('b')
315
374
        tree1.commit('commit two')
316
 
        rev = branch1.repository.get_revision(branch1.revision_history()[-1])
 
375
        rev = branch1.repository.get_revision(branch1.last_revision())
317
376
        datestring_last = osutils.format_date(rev.timestamp, rev.timezone)
318
377
 
319
378
        # Out of date branched standalone branch will not be detected
320
379
        out, err = self.run_bzr('info -v branch')
321
380
        self.assertEqualDiff(
322
 
"""Standalone tree (format: weave)
 
381
"""Standalone tree (format: knit)
323
382
Location:
324
383
  branch root: branch
325
384
 
328
387
  parent branch: standalone
329
388
 
330
389
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
 
390
       control: Meta directory format 1
 
391
  working tree: Working tree format 3
 
392
        branch: Branch format 5
 
393
    repository: Knit repository format 1
 
394
 
 
395
Control directory:
 
396
         1 branches
335
397
 
336
398
In the working tree:
337
399
         1 unchanged
372
434
        branch: Branch format 5
373
435
    repository: %s
374
436
 
 
437
Control directory:
 
438
         1 branches
 
439
 
375
440
Branch is out of date: missing 1 revision.
376
441
 
377
442
In the working tree:
381
446
         0 removed
382
447
         0 renamed
383
448
         0 unknown
384
 
         1 ignored
 
449
         0 ignored
385
450
         0 versioned subdirectories
386
451
 
387
452
Branch history:
411
476
        branch: Branch format 5
412
477
    repository: %s
413
478
 
 
479
Control directory:
 
480
         1 branches
 
481
 
414
482
Branch is out of date: missing 1 revision.
415
483
 
416
484
In the working tree:
446
514
 
447
515
Format:
448
516
       control: Meta directory format 1
449
 
  working tree: Working tree format 6
450
 
        branch: Branch format 4
451
 
    repository: Weave repository format 6
 
517
  working tree: Working tree format 3
 
518
        branch: Branch format 5
 
519
    repository: Knit repository format 1
 
520
 
 
521
Control directory:
 
522
         1 branches
452
523
 
453
524
Working tree is out of date: missing 1 revision.
454
525
 
470
541
 
471
542
Repository:
472
543
         2 revisions
473
 
""" % (self._repo_strings, datestring_first, datestring_last,), out)
 
544
""" % (format_description, datestring_first, datestring_last,), out)
474
545
        self.assertEqual('', err)
475
546
 
476
547
    def test_info_standalone_no_tree(self):
477
548
        # create standalone branch without a working tree
478
 
        format = bzrdir.format_registry.make_bzrdir('default')
 
549
        format = controldir.format_registry.make_bzrdir('default')
479
550
        branch = self.make_branch('branch')
480
551
        repo = branch.repository
481
552
        out, err = self.run_bzr('info branch -v')
489
560
        branch: %s
490
561
    repository: %s
491
562
 
 
563
Control directory:
 
564
         1 branches
 
565
 
492
566
Branch history:
493
567
         0 revisions
494
568
 
501
575
        self.assertEqual('', err)
502
576
 
503
577
    def test_info_shared_repository(self):
504
 
        format = bzrdir.format_registry.make_bzrdir('knit')
 
578
        format = controldir.format_registry.make_bzrdir('knit')
505
579
        transport = self.get_transport()
506
580
 
507
581
        # Create shared repository
517
591
       control: Meta directory format 1
518
592
    repository: %s
519
593
 
 
594
Control directory:
 
595
         0 branches
 
596
 
520
597
Repository:
521
598
         0 revisions
522
599
""" % ('repo', format.repository_format.get_format_description(),
525
602
 
526
603
        # Create branch inside shared repository
527
604
        repo.bzrdir.root_transport.mkdir('branch')
528
 
        branch1 = repo.bzrdir.create_branch_convenience('repo/branch',
529
 
            format=format)
 
605
        branch1 = controldir.ControlDir.create_branch_convenience(
 
606
            'repo/branch', format=format)
530
607
        out, err = self.run_bzr('info -v repo/branch')
531
608
        self.assertEqualDiff(
532
609
"""Repository branch (format: dirstate or knit)
539
616
        branch: %s
540
617
    repository: %s
541
618
 
 
619
Control directory:
 
620
         1 branches
 
621
 
542
622
Branch history:
543
623
         0 revisions
544
624
 
567
647
        self.build_tree(['tree/lightcheckout/a'])
568
648
        tree2.add('a')
569
649
        tree2.commit('commit one')
570
 
        rev = repo.get_revision(branch2.revision_history()[0])
 
650
        rev = repo.get_revision(branch2.last_revision())
571
651
        datestring_first = osutils.format_date(rev.timestamp, rev.timezone)
572
652
        out, err = self.run_bzr('info tree/lightcheckout --verbose')
573
653
        self.assertEqualDiff(
583
663
        branch: %s
584
664
    repository: %s
585
665
 
 
666
Control directory:
 
667
         1 branches
 
668
 
586
669
In the working tree:
587
670
         1 unchanged
588
671
         0 modified
621
704
        branch: %s
622
705
    repository: %s
623
706
 
 
707
Control directory:
 
708
         1 branches
 
709
 
624
710
Branch is out of date: missing 1 revision.
625
711
 
626
712
In the working tree:
660
746
        branch: %s
661
747
    repository: %s
662
748
 
 
749
Control directory:
 
750
         1 branches
 
751
 
663
752
In the working tree:
664
753
         1 unchanged
665
754
         0 modified
686
775
        tree3.commit('commit two')
687
776
 
688
777
        # Out of date lightweight checkout
689
 
        rev = repo.get_revision(branch1.revision_history()[-1])
 
778
        rev = repo.get_revision(branch1.last_revision())
690
779
        datestring_last = osutils.format_date(rev.timestamp, rev.timezone)
691
780
        out, err = self.run_bzr('info tree/lightcheckout --verbose')
692
781
        self.assertEqualDiff(
702
791
        branch: %s
703
792
    repository: %s
704
793
 
 
794
Control directory:
 
795
         1 branches
 
796
 
705
797
Working tree is out of date: missing 1 revision.
706
798
 
707
799
In the working tree:
741
833
        branch: %s
742
834
    repository: %s
743
835
 
 
836
Control directory:
 
837
         1 branches
 
838
 
744
839
Branch history:
745
840
         2 revisions
746
841
         0 days old
766
861
       control: Meta directory format 1
767
862
    repository: %s
768
863
 
 
864
Control directory:
 
865
         0 branches
 
866
 
769
867
Repository:
770
868
         2 revisions
771
869
""" % (format.repository_format.get_format_description(),
773
871
        self.assertEqual('', err)
774
872
 
775
873
    def test_info_shared_repository_with_trees(self):
776
 
        format = bzrdir.format_registry.make_bzrdir('knit')
 
874
        format = controldir.format_registry.make_bzrdir('knit')
777
875
        transport = self.get_transport()
778
876
 
779
877
        # Create shared repository with working trees
789
887
       control: Meta directory format 1
790
888
    repository: %s
791
889
 
 
890
Control directory:
 
891
         0 branches
 
892
 
792
893
Create working tree for new branches inside the repository.
793
894
 
794
895
Repository:
799
900
 
800
901
        # Create two branches
801
902
        repo.bzrdir.root_transport.mkdir('branch1')
802
 
        branch1 = repo.bzrdir.create_branch_convenience('repo/branch1',
 
903
        branch1 = controldir.ControlDir.create_branch_convenience('repo/branch1',
803
904
            format=format)
804
905
        branch2 = branch1.bzrdir.sprout('repo/branch2').open_branch()
805
906
 
817
918
        branch: %s
818
919
    repository: %s
819
920
 
 
921
Control directory:
 
922
         1 branches
 
923
 
820
924
In the working tree:
821
925
         0 unchanged
822
926
         0 modified
842
946
        tree1 = branch1.bzrdir.open_workingtree()
843
947
        tree1.add('a')
844
948
        tree1.commit('commit one')
845
 
        rev = repo.get_revision(branch1.revision_history()[0])
 
949
        rev = repo.get_revision(branch1.last_revision())
846
950
        datestring_first = osutils.format_date(rev.timestamp, rev.timezone)
847
951
        out, err = self.run_bzr('info -v repo/branch1')
848
952
        self.assertEqualDiff(
857
961
        branch: %s
858
962
    repository: %s
859
963
 
 
964
Control directory:
 
965
         1 branches
 
966
 
860
967
In the working tree:
861
968
         1 unchanged
862
969
         0 modified
898
1005
        branch: %s
899
1006
    repository: %s
900
1007
 
 
1008
Control directory:
 
1009
         1 branches
 
1010
 
901
1011
In the working tree:
902
1012
         0 unchanged
903
1013
         0 modified
937
1047
        branch: %s
938
1048
    repository: %s
939
1049
 
 
1050
Control directory:
 
1051
         1 branches
 
1052
 
940
1053
In the working tree:
941
1054
         1 unchanged
942
1055
         0 modified
972
1085
       control: Meta directory format 1
973
1086
    repository: %s
974
1087
 
 
1088
Control directory:
 
1089
         0 branches
 
1090
 
975
1091
Create working tree for new branches inside the repository.
976
1092
 
977
1093
Repository:
982
1098
        self.assertEqual('', err)
983
1099
 
984
1100
    def test_info_shared_repository_with_tree_in_root(self):
985
 
        format = bzrdir.format_registry.make_bzrdir('knit')
 
1101
        format = controldir.format_registry.make_bzrdir('knit')
986
1102
        transport = self.get_transport()
987
1103
 
988
1104
        # Create shared repository with working trees
998
1114
       control: Meta directory format 1
999
1115
    repository: %s
1000
1116
 
 
1117
Control directory:
 
1118
         0 branches
 
1119
 
1001
1120
Create working tree for new branches inside the repository.
1002
1121
 
1003
1122
Repository:
1023
1142
        branch: %s
1024
1143
    repository: %s
1025
1144
 
 
1145
Control directory:
 
1146
         1 branches
 
1147
 
1026
1148
In the working tree:
1027
1149
         0 unchanged
1028
1150
         0 modified
1044
1166
        self.assertEqual('', err)
1045
1167
 
1046
1168
    def test_info_repository_hook(self):
1047
 
        format = bzrdir.format_registry.make_bzrdir('knit')
 
1169
        format = controldir.format_registry.make_bzrdir('knit')
1048
1170
        def repo_info(repo, stats, outf):
1049
1171
            outf.write("more info\n")
1050
1172
        info.hooks.install_named_hook('repository', repo_info, None)
1060
1182
       control: Meta directory format 1
1061
1183
    repository: %s
1062
1184
 
 
1185
Control directory:
 
1186
         0 branches
 
1187
 
1063
1188
Create working tree for new branches inside the repository.
1064
1189
 
1065
1190
Repository:
1069
1194
       ), out)
1070
1195
        self.assertEqual('', err)
1071
1196
 
 
1197
    def test_info_unshared_repository_with_colocated_branches(self):
 
1198
        format = controldir.format_registry.make_bzrdir('development-colo')
 
1199
        transport = self.get_transport()
 
1200
 
 
1201
        # Create unshared repository
 
1202
        repo = self.make_repository('repo', shared=False, format=format)
 
1203
        repo.set_make_working_trees(True)
 
1204
        repo.bzrdir.create_branch(name='foo')
 
1205
        out, err = self.run_bzr('info repo')
 
1206
        self.assertEqualDiff(
 
1207
"""Unshared repository with trees and colocated branches (format: development-colo)
 
1208
Location:
 
1209
  repository: repo
 
1210
""", out)
 
1211
        self.assertEqual('', err)
 
1212
 
1072
1213
    def assertCheckoutStatusOutput(self,
1073
1214
        command_string, lco_tree, shared_repo=None,
1074
1215
        repo_branch=None,
1183
1324
        branch: %s
1184
1325
    repository: %s
1185
1326
%s
 
1327
Control directory:
 
1328
         1 branches
 
1329
 
1186
1330
In the working tree:
1187
1331
         0 unchanged
1188
1332
         0 modified
1217
1361
                                    format=bzrdir.BzrDirMetaFormat1())
1218
1362
        repo.set_make_working_trees(False)
1219
1363
        repo.bzrdir.root_transport.mkdir('branch')
1220
 
        repo_branch = repo.bzrdir.create_branch_convenience('repo/branch',
1221
 
                                    format=bzrdir.BzrDirMetaFormat1())
 
1364
        repo_branch = controldir.ControlDir.create_branch_convenience(
 
1365
            'repo/branch', format=bzrdir.BzrDirMetaFormat1())
1222
1366
        # Do a heavy checkout
1223
1367
        transport.mkdir('tree')
1224
1368
        transport.mkdir('tree/checkout')
1225
 
        co_branch = bzrdir.BzrDir.create_branch_convenience('tree/checkout',
1226
 
            format=bzrdir.BzrDirMetaFormat1())
 
1369
        co_branch = controldir.ControlDir.create_branch_convenience(
 
1370
            'tree/checkout', format=bzrdir.BzrDirMetaFormat1())
1227
1371
        co_branch.bind(repo_branch)
1228
1372
        # Do a light checkout of the heavy one
1229
1373
        transport.mkdir('tree/lightcheckout')
1230
1374
        lco_dir = bzrdir.BzrDirMetaFormat1().initialize('tree/lightcheckout')
1231
 
        branch.BranchReferenceFormat().initialize(lco_dir,
1232
 
            target_branch=co_branch)
 
1375
        lco_dir.set_branch_reference(co_branch)
1233
1376
        lco_dir.create_workingtree()
1234
1377
        lco_tree = lco_dir.open_workingtree()
1235
1378
 
1323
1466
            self.knownFailure('Win32 cannot run "bzr info"'
1324
1467
                              ' when the tree is locked.')
1325
1468
 
1326
 
    def test_info_locking_oslocks(self):
1327
 
        if sys.platform == "win32":
1328
 
            raise TestSkipped("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
1469
    def test_info_stacked(self):
1410
1470
        # We have a mainline
1411
1471
        trunk_tree = self.make_branch_and_tree('mainline',
1424
1484
     stacked on: mainline
1425
1485
""", out)
1426
1486
        self.assertEqual("", err)
 
1487
 
 
1488
    def test_info_revinfo_optional(self):
 
1489
        tree = self.make_branch_and_tree('.')
 
1490
        def last_revision_info(self):
 
1491
            raise errors.UnsupportedOperation(last_revision_info, self)
 
1492
        self.overrideAttr(
 
1493
            branch.Branch, "last_revision_info", last_revision_info)
 
1494
        out, err = self.run_bzr('info -v .')
 
1495
        self.assertEqual(
 
1496
"""Standalone tree (format: 2a)
 
1497
Location:
 
1498
  branch root: .
 
1499
 
 
1500
Format:
 
1501
       control: Meta directory format 1
 
1502
  working tree: Working tree format 6
 
1503
        branch: Branch format 7
 
1504
    repository: Repository format 2a - rich roots, group compression and chk inventories
 
1505
 
 
1506
Control directory:
 
1507
         1 branches
 
1508
 
 
1509
In the working tree:
 
1510
         0 unchanged
 
1511
         0 modified
 
1512
         0 added
 
1513
         0 removed
 
1514
         0 renamed
 
1515
         0 unknown
 
1516
         0 ignored
 
1517
         0 versioned subdirectories
 
1518
""", out)
 
1519
        self.assertEqual("", err)
 
1520
 
 
1521
    def test_info_shows_colocated_branches(self):
 
1522
        bzrdir = self.make_branch('.', format='development-colo').bzrdir
 
1523
        bzrdir.create_branch(name="colo1")
 
1524
        bzrdir.create_branch(name="colo2")
 
1525
        bzrdir.create_branch(name="colo3")
 
1526
        out, err = self.run_bzr('info -v .')
 
1527
        self.assertEqualDiff(
 
1528
"""Standalone branch (format: development-colo)
 
1529
Location:
 
1530
  branch root: .
 
1531
 
 
1532
Format:
 
1533
       control: Meta directory format 1 with support for colocated branches
 
1534
        branch: Branch format 7
 
1535
    repository: Repository format 2a - rich roots, group compression and chk inventories
 
1536
 
 
1537
Control directory:
 
1538
         4 branches
 
1539
 
 
1540
Branch history:
 
1541
         0 revisions
 
1542
 
 
1543
Repository:
 
1544
         0 revisions
 
1545
""", out)
 
1546
        self.assertEqual("", err)
 
1547
 
 
1548
 
 
1549
class TestSmartServerInfo(tests.TestCaseWithTransport):
 
1550
 
 
1551
    def test_simple_branch_info(self):
 
1552
        self.setup_smart_server_with_call_log()
 
1553
        t = self.make_branch_and_tree('branch')
 
1554
        self.build_tree_contents([('branch/foo', 'thecontents')])
 
1555
        t.add("foo")
 
1556
        t.commit("message")
 
1557
        self.reset_smart_call_log()
 
1558
        out, err = self.run_bzr(['info', self.get_url('branch')])
 
1559
        # This figure represent the amount of work to perform this use case. It
 
1560
        # is entirely ok to reduce this number if a test fails due to rpc_count
 
1561
        # being too low. If rpc_count increases, more network roundtrips have
 
1562
        # become necessary for this use case. Please do not adjust this number
 
1563
        # upwards without agreement from bzr's network support maintainers.
 
1564
        self.assertLength(10, self.hpss_calls)
 
1565
        self.assertLength(1, self.hpss_connections)
 
1566
        self.assertThat(self.hpss_calls, ContainsNoVfsCalls)
 
1567
 
 
1568
    def test_verbose_branch_info(self):
 
1569
        self.setup_smart_server_with_call_log()
 
1570
        t = self.make_branch_and_tree('branch')
 
1571
        self.build_tree_contents([('branch/foo', 'thecontents')])
 
1572
        t.add("foo")
 
1573
        t.commit("message")
 
1574
        self.reset_smart_call_log()
 
1575
        out, err = self.run_bzr(['info', '-v', self.get_url('branch')])
 
1576
        # This figure represent the amount of work to perform this use case. It
 
1577
        # is entirely ok to reduce this number if a test fails due to rpc_count
 
1578
        # being too low. If rpc_count increases, more network roundtrips have
 
1579
        # become necessary for this use case. Please do not adjust this number
 
1580
        # upwards without agreement from bzr's network support maintainers.
 
1581
        self.assertLength(14, self.hpss_calls)
 
1582
        self.assertLength(1, self.hpss_connections)
 
1583
        self.assertThat(self.hpss_calls, ContainsNoVfsCalls)