← 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: Martin Pool
  • Date: 2009-09-14 01:19:11 UTC
  • mto: This revision was merged to the branch mainline in revision 4688.
  • Revision ID: mbp@sourcefrog.net-20090914011911-llu9ujul97k8f8s7
https://launchpad.net/bugs/406113
News for fix of 406113

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_info.py
1
 
# Copyright (C) 2006 by Canonical Ltd
2
 
# -*- coding: utf-8 -*-
 
1
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
3
2
#
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
13
12
#
14
13
# You should have received a copy of the GNU General Public License
15
14
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
16
 
18
17
 
19
18
"""Tests for the info command of bzr."""
20
19
 
21
20
import sys
22
21
 
23
 
import bzrlib
 
22
from bzrlib import (
 
23
    branch,
 
24
    bzrdir,
 
25
    errors,
 
26
    info,
 
27
    osutils,
 
28
    upgrade,
 
29
    urlutils,
 
30
    )
24
31
from bzrlib.osutils import format_date
25
32
from bzrlib.tests import TestSkipped
26
33
from bzrlib.tests.blackbox import ExternalBase
33
40
            location = "C:/i/do/not/exist/"
34
41
        else:
35
42
            location = "/i/do/not/exist/"
36
 
        out, err = self.runbzr('info '+location, retcode=3)
 
43
        out, err = self.run_bzr('info '+location, retcode=3)
37
44
        self.assertEqual(out, '')
38
 
        self.assertEqual(err, 'bzr: ERROR: Not a branch: %s\n' % location)
 
45
        self.assertEqual(err, 'bzr: ERROR: Not a branch: "%s".\n' % location)
39
46
 
40
47
    def test_info_standalone(self):
41
48
        transport = self.get_transport()
42
49
 
43
50
        # Create initial standalone branch
44
 
        old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
45
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(bzrlib.bzrdir.BzrDirFormat6())
46
 
        tree1 = self.make_branch_and_tree('standalone')
47
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
 
51
        tree1 = self.make_branch_and_tree('standalone', 'weave')
48
52
        self.build_tree(['standalone/a'])
49
53
        tree1.add('a')
50
54
        branch1 = tree1.branch
51
 
        out, err = self.runbzr('info standalone')
52
 
        self.assertEqualDiff(
53
 
"""Location:
54
 
  branch root: %s
55
 
 
56
 
Format:
57
 
       control: All-in-one format 6
58
 
  working tree: Working tree format 2
59
 
        branch: Branch format 4
60
 
    repository: Weave repository format 6
61
 
 
62
 
In the working tree:
63
 
         0 unchanged
64
 
         0 modified
65
 
         1 added
66
 
         0 removed
67
 
         0 renamed
68
 
         0 unknown
69
 
         0 ignored
70
 
         0 versioned subdirectories
71
 
 
72
 
Branch history:
73
 
         0 revisions
74
 
 
75
 
Revision store:
76
 
         0 revisions
77
 
         0 KiB
78
 
""" % branch1.bzrdir.root_transport.base, out)
 
55
 
 
56
        out, err = self.run_bzr('info standalone')
 
57
        self.assertEqualDiff(
 
58
"""Standalone tree (format: weave)
 
59
Location:
 
60
  branch root: standalone
 
61
""", out)
 
62
        self.assertEqual('', err)
 
63
 
 
64
        # Standalone branch - verbose mode
 
65
        out, err = self.run_bzr('info standalone -v')
 
66
        self.assertEqualDiff(
 
67
"""Standalone tree (format: weave)
 
68
Location:
 
69
  branch root: standalone
 
70
 
 
71
Format:
 
72
       control: All-in-one format 6
 
73
  working tree: Working tree format 2
 
74
        branch: Branch format 4
 
75
    repository: Weave repository format 6
 
76
 
 
77
In the working tree:
 
78
         0 unchanged
 
79
         0 modified
 
80
         1 added
 
81
         0 removed
 
82
         0 renamed
 
83
         0 unknown
 
84
         0 ignored
 
85
         0 versioned subdirectories
 
86
 
 
87
Branch history:
 
88
         0 revisions
 
89
 
 
90
Repository:
 
91
         0 revisions
 
92
""", out)
 
93
        self.assertEqual('', err)
 
94
 
 
95
        # Standalone branch - really verbose mode
 
96
        out, err = self.run_bzr('info standalone -vv')
 
97
        self.assertEqualDiff(
 
98
"""Standalone tree (format: weave)
 
99
Location:
 
100
  branch root: standalone
 
101
 
 
102
Format:
 
103
       control: All-in-one format 6
 
104
  working tree: Working tree format 2
 
105
        branch: Branch format 4
 
106
    repository: Weave repository format 6
 
107
 
 
108
In the working tree:
 
109
         0 unchanged
 
110
         0 modified
 
111
         1 added
 
112
         0 removed
 
113
         0 renamed
 
114
         0 unknown
 
115
         0 ignored
 
116
         0 versioned subdirectories
 
117
 
 
118
Branch history:
 
119
         0 revisions
 
120
         0 committers
 
121
 
 
122
Repository:
 
123
         0 revisions
 
124
""", out)
79
125
        self.assertEqual('', err)
80
126
        tree1.commit('commit one')
81
127
        rev = branch1.repository.get_revision(branch1.revision_history()[0])
84
130
        # Branch standalone with push location
85
131
        branch2 = branch1.bzrdir.sprout('branch').open_branch()
86
132
        branch2.set_push_location(branch1.bzrdir.root_transport.base)
87
 
        out, err = self.runbzr('info branch --verbose')
88
 
        self.assertEqualDiff(
89
 
"""Location:
90
 
  branch root: %s
91
 
 
92
 
Related branches:
93
 
      parent branch: %s
94
 
  publish to branch: %s
 
133
 
 
134
        out, err = self.run_bzr('info branch')
 
135
        self.assertEqualDiff(
 
136
"""Standalone tree (format: weave)
 
137
Location:
 
138
  branch root: branch
 
139
 
 
140
Related branches:
 
141
    push branch: standalone
 
142
  parent branch: standalone
 
143
""", out)
 
144
        self.assertEqual('', err)
 
145
 
 
146
        out, err = self.run_bzr('info branch --verbose')
 
147
        self.assertEqualDiff(
 
148
"""Standalone tree (format: weave)
 
149
Location:
 
150
  branch root: branch
 
151
 
 
152
Related branches:
 
153
    push branch: standalone
 
154
  parent branch: standalone
95
155
 
96
156
Format:
97
157
       control: All-in-one format 6
111
171
 
112
172
Branch history:
113
173
         1 revision
114
 
         1 committer
115
174
         0 days old
116
175
   first revision: %s
117
176
  latest revision: %s
118
177
 
119
 
Revision store:
 
178
Repository:
120
179
         1 revision
121
 
         %d KiB
122
 
""" % (branch2.bzrdir.root_transport.base,
123
 
       branch1.bzrdir.root_transport.base,
124
 
       branch1.bzrdir.root_transport.base,
125
 
       datestring_first, datestring_first,
126
 
       # poking at _revision_store isn't all that clean, but neither is
127
 
       # having the ui test dependent on the exact overhead of a given store.
128
 
       branch2.repository._revision_store.total_size(
129
 
        branch2.repository.get_transaction())[1] / 1024,
 
180
""" % (datestring_first, datestring_first,
130
181
       ), out)
131
182
        self.assertEqual('', err)
132
183
 
133
184
        # Branch and bind to standalone, needs upgrade to metadir
134
185
        # (creates backup as unknown)
135
186
        branch1.bzrdir.sprout('bound')
136
 
        bzrlib.upgrade.upgrade('bound', bzrlib.bzrdir.BzrDirMetaFormat1())
137
 
        branch3 = bzrlib.bzrdir.BzrDir.open('bound').open_branch()
 
187
        knit1_format = bzrdir.format_registry.make_bzrdir('knit')
 
188
        upgrade.upgrade('bound', knit1_format)
 
189
        branch3 = bzrdir.BzrDir.open('bound').open_branch()
138
190
        branch3.bind(branch1)
139
191
        bound_tree = branch3.bzrdir.open_workingtree()
140
 
        out, err = self.runbzr('info bound')
 
192
        out, err = self.run_bzr('info -v bound')
141
193
        self.assertEqualDiff(
142
 
"""Location:
143
 
       checkout root: %s
144
 
  checkout of branch: %s
 
194
"""Checkout (format: knit)
 
195
Location:
 
196
       checkout root: bound
 
197
  checkout of branch: standalone
145
198
 
146
199
Related branches:
147
 
  parent branch: %s
 
200
  parent branch: standalone
148
201
 
149
202
Format:
150
203
       control: Meta directory format 1
151
204
  working tree: %s
152
 
        branch: Branch format 5
 
205
        branch: %s
153
206
    repository: %s
154
207
 
155
208
In the working tree:
168
221
   first revision: %s
169
222
  latest revision: %s
170
223
 
171
 
Revision store:
 
224
Repository:
172
225
         1 revision
173
 
         %d KiB
174
 
""" % (branch3.bzrdir.root_transport.base,
175
 
       branch1.bzrdir.root_transport.base,
176
 
       branch1.bzrdir.root_transport.base,
177
 
       bound_tree._format.get_format_description(),      
 
226
""" % (bound_tree._format.get_format_description(),
 
227
       branch3._format.get_format_description(),
178
228
       branch3.repository._format.get_format_description(),
179
229
       datestring_first, datestring_first,
180
 
       # poking at _revision_store isn't all that clean, but neither is
181
 
       # having the ui test dependent on the exact overhead of a given store.
182
 
       branch3.repository._revision_store.total_size(
183
 
        branch3.repository.get_transaction())[1] / 1024,
184
230
       ), out)
185
231
        self.assertEqual('', err)
186
232
 
187
233
        # Checkout standalone (same as above, but does not have parent set)
188
 
        old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
189
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(bzrlib.bzrdir.BzrDirMetaFormat1())
190
 
        branch4 = bzrlib.bzrdir.BzrDir.create_branch_convenience('checkout')
191
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
 
234
        branch4 = bzrdir.BzrDir.create_branch_convenience('checkout',
 
235
            format=knit1_format)
192
236
        branch4.bind(branch1)
193
237
        branch4.bzrdir.open_workingtree().update()
194
 
        out, err = self.runbzr('info checkout --verbose')
 
238
        out, err = self.run_bzr('info checkout --verbose')
195
239
        self.assertEqualDiff(
196
 
"""Location:
197
 
       checkout root: %s
198
 
  checkout of branch: %s
 
240
"""Checkout (format: knit)
 
241
Location:
 
242
       checkout root: checkout
 
243
  checkout of branch: standalone
199
244
 
200
245
Format:
201
246
       control: Meta directory format 1
215
260
 
216
261
Branch history:
217
262
         1 revision
218
 
         1 committer
219
263
         0 days old
220
264
   first revision: %s
221
265
  latest revision: %s
222
266
 
223
 
Revision store:
 
267
Repository:
224
268
         1 revision
225
 
         %d KiB
226
 
""" % (branch4.bzrdir.root_transport.base,
227
 
       branch1.bzrdir.root_transport.base,
228
 
       branch4.repository._format.get_format_description(),
 
269
""" % (branch4.repository._format.get_format_description(),
229
270
       datestring_first, datestring_first,
230
 
       # poking at _revision_store isn't all that clean, but neither is
231
 
       # having the ui test dependent on the exact overhead of a given store.
232
 
       branch4.repository._revision_store.total_size(
233
 
        branch4.repository.get_transaction())[1] / 1024,
234
271
       ), out)
235
272
        self.assertEqual('', err)
236
273
 
237
274
        # Lightweight checkout (same as above, different branch and repository)
238
 
        old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
239
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(bzrlib.bzrdir.BzrDirMetaFormat1())
240
 
        transport.mkdir('lightcheckout')
241
 
        dir5 = bzrlib.bzrdir.BzrDirMetaFormat1().initialize('lightcheckout')
242
 
        bzrlib.branch.BranchReferenceFormat().initialize(dir5, branch1)
243
 
        dir5.create_workingtree()
244
 
        tree5 = dir5.open_workingtree()
245
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
 
275
        tree5 = branch1.create_checkout('lightcheckout', lightweight=True)
246
276
        branch5 = tree5.branch
247
 
        out, err = self.runbzr('info lightcheckout')
 
277
        out, err = self.run_bzr('info -v lightcheckout')
248
278
        self.assertEqualDiff(
249
 
"""Location:
250
 
 light checkout root: %s
251
 
  checkout of branch: %s
 
279
"""Lightweight checkout (format: 1.6 or 1.6.1-rich-root \
 
280
or 1.9 or 1.9-rich-root \
 
281
or dirstate or dirstate-tags or \
 
282
pack-0.92 or rich-root or rich-root-pack)
 
283
Location:
 
284
  light checkout root: lightcheckout
 
285
   checkout of branch: standalone
252
286
 
253
287
Format:
254
288
       control: Meta directory format 1
255
 
  working tree: Working tree format 3
 
289
  working tree: Working tree format 4
256
290
        branch: Branch format 4
257
291
    repository: Weave repository format 6
258
292
 
272
306
   first revision: %s
273
307
  latest revision: %s
274
308
 
275
 
Revision store:
 
309
Repository:
276
310
         1 revision
277
 
         0 KiB
278
 
""" % (tree5.bzrdir.root_transport.base,
279
 
       branch1.bzrdir.root_transport.base,
280
 
       datestring_first, datestring_first,
281
 
       ), out)
 
311
""" % (datestring_first, datestring_first,), out)
282
312
        self.assertEqual('', err)
283
313
 
284
314
        # Update initial standalone branch
289
319
        datestring_last = format_date(rev.timestamp, rev.timezone)
290
320
 
291
321
        # Out of date branched standalone branch will not be detected
292
 
        out, err = self.runbzr('info branch')
 
322
        out, err = self.run_bzr('info -v branch')
293
323
        self.assertEqualDiff(
294
 
"""Location:
295
 
  branch root: %s
 
324
"""Standalone tree (format: weave)
 
325
Location:
 
326
  branch root: branch
296
327
 
297
328
Related branches:
298
 
      parent branch: %s
299
 
  publish to branch: %s
 
329
    push branch: standalone
 
330
  parent branch: standalone
300
331
 
301
332
Format:
302
333
       control: All-in-one format 6
320
351
   first revision: %s
321
352
  latest revision: %s
322
353
 
323
 
Revision store:
 
354
Repository:
324
355
         1 revision
325
 
         0 KiB
326
 
""" % (branch2.bzrdir.root_transport.base,
327
 
       branch1.bzrdir.root_transport.base,
328
 
       branch1.bzrdir.root_transport.base,
329
 
       datestring_first, datestring_first,
 
356
""" % (datestring_first, datestring_first,
330
357
       ), out)
331
358
        self.assertEqual('', err)
332
359
 
333
360
        # Out of date bound branch
334
 
        out, err = self.runbzr('info bound')
 
361
        out, err = self.run_bzr('info -v bound')
335
362
        self.assertEqualDiff(
336
 
"""Location:
337
 
       checkout root: %s
338
 
  checkout of branch: %s
 
363
"""Checkout (format: knit)
 
364
Location:
 
365
       checkout root: bound
 
366
  checkout of branch: standalone
339
367
 
340
368
Related branches:
341
 
  parent branch: %s
 
369
  parent branch: standalone
342
370
 
343
371
Format:
344
372
       control: Meta directory format 1
364
392
   first revision: %s
365
393
  latest revision: %s
366
394
 
367
 
Revision store:
 
395
Repository:
368
396
         1 revision
369
 
         %d KiB
370
 
""" % (branch3.bzrdir.root_transport.base,
371
 
       branch1.bzrdir.root_transport.base,
372
 
       branch1.bzrdir.root_transport.base,
373
 
       branch3.repository._format.get_format_description(),
 
397
""" % (branch3.repository._format.get_format_description(),
374
398
       datestring_first, datestring_first,
375
 
       # poking at _revision_store isn't all that clean, but neither is
376
 
       # having the ui test dependent on the exact overhead of a given store.
377
 
       branch3.repository._revision_store.total_size(
378
 
        branch3.repository.get_transaction())[1] / 1024,
379
399
       ), out)
380
400
        self.assertEqual('', err)
381
401
 
382
402
        # Out of date checkout
383
 
        out, err = self.runbzr('info checkout')
 
403
        out, err = self.run_bzr('info -v checkout')
384
404
        self.assertEqualDiff(
385
 
"""Location:
386
 
       checkout root: %s
387
 
  checkout of branch: %s
 
405
"""Checkout (format: knit)
 
406
Location:
 
407
       checkout root: checkout
 
408
  checkout of branch: standalone
388
409
 
389
410
Format:
390
411
       control: Meta directory format 1
410
431
   first revision: %s
411
432
  latest revision: %s
412
433
 
413
 
Revision store:
 
434
Repository:
414
435
         1 revision
415
 
         %d KiB
416
 
""" % (branch4.bzrdir.root_transport.base,
417
 
       branch1.bzrdir.root_transport.base,
418
 
       branch4.repository._format.get_format_description(),
 
436
""" % (branch4.repository._format.get_format_description(),
419
437
       datestring_first, datestring_first,
420
 
       # poking at _revision_store isn't all that clean, but neither is
421
 
       # having the ui test dependent on the exact overhead of a given store.
422
 
       branch4.repository._revision_store.total_size(
423
 
        branch4.repository.get_transaction())[1] / 1024,
424
438
       ), out)
425
439
        self.assertEqual('', err)
426
440
 
427
441
        # Out of date lightweight checkout
428
 
        out, err = self.runbzr('info lightcheckout --verbose')
 
442
        out, err = self.run_bzr('info lightcheckout --verbose')
429
443
        self.assertEqualDiff(
430
 
"""Location:
431
 
 light checkout root: %s
432
 
  checkout of branch: %s
 
444
"""Lightweight checkout (format: 1.6 or 1.6.1-rich-root or \
 
445
1.9 or 1.9-rich-root or \
 
446
dirstate or dirstate-tags or \
 
447
pack-0.92 or rich-root or rich-root-pack)
 
448
Location:
 
449
  light checkout root: lightcheckout
 
450
   checkout of branch: standalone
433
451
 
434
452
Format:
435
453
       control: Meta directory format 1
436
 
  working tree: Working tree format 3
 
454
  working tree: Working tree format 4
437
455
        branch: Branch format 4
438
456
    repository: Weave repository format 6
439
457
 
451
469
 
452
470
Branch history:
453
471
         2 revisions
454
 
         1 committer
455
472
         0 days old
456
473
   first revision: %s
457
474
  latest revision: %s
458
475
 
459
 
Revision store:
 
476
Repository:
460
477
         2 revisions
461
 
         0 KiB
462
 
""" % (tree5.bzrdir.root_transport.base,
463
 
       branch1.bzrdir.root_transport.base,
464
 
       datestring_first, datestring_last,
465
 
       ), out)
 
478
""" % (datestring_first, datestring_last,), out)
466
479
        self.assertEqual('', err)
467
480
 
468
481
    def test_info_standalone_no_tree(self):
469
482
        # create standalone branch without a working tree
 
483
        format = bzrdir.format_registry.make_bzrdir('default')
470
484
        branch = self.make_branch('branch')
471
485
        repo = branch.repository
472
 
        out, err = self.runbzr('info branch')
 
486
        out, err = self.run_bzr('info branch -v')
473
487
        self.assertEqualDiff(
474
 
"""Location:
475
 
  branch root: %s
 
488
"""Standalone branch (format: %s)
 
489
Location:
 
490
  branch root: branch
476
491
 
477
492
Format:
478
493
       control: Meta directory format 1
479
 
        branch: Branch format 5
 
494
        branch: %s
480
495
    repository: %s
481
496
 
482
497
Branch history:
483
498
         0 revisions
484
499
 
485
 
Revision store:
 
500
Repository:
486
501
         0 revisions
487
 
         0 KiB
488
 
""" % (branch.bzrdir.root_transport.base,
489
 
       repo._format.get_format_description(),
 
502
""" % (info.describe_format(repo.bzrdir, repo, branch, None),
 
503
       format.get_branch_format().get_format_description(),
 
504
       format.repository_format.get_format_description(),
490
505
       ), out)
491
506
        self.assertEqual('', err)
492
507
 
493
508
    def test_info_shared_repository(self):
494
 
        old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
495
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(bzrlib.bzrdir.BzrDirMetaFormat1())
 
509
        format = bzrdir.format_registry.make_bzrdir('knit')
496
510
        transport = self.get_transport()
497
511
 
498
512
        # Create shared repository
499
 
        repo = self.make_repository('repo', shared=True)
 
513
        repo = self.make_repository('repo', shared=True, format=format)
500
514
        repo.set_make_working_trees(False)
501
 
        out, err = self.runbzr('info repo')
 
515
        out, err = self.run_bzr('info -v repo')
502
516
        self.assertEqualDiff(
503
 
"""Location:
 
517
"""Shared repository (format: dirstate or dirstate-tags or knit)
 
518
Location:
504
519
  shared repository: %s
505
520
 
506
521
Format:
507
522
       control: Meta directory format 1
508
523
    repository: %s
509
524
 
510
 
Revision store:
 
525
Repository:
511
526
         0 revisions
512
 
         0 KiB
513
 
""" % (repo.bzrdir.root_transport.base,
514
 
       repo._format.get_format_description(),
 
527
""" % ('repo', format.repository_format.get_format_description(),
515
528
       ), out)
516
529
        self.assertEqual('', err)
517
530
 
518
531
        # Create branch inside shared repository
519
532
        repo.bzrdir.root_transport.mkdir('branch')
520
 
        branch1 = repo.bzrdir.create_branch_convenience('repo/branch')
521
 
        out, err = self.runbzr('info repo/branch')
 
533
        branch1 = repo.bzrdir.create_branch_convenience('repo/branch',
 
534
            format=format)
 
535
        out, err = self.run_bzr('info -v repo/branch')
522
536
        self.assertEqualDiff(
523
 
"""Location:
524
 
  shared repository: %s
525
 
  repository branch: branch
 
537
"""Repository branch (format: dirstate or knit)
 
538
Location:
 
539
  shared repository: repo
 
540
  repository branch: repo/branch
526
541
 
527
542
Format:
528
543
       control: Meta directory format 1
529
 
        branch: Branch format 5
 
544
        branch: %s
530
545
    repository: %s
531
546
 
532
547
Branch history:
533
548
         0 revisions
534
549
 
535
 
Revision store:
 
550
Repository:
536
551
         0 revisions
537
 
         0 KiB
538
 
""" % (repo.bzrdir.root_transport.base,
539
 
       repo._format.get_format_description(),
 
552
""" % (format.get_branch_format().get_format_description(),
 
553
       format.repository_format.get_format_description(),
540
554
       ), out)
541
555
        self.assertEqual('', err)
542
556
 
543
557
        # Create lightweight checkout
544
558
        transport.mkdir('tree')
545
559
        transport.mkdir('tree/lightcheckout')
546
 
        dir2 = bzrlib.bzrdir.BzrDirMetaFormat1().initialize('tree/lightcheckout')
547
 
        bzrlib.branch.BranchReferenceFormat().initialize(dir2, branch1)
548
 
        dir2.create_workingtree()
549
 
        tree2 = dir2.open_workingtree()
 
560
        tree2 = branch1.create_checkout('tree/lightcheckout',
 
561
            lightweight=True)
550
562
        branch2 = tree2.branch
551
 
        self.assertCheckoutStatusOutput('tree/lightcheckout', tree2, shared_repo=repo)
 
563
        self.assertCheckoutStatusOutput('-v tree/lightcheckout', tree2,
 
564
                   shared_repo=repo, repo_branch=branch1, verbose=True)
552
565
 
553
566
        # Create normal checkout
554
567
        tree3 = branch1.create_checkout('tree/checkout')
561
574
        tree2.commit('commit one')
562
575
        rev = repo.get_revision(branch2.revision_history()[0])
563
576
        datestring_first = format_date(rev.timestamp, rev.timezone)
564
 
        out, err = self.runbzr('info tree/lightcheckout --verbose')
 
577
        out, err = self.run_bzr('info tree/lightcheckout --verbose')
565
578
        self.assertEqualDiff(
566
 
"""Location:
567
 
 light checkout root: %s
568
 
   shared repository: %s
569
 
   repository branch: branch
 
579
"""Lightweight checkout (format: 1.6 or 1.6.1-rich-root or \
 
580
1.9 or 1.9-rich-root or \
 
581
dirstate or dirstate-tags or \
 
582
pack-0.92 or rich-root or rich-root-pack)
 
583
Location:
 
584
  light checkout root: tree/lightcheckout
 
585
   checkout of branch: repo/branch
 
586
    shared repository: repo
570
587
 
571
588
Format:
572
589
       control: Meta directory format 1
573
 
  working tree: Working tree format 3
574
 
        branch: Branch format 5
 
590
  working tree: Working tree format 4
 
591
        branch: %s
575
592
    repository: %s
576
593
 
577
594
In the working tree:
586
603
 
587
604
Branch history:
588
605
         1 revision
589
 
         1 committer
590
606
         0 days old
591
607
   first revision: %s
592
608
  latest revision: %s
593
609
 
594
 
Revision store:
 
610
Repository:
595
611
         1 revision
596
 
         %d KiB
597
 
""" % (tree2.bzrdir.root_transport.base,
598
 
       repo.bzrdir.root_transport.base,
599
 
       repo._format.get_format_description(),
 
612
""" % (format.get_branch_format().get_format_description(),
 
613
       format.repository_format.get_format_description(),
600
614
       datestring_first, datestring_first,
601
 
       # poking at _revision_store isn't all that clean, but neither is
602
 
       # having the ui test dependent on the exact overhead of a given store.
603
 
       repo._revision_store.total_size(repo.get_transaction())[1] / 1024,
604
615
       ), out)
605
616
        self.assertEqual('', err)
606
617
 
607
618
        # Out of date checkout
608
 
        out, err = self.runbzr('info tree/checkout')
 
619
        out, err = self.run_bzr('info -v tree/checkout')
609
620
        self.assertEqualDiff(
610
 
"""Location:
611
 
       checkout root: %s
612
 
  checkout of branch: %s
 
621
"""Checkout (format: dirstate)
 
622
Location:
 
623
       checkout root: tree/checkout
 
624
  checkout of branch: repo/branch
613
625
 
614
626
Format:
615
627
       control: Meta directory format 1
616
 
  working tree: Working tree format 3
617
 
        branch: Branch format 5
 
628
  working tree: Working tree format 4
 
629
        branch: %s
618
630
    repository: %s
619
631
 
620
632
Branch is out of date: missing 1 revision.
632
644
Branch history:
633
645
         0 revisions
634
646
 
635
 
Revision store:
 
647
Repository:
636
648
         0 revisions
637
 
         0 KiB
638
 
""" % (tree3.bzrdir.root_transport.base,
639
 
       branch1.bzrdir.root_transport.base,
640
 
       repo._format.get_format_description(),
 
649
""" % (format.get_branch_format().get_format_description(),
 
650
       format.repository_format.get_format_description(),
641
651
       ), out)
642
652
        self.assertEqual('', err)
643
653
 
645
655
        tree3.update()
646
656
        self.build_tree(['tree/checkout/b'])
647
657
        tree3.add('b')
648
 
        out, err = self.runbzr('info tree/checkout --verbose')
 
658
        out, err = self.run_bzr('info tree/checkout --verbose')
649
659
        self.assertEqualDiff(
650
 
"""Location:
651
 
       checkout root: %s
652
 
  checkout of branch: %s
 
660
"""Checkout (format: dirstate)
 
661
Location:
 
662
       checkout root: tree/checkout
 
663
  checkout of branch: repo/branch
653
664
 
654
665
Format:
655
666
       control: Meta directory format 1
656
 
  working tree: Working tree format 3
657
 
        branch: Branch format 5
 
667
  working tree: Working tree format 4
 
668
        branch: %s
658
669
    repository: %s
659
670
 
660
671
In the working tree:
669
680
 
670
681
Branch history:
671
682
         1 revision
672
 
         1 committer
673
683
         0 days old
674
684
   first revision: %s
675
685
  latest revision: %s
676
686
 
677
 
Revision store:
 
687
Repository:
678
688
         1 revision
679
 
         %d KiB
680
 
""" % (tree3.bzrdir.root_transport.base, branch1.bzrdir.root_transport.base,
681
 
       repo._format.get_format_description(),
 
689
""" % (format.get_branch_format().get_format_description(),
 
690
       format.repository_format.get_format_description(),
682
691
       datestring_first, datestring_first,
683
 
       # poking at _revision_store isn't all that clean, but neither is
684
 
       # having the ui test dependent on the exact overhead of a given store.
685
 
       repo._revision_store.total_size(repo.get_transaction())[1] / 1024,
686
692
       ), out)
687
693
        self.assertEqual('', err)
688
694
        tree3.commit('commit two')
690
696
        # Out of date lightweight checkout
691
697
        rev = repo.get_revision(branch1.revision_history()[-1])
692
698
        datestring_last = format_date(rev.timestamp, rev.timezone)
693
 
        out, err = self.runbzr('info tree/lightcheckout --verbose')
 
699
        out, err = self.run_bzr('info tree/lightcheckout --verbose')
694
700
        self.assertEqualDiff(
695
 
"""Location:
696
 
 light checkout root: %s
697
 
   shared repository: %s
698
 
   repository branch: branch
 
701
"""Lightweight checkout (format: 1.6 or 1.6.1-rich-root or \
 
702
1.9 or 1.9-rich-root or \
 
703
dirstate or dirstate-tags or \
 
704
pack-0.92 or rich-root or rich-root-pack)
 
705
Location:
 
706
  light checkout root: tree/lightcheckout
 
707
   checkout of branch: repo/branch
 
708
    shared repository: repo
699
709
 
700
710
Format:
701
711
       control: Meta directory format 1
702
 
  working tree: Working tree format 3
703
 
        branch: Branch format 5
 
712
  working tree: Working tree format 4
 
713
        branch: %s
704
714
    repository: %s
705
715
 
706
716
Working tree is out of date: missing 1 revision.
717
727
 
718
728
Branch history:
719
729
         2 revisions
720
 
         1 committer
721
730
         0 days old
722
731
   first revision: %s
723
732
  latest revision: %s
724
733
 
725
 
Revision store:
 
734
Repository:
726
735
         2 revisions
727
 
         %d KiB
728
 
""" % (tree2.bzrdir.root_transport.base,
729
 
       repo.bzrdir.root_transport.base,
730
 
       repo._format.get_format_description(),
 
736
""" % (format.get_branch_format().get_format_description(),
 
737
       format.repository_format.get_format_description(),
731
738
       datestring_first, datestring_last,
732
 
       # poking at _revision_store isn't all that clean, but neither is
733
 
       # having the ui test dependent on the exact overhead of a given store.
734
 
       repo._revision_store.total_size(repo.get_transaction())[1] / 1024,
735
739
       ), out)
736
740
        self.assertEqual('', err)
737
741
 
738
742
        # Show info about shared branch
739
 
        out, err = self.runbzr('info repo/branch --verbose')
 
743
        out, err = self.run_bzr('info repo/branch --verbose')
740
744
        self.assertEqualDiff(
741
 
"""Location:
742
 
  shared repository: %s
743
 
  repository branch: branch
 
745
"""Repository branch (format: dirstate or knit)
 
746
Location:
 
747
  shared repository: repo
 
748
  repository branch: repo/branch
744
749
 
745
750
Format:
746
751
       control: Meta directory format 1
747
 
        branch: Branch format 5
 
752
        branch: %s
748
753
    repository: %s
749
754
 
750
755
Branch history:
751
756
         2 revisions
752
 
         1 committer
753
757
         0 days old
754
758
   first revision: %s
755
759
  latest revision: %s
756
760
 
757
 
Revision store:
 
761
Repository:
758
762
         2 revisions
759
 
         %d KiB
760
 
""" % (repo.bzrdir.root_transport.base,
761
 
       repo._format.get_format_description(),
 
763
""" % (format.get_branch_format().get_format_description(),
 
764
       format.repository_format.get_format_description(),
762
765
       datestring_first, datestring_last,
763
 
       # poking at _revision_store isn't all that clean, but neither is
764
 
       # having the ui test dependent on the exact overhead of a given store.
765
 
       repo._revision_store.total_size(repo.get_transaction())[1] / 1024,
766
766
       ), out)
767
767
        self.assertEqual('', err)
768
768
 
769
769
        # Show info about repository with revisions
770
 
        out, err = self.runbzr('info repo')
 
770
        out, err = self.run_bzr('info -v repo')
771
771
        self.assertEqualDiff(
772
 
"""Location:
773
 
  shared repository: %s
 
772
"""Shared repository (format: dirstate or dirstate-tags or knit)
 
773
Location:
 
774
  shared repository: repo
774
775
 
775
776
Format:
776
777
       control: Meta directory format 1
777
778
    repository: %s
778
779
 
779
 
Revision store:
 
780
Repository:
780
781
         2 revisions
781
 
         %d KiB
782
 
""" % (repo.bzrdir.root_transport.base,
783
 
       repo._format.get_format_description(),
784
 
       # poking at _revision_store isn't all that clean, but neither is
785
 
       # having the ui test dependent on the exact overhead of a given store.
786
 
       repo._revision_store.total_size(repo.get_transaction())[1] / 1024,
 
782
""" % (format.repository_format.get_format_description(),
787
783
       ), out)
788
784
        self.assertEqual('', err)
789
785
 
790
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
791
 
 
792
786
    def test_info_shared_repository_with_trees(self):
793
 
        old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
794
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(bzrlib.bzrdir.BzrDirMetaFormat1())
 
787
        format = bzrdir.format_registry.make_bzrdir('knit')
795
788
        transport = self.get_transport()
796
789
 
797
790
        # Create shared repository with working trees
798
 
        repo = self.make_repository('repo', shared=True)
 
791
        repo = self.make_repository('repo', shared=True, format=format)
799
792
        repo.set_make_working_trees(True)
800
 
        out, err = self.runbzr('info repo')
 
793
        out, err = self.run_bzr('info -v repo')
801
794
        self.assertEqualDiff(
802
 
"""Location:
803
 
  shared repository: %s
 
795
"""Shared repository with trees (format: dirstate or dirstate-tags or knit)
 
796
Location:
 
797
  shared repository: repo
804
798
 
805
799
Format:
806
800
       control: Meta directory format 1
808
802
 
809
803
Create working tree for new branches inside the repository.
810
804
 
811
 
Revision store:
 
805
Repository:
812
806
         0 revisions
813
 
         0 KiB
814
 
""" % (repo.bzrdir.root_transport.base,
815
 
       repo._format.get_format_description(),
 
807
""" % (format.repository_format.get_format_description(),
816
808
       ), out)
817
809
        self.assertEqual('', err)
818
810
 
819
811
        # Create two branches
820
812
        repo.bzrdir.root_transport.mkdir('branch1')
821
 
        branch1 = repo.bzrdir.create_branch_convenience('repo/branch1')
 
813
        branch1 = repo.bzrdir.create_branch_convenience('repo/branch1',
 
814
            format=format)
822
815
        branch2 = branch1.bzrdir.sprout('repo/branch2').open_branch()
823
816
 
824
817
        # Empty first branch
825
 
        out, err = self.runbzr('info repo/branch1 --verbose')
 
818
        out, err = self.run_bzr('info repo/branch1 --verbose')
826
819
        self.assertEqualDiff(
827
 
"""Location:
828
 
    shared repository: %s
829
 
  repository checkout: branch1
 
820
"""Repository tree (format: knit)
 
821
Location:
 
822
  shared repository: repo
 
823
  repository branch: repo/branch1
830
824
 
831
825
Format:
832
826
       control: Meta directory format 1
833
827
  working tree: Working tree format 3
834
 
        branch: Branch format 5
 
828
        branch: %s
835
829
    repository: %s
836
830
 
837
831
In the working tree:
846
840
 
847
841
Branch history:
848
842
         0 revisions
849
 
         0 committers
850
843
 
851
 
Revision store:
 
844
Repository:
852
845
         0 revisions
853
 
         0 KiB
854
 
""" % (repo.bzrdir.root_transport.base,
855
 
       repo._format.get_format_description(),
 
846
""" % (format.get_branch_format().get_format_description(),
 
847
       format.repository_format.get_format_description(),
856
848
       ), out)
857
849
        self.assertEqual('', err)
858
850
 
863
855
        tree1.commit('commit one')
864
856
        rev = repo.get_revision(branch1.revision_history()[0])
865
857
        datestring_first = format_date(rev.timestamp, rev.timezone)
866
 
        out, err = self.runbzr('info repo/branch1')
 
858
        out, err = self.run_bzr('info -v repo/branch1')
867
859
        self.assertEqualDiff(
868
 
"""Location:
869
 
    shared repository: %s
870
 
  repository checkout: branch1
 
860
"""Repository tree (format: knit)
 
861
Location:
 
862
  shared repository: repo
 
863
  repository branch: repo/branch1
871
864
 
872
865
Format:
873
866
       control: Meta directory format 1
874
867
  working tree: Working tree format 3
875
 
        branch: Branch format 5
 
868
        branch: %s
876
869
    repository: %s
877
870
 
878
871
In the working tree:
891
884
   first revision: %s
892
885
  latest revision: %s
893
886
 
894
 
Revision store:
 
887
Repository:
895
888
         1 revision
896
 
         %d KiB
897
 
""" % (repo.bzrdir.root_transport.base,
898
 
       repo._format.get_format_description(),
 
889
""" % (format.get_branch_format().get_format_description(),
 
890
       format.repository_format.get_format_description(),
899
891
       datestring_first, datestring_first,
900
 
       # poking at _revision_store isn't all that clean, but neither is
901
 
       # having the ui test dependent on the exact overhead of a given store.
902
 
       repo._revision_store.total_size(repo.get_transaction())[1] / 1024,
903
892
       ), out)
904
893
        self.assertEqual('', err)
905
894
 
906
895
        # Out of date second branch
907
 
        out, err = self.runbzr('info repo/branch2 --verbose')
 
896
        out, err = self.run_bzr('info repo/branch2 --verbose')
908
897
        self.assertEqualDiff(
909
 
"""Location:
910
 
    shared repository: %s
911
 
  repository checkout: branch2
 
898
"""Repository tree (format: knit)
 
899
Location:
 
900
  shared repository: repo
 
901
  repository branch: repo/branch2
912
902
 
913
903
Related branches:
914
 
  parent branch: %s
 
904
  parent branch: repo/branch1
915
905
 
916
906
Format:
917
907
       control: Meta directory format 1
918
908
  working tree: Working tree format 3
919
 
        branch: Branch format 5
 
909
        branch: %s
920
910
    repository: %s
921
911
 
922
912
In the working tree:
931
921
 
932
922
Branch history:
933
923
         0 revisions
934
 
         0 committers
935
924
 
936
 
Revision store:
 
925
Repository:
937
926
         1 revision
938
 
         %d KiB
939
 
""" % (repo.bzrdir.root_transport.base,
940
 
       branch1.bzrdir.root_transport.base,
941
 
       repo._format.get_format_description(),
942
 
       # poking at _revision_store isn't all that clean, but neither is
943
 
       # having the ui test dependent on the exact overhead of a given store.
944
 
       repo._revision_store.total_size(repo.get_transaction())[1] / 1024,
 
927
""" % (format.get_branch_format().get_format_description(),
 
928
       format.repository_format.get_format_description(),
945
929
       ), out)
946
930
        self.assertEqual('', err)
947
931
 
948
932
        # Update second branch
949
933
        tree2 = branch2.bzrdir.open_workingtree()
950
934
        tree2.pull(branch1)
951
 
        out, err = self.runbzr('info repo/branch2')
 
935
        out, err = self.run_bzr('info -v repo/branch2')
952
936
        self.assertEqualDiff(
953
 
"""Location:
954
 
    shared repository: %s
955
 
  repository checkout: branch2
 
937
"""Repository tree (format: knit)
 
938
Location:
 
939
  shared repository: repo
 
940
  repository branch: repo/branch2
956
941
 
957
942
Related branches:
958
 
  parent branch: %s
 
943
  parent branch: repo/branch1
959
944
 
960
945
Format:
961
946
       control: Meta directory format 1
962
947
  working tree: Working tree format 3
963
 
        branch: Branch format 5
 
948
        branch: %s
964
949
    repository: %s
965
950
 
966
951
In the working tree:
979
964
   first revision: %s
980
965
  latest revision: %s
981
966
 
982
 
Revision store:
 
967
Repository:
983
968
         1 revision
984
 
         %d KiB
985
 
""" % (repo.bzrdir.root_transport.base,
986
 
       branch1.bzrdir.root_transport.base,
987
 
       repo._format.get_format_description(),
 
969
""" % (format.get_branch_format().get_format_description(),
 
970
       format.repository_format.get_format_description(),
988
971
       datestring_first, datestring_first,
989
 
       # poking at _revision_store isn't all that clean, but neither is
990
 
       # having the ui test dependent on the exact overhead of a given store.
991
 
       repo._revision_store.total_size(repo.get_transaction())[1] / 1024,
992
972
       ), out)
993
973
        self.assertEqual('', err)
994
974
 
995
975
        # Show info about repository with revisions
996
 
        out, err = self.runbzr('info repo')
 
976
        out, err = self.run_bzr('info -v repo')
997
977
        self.assertEqualDiff(
998
 
"""Location:
999
 
  shared repository: %s
 
978
"""Shared repository with trees (format: dirstate or dirstate-tags or knit)
 
979
Location:
 
980
  shared repository: repo
1000
981
 
1001
982
Format:
1002
983
       control: Meta directory format 1
1004
985
 
1005
986
Create working tree for new branches inside the repository.
1006
987
 
1007
 
Revision store:
 
988
Repository:
1008
989
         1 revision
1009
 
         %d KiB
1010
 
""" % (repo.bzrdir.root_transport.base,
1011
 
       repo._format.get_format_description(),
1012
 
       # poking at _revision_store isn't all that clean, but neither is
1013
 
       # having the ui test dependent on the exact overhead of a given store.
1014
 
       repo._revision_store.total_size(repo.get_transaction())[1] / 1024,
 
990
""" % (format.repository_format.get_format_description(),
1015
991
       ),
1016
992
       out)
1017
993
        self.assertEqual('', err)
1018
994
 
1019
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
1020
 
    
1021
995
    def test_info_shared_repository_with_tree_in_root(self):
1022
 
        old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
1023
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(bzrlib.bzrdir.BzrDirMetaFormat1())
 
996
        format = bzrdir.format_registry.make_bzrdir('knit')
1024
997
        transport = self.get_transport()
1025
998
 
1026
999
        # Create shared repository with working trees
1027
 
        repo = self.make_repository('repo', shared=True)
 
1000
        repo = self.make_repository('repo', shared=True, format=format)
1028
1001
        repo.set_make_working_trees(True)
1029
 
        out, err = self.runbzr('info repo')
 
1002
        out, err = self.run_bzr('info -v repo')
1030
1003
        self.assertEqualDiff(
1031
 
"""Location:
1032
 
  shared repository: %s
 
1004
"""Shared repository with trees (format: dirstate or dirstate-tags or knit)
 
1005
Location:
 
1006
  shared repository: repo
1033
1007
 
1034
1008
Format:
1035
1009
       control: Meta directory format 1
1037
1011
 
1038
1012
Create working tree for new branches inside the repository.
1039
1013
 
1040
 
Revision store:
 
1014
Repository:
1041
1015
         0 revisions
1042
 
         0 KiB
1043
 
""" % (repo.bzrdir.root_transport.base,
1044
 
       repo._format.get_format_description(),
 
1016
""" % (format.repository_format.get_format_description(),
1045
1017
       ), out)
1046
1018
        self.assertEqual('', err)
1047
1019
 
1049
1021
        control = repo.bzrdir
1050
1022
        branch = control.create_branch()
1051
1023
        control.create_workingtree()
1052
 
        out, err = self.runbzr('info repo')
 
1024
        out, err = self.run_bzr('info -v repo')
1053
1025
        self.assertEqualDiff(
1054
 
"""Location:
1055
 
    shared repository: %s
1056
 
  repository checkout: .
 
1026
"""Repository tree (format: knit)
 
1027
Location:
 
1028
  shared repository: repo
 
1029
  repository branch: repo
1057
1030
 
1058
1031
Format:
1059
1032
       control: Meta directory format 1
1060
1033
  working tree: Working tree format 3
1061
 
        branch: Branch format 5
 
1034
        branch: %s
1062
1035
    repository: %s
1063
1036
 
1064
1037
In the working tree:
1074
1047
Branch history:
1075
1048
         0 revisions
1076
1049
 
1077
 
Revision store:
1078
 
         0 revisions
1079
 
         0 KiB
1080
 
""" % (repo.bzrdir.root_transport.base,
1081
 
       repo._format.get_format_description(),
1082
 
       ), out)
1083
 
        self.assertEqual('', err)
1084
 
 
1085
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
1086
 
 
1087
 
    def assertCheckoutStatusOutput(self, 
 
1050
Repository:
 
1051
         0 revisions
 
1052
""" % (format.get_branch_format().get_format_description(),
 
1053
       format.repository_format.get_format_description(),
 
1054
       ), out)
 
1055
        self.assertEqual('', err)
 
1056
 
 
1057
    def test_info_repository_hook(self):
 
1058
        format = bzrdir.format_registry.make_bzrdir('knit')
 
1059
        def repo_info(repo, stats, outf):
 
1060
            outf.write("more info\n")
 
1061
        info.hooks.install_named_hook('repository', repo_info, None)
 
1062
        # Create shared repository with working trees
 
1063
        repo = self.make_repository('repo', shared=True, format=format)
 
1064
        out, err = self.run_bzr('info -v repo')
 
1065
        self.assertEqualDiff(
 
1066
"""Shared repository with trees (format: dirstate or dirstate-tags or knit)
 
1067
Location:
 
1068
  shared repository: repo
 
1069
 
 
1070
Format:
 
1071
       control: Meta directory format 1
 
1072
    repository: %s
 
1073
 
 
1074
Create working tree for new branches inside the repository.
 
1075
 
 
1076
Repository:
 
1077
         0 revisions
 
1078
more info
 
1079
""" % (format.repository_format.get_format_description(),
 
1080
       ), out)
 
1081
        self.assertEqual('', err)
 
1082
 
 
1083
    def assertCheckoutStatusOutput(self,
1088
1084
        command_string, lco_tree, shared_repo=None,
1089
1085
        repo_branch=None,
1090
1086
        tree_locked=False,
1091
1087
        branch_locked=False, repo_locked=False,
1092
1088
        verbose=False,
1093
 
        light_checkout=True):
1094
 
        """Check the output of info in a light checkout tree.
 
1089
        light_checkout=True,
 
1090
        checkout_root=None):
 
1091
        """Check the output of info in a checkout.
1095
1092
 
1096
1093
        This is not quite a mirror of the info code: rather than using the
1097
1094
        tree being examined to predict output, it uses a bunch of flags which
1098
1095
        allow us, the test writers, to document what *should* be present in
1099
1096
        the output. Removing this separation would remove the value of the
1100
1097
        tests.
1101
 
        
 
1098
 
1102
1099
        :param path: the path to the light checkout.
1103
1100
        :param lco_tree: the tree object for the light checkout.
1104
1101
        :param shared_repo: A shared repository is in use, expect that in
1108
1105
        :param tree_locked: If true, expect the tree to be locked.
1109
1106
        :param branch_locked: If true, expect the branch to be locked.
1110
1107
        :param repo_locked: If true, expect the repository to be locked.
1111
 
        :param verbose: If true, expect verbose output
 
1108
            Note that the lco_tree.branch.repository is inspected, and if is not
 
1109
            actually locked then this parameter is overridden. This is because
 
1110
            pack repositories do not have any public API for obtaining an
 
1111
            exclusive repository wide lock.
 
1112
        :param verbose: verbosity level: 2 or higher to show committers
1112
1113
        """
1113
 
        out, err = self.runbzr('info %s' % command_string)
 
1114
        def friendly_location(url):
 
1115
            path = urlutils.unescape_for_display(url, 'ascii')
 
1116
            try:
 
1117
                return osutils.relpath(osutils.getcwd(), path)
 
1118
            except errors.PathNotChild:
 
1119
                return path
 
1120
 
 
1121
        if tree_locked:
 
1122
            # We expect this to fail because of locking errors.
 
1123
            # (A write-locked file cannot be read-locked
 
1124
            # in the different process -- either on win32 or on linux).
 
1125
            # This should be removed when the locking errors are fixed.
 
1126
            self.expectFailure('OS locks are exclusive '
 
1127
                'for different processes (Bug #174055)',
 
1128
                self.run_bzr_subprocess,
 
1129
                'info ' + command_string)
 
1130
        out, err = self.run_bzr('info %s' % command_string)
 
1131
        description = {
 
1132
            (True, True): 'Lightweight checkout',
 
1133
            (True, False): 'Repository checkout',
 
1134
            (False, True): 'Lightweight checkout',
 
1135
            (False, False): 'Checkout',
 
1136
            }[(shared_repo is not None, light_checkout)]
 
1137
        format = {True: '1.6 or 1.6.1-rich-root'
 
1138
                        ' or 1.9 or 1.9-rich-root'
 
1139
                        ' or dirstate or dirstate-tags or pack-0.92'
 
1140
                        ' or rich-root or rich-root-pack',
 
1141
                  False: 'dirstate'}[light_checkout]
 
1142
        if repo_locked:
 
1143
            repo_locked = lco_tree.branch.repository.get_physical_lock_status()
1114
1144
        if repo_locked or branch_locked or tree_locked:
1115
1145
            def locked_message(a_bool):
1116
1146
                if a_bool:
1128
1158
                    locked_message(repo_locked)))
1129
1159
        else:
1130
1160
            expected_lock_output = ''
 
1161
        tree_data = ''
 
1162
        extra_space = ''
1131
1163
        if light_checkout:
1132
 
            tree_data = (" light checkout root: %s" %
1133
 
                lco_tree.bzrdir.root_transport.base)
1134
 
        else:
1135
 
            tree_data = ("       checkout root: %s" %
1136
 
                lco_tree.bzrdir.root_transport.base)
 
1164
            tree_data = ("  light checkout root: %s\n" %
 
1165
                friendly_location(lco_tree.bzrdir.root_transport.base))
 
1166
            extra_space = ' '
 
1167
        if lco_tree.branch.get_bound_location() is not None:
 
1168
            tree_data += ("%s       checkout root: %s\n" % (extra_space,
 
1169
                friendly_location(lco_tree.branch.bzrdir.root_transport.base)))
1137
1170
        if shared_repo is not None:
1138
1171
            branch_data = (
1139
 
                "   shared repository: %s\n"
1140
 
                "   repository branch: branch\n" %
1141
 
                shared_repo.bzrdir.root_transport.base)
 
1172
                "   checkout of branch: %s\n"
 
1173
                "    shared repository: %s\n" %
 
1174
                (friendly_location(repo_branch.bzrdir.root_transport.base),
 
1175
                 friendly_location(shared_repo.bzrdir.root_transport.base)))
1142
1176
        elif repo_branch is not None:
1143
1177
            branch_data = (
1144
 
                "  checkout of branch: %s\n" % 
1145
 
                repo_branch.bzrdir.root_transport.base)
 
1178
                "%s  checkout of branch: %s\n" %
 
1179
                (extra_space,
 
1180
                 friendly_location(repo_branch.bzrdir.root_transport.base)))
1146
1181
        else:
1147
 
            branch_data = ("  checkout of branch: %s\n" % 
 
1182
            branch_data = ("   checkout of branch: %s\n" %
1148
1183
                lco_tree.branch.bzrdir.root_transport.base)
1149
 
        
1150
 
        if verbose:
 
1184
 
 
1185
        if verbose >= 2:
1151
1186
            verbose_info = '         0 committers\n'
1152
1187
        else:
1153
1188
            verbose_info = ''
1154
 
            
 
1189
 
1155
1190
        self.assertEqualDiff(
1156
 
"""Location:
1157
 
%s
1158
 
%s
 
1191
"""%s (format: %s)
 
1192
Location:
 
1193
%s%s
1159
1194
Format:
1160
1195
       control: Meta directory format 1
1161
1196
  working tree: %s
1162
 
        branch: Branch format 5
 
1197
        branch: %s
1163
1198
    repository: %s
1164
1199
%s
1165
1200
In the working tree:
1175
1210
Branch history:
1176
1211
         0 revisions
1177
1212
%s
1178
 
Revision store:
 
1213
Repository:
1179
1214
         0 revisions
1180
 
         0 KiB
1181
 
""" %  (tree_data,
 
1215
""" %  (description,
 
1216
        format,
 
1217
        tree_data,
1182
1218
        branch_data,
1183
1219
        lco_tree._format.get_format_description(),
 
1220
        lco_tree.branch._format.get_format_description(),
1184
1221
        lco_tree.branch.repository._format.get_format_description(),
1185
1222
        expected_lock_output,
1186
1223
        verbose_info,
1191
1228
        transport = self.get_transport()
1192
1229
        # Create shared repository with a branch
1193
1230
        repo = self.make_repository('repo', shared=True,
1194
 
                                    format=bzrlib.bzrdir.BzrDirMetaFormat1())
 
1231
                                    format=bzrdir.BzrDirMetaFormat1())
1195
1232
        repo.set_make_working_trees(False)
1196
1233
        repo.bzrdir.root_transport.mkdir('branch')
1197
1234
        repo_branch = repo.bzrdir.create_branch_convenience('repo/branch',
1198
 
                                    format=bzrlib.bzrdir.BzrDirMetaFormat1())
 
1235
                                    format=bzrdir.BzrDirMetaFormat1())
1199
1236
        # Do a heavy checkout
1200
1237
        transport.mkdir('tree')
1201
1238
        transport.mkdir('tree/checkout')
1202
 
        co_branch = bzrlib.bzrdir.BzrDir.create_branch_convenience('tree/checkout',
1203
 
                                    format=bzrlib.bzrdir.BzrDirMetaFormat1())
 
1239
        co_branch = bzrdir.BzrDir.create_branch_convenience('tree/checkout',
 
1240
            format=bzrdir.BzrDirMetaFormat1())
1204
1241
        co_branch.bind(repo_branch)
1205
1242
        # Do a light checkout of the heavy one
1206
1243
        transport.mkdir('tree/lightcheckout')
1207
 
        lco_dir = bzrlib.bzrdir.BzrDirMetaFormat1().initialize('tree/lightcheckout')
1208
 
        bzrlib.branch.BranchReferenceFormat().initialize(lco_dir, co_branch)
 
1244
        lco_dir = bzrdir.BzrDirMetaFormat1().initialize('tree/lightcheckout')
 
1245
        branch.BranchReferenceFormat().initialize(lco_dir, co_branch)
1209
1246
        lco_dir.create_workingtree()
1210
1247
        lco_tree = lco_dir.open_workingtree()
1211
1248
 
1213
1250
        # W B R
1214
1251
 
1215
1252
        # U U U
1216
 
        self.assertCheckoutStatusOutput('tree/lightcheckout', lco_tree)
 
1253
        self.assertCheckoutStatusOutput('-v tree/lightcheckout', lco_tree,
 
1254
                                        repo_branch=repo_branch,
 
1255
                                        verbose=True, light_checkout=True)
1217
1256
        # U U L
1218
1257
        lco_tree.branch.repository.lock_write()
1219
1258
        try:
1220
 
            self.assertCheckoutStatusOutput('tree/lightcheckout',
1221
 
            lco_tree,
1222
 
            repo_locked=True)
 
1259
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
 
1260
            lco_tree, repo_branch=repo_branch,
 
1261
            repo_locked=True, verbose=True, light_checkout=True)
1223
1262
        finally:
1224
1263
            lco_tree.branch.repository.unlock()
1225
1264
        # U L L
1226
1265
        lco_tree.branch.lock_write()
1227
1266
        try:
1228
 
            self.assertCheckoutStatusOutput('tree/lightcheckout',
 
1267
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
1229
1268
            lco_tree,
1230
1269
            branch_locked=True,
1231
 
            repo_locked=True)
 
1270
            repo_locked=True,
 
1271
            repo_branch=repo_branch,
 
1272
            verbose=True)
1232
1273
        finally:
1233
1274
            lco_tree.branch.unlock()
1234
1275
        # L L L
1235
1276
        lco_tree.lock_write()
1236
1277
        try:
1237
 
            self.assertCheckoutStatusOutput('tree/lightcheckout',
1238
 
            lco_tree,
 
1278
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
 
1279
            lco_tree, repo_branch=repo_branch,
1239
1280
            tree_locked=True,
1240
1281
            branch_locked=True,
1241
 
            repo_locked=True)
 
1282
            repo_locked=True,
 
1283
            verbose=True)
1242
1284
        finally:
1243
1285
            lco_tree.unlock()
1244
1286
        # L L U
1245
1287
        lco_tree.lock_write()
1246
1288
        lco_tree.branch.repository.unlock()
1247
1289
        try:
1248
 
            self.assertCheckoutStatusOutput('tree/lightcheckout',
1249
 
            lco_tree,
 
1290
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
 
1291
            lco_tree, repo_branch=repo_branch,
1250
1292
            tree_locked=True,
1251
 
            branch_locked=True)
 
1293
            branch_locked=True,
 
1294
            verbose=True)
1252
1295
        finally:
1253
1296
            lco_tree.branch.repository.lock_write()
1254
1297
            lco_tree.unlock()
1256
1299
        lco_tree.lock_write()
1257
1300
        lco_tree.branch.unlock()
1258
1301
        try:
1259
 
            self.assertCheckoutStatusOutput('tree/lightcheckout',
1260
 
            lco_tree,
1261
 
            tree_locked=True)
 
1302
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
 
1303
            lco_tree, repo_branch=repo_branch,
 
1304
            tree_locked=True,
 
1305
            verbose=True)
1262
1306
        finally:
1263
1307
            lco_tree.branch.lock_write()
1264
1308
            lco_tree.unlock()
1267
1311
        lco_tree.branch.unlock()
1268
1312
        lco_tree.branch.repository.lock_write()
1269
1313
        try:
1270
 
            self.assertCheckoutStatusOutput('tree/lightcheckout',
1271
 
            lco_tree,
 
1314
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
 
1315
            lco_tree, repo_branch=repo_branch,
1272
1316
            tree_locked=True,
1273
 
            repo_locked=True)
 
1317
            repo_locked=True,
 
1318
            verbose=True)
1274
1319
        finally:
1275
1320
            lco_tree.branch.repository.unlock()
1276
1321
            lco_tree.branch.lock_write()
1279
1324
        lco_tree.branch.lock_write()
1280
1325
        lco_tree.branch.repository.unlock()
1281
1326
        try:
1282
 
            self.assertCheckoutStatusOutput('tree/lightcheckout',
1283
 
            lco_tree,
1284
 
            branch_locked=True)
 
1327
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
 
1328
            lco_tree, repo_branch=repo_branch,
 
1329
            branch_locked=True,
 
1330
            verbose=True)
1285
1331
        finally:
1286
1332
            lco_tree.branch.repository.lock_write()
1287
1333
            lco_tree.branch.unlock()
1288
1334
 
 
1335
        if sys.platform == 'win32':
 
1336
            self.knownFailure('Win32 cannot run "bzr info"'
 
1337
                              ' when the tree is locked.')
 
1338
 
1289
1339
    def test_info_locking_oslocks(self):
1290
1340
        if sys.platform == "win32":
1291
1341
            raise TestSkipped("don't use oslocks on win32 in unix manner")
1292
1342
 
1293
1343
        tree = self.make_branch_and_tree('branch',
1294
 
                                         format=bzrlib.bzrdir.BzrDirFormat6())
 
1344
                                         format=bzrdir.BzrDirFormat6())
1295
1345
 
1296
1346
        # Test all permutations of locking the working tree, branch and repository
1297
1347
        # XXX: Well not yet, as we can't query oslocks yet. Currently, it's
1300
1350
        # W B R
1301
1351
 
1302
1352
        # U U U
1303
 
        out, err = self.runbzr('info branch')
 
1353
        out, err = self.run_bzr('info -v branch')
1304
1354
        self.assertEqualDiff(
1305
 
"""Location:
 
1355
"""Standalone tree (format: weave)
 
1356
Location:
1306
1357
  branch root: %s
1307
1358
 
1308
1359
Format:
1324
1375
Branch history:
1325
1376
         0 revisions
1326
1377
 
1327
 
Revision store:
 
1378
Repository:
1328
1379
         0 revisions
1329
 
         0 KiB
1330
 
""" % (tree.bzrdir.root_transport.base,
1331
 
       tree.branch.repository._format.get_format_description(),
 
1380
""" % ('branch', tree.branch.repository._format.get_format_description(),
1332
1381
       ), out)
1333
1382
        self.assertEqual('', err)
1334
1383
        # L L L
1335
1384
        tree.lock_write()
1336
 
        out, err = self.runbzr('info branch')
 
1385
        out, err = self.run_bzr('info -v branch')
1337
1386
        self.assertEqualDiff(
1338
 
"""Location:
 
1387
"""Standalone tree (format: weave)
 
1388
Location:
1339
1389
  branch root: %s
1340
1390
 
1341
1391
Format:
1357
1407
Branch history:
1358
1408
         0 revisions
1359
1409
 
1360
 
Revision store:
 
1410
Repository:
1361
1411
         0 revisions
1362
 
         0 KiB
1363
 
""" % (tree.bzrdir.root_transport.base,
1364
 
       tree.branch.repository._format.get_format_description(),
 
1412
""" % ('branch', tree.branch.repository._format.get_format_description(),
1365
1413
       ), out)
1366
1414
        self.assertEqual('', err)
1367
1415
        tree.unlock()
 
1416
 
 
1417
    def test_info_stacked(self):
 
1418
        # We have a mainline
 
1419
        trunk_tree = self.make_branch_and_tree('mainline',
 
1420
            format='1.6')
 
1421
        trunk_tree.commit('mainline')
 
1422
        # and a branch from it which is stacked
 
1423
        new_dir = trunk_tree.bzrdir.sprout('newbranch', stacked=True)
 
1424
        out, err = self.run_bzr('info newbranch')
 
1425
        self.assertEqual(
 
1426
"""Standalone tree (format: 1.6)
 
1427
Location:
 
1428
  branch root: newbranch
 
1429
 
 
1430
Related branches:
 
1431
  parent branch: mainline
 
1432
     stacked on: mainline
 
1433
""", out)
 
1434
        self.assertEqual("", err)