/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: Jelmer Vernooij
  • Date: 2018-07-06 23:36:14 UTC
  • mto: (7027.3.2 python3-n)
  • mto: This revision was merged to the branch mainline in revision 7030.
  • Revision ID: jelmer@jelmer.uk-20180706233614-t4m8krag15t4z4lp
Update python3.passing.

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
            b'Empty control directory (format: 2a)\n'
 
58
            b'Location:\n'
 
59
            b'  control directory: ctrl\n')
 
60
        self.assertEqual(err, b'')
 
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
            b'Empty control directory (format: 2a)\n'
 
67
            b'Location:\n'
 
68
            b'  control directory: ctrl\n\n'
 
69
            b'Format:\n'
 
70
            b'       control: Meta directory format 1\n\n'
 
71
            b'Control directory:\n'
 
72
            b'         0 branches\n')
 
73
        self.assertEqual(err, b'')
 
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
            b'Dangling branch reference (format: 2a)\n'
 
82
            b'Location:\n'
 
83
            b'   control directory: from\n'
 
84
            b'  checkout of branch: target\n')
 
85
        self.assertEqual(err, b'')
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
b"""Standalone tree (format: knit)
60
99
Location:
61
100
  branch root: standalone
62
101
""", out)
63
 
        self.assertEqual('', err)
 
102
        self.assertEqual(b'', err)
64
103
 
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
b"""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
91
133
Repository:
92
134
         0 revisions
93
135
""", out)
94
 
        self.assertEqual('', err)
 
136
        self.assertEqual(b'', err)
95
137
 
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
b"""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
123
168
Repository:
124
169
         0 revisions
125
170
""", out)
126
 
        self.assertEqual('', err)
 
171
        self.assertEqual(b'', 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
 
142
187
    push branch: standalone
143
188
  parent branch: standalone
144
189
""", out)
145
 
        self.assertEqual('', err)
 
190
        self.assertEqual(b'', err)
146
191
 
147
192
        out, err = self.run_bzr('info branch --verbose')
148
193
        self.assertEqualDiff(
149
 
"""Standalone tree (format: weave)
 
194
b"""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
180
228
         1 revision
181
229
""" % (datestring_first, datestring_first,
182
230
       ), out)
183
 
        self.assertEqual('', err)
 
231
        self.assertEqual(b'', err)
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
 
"""Checkout (format: knit)
 
243
b"""Checkout (format: knit)
196
244
Location:
197
245
       checkout root: bound
198
246
  checkout of branch: standalone
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:
229
280
       branch3.repository._format.get_format_description(),
230
281
       datestring_first, datestring_first,
231
282
       ), out)
232
 
        self.assertEqual('', err)
 
283
        self.assertEqual(b'', 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
 
"""Checkout (format: knit)
 
292
b"""Checkout (format: knit)
242
293
Location:
243
294
       checkout root: checkout
244
295
  checkout of branch: standalone
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
270
324
""" % (branch4.repository._format.get_format_description(),
271
325
       datestring_first, datestring_first,
272
326
       ), out)
273
 
        self.assertEqual('', err)
 
327
        self.assertEqual(b'', err)
274
328
 
275
329
        # Lightweight checkout (same as above, different branch and repository)
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)
310
 
        self.assertEqual('', err)
 
370
""" % (format_description, datestring_first, datestring_first,), out)
 
371
        self.assertEqual(b'', 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
b"""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
353
417
         1 revision
354
418
""" % (datestring_first, datestring_first,
355
419
       ), out)
356
 
        self.assertEqual('', err)
 
420
        self.assertEqual(b'', err)
357
421
 
358
422
        # Out of date bound branch
359
423
        out, err = self.run_bzr('info -v bound')
360
424
        self.assertEqualDiff(
361
 
"""Checkout (format: knit)
 
425
b"""Checkout (format: knit)
362
426
Location:
363
427
       checkout root: bound
364
428
  checkout of branch: standalone
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:
395
462
""" % (branch3.repository._format.get_format_description(),
396
463
       datestring_first, datestring_first,
397
464
       ), out)
398
 
        self.assertEqual('', err)
 
465
        self.assertEqual(b'', err)
399
466
 
400
467
        # Out of date checkout
401
468
        out, err = self.run_bzr('info -v checkout')
402
469
        self.assertEqualDiff(
403
 
"""Checkout (format: knit)
 
470
b"""Checkout (format: knit)
404
471
Location:
405
472
       checkout root: checkout
406
473
  checkout of branch: standalone
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:
434
504
""" % (branch4.repository._format.get_format_description(),
435
505
       datestring_first, datestring_first,
436
506
       ), out)
437
 
        self.assertEqual('', err)
 
507
        self.assertEqual(b'', err)
438
508
 
439
509
        # Out of date lightweight checkout
440
510
        out, err = self.run_bzr('info lightcheckout --verbose')
441
511
        self.assertEqualDiff(
442
 
"""Lightweight checkout (format: %s)
 
512
b"""Lightweight checkout (format: %s)
443
513
Location:
444
514
  light checkout root: lightcheckout
445
515
   checkout of branch: standalone
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)
474
 
        self.assertEqual('', err)
 
546
""" % (format_description, datestring_first, datestring_last,), out)
 
547
        self.assertEqual(b'', 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')
482
555
        self.assertEqualDiff(
483
 
"""Standalone branch (format: %s)
 
556
b"""Standalone branch (format: %s)
484
557
Location:
485
558
  branch root: branch
486
559
 
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),
498
 
       format.get_branch_format().get_format_description(),
499
 
       format.repository_format.get_format_description(),
 
573
""" % (info.describe_format(repo.controldir, repo, branch, None).encode('ascii'),
 
574
       format.get_branch_format().get_format_description().encode('ascii'),
 
575
       format.repository_format.get_format_description().encode('ascii'),
500
576
       ), out)
501
 
        self.assertEqual('', err)
 
577
        self.assertEqual(b'', 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
509
585
        repo.set_make_working_trees(False)
510
586
        out, err = self.run_bzr('info -v repo')
511
587
        self.assertEqualDiff(
512
 
"""Shared repository (format: dirstate or dirstate-tags or knit)
 
588
b"""Shared repository (format: dirstate or dirstate-tags or knit)
513
589
Location:
514
590
  shared repository: %s
515
591
 
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
 
""" % ('repo', format.repository_format.get_format_description(),
 
601
""" % (b'repo', format.repository_format.get_format_description().encode('ascii'),
523
602
       ), out)
524
 
        self.assertEqual('', err)
 
603
        self.assertEqual(b'', 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
 
"""Repository branch (format: dirstate or knit)
 
611
b"""Repository branch (format: dirstate or knit)
533
612
Location:
534
613
  shared repository: repo
535
614
  repository branch: repo/branch
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
 
545
627
Repository:
546
628
         0 revisions
547
 
""" % (format.get_branch_format().get_format_description(),
548
 
       format.repository_format.get_format_description(),
 
629
""" % (format.get_branch_format().get_format_description().encode('ascii'),
 
630
       format.repository_format.get_format_description().encode('ascii'),
549
631
       ), out)
550
 
        self.assertEqual('', err)
 
632
        self.assertEqual(b'', err)
551
633
 
552
634
        # Create lightweight checkout
553
635
        transport.mkdir('tree')
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
605
690
       format.repository_format.get_format_description(),
606
691
       datestring_first, datestring_first,
607
692
       ), out)
608
 
        self.assertEqual('', err)
 
693
        self.assertEqual(b'', err)
609
694
 
610
695
        # Out of date checkout
611
696
        out, err = self.run_bzr('info -v tree/checkout')
612
697
        self.assertEqualDiff(
613
 
"""Checkout (format: unnamed)
 
698
b"""Checkout (format: unnamed)
614
699
Location:
615
700
       checkout root: tree/checkout
616
701
  checkout of branch: repo/branch
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:
641
729
""" % (format.get_branch_format().get_format_description(),
642
730
       format.repository_format.get_format_description(),
643
731
       ), out)
644
 
        self.assertEqual('', err)
 
732
        self.assertEqual(b'', err)
645
733
 
646
734
        # Update checkout
647
735
        tree3.update()
649
737
        tree3.add('b')
650
738
        out, err = self.run_bzr('info tree/checkout --verbose')
651
739
        self.assertEqualDiff(
652
 
"""Checkout (format: unnamed)
 
740
b"""Checkout (format: unnamed)
653
741
Location:
654
742
       checkout root: tree/checkout
655
743
  checkout of branch: repo/branch
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
682
773
       format.repository_format.get_format_description(),
683
774
       datestring_first, datestring_first,
684
775
       ), out)
685
 
        self.assertEqual('', err)
 
776
        self.assertEqual(b'', err)
686
777
        tree3.commit('commit two')
687
778
 
688
779
        # Out of date lightweight checkout
689
 
        rev = repo.get_revision(branch1.revision_history()[-1])
690
 
        datestring_last = osutils.format_date(rev.timestamp, rev.timezone)
 
780
        rev = repo.get_revision(branch1.last_revision())
 
781
        datestring_last = osutils.format_date(rev.timestamp, rev.timezone).encode('ascii')
691
782
        out, err = self.run_bzr('info tree/lightcheckout --verbose')
692
783
        self.assertEqualDiff(
693
 
"""Lightweight checkout (format: %s)
 
784
b"""Lightweight checkout (format: %s)
694
785
Location:
695
786
  light checkout root: tree/lightcheckout
696
787
   checkout of branch: repo/branch
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:
722
816
 
723
817
Repository:
724
818
         2 revisions
725
 
""" % (self._repo_strings, format.get_branch_format().get_format_description(),
726
 
       format.repository_format.get_format_description(),
 
819
""" % (self._repo_strings, format.get_branch_format().get_format_description().encode('ascii'),
 
820
       format.repository_format.get_format_description().encode('ascii'),
727
821
       datestring_first, datestring_last,
728
822
       ), out)
729
 
        self.assertEqual('', err)
 
823
        self.assertEqual(b'', err)
730
824
 
731
825
        # Show info about shared branch
732
826
        out, err = self.run_bzr('info repo/branch --verbose')
733
827
        self.assertEqualDiff(
734
 
"""Repository branch (format: dirstate or knit)
 
828
b"""Repository branch (format: dirstate or knit)
735
829
Location:
736
830
  shared repository: repo
737
831
  repository branch: repo/branch
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
749
846
 
750
847
Repository:
751
848
         2 revisions
752
 
""" % (format.get_branch_format().get_format_description(),
753
 
       format.repository_format.get_format_description(),
 
849
""" % (format.get_branch_format().get_format_description().encode('ascii'),
 
850
       format.repository_format.get_format_description().encode('ascii'),
754
851
       datestring_first, datestring_last,
755
852
       ), out)
756
 
        self.assertEqual('', err)
 
853
        self.assertEqual(b'', err)
757
854
 
758
855
        # Show info about repository with revisions
759
856
        out, err = self.run_bzr('info -v repo')
760
857
        self.assertEqualDiff(
761
 
"""Shared repository (format: dirstate or dirstate-tags or knit)
 
858
b"""Shared repository (format: dirstate or dirstate-tags or knit)
762
859
Location:
763
860
  shared repository: repo
764
861
 
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(),
772
872
       ), out)
773
 
        self.assertEqual('', err)
 
873
        self.assertEqual(b'', 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
781
881
        repo.set_make_working_trees(True)
782
882
        out, err = self.run_bzr('info -v repo')
783
883
        self.assertEqualDiff(
784
 
"""Shared repository with trees (format: dirstate or dirstate-tags or knit)
 
884
b"""Shared repository with trees (format: dirstate or dirstate-tags or knit)
785
885
Location:
786
886
  shared repository: repo
787
887
 
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:
795
898
         0 revisions
796
 
""" % (format.repository_format.get_format_description(),
 
899
""" % (format.repository_format.get_format_description().encode('ascii'),
797
900
       ), out)
798
 
        self.assertEqual('', err)
 
901
        self.assertEqual(b'', 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
835
941
""" % (format.get_branch_format().get_format_description(),
836
942
       format.repository_format.get_format_description(),
837
943
       ), out)
838
 
        self.assertEqual('', err)
 
944
        self.assertEqual(b'', err)
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(
849
 
"""Repository tree (format: knit)
 
955
b"""Repository tree (format: knit)
850
956
Location:
851
957
  shared repository: repo
852
958
  repository branch: repo/branch1
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
879
988
       format.repository_format.get_format_description(),
880
989
       datestring_first, datestring_first,
881
990
       ), out)
882
 
        self.assertEqual('', err)
 
991
        self.assertEqual(b'', err)
883
992
 
884
993
        # Out of date second branch
885
994
        out, err = self.run_bzr('info repo/branch2 --verbose')
886
995
        self.assertEqualDiff(
887
 
"""Repository tree (format: knit)
 
996
b"""Repository tree (format: knit)
888
997
Location:
889
998
  shared repository: repo
890
999
  repository branch: repo/branch2
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
916
1028
""" % (format.get_branch_format().get_format_description(),
917
1029
       format.repository_format.get_format_description(),
918
1030
       ), out)
919
 
        self.assertEqual('', err)
 
1031
        self.assertEqual(b'', 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(
926
 
"""Repository tree (format: knit)
 
1038
b"""Repository tree (format: knit)
927
1039
Location:
928
1040
  shared repository: repo
929
1041
  repository branch: repo/branch2
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
959
1074
       format.repository_format.get_format_description(),
960
1075
       datestring_first, datestring_first,
961
1076
       ), out)
962
 
        self.assertEqual('', err)
 
1077
        self.assertEqual(b'', err)
963
1078
 
964
1079
        # Show info about repository with revisions
965
1080
        out, err = self.run_bzr('info -v repo')
966
1081
        self.assertEqualDiff(
967
 
"""Shared repository with trees (format: dirstate or dirstate-tags or knit)
 
1082
b"""Shared repository with trees (format: dirstate or dirstate-tags or knit)
968
1083
Location:
969
1084
  shared repository: repo
970
1085
 
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:
979
1097
""" % (format.repository_format.get_format_description(),
980
1098
       ),
981
1099
       out)
982
 
        self.assertEqual('', err)
 
1100
        self.assertEqual(b'', 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
990
1108
        repo.set_make_working_trees(True)
991
1109
        out, err = self.run_bzr('info -v repo')
992
1110
        self.assertEqualDiff(
993
 
"""Shared repository with trees (format: dirstate or dirstate-tags or knit)
 
1111
b"""Shared repository with trees (format: dirstate or dirstate-tags or knit)
994
1112
Location:
995
1113
  shared repository: repo
996
1114
 
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:
1004
1125
         0 revisions
1005
 
""" % (format.repository_format.get_format_description(),
 
1126
""" % (format.repository_format.get_format_description().encode('ascii'),
1006
1127
       ), out)
1007
 
        self.assertEqual('', err)
 
1128
        self.assertEqual(b'', 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')
1014
1135
        self.assertEqualDiff(
1015
 
"""Repository tree (format: knit)
 
1136
b"""Repository tree (format: knit)
1016
1137
Location:
1017
1138
  shared repository: repo
1018
1139
  repository branch: 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
1038
1162
 
1039
1163
Repository:
1040
1164
         0 revisions
1041
 
""" % (format.get_branch_format().get_format_description(),
1042
 
       format.repository_format.get_format_description(),
 
1165
""" % (format.get_branch_format().get_format_description().encode('ascii'),
 
1166
       format.repository_format.get_format_description().encode('ascii'),
1043
1167
       ), out)
1044
 
        self.assertEqual('', err)
 
1168
        self.assertEqual(b'', 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)
1053
1177
        out, err = self.run_bzr('info -v repo')
1054
1178
        self.assertEqualDiff(
1055
 
"""Shared repository with trees (format: dirstate or dirstate-tags or knit)
 
1179
b"""Shared repository with trees (format: dirstate or dirstate-tags or knit)
1056
1180
Location:
1057
1181
  shared repository: repo
1058
1182
 
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:
1066
1193
         0 revisions
1067
1194
more info
1068
 
""" % (format.repository_format.get_format_description(),
 
1195
""" % (format.repository_format.get_format_description().encode('ascii'),
1069
1196
       ), out)
1070
 
        self.assertEqual('', err)
 
1197
        self.assertEqual(b'', err)
 
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
b"""Unshared repository with trees and colocated branches (format: development-colo)
 
1210
Location:
 
1211
  repository: repo
 
1212
""", out)
 
1213
        self.assertEqual(b'', err)
1071
1214
 
1072
1215
    def assertCheckoutStatusOutput(self,
1073
1216
        command_string, lco_tree, shared_repo=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
1208
1354
        expected_lock_output,
1209
1355
        verbose_info,
1210
1356
        ), out)
1211
 
        self.assertEqual('', err)
 
1357
        self.assertEqual(b'', err)
1212
1358
 
1213
1359
    def test_info_locking(self):
1214
1360
        transport = self.get_transport()
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
 
"""Standalone tree (format: 1.6)
 
1480
b"""Standalone tree (format: 1.6)
1419
1481
Location:
1420
1482
  branch root: newbranch
1421
1483
 
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
b"""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(b"", 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(b"", 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)