← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

  • Committer: Patch Queue Manager
  • Date: 2012-12-10 10:18:33 UTC
  • mfrom: (6571.1.2 1086209-lc-all-c)
  • Revision ID: pqm@pqm.ubuntu.com-20121210101833-06scfp3a4w0x0z87
(vila) Fix LC_ALL=C test failures related to utf8 stderr encoding (Vincent
 Ladeuil)

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-2012 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
 
 
20
import shutil
21
21
import sys
22
22
 
23
 
import bzrlib
24
 
from bzrlib.osutils import format_date
25
 
from bzrlib.tests import TestSkipped
26
 
from bzrlib.tests.blackbox import ExternalBase
27
 
 
28
 
 
29
 
class TestInfo(ExternalBase):
 
23
from bzrlib import (
 
24
    branch,
 
25
    bzrdir,
 
26
    controldir,
 
27
    errors,
 
28
    info,
 
29
    osutils,
 
30
    tests,
 
31
    upgrade,
 
32
    urlutils,
 
33
    )
 
34
from bzrlib.tests.matchers import ContainsNoVfsCalls
 
35
from bzrlib.transport import memory
 
36
 
 
37
 
 
38
class TestInfo(tests.TestCaseWithTransport):
 
39
 
 
40
    def setUp(self):
 
41
        super(TestInfo, self).setUp()
 
42
        self._repo_strings = "2a"
30
43
 
31
44
    def test_info_non_existing(self):
32
 
        if sys.platform == "win32":
33
 
            location = "C:/i/do/not/exist/"
34
 
        else:
35
 
            location = "/i/do/not/exist/"
36
 
        out, err = self.runbzr('info '+location, retcode=3)
 
45
        self.vfs_transport_factory = memory.MemoryServer
 
46
        location = self.get_url()
 
47
        out, err = self.run_bzr('info '+location, retcode=3)
37
48
        self.assertEqual(out, '')
38
 
        self.assertEqual(err, 'bzr: ERROR: Not a branch: %s\n' % location)
 
49
        self.assertEqual(err, 'bzr: ERROR: Not a branch: "%s".\n' % location)
 
50
 
 
51
    def test_info_empty_controldir(self):
 
52
        self.make_bzrdir('ctrl')
 
53
        out, err = self.run_bzr('info ctrl')
 
54
        self.assertEquals(out,
 
55
            'Empty control directory (format: 2a or pack-0.92)\n'
 
56
            'Location:\n'
 
57
            '  control directory: ctrl\n')
 
58
        self.assertEquals(err, '')
 
59
 
 
60
    def test_info_empty_controldir_verbose(self):
 
61
        self.make_bzrdir('ctrl')
 
62
        out, err = self.run_bzr('info -v ctrl')
 
63
        self.assertEqualDiff(out,
 
64
            'Empty control directory (format: 2a or pack-0.92)\n'
 
65
            'Location:\n'
 
66
            '  control directory: ctrl\n\n'
 
67
            'Format:\n'
 
68
            '       control: Meta directory format 1\n\n'
 
69
            'Control directory:\n'
 
70
            '         0 branches\n')
 
71
        self.assertEquals(err, '')
 
72
 
 
73
    def test_info_dangling_branch_reference(self):
 
74
        br = self.make_branch('target')
 
75
        br.create_checkout('from', lightweight=True)
 
76
        shutil.rmtree('target')
 
77
        out, err = self.run_bzr('info from')
 
78
        self.assertEquals(out,
 
79
            'Dangling branch reference (format: 2a or pack-0.92)\n'
 
80
            'Location:\n'
 
81
            '   control directory: from\n'
 
82
            '  checkout of branch: target\n')
 
83
        self.assertEquals(err, '')
39
84
 
40
85
    def test_info_standalone(self):
41
86
        transport = self.get_transport()
42
87
 
43
88
        # 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)
 
89
        tree1 = self.make_branch_and_tree('standalone', 'knit')
48
90
        self.build_tree(['standalone/a'])
49
91
        tree1.add('a')
50
92
        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)
 
93
 
 
94
        out, err = self.run_bzr('info standalone')
 
95
        self.assertEqualDiff(
 
96
"""Standalone tree (format: knit)
 
97
Location:
 
98
  branch root: standalone
 
99
""", out)
 
100
        self.assertEqual('', err)
 
101
 
 
102
        # Standalone branch - verbose mode
 
103
        out, err = self.run_bzr('info standalone -v')
 
104
        self.assertEqualDiff(
 
105
"""Standalone tree (format: knit)
 
106
Location:
 
107
  branch root: standalone
 
108
 
 
109
Format:
 
110
       control: Meta directory format 1
 
111
  working tree: Working tree format 3
 
112
        branch: Branch format 5
 
113
    repository: Knit repository format 1
 
114
 
 
115
Control directory:
 
116
         1 branches
 
117
 
 
118
In the working tree:
 
119
         0 unchanged
 
120
         0 modified
 
121
         1 added
 
122
         0 removed
 
123
         0 renamed
 
124
         0 unknown
 
125
         0 ignored
 
126
         0 versioned subdirectories
 
127
 
 
128
Branch history:
 
129
         0 revisions
 
130
 
 
131
Repository:
 
132
         0 revisions
 
133
""", out)
 
134
        self.assertEqual('', err)
 
135
 
 
136
        # Standalone branch - really verbose mode
 
137
        out, err = self.run_bzr('info standalone -vv')
 
138
        self.assertEqualDiff(
 
139
"""Standalone tree (format: knit)
 
140
Location:
 
141
  branch root: standalone
 
142
 
 
143
Format:
 
144
       control: Meta directory format 1
 
145
  working tree: Working tree format 3
 
146
        branch: Branch format 5
 
147
    repository: Knit repository format 1
 
148
 
 
149
Control directory:
 
150
         1 branches
 
151
 
 
152
In the working tree:
 
153
         0 unchanged
 
154
         0 modified
 
155
         1 added
 
156
         0 removed
 
157
         0 renamed
 
158
         0 unknown
 
159
         0 ignored
 
160
         0 versioned subdirectories
 
161
 
 
162
Branch history:
 
163
         0 revisions
 
164
         0 committers
 
165
 
 
166
Repository:
 
167
         0 revisions
 
168
""", out)
79
169
        self.assertEqual('', err)
80
170
        tree1.commit('commit one')
81
 
        rev = branch1.repository.get_revision(branch1.revision_history()[0])
82
 
        datestring_first = format_date(rev.timestamp, rev.timezone)
 
171
        rev = branch1.repository.get_revision(branch1.last_revision())
 
172
        datestring_first = osutils.format_date(rev.timestamp, rev.timezone)
83
173
 
84
174
        # Branch standalone with push location
85
175
        branch2 = branch1.bzrdir.sprout('branch').open_branch()
86
176
        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
 
177
 
 
178
        out, err = self.run_bzr('info branch')
 
179
        self.assertEqualDiff(
 
180
"""Standalone tree (format: knit)
 
181
Location:
 
182
  branch root: branch
 
183
 
 
184
Related branches:
 
185
    push branch: standalone
 
186
  parent branch: standalone
 
187
""", out)
 
188
        self.assertEqual('', err)
 
189
 
 
190
        out, err = self.run_bzr('info branch --verbose')
 
191
        self.assertEqualDiff(
 
192
"""Standalone tree (format: knit)
 
193
Location:
 
194
  branch root: branch
 
195
 
 
196
Related branches:
 
197
    push branch: standalone
 
198
  parent branch: standalone
95
199
 
96
200
Format:
97
 
       control: All-in-one format 6
98
 
  working tree: Working tree format 2
99
 
        branch: Branch format 4
100
 
    repository: Weave repository format 6
 
201
       control: Meta directory format 1
 
202
  working tree: Working tree format 3
 
203
        branch: Branch format 5
 
204
    repository: Knit repository format 1
 
205
 
 
206
Control directory:
 
207
         1 branches
101
208
 
102
209
In the working tree:
103
210
         1 unchanged
111
218
 
112
219
Branch history:
113
220
         1 revision
114
 
         1 committer
115
221
         0 days old
116
222
   first revision: %s
117
223
  latest revision: %s
118
224
 
119
 
Revision store:
 
225
Repository:
120
226
         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,
 
227
""" % (datestring_first, datestring_first,
130
228
       ), out)
131
229
        self.assertEqual('', err)
132
230
 
133
231
        # Branch and bind to standalone, needs upgrade to metadir
134
232
        # (creates backup as unknown)
135
233
        branch1.bzrdir.sprout('bound')
136
 
        bzrlib.upgrade.upgrade('bound', bzrlib.bzrdir.BzrDirMetaFormat1())
137
 
        branch3 = bzrlib.bzrdir.BzrDir.open('bound').open_branch()
 
234
        knit1_format = controldir.format_registry.make_bzrdir('knit')
 
235
        upgrade.upgrade('bound', knit1_format)
 
236
        branch3 = controldir.ControlDir.open('bound').open_branch()
138
237
        branch3.bind(branch1)
139
238
        bound_tree = branch3.bzrdir.open_workingtree()
140
 
        out, err = self.runbzr('info bound')
 
239
        out, err = self.run_bzr('info -v bound')
141
240
        self.assertEqualDiff(
142
 
"""Location:
143
 
       checkout root: %s
144
 
  checkout of branch: %s
 
241
"""Checkout (format: knit)
 
242
Location:
 
243
       checkout root: bound
 
244
  checkout of branch: standalone
145
245
 
146
246
Related branches:
147
 
  parent branch: %s
 
247
  parent branch: standalone
148
248
 
149
249
Format:
150
250
       control: Meta directory format 1
151
251
  working tree: %s
152
 
        branch: Branch format 5
 
252
        branch: %s
153
253
    repository: %s
154
254
 
 
255
Control directory:
 
256
         1 branches
 
257
 
155
258
In the working tree:
156
259
         1 unchanged
157
260
         0 modified
158
261
         0 added
159
262
         0 removed
160
263
         0 renamed
161
 
         1 unknown
 
264
         0 unknown
162
265
         0 ignored
163
266
         0 versioned subdirectories
164
267
 
168
271
   first revision: %s
169
272
  latest revision: %s
170
273
 
171
 
Revision store:
 
274
Repository:
172
275
         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(),      
 
276
""" % (bound_tree._format.get_format_description(),
 
277
       branch3._format.get_format_description(),
178
278
       branch3.repository._format.get_format_description(),
179
279
       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
280
       ), out)
185
281
        self.assertEqual('', err)
186
282
 
187
283
        # 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)
 
284
        branch4 = controldir.ControlDir.create_branch_convenience('checkout',
 
285
            format=knit1_format)
192
286
        branch4.bind(branch1)
193
287
        branch4.bzrdir.open_workingtree().update()
194
 
        out, err = self.runbzr('info checkout --verbose')
 
288
        out, err = self.run_bzr('info checkout --verbose')
195
289
        self.assertEqualDiff(
196
 
"""Location:
197
 
       checkout root: %s
198
 
  checkout of branch: %s
 
290
"""Checkout (format: knit)
 
291
Location:
 
292
       checkout root: checkout
 
293
  checkout of branch: standalone
199
294
 
200
295
Format:
201
296
       control: Meta directory format 1
203
298
        branch: Branch format 5
204
299
    repository: %s
205
300
 
 
301
Control directory:
 
302
         1 branches
 
303
 
206
304
In the working tree:
207
305
         1 unchanged
208
306
         0 modified
215
313
 
216
314
Branch history:
217
315
         1 revision
218
 
         1 committer
219
316
         0 days old
220
317
   first revision: %s
221
318
  latest revision: %s
222
319
 
223
 
Revision store:
 
320
Repository:
224
321
         1 revision
225
 
         %d KiB
226
 
""" % (branch4.bzrdir.root_transport.base,
227
 
       branch1.bzrdir.root_transport.base,
228
 
       branch4.repository._format.get_format_description(),
 
322
""" % (branch4.repository._format.get_format_description(),
229
323
       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
324
       ), out)
235
325
        self.assertEqual('', err)
236
326
 
237
327
        # 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)
 
328
        tree5 = branch1.create_checkout('lightcheckout', lightweight=True)
246
329
        branch5 = tree5.branch
247
 
        out, err = self.runbzr('info lightcheckout')
 
330
        out, err = self.run_bzr('info -v lightcheckout')
 
331
        if "metaweave" in controldir.format_registry:
 
332
            format_description = "knit or metaweave"
 
333
        else:
 
334
            format_description = "knit"
248
335
        self.assertEqualDiff(
249
 
"""Location:
250
 
 light checkout root: %s
251
 
  checkout of branch: %s
 
336
"""Lightweight checkout (format: %s)
 
337
Location:
 
338
  light checkout root: lightcheckout
 
339
   checkout of branch: standalone
252
340
 
253
341
Format:
254
342
       control: Meta directory format 1
255
343
  working tree: Working tree format 3
256
 
        branch: Branch format 4
257
 
    repository: Weave repository format 6
 
344
        branch: Branch format 5
 
345
    repository: Knit repository format 1
 
346
 
 
347
Control directory:
 
348
         1 branches
258
349
 
259
350
In the working tree:
260
351
         1 unchanged
272
363
   first revision: %s
273
364
  latest revision: %s
274
365
 
275
 
Revision store:
 
366
Repository:
276
367
         1 revision
277
 
         0 KiB
278
 
""" % (tree5.bzrdir.root_transport.base,
279
 
       branch1.bzrdir.root_transport.base,
280
 
       datestring_first, datestring_first,
281
 
       ), out)
 
368
""" % (format_description, datestring_first, datestring_first,), out)
282
369
        self.assertEqual('', err)
283
370
 
284
371
        # Update initial standalone branch
285
372
        self.build_tree(['standalone/b'])
286
373
        tree1.add('b')
287
374
        tree1.commit('commit two')
288
 
        rev = branch1.repository.get_revision(branch1.revision_history()[-1])
289
 
        datestring_last = format_date(rev.timestamp, rev.timezone)
 
375
        rev = branch1.repository.get_revision(branch1.last_revision())
 
376
        datestring_last = osutils.format_date(rev.timestamp, rev.timezone)
290
377
 
291
378
        # Out of date branched standalone branch will not be detected
292
 
        out, err = self.runbzr('info branch')
 
379
        out, err = self.run_bzr('info -v branch')
293
380
        self.assertEqualDiff(
294
 
"""Location:
295
 
  branch root: %s
 
381
"""Standalone tree (format: knit)
 
382
Location:
 
383
  branch root: branch
296
384
 
297
385
Related branches:
298
 
      parent branch: %s
299
 
  publish to branch: %s
 
386
    push branch: standalone
 
387
  parent branch: standalone
300
388
 
301
389
Format:
302
 
       control: All-in-one format 6
303
 
  working tree: Working tree format 2
304
 
        branch: Branch format 4
305
 
    repository: Weave repository format 6
 
390
       control: Meta directory format 1
 
391
  working tree: Working tree format 3
 
392
        branch: Branch format 5
 
393
    repository: Knit repository format 1
 
394
 
 
395
Control directory:
 
396
         1 branches
306
397
 
307
398
In the working tree:
308
399
         1 unchanged
320
411
   first revision: %s
321
412
  latest revision: %s
322
413
 
323
 
Revision store:
 
414
Repository:
324
415
         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,
 
416
""" % (datestring_first, datestring_first,
330
417
       ), out)
331
418
        self.assertEqual('', err)
332
419
 
333
420
        # Out of date bound branch
334
 
        out, err = self.runbzr('info bound')
 
421
        out, err = self.run_bzr('info -v bound')
335
422
        self.assertEqualDiff(
336
 
"""Location:
337
 
       checkout root: %s
338
 
  checkout of branch: %s
 
423
"""Checkout (format: knit)
 
424
Location:
 
425
       checkout root: bound
 
426
  checkout of branch: standalone
339
427
 
340
428
Related branches:
341
 
  parent branch: %s
 
429
  parent branch: standalone
342
430
 
343
431
Format:
344
432
       control: Meta directory format 1
346
434
        branch: Branch format 5
347
435
    repository: %s
348
436
 
 
437
Control directory:
 
438
         1 branches
 
439
 
349
440
Branch is out of date: missing 1 revision.
350
441
 
351
442
In the working tree:
354
445
         0 added
355
446
         0 removed
356
447
         0 renamed
357
 
         1 unknown
 
448
         0 unknown
358
449
         0 ignored
359
450
         0 versioned subdirectories
360
451
 
364
455
   first revision: %s
365
456
  latest revision: %s
366
457
 
367
 
Revision store:
 
458
Repository:
368
459
         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(),
 
460
""" % (branch3.repository._format.get_format_description(),
374
461
       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
462
       ), out)
380
463
        self.assertEqual('', err)
381
464
 
382
465
        # Out of date checkout
383
 
        out, err = self.runbzr('info checkout')
 
466
        out, err = self.run_bzr('info -v checkout')
384
467
        self.assertEqualDiff(
385
 
"""Location:
386
 
       checkout root: %s
387
 
  checkout of branch: %s
 
468
"""Checkout (format: knit)
 
469
Location:
 
470
       checkout root: checkout
 
471
  checkout of branch: standalone
388
472
 
389
473
Format:
390
474
       control: Meta directory format 1
392
476
        branch: Branch format 5
393
477
    repository: %s
394
478
 
 
479
Control directory:
 
480
         1 branches
 
481
 
395
482
Branch is out of date: missing 1 revision.
396
483
 
397
484
In the working tree:
410
497
   first revision: %s
411
498
  latest revision: %s
412
499
 
413
 
Revision store:
 
500
Repository:
414
501
         1 revision
415
 
         %d KiB
416
 
""" % (branch4.bzrdir.root_transport.base,
417
 
       branch1.bzrdir.root_transport.base,
418
 
       branch4.repository._format.get_format_description(),
 
502
""" % (branch4.repository._format.get_format_description(),
419
503
       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
504
       ), out)
425
505
        self.assertEqual('', err)
426
506
 
427
507
        # Out of date lightweight checkout
428
 
        out, err = self.runbzr('info lightcheckout --verbose')
 
508
        out, err = self.run_bzr('info lightcheckout --verbose')
429
509
        self.assertEqualDiff(
430
 
"""Location:
431
 
 light checkout root: %s
432
 
  checkout of branch: %s
 
510
"""Lightweight checkout (format: %s)
 
511
Location:
 
512
  light checkout root: lightcheckout
 
513
   checkout of branch: standalone
433
514
 
434
515
Format:
435
516
       control: Meta directory format 1
436
517
  working tree: Working tree format 3
437
 
        branch: Branch format 4
438
 
    repository: Weave repository format 6
 
518
        branch: Branch format 5
 
519
    repository: Knit repository format 1
 
520
 
 
521
Control directory:
 
522
         1 branches
439
523
 
440
524
Working tree is out of date: missing 1 revision.
441
525
 
451
535
 
452
536
Branch history:
453
537
         2 revisions
454
 
         1 committer
455
538
         0 days old
456
539
   first revision: %s
457
540
  latest revision: %s
458
541
 
459
 
Revision store:
 
542
Repository:
460
543
         2 revisions
461
 
         0 KiB
462
 
""" % (tree5.bzrdir.root_transport.base,
463
 
       branch1.bzrdir.root_transport.base,
464
 
       datestring_first, datestring_last,
465
 
       ), out)
 
544
""" % (format_description, datestring_first, datestring_last,), out)
466
545
        self.assertEqual('', err)
467
546
 
468
547
    def test_info_standalone_no_tree(self):
469
548
        # create standalone branch without a working tree
 
549
        format = controldir.format_registry.make_bzrdir('default')
470
550
        branch = self.make_branch('branch')
471
551
        repo = branch.repository
472
 
        out, err = self.runbzr('info branch')
 
552
        out, err = self.run_bzr('info branch -v')
473
553
        self.assertEqualDiff(
474
 
"""Location:
475
 
  branch root: %s
 
554
"""Standalone branch (format: %s)
 
555
Location:
 
556
  branch root: branch
476
557
 
477
558
Format:
478
559
       control: Meta directory format 1
479
 
        branch: Branch format 5
 
560
        branch: %s
480
561
    repository: %s
481
562
 
 
563
Control directory:
 
564
         1 branches
 
565
 
482
566
Branch history:
483
567
         0 revisions
484
568
 
485
 
Revision store:
 
569
Repository:
486
570
         0 revisions
487
 
         0 KiB
488
 
""" % (branch.bzrdir.root_transport.base,
489
 
       repo._format.get_format_description(),
 
571
""" % (info.describe_format(repo.bzrdir, repo, branch, None),
 
572
       format.get_branch_format().get_format_description(),
 
573
       format.repository_format.get_format_description(),
490
574
       ), out)
491
575
        self.assertEqual('', err)
492
576
 
493
577
    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())
 
578
        format = controldir.format_registry.make_bzrdir('knit')
496
579
        transport = self.get_transport()
497
580
 
498
581
        # Create shared repository
499
 
        repo = self.make_repository('repo', shared=True)
 
582
        repo = self.make_repository('repo', shared=True, format=format)
500
583
        repo.set_make_working_trees(False)
501
 
        out, err = self.runbzr('info repo')
 
584
        out, err = self.run_bzr('info -v repo')
502
585
        self.assertEqualDiff(
503
 
"""Location:
 
586
"""Shared repository (format: dirstate or dirstate-tags or knit)
 
587
Location:
504
588
  shared repository: %s
505
589
 
506
590
Format:
507
591
       control: Meta directory format 1
508
592
    repository: %s
509
593
 
510
 
Revision store:
 
594
Control directory:
 
595
         0 branches
 
596
 
 
597
Repository:
511
598
         0 revisions
512
 
         0 KiB
513
 
""" % (repo.bzrdir.root_transport.base,
514
 
       repo._format.get_format_description(),
 
599
""" % ('repo', format.repository_format.get_format_description(),
515
600
       ), out)
516
601
        self.assertEqual('', err)
517
602
 
518
603
        # Create branch inside shared repository
519
604
        repo.bzrdir.root_transport.mkdir('branch')
520
 
        branch1 = repo.bzrdir.create_branch_convenience('repo/branch')
521
 
        out, err = self.runbzr('info repo/branch')
 
605
        branch1 = controldir.ControlDir.create_branch_convenience(
 
606
            'repo/branch', format=format)
 
607
        out, err = self.run_bzr('info -v repo/branch')
522
608
        self.assertEqualDiff(
523
 
"""Location:
524
 
  shared repository: %s
525
 
  repository branch: branch
 
609
"""Repository branch (format: dirstate or knit)
 
610
Location:
 
611
  shared repository: repo
 
612
  repository branch: repo/branch
526
613
 
527
614
Format:
528
615
       control: Meta directory format 1
529
 
        branch: Branch format 5
 
616
        branch: %s
530
617
    repository: %s
531
618
 
 
619
Control directory:
 
620
         1 branches
 
621
 
532
622
Branch history:
533
623
         0 revisions
534
624
 
535
 
Revision store:
 
625
Repository:
536
626
         0 revisions
537
 
         0 KiB
538
 
""" % (repo.bzrdir.root_transport.base,
539
 
       repo._format.get_format_description(),
 
627
""" % (format.get_branch_format().get_format_description(),
 
628
       format.repository_format.get_format_description(),
540
629
       ), out)
541
630
        self.assertEqual('', err)
542
631
 
543
632
        # Create lightweight checkout
544
633
        transport.mkdir('tree')
545
634
        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()
 
635
        tree2 = branch1.create_checkout('tree/lightcheckout',
 
636
            lightweight=True)
550
637
        branch2 = tree2.branch
551
 
        self.assertCheckoutStatusOutput('tree/lightcheckout', tree2, shared_repo=repo)
 
638
        self.assertCheckoutStatusOutput('-v tree/lightcheckout', tree2,
 
639
                   shared_repo=repo, repo_branch=branch1, verbose=True)
552
640
 
553
641
        # Create normal checkout
554
642
        tree3 = branch1.create_checkout('tree/checkout')
559
647
        self.build_tree(['tree/lightcheckout/a'])
560
648
        tree2.add('a')
561
649
        tree2.commit('commit one')
562
 
        rev = repo.get_revision(branch2.revision_history()[0])
563
 
        datestring_first = format_date(rev.timestamp, rev.timezone)
564
 
        out, err = self.runbzr('info tree/lightcheckout --verbose')
 
650
        rev = repo.get_revision(branch2.last_revision())
 
651
        datestring_first = osutils.format_date(rev.timestamp, rev.timezone)
 
652
        out, err = self.run_bzr('info tree/lightcheckout --verbose')
565
653
        self.assertEqualDiff(
566
 
"""Location:
567
 
 light checkout root: %s
568
 
   shared repository: %s
569
 
   repository branch: branch
 
654
"""Lightweight checkout (format: %s)
 
655
Location:
 
656
  light checkout root: tree/lightcheckout
 
657
   checkout of branch: repo/branch
 
658
    shared repository: repo
570
659
 
571
660
Format:
572
661
       control: Meta directory format 1
573
 
  working tree: Working tree format 3
574
 
        branch: Branch format 5
 
662
  working tree: Working tree format 6
 
663
        branch: %s
575
664
    repository: %s
576
665
 
 
666
Control directory:
 
667
         1 branches
 
668
 
577
669
In the working tree:
578
670
         1 unchanged
579
671
         0 modified
586
678
 
587
679
Branch history:
588
680
         1 revision
589
 
         1 committer
590
681
         0 days old
591
682
   first revision: %s
592
683
  latest revision: %s
593
684
 
594
 
Revision store:
 
685
Repository:
595
686
         1 revision
596
 
         %d KiB
597
 
""" % (tree2.bzrdir.root_transport.base,
598
 
       repo.bzrdir.root_transport.base,
599
 
       repo._format.get_format_description(),
 
687
""" % (self._repo_strings, format.get_branch_format().get_format_description(),
 
688
       format.repository_format.get_format_description(),
600
689
       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
690
       ), out)
605
691
        self.assertEqual('', err)
606
692
 
607
693
        # Out of date checkout
608
 
        out, err = self.runbzr('info tree/checkout')
 
694
        out, err = self.run_bzr('info -v tree/checkout')
609
695
        self.assertEqualDiff(
610
 
"""Location:
611
 
       checkout root: %s
612
 
  checkout of branch: %s
 
696
"""Checkout (format: unnamed)
 
697
Location:
 
698
       checkout root: tree/checkout
 
699
  checkout of branch: repo/branch
613
700
 
614
701
Format:
615
702
       control: Meta directory format 1
616
 
  working tree: Working tree format 3
617
 
        branch: Branch format 5
 
703
  working tree: Working tree format 6
 
704
        branch: %s
618
705
    repository: %s
619
706
 
 
707
Control directory:
 
708
         1 branches
 
709
 
620
710
Branch is out of date: missing 1 revision.
621
711
 
622
712
In the working tree:
632
722
Branch history:
633
723
         0 revisions
634
724
 
635
 
Revision store:
 
725
Repository:
636
726
         0 revisions
637
 
         0 KiB
638
 
""" % (tree3.bzrdir.root_transport.base,
639
 
       branch1.bzrdir.root_transport.base,
640
 
       repo._format.get_format_description(),
 
727
""" % (format.get_branch_format().get_format_description(),
 
728
       format.repository_format.get_format_description(),
641
729
       ), out)
642
730
        self.assertEqual('', err)
643
731
 
645
733
        tree3.update()
646
734
        self.build_tree(['tree/checkout/b'])
647
735
        tree3.add('b')
648
 
        out, err = self.runbzr('info tree/checkout --verbose')
 
736
        out, err = self.run_bzr('info tree/checkout --verbose')
649
737
        self.assertEqualDiff(
650
 
"""Location:
651
 
       checkout root: %s
652
 
  checkout of branch: %s
 
738
"""Checkout (format: unnamed)
 
739
Location:
 
740
       checkout root: tree/checkout
 
741
  checkout of branch: repo/branch
653
742
 
654
743
Format:
655
744
       control: Meta directory format 1
656
 
  working tree: Working tree format 3
657
 
        branch: Branch format 5
 
745
  working tree: Working tree format 6
 
746
        branch: %s
658
747
    repository: %s
659
748
 
 
749
Control directory:
 
750
         1 branches
 
751
 
660
752
In the working tree:
661
753
         1 unchanged
662
754
         0 modified
669
761
 
670
762
Branch history:
671
763
         1 revision
672
 
         1 committer
673
764
         0 days old
674
765
   first revision: %s
675
766
  latest revision: %s
676
767
 
677
 
Revision store:
 
768
Repository:
678
769
         1 revision
679
 
         %d KiB
680
 
""" % (tree3.bzrdir.root_transport.base, branch1.bzrdir.root_transport.base,
681
 
       repo._format.get_format_description(),
 
770
""" % (format.get_branch_format().get_format_description(),
 
771
       format.repository_format.get_format_description(),
682
772
       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
773
       ), out)
687
774
        self.assertEqual('', err)
688
775
        tree3.commit('commit two')
689
776
 
690
777
        # Out of date lightweight checkout
691
 
        rev = repo.get_revision(branch1.revision_history()[-1])
692
 
        datestring_last = format_date(rev.timestamp, rev.timezone)
693
 
        out, err = self.runbzr('info tree/lightcheckout --verbose')
 
778
        rev = repo.get_revision(branch1.last_revision())
 
779
        datestring_last = osutils.format_date(rev.timestamp, rev.timezone)
 
780
        out, err = self.run_bzr('info tree/lightcheckout --verbose')
694
781
        self.assertEqualDiff(
695
 
"""Location:
696
 
 light checkout root: %s
697
 
   shared repository: %s
698
 
   repository branch: branch
 
782
"""Lightweight checkout (format: %s)
 
783
Location:
 
784
  light checkout root: tree/lightcheckout
 
785
   checkout of branch: repo/branch
 
786
    shared repository: repo
699
787
 
700
788
Format:
701
789
       control: Meta directory format 1
702
 
  working tree: Working tree format 3
703
 
        branch: Branch format 5
 
790
  working tree: Working tree format 6
 
791
        branch: %s
704
792
    repository: %s
705
793
 
 
794
Control directory:
 
795
         1 branches
 
796
 
706
797
Working tree is out of date: missing 1 revision.
707
798
 
708
799
In the working tree:
717
808
 
718
809
Branch history:
719
810
         2 revisions
720
 
         1 committer
721
811
         0 days old
722
812
   first revision: %s
723
813
  latest revision: %s
724
814
 
725
 
Revision store:
 
815
Repository:
726
816
         2 revisions
727
 
         %d KiB
728
 
""" % (tree2.bzrdir.root_transport.base,
729
 
       repo.bzrdir.root_transport.base,
730
 
       repo._format.get_format_description(),
 
817
""" % (self._repo_strings, format.get_branch_format().get_format_description(),
 
818
       format.repository_format.get_format_description(),
731
819
       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
820
       ), out)
736
821
        self.assertEqual('', err)
737
822
 
738
823
        # Show info about shared branch
739
 
        out, err = self.runbzr('info repo/branch --verbose')
 
824
        out, err = self.run_bzr('info repo/branch --verbose')
740
825
        self.assertEqualDiff(
741
 
"""Location:
742
 
  shared repository: %s
743
 
  repository branch: branch
 
826
"""Repository branch (format: dirstate or knit)
 
827
Location:
 
828
  shared repository: repo
 
829
  repository branch: repo/branch
744
830
 
745
831
Format:
746
832
       control: Meta directory format 1
747
 
        branch: Branch format 5
 
833
        branch: %s
748
834
    repository: %s
749
835
 
 
836
Control directory:
 
837
         1 branches
 
838
 
750
839
Branch history:
751
840
         2 revisions
752
 
         1 committer
753
841
         0 days old
754
842
   first revision: %s
755
843
  latest revision: %s
756
844
 
757
 
Revision store:
 
845
Repository:
758
846
         2 revisions
759
 
         %d KiB
760
 
""" % (repo.bzrdir.root_transport.base,
761
 
       repo._format.get_format_description(),
 
847
""" % (format.get_branch_format().get_format_description(),
 
848
       format.repository_format.get_format_description(),
762
849
       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
850
       ), out)
767
851
        self.assertEqual('', err)
768
852
 
769
853
        # Show info about repository with revisions
770
 
        out, err = self.runbzr('info repo')
 
854
        out, err = self.run_bzr('info -v repo')
771
855
        self.assertEqualDiff(
772
 
"""Location:
773
 
  shared repository: %s
 
856
"""Shared repository (format: dirstate or dirstate-tags or knit)
 
857
Location:
 
858
  shared repository: repo
774
859
 
775
860
Format:
776
861
       control: Meta directory format 1
777
862
    repository: %s
778
863
 
779
 
Revision store:
 
864
Control directory:
 
865
         0 branches
 
866
 
 
867
Repository:
780
868
         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,
 
869
""" % (format.repository_format.get_format_description(),
787
870
       ), out)
788
871
        self.assertEqual('', err)
789
872
 
790
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
791
 
 
792
873
    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())
 
874
        format = controldir.format_registry.make_bzrdir('knit')
795
875
        transport = self.get_transport()
796
876
 
797
877
        # Create shared repository with working trees
798
 
        repo = self.make_repository('repo', shared=True)
 
878
        repo = self.make_repository('repo', shared=True, format=format)
799
879
        repo.set_make_working_trees(True)
800
 
        out, err = self.runbzr('info repo')
 
880
        out, err = self.run_bzr('info -v repo')
801
881
        self.assertEqualDiff(
802
 
"""Location:
803
 
  shared repository: %s
 
882
"""Shared repository with trees (format: dirstate or dirstate-tags or knit)
 
883
Location:
 
884
  shared repository: repo
804
885
 
805
886
Format:
806
887
       control: Meta directory format 1
807
888
    repository: %s
808
889
 
 
890
Control directory:
 
891
         0 branches
 
892
 
809
893
Create working tree for new branches inside the repository.
810
894
 
811
 
Revision store:
 
895
Repository:
812
896
         0 revisions
813
 
         0 KiB
814
 
""" % (repo.bzrdir.root_transport.base,
815
 
       repo._format.get_format_description(),
 
897
""" % (format.repository_format.get_format_description(),
816
898
       ), out)
817
899
        self.assertEqual('', err)
818
900
 
819
901
        # Create two branches
820
902
        repo.bzrdir.root_transport.mkdir('branch1')
821
 
        branch1 = repo.bzrdir.create_branch_convenience('repo/branch1')
 
903
        branch1 = controldir.ControlDir.create_branch_convenience('repo/branch1',
 
904
            format=format)
822
905
        branch2 = branch1.bzrdir.sprout('repo/branch2').open_branch()
823
906
 
824
907
        # Empty first branch
825
 
        out, err = self.runbzr('info repo/branch1 --verbose')
 
908
        out, err = self.run_bzr('info repo/branch1 --verbose')
826
909
        self.assertEqualDiff(
827
 
"""Location:
828
 
    shared repository: %s
829
 
  repository checkout: branch1
 
910
"""Repository tree (format: knit)
 
911
Location:
 
912
  shared repository: repo
 
913
  repository branch: repo/branch1
830
914
 
831
915
Format:
832
916
       control: Meta directory format 1
833
917
  working tree: Working tree format 3
834
 
        branch: Branch format 5
 
918
        branch: %s
835
919
    repository: %s
836
920
 
 
921
Control directory:
 
922
         1 branches
 
923
 
837
924
In the working tree:
838
925
         0 unchanged
839
926
         0 modified
846
933
 
847
934
Branch history:
848
935
         0 revisions
849
 
         0 committers
850
936
 
851
 
Revision store:
 
937
Repository:
852
938
         0 revisions
853
 
         0 KiB
854
 
""" % (repo.bzrdir.root_transport.base,
855
 
       repo._format.get_format_description(),
 
939
""" % (format.get_branch_format().get_format_description(),
 
940
       format.repository_format.get_format_description(),
856
941
       ), out)
857
942
        self.assertEqual('', err)
858
943
 
861
946
        tree1 = branch1.bzrdir.open_workingtree()
862
947
        tree1.add('a')
863
948
        tree1.commit('commit one')
864
 
        rev = repo.get_revision(branch1.revision_history()[0])
865
 
        datestring_first = format_date(rev.timestamp, rev.timezone)
866
 
        out, err = self.runbzr('info repo/branch1')
 
949
        rev = repo.get_revision(branch1.last_revision())
 
950
        datestring_first = osutils.format_date(rev.timestamp, rev.timezone)
 
951
        out, err = self.run_bzr('info -v repo/branch1')
867
952
        self.assertEqualDiff(
868
 
"""Location:
869
 
    shared repository: %s
870
 
  repository checkout: branch1
 
953
"""Repository tree (format: knit)
 
954
Location:
 
955
  shared repository: repo
 
956
  repository branch: repo/branch1
871
957
 
872
958
Format:
873
959
       control: Meta directory format 1
874
960
  working tree: Working tree format 3
875
 
        branch: Branch format 5
 
961
        branch: %s
876
962
    repository: %s
877
963
 
 
964
Control directory:
 
965
         1 branches
 
966
 
878
967
In the working tree:
879
968
         1 unchanged
880
969
         0 modified
891
980
   first revision: %s
892
981
  latest revision: %s
893
982
 
894
 
Revision store:
 
983
Repository:
895
984
         1 revision
896
 
         %d KiB
897
 
""" % (repo.bzrdir.root_transport.base,
898
 
       repo._format.get_format_description(),
 
985
""" % (format.get_branch_format().get_format_description(),
 
986
       format.repository_format.get_format_description(),
899
987
       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
988
       ), out)
904
989
        self.assertEqual('', err)
905
990
 
906
991
        # Out of date second branch
907
 
        out, err = self.runbzr('info repo/branch2 --verbose')
 
992
        out, err = self.run_bzr('info repo/branch2 --verbose')
908
993
        self.assertEqualDiff(
909
 
"""Location:
910
 
    shared repository: %s
911
 
  repository checkout: branch2
 
994
"""Repository tree (format: knit)
 
995
Location:
 
996
  shared repository: repo
 
997
  repository branch: repo/branch2
912
998
 
913
999
Related branches:
914
 
  parent branch: %s
 
1000
  parent branch: repo/branch1
915
1001
 
916
1002
Format:
917
1003
       control: Meta directory format 1
918
1004
  working tree: Working tree format 3
919
 
        branch: Branch format 5
 
1005
        branch: %s
920
1006
    repository: %s
921
1007
 
 
1008
Control directory:
 
1009
         1 branches
 
1010
 
922
1011
In the working tree:
923
1012
         0 unchanged
924
1013
         0 modified
931
1020
 
932
1021
Branch history:
933
1022
         0 revisions
934
 
         0 committers
935
1023
 
936
 
Revision store:
 
1024
Repository:
937
1025
         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,
 
1026
""" % (format.get_branch_format().get_format_description(),
 
1027
       format.repository_format.get_format_description(),
945
1028
       ), out)
946
1029
        self.assertEqual('', err)
947
1030
 
948
1031
        # Update second branch
949
1032
        tree2 = branch2.bzrdir.open_workingtree()
950
1033
        tree2.pull(branch1)
951
 
        out, err = self.runbzr('info repo/branch2')
 
1034
        out, err = self.run_bzr('info -v repo/branch2')
952
1035
        self.assertEqualDiff(
953
 
"""Location:
954
 
    shared repository: %s
955
 
  repository checkout: branch2
 
1036
"""Repository tree (format: knit)
 
1037
Location:
 
1038
  shared repository: repo
 
1039
  repository branch: repo/branch2
956
1040
 
957
1041
Related branches:
958
 
  parent branch: %s
 
1042
  parent branch: repo/branch1
959
1043
 
960
1044
Format:
961
1045
       control: Meta directory format 1
962
1046
  working tree: Working tree format 3
963
 
        branch: Branch format 5
 
1047
        branch: %s
964
1048
    repository: %s
965
1049
 
 
1050
Control directory:
 
1051
         1 branches
 
1052
 
966
1053
In the working tree:
967
1054
         1 unchanged
968
1055
         0 modified
979
1066
   first revision: %s
980
1067
  latest revision: %s
981
1068
 
982
 
Revision store:
 
1069
Repository:
983
1070
         1 revision
984
 
         %d KiB
985
 
""" % (repo.bzrdir.root_transport.base,
986
 
       branch1.bzrdir.root_transport.base,
987
 
       repo._format.get_format_description(),
 
1071
""" % (format.get_branch_format().get_format_description(),
 
1072
       format.repository_format.get_format_description(),
988
1073
       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
1074
       ), out)
993
1075
        self.assertEqual('', err)
994
1076
 
995
1077
        # Show info about repository with revisions
996
 
        out, err = self.runbzr('info repo')
 
1078
        out, err = self.run_bzr('info -v repo')
997
1079
        self.assertEqualDiff(
998
 
"""Location:
999
 
  shared repository: %s
 
1080
"""Shared repository with trees (format: dirstate or dirstate-tags or knit)
 
1081
Location:
 
1082
  shared repository: repo
1000
1083
 
1001
1084
Format:
1002
1085
       control: Meta directory format 1
1003
1086
    repository: %s
1004
1087
 
 
1088
Control directory:
 
1089
         0 branches
 
1090
 
1005
1091
Create working tree for new branches inside the repository.
1006
1092
 
1007
 
Revision store:
 
1093
Repository:
1008
1094
         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,
 
1095
""" % (format.repository_format.get_format_description(),
1015
1096
       ),
1016
1097
       out)
1017
1098
        self.assertEqual('', err)
1018
1099
 
1019
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
1020
 
    
1021
1100
    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())
 
1101
        format = controldir.format_registry.make_bzrdir('knit')
1024
1102
        transport = self.get_transport()
1025
1103
 
1026
1104
        # Create shared repository with working trees
1027
 
        repo = self.make_repository('repo', shared=True)
 
1105
        repo = self.make_repository('repo', shared=True, format=format)
1028
1106
        repo.set_make_working_trees(True)
1029
 
        out, err = self.runbzr('info repo')
 
1107
        out, err = self.run_bzr('info -v repo')
1030
1108
        self.assertEqualDiff(
1031
 
"""Location:
1032
 
  shared repository: %s
 
1109
"""Shared repository with trees (format: dirstate or dirstate-tags or knit)
 
1110
Location:
 
1111
  shared repository: repo
1033
1112
 
1034
1113
Format:
1035
1114
       control: Meta directory format 1
1036
1115
    repository: %s
1037
1116
 
 
1117
Control directory:
 
1118
         0 branches
 
1119
 
1038
1120
Create working tree for new branches inside the repository.
1039
1121
 
1040
 
Revision store:
 
1122
Repository:
1041
1123
         0 revisions
1042
 
         0 KiB
1043
 
""" % (repo.bzrdir.root_transport.base,
1044
 
       repo._format.get_format_description(),
 
1124
""" % (format.repository_format.get_format_description(),
1045
1125
       ), out)
1046
1126
        self.assertEqual('', err)
1047
1127
 
1049
1129
        control = repo.bzrdir
1050
1130
        branch = control.create_branch()
1051
1131
        control.create_workingtree()
1052
 
        out, err = self.runbzr('info repo')
 
1132
        out, err = self.run_bzr('info -v repo')
1053
1133
        self.assertEqualDiff(
1054
 
"""Location:
1055
 
    shared repository: %s
1056
 
  repository checkout: .
 
1134
"""Repository tree (format: knit)
 
1135
Location:
 
1136
  shared repository: repo
 
1137
  repository branch: repo
1057
1138
 
1058
1139
Format:
1059
1140
       control: Meta directory format 1
1060
1141
  working tree: Working tree format 3
1061
 
        branch: Branch format 5
 
1142
        branch: %s
1062
1143
    repository: %s
1063
1144
 
 
1145
Control directory:
 
1146
         1 branches
 
1147
 
1064
1148
In the working tree:
1065
1149
         0 unchanged
1066
1150
         0 modified
1074
1158
Branch history:
1075
1159
         0 revisions
1076
1160
 
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, 
 
1161
Repository:
 
1162
         0 revisions
 
1163
""" % (format.get_branch_format().get_format_description(),
 
1164
       format.repository_format.get_format_description(),
 
1165
       ), out)
 
1166
        self.assertEqual('', err)
 
1167
 
 
1168
    def test_info_repository_hook(self):
 
1169
        format = controldir.format_registry.make_bzrdir('knit')
 
1170
        def repo_info(repo, stats, outf):
 
1171
            outf.write("more info\n")
 
1172
        info.hooks.install_named_hook('repository', repo_info, None)
 
1173
        # Create shared repository with working trees
 
1174
        repo = self.make_repository('repo', shared=True, format=format)
 
1175
        out, err = self.run_bzr('info -v repo')
 
1176
        self.assertEqualDiff(
 
1177
"""Shared repository with trees (format: dirstate or dirstate-tags or knit)
 
1178
Location:
 
1179
  shared repository: repo
 
1180
 
 
1181
Format:
 
1182
       control: Meta directory format 1
 
1183
    repository: %s
 
1184
 
 
1185
Control directory:
 
1186
         0 branches
 
1187
 
 
1188
Create working tree for new branches inside the repository.
 
1189
 
 
1190
Repository:
 
1191
         0 revisions
 
1192
more info
 
1193
""" % (format.repository_format.get_format_description(),
 
1194
       ), out)
 
1195
        self.assertEqual('', err)
 
1196
 
 
1197
    def test_info_unshared_repository_with_colocated_branches(self):
 
1198
        format = controldir.format_registry.make_bzrdir('development-colo')
 
1199
        transport = self.get_transport()
 
1200
 
 
1201
        # Create unshared repository
 
1202
        repo = self.make_repository('repo', shared=False, format=format)
 
1203
        repo.set_make_working_trees(True)
 
1204
        repo.bzrdir.create_branch(name='foo')
 
1205
        out, err = self.run_bzr('info repo')
 
1206
        self.assertEqualDiff(
 
1207
"""Unshared repository with trees and colocated branches (format: development-colo)
 
1208
Location:
 
1209
  repository: repo
 
1210
""", out)
 
1211
        self.assertEqual('', err)
 
1212
 
 
1213
    def assertCheckoutStatusOutput(self,
1088
1214
        command_string, lco_tree, shared_repo=None,
1089
1215
        repo_branch=None,
1090
1216
        tree_locked=False,
1091
1217
        branch_locked=False, repo_locked=False,
1092
1218
        verbose=False,
1093
 
        light_checkout=True):
1094
 
        """Check the output of info in a light checkout tree.
 
1219
        light_checkout=True,
 
1220
        checkout_root=None):
 
1221
        """Check the output of info in a checkout.
1095
1222
 
1096
1223
        This is not quite a mirror of the info code: rather than using the
1097
1224
        tree being examined to predict output, it uses a bunch of flags which
1098
1225
        allow us, the test writers, to document what *should* be present in
1099
1226
        the output. Removing this separation would remove the value of the
1100
1227
        tests.
1101
 
        
 
1228
 
1102
1229
        :param path: the path to the light checkout.
1103
1230
        :param lco_tree: the tree object for the light checkout.
1104
1231
        :param shared_repo: A shared repository is in use, expect that in
1108
1235
        :param tree_locked: If true, expect the tree to be locked.
1109
1236
        :param branch_locked: If true, expect the branch to be locked.
1110
1237
        :param repo_locked: If true, expect the repository to be locked.
1111
 
        :param verbose: If true, expect verbose output
 
1238
            Note that the lco_tree.branch.repository is inspected, and if is not
 
1239
            actually locked then this parameter is overridden. This is because
 
1240
            pack repositories do not have any public API for obtaining an
 
1241
            exclusive repository wide lock.
 
1242
        :param verbose: verbosity level: 2 or higher to show committers
1112
1243
        """
1113
 
        out, err = self.runbzr('info %s' % command_string)
 
1244
        def friendly_location(url):
 
1245
            path = urlutils.unescape_for_display(url, 'ascii')
 
1246
            try:
 
1247
                return osutils.relpath(osutils.getcwd(), path)
 
1248
            except errors.PathNotChild:
 
1249
                return path
 
1250
 
 
1251
        if tree_locked:
 
1252
            # We expect this to fail because of locking errors.
 
1253
            # (A write-locked file cannot be read-locked
 
1254
            # in the different process -- either on win32 or on linux).
 
1255
            # This should be removed when the locking errors are fixed.
 
1256
            self.expectFailure('OS locks are exclusive '
 
1257
                'for different processes (Bug #174055)',
 
1258
                self.run_bzr_subprocess,
 
1259
                'info ' + command_string)
 
1260
        out, err = self.run_bzr('info %s' % command_string)
 
1261
        description = {
 
1262
            (True, True): 'Lightweight checkout',
 
1263
            (True, False): 'Repository checkout',
 
1264
            (False, True): 'Lightweight checkout',
 
1265
            (False, False): 'Checkout',
 
1266
            }[(shared_repo is not None, light_checkout)]
 
1267
        format = {True: self._repo_strings,
 
1268
                  False: 'unnamed'}[light_checkout]
 
1269
        if repo_locked:
 
1270
            repo_locked = lco_tree.branch.repository.get_physical_lock_status()
1114
1271
        if repo_locked or branch_locked or tree_locked:
1115
1272
            def locked_message(a_bool):
1116
1273
                if a_bool:
1128
1285
                    locked_message(repo_locked)))
1129
1286
        else:
1130
1287
            expected_lock_output = ''
 
1288
        tree_data = ''
 
1289
        extra_space = ''
1131
1290
        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)
 
1291
            tree_data = ("  light checkout root: %s\n" %
 
1292
                friendly_location(lco_tree.bzrdir.root_transport.base))
 
1293
            extra_space = ' '
 
1294
        if lco_tree.branch.get_bound_location() is not None:
 
1295
            tree_data += ("%s       checkout root: %s\n" % (extra_space,
 
1296
                friendly_location(lco_tree.branch.bzrdir.root_transport.base)))
1137
1297
        if shared_repo is not None:
1138
1298
            branch_data = (
1139
 
                "   shared repository: %s\n"
1140
 
                "   repository branch: branch\n" %
1141
 
                shared_repo.bzrdir.root_transport.base)
 
1299
                "   checkout of branch: %s\n"
 
1300
                "    shared repository: %s\n" %
 
1301
                (friendly_location(repo_branch.bzrdir.root_transport.base),
 
1302
                 friendly_location(shared_repo.bzrdir.root_transport.base)))
1142
1303
        elif repo_branch is not None:
1143
1304
            branch_data = (
1144
 
                "  checkout of branch: %s\n" % 
1145
 
                repo_branch.bzrdir.root_transport.base)
 
1305
                "%s  checkout of branch: %s\n" %
 
1306
                (extra_space,
 
1307
                 friendly_location(repo_branch.bzrdir.root_transport.base)))
1146
1308
        else:
1147
 
            branch_data = ("  checkout of branch: %s\n" % 
 
1309
            branch_data = ("   checkout of branch: %s\n" %
1148
1310
                lco_tree.branch.bzrdir.root_transport.base)
1149
 
        
1150
 
        if verbose:
 
1311
 
 
1312
        if verbose >= 2:
1151
1313
            verbose_info = '         0 committers\n'
1152
1314
        else:
1153
1315
            verbose_info = ''
1154
 
            
 
1316
 
1155
1317
        self.assertEqualDiff(
1156
 
"""Location:
1157
 
%s
1158
 
%s
 
1318
"""%s (format: %s)
 
1319
Location:
 
1320
%s%s
1159
1321
Format:
1160
1322
       control: Meta directory format 1
1161
1323
  working tree: %s
1162
 
        branch: Branch format 5
 
1324
        branch: %s
1163
1325
    repository: %s
1164
1326
%s
 
1327
Control directory:
 
1328
         1 branches
 
1329
 
1165
1330
In the working tree:
1166
1331
         0 unchanged
1167
1332
         0 modified
1175
1340
Branch history:
1176
1341
         0 revisions
1177
1342
%s
1178
 
Revision store:
 
1343
Repository:
1179
1344
         0 revisions
1180
 
         0 KiB
1181
 
""" %  (tree_data,
 
1345
""" %  (description,
 
1346
        format,
 
1347
        tree_data,
1182
1348
        branch_data,
1183
1349
        lco_tree._format.get_format_description(),
 
1350
        lco_tree.branch._format.get_format_description(),
1184
1351
        lco_tree.branch.repository._format.get_format_description(),
1185
1352
        expected_lock_output,
1186
1353
        verbose_info,
1191
1358
        transport = self.get_transport()
1192
1359
        # Create shared repository with a branch
1193
1360
        repo = self.make_repository('repo', shared=True,
1194
 
                                    format=bzrlib.bzrdir.BzrDirMetaFormat1())
 
1361
                                    format=bzrdir.BzrDirMetaFormat1())
1195
1362
        repo.set_make_working_trees(False)
1196
1363
        repo.bzrdir.root_transport.mkdir('branch')
1197
 
        repo_branch = repo.bzrdir.create_branch_convenience('repo/branch',
1198
 
                                    format=bzrlib.bzrdir.BzrDirMetaFormat1())
 
1364
        repo_branch = controldir.ControlDir.create_branch_convenience(
 
1365
            'repo/branch', format=bzrdir.BzrDirMetaFormat1())
1199
1366
        # Do a heavy checkout
1200
1367
        transport.mkdir('tree')
1201
1368
        transport.mkdir('tree/checkout')
1202
 
        co_branch = bzrlib.bzrdir.BzrDir.create_branch_convenience('tree/checkout',
1203
 
                                    format=bzrlib.bzrdir.BzrDirMetaFormat1())
 
1369
        co_branch = controldir.ControlDir.create_branch_convenience(
 
1370
            'tree/checkout', format=bzrdir.BzrDirMetaFormat1())
1204
1371
        co_branch.bind(repo_branch)
1205
1372
        # Do a light checkout of the heavy one
1206
1373
        transport.mkdir('tree/lightcheckout')
1207
 
        lco_dir = bzrlib.bzrdir.BzrDirMetaFormat1().initialize('tree/lightcheckout')
1208
 
        bzrlib.branch.BranchReferenceFormat().initialize(lco_dir, co_branch)
 
1374
        lco_dir = bzrdir.BzrDirMetaFormat1().initialize('tree/lightcheckout')
 
1375
        lco_dir.set_branch_reference(co_branch)
1209
1376
        lco_dir.create_workingtree()
1210
1377
        lco_tree = lco_dir.open_workingtree()
1211
1378
 
1213
1380
        # W B R
1214
1381
 
1215
1382
        # U U U
1216
 
        self.assertCheckoutStatusOutput('tree/lightcheckout', lco_tree)
 
1383
        self.assertCheckoutStatusOutput('-v tree/lightcheckout', lco_tree,
 
1384
                                        repo_branch=repo_branch,
 
1385
                                        verbose=True, light_checkout=True)
1217
1386
        # U U L
1218
1387
        lco_tree.branch.repository.lock_write()
1219
1388
        try:
1220
 
            self.assertCheckoutStatusOutput('tree/lightcheckout',
1221
 
            lco_tree,
1222
 
            repo_locked=True)
 
1389
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
 
1390
            lco_tree, repo_branch=repo_branch,
 
1391
            repo_locked=True, verbose=True, light_checkout=True)
1223
1392
        finally:
1224
1393
            lco_tree.branch.repository.unlock()
1225
1394
        # U L L
1226
1395
        lco_tree.branch.lock_write()
1227
1396
        try:
1228
 
            self.assertCheckoutStatusOutput('tree/lightcheckout',
 
1397
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
1229
1398
            lco_tree,
1230
1399
            branch_locked=True,
1231
 
            repo_locked=True)
 
1400
            repo_locked=True,
 
1401
            repo_branch=repo_branch,
 
1402
            verbose=True)
1232
1403
        finally:
1233
1404
            lco_tree.branch.unlock()
1234
1405
        # L L L
1235
1406
        lco_tree.lock_write()
1236
1407
        try:
1237
 
            self.assertCheckoutStatusOutput('tree/lightcheckout',
1238
 
            lco_tree,
 
1408
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
 
1409
            lco_tree, repo_branch=repo_branch,
1239
1410
            tree_locked=True,
1240
1411
            branch_locked=True,
1241
 
            repo_locked=True)
 
1412
            repo_locked=True,
 
1413
            verbose=True)
1242
1414
        finally:
1243
1415
            lco_tree.unlock()
1244
1416
        # L L U
1245
1417
        lco_tree.lock_write()
1246
1418
        lco_tree.branch.repository.unlock()
1247
1419
        try:
1248
 
            self.assertCheckoutStatusOutput('tree/lightcheckout',
1249
 
            lco_tree,
 
1420
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
 
1421
            lco_tree, repo_branch=repo_branch,
1250
1422
            tree_locked=True,
1251
 
            branch_locked=True)
 
1423
            branch_locked=True,
 
1424
            verbose=True)
1252
1425
        finally:
1253
1426
            lco_tree.branch.repository.lock_write()
1254
1427
            lco_tree.unlock()
1256
1429
        lco_tree.lock_write()
1257
1430
        lco_tree.branch.unlock()
1258
1431
        try:
1259
 
            self.assertCheckoutStatusOutput('tree/lightcheckout',
1260
 
            lco_tree,
1261
 
            tree_locked=True)
 
1432
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
 
1433
            lco_tree, repo_branch=repo_branch,
 
1434
            tree_locked=True,
 
1435
            verbose=True)
1262
1436
        finally:
1263
1437
            lco_tree.branch.lock_write()
1264
1438
            lco_tree.unlock()
1267
1441
        lco_tree.branch.unlock()
1268
1442
        lco_tree.branch.repository.lock_write()
1269
1443
        try:
1270
 
            self.assertCheckoutStatusOutput('tree/lightcheckout',
1271
 
            lco_tree,
 
1444
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
 
1445
            lco_tree, repo_branch=repo_branch,
1272
1446
            tree_locked=True,
1273
 
            repo_locked=True)
 
1447
            repo_locked=True,
 
1448
            verbose=True)
1274
1449
        finally:
1275
1450
            lco_tree.branch.repository.unlock()
1276
1451
            lco_tree.branch.lock_write()
1279
1454
        lco_tree.branch.lock_write()
1280
1455
        lco_tree.branch.repository.unlock()
1281
1456
        try:
1282
 
            self.assertCheckoutStatusOutput('tree/lightcheckout',
1283
 
            lco_tree,
1284
 
            branch_locked=True)
 
1457
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
 
1458
            lco_tree, repo_branch=repo_branch,
 
1459
            branch_locked=True,
 
1460
            verbose=True)
1285
1461
        finally:
1286
1462
            lco_tree.branch.repository.lock_write()
1287
1463
            lco_tree.branch.unlock()
1288
1464
 
1289
 
    def test_info_locking_oslocks(self):
1290
 
        if sys.platform == "win32":
1291
 
            raise TestSkipped("don't use oslocks on win32 in unix manner")
1292
 
 
1293
 
        tree = self.make_branch_and_tree('branch',
1294
 
                                         format=bzrlib.bzrdir.BzrDirFormat6())
1295
 
 
1296
 
        # Test all permutations of locking the working tree, branch and repository
1297
 
        # XXX: Well not yet, as we can't query oslocks yet. Currently, it's
1298
 
        # implemented by raising NotImplementedError and get_physical_lock_status()
1299
 
        # always returns false. This makes bzr info hide the lock status.  (Olaf)
1300
 
        # W B R
1301
 
 
1302
 
        # U U U
1303
 
        out, err = self.runbzr('info branch')
1304
 
        self.assertEqualDiff(
1305
 
"""Location:
1306
 
  branch root: %s
1307
 
 
1308
 
Format:
1309
 
       control: All-in-one format 6
1310
 
  working tree: Working tree format 2
1311
 
        branch: Branch format 4
1312
 
    repository: %s
1313
 
 
1314
 
In the working tree:
1315
 
         0 unchanged
1316
 
         0 modified
1317
 
         0 added
1318
 
         0 removed
1319
 
         0 renamed
1320
 
         0 unknown
1321
 
         0 ignored
1322
 
         0 versioned subdirectories
1323
 
 
1324
 
Branch history:
1325
 
         0 revisions
1326
 
 
1327
 
Revision store:
1328
 
         0 revisions
1329
 
         0 KiB
1330
 
""" % (tree.bzrdir.root_transport.base,
1331
 
       tree.branch.repository._format.get_format_description(),
1332
 
       ), out)
1333
 
        self.assertEqual('', err)
1334
 
        # L L L
1335
 
        tree.lock_write()
1336
 
        out, err = self.runbzr('info branch')
1337
 
        self.assertEqualDiff(
1338
 
"""Location:
1339
 
  branch root: %s
1340
 
 
1341
 
Format:
1342
 
       control: All-in-one format 6
1343
 
  working tree: Working tree format 2
1344
 
        branch: Branch format 4
1345
 
    repository: %s
1346
 
 
1347
 
In the working tree:
1348
 
         0 unchanged
1349
 
         0 modified
1350
 
         0 added
1351
 
         0 removed
1352
 
         0 renamed
1353
 
         0 unknown
1354
 
         0 ignored
1355
 
         0 versioned subdirectories
1356
 
 
1357
 
Branch history:
1358
 
         0 revisions
1359
 
 
1360
 
Revision store:
1361
 
         0 revisions
1362
 
         0 KiB
1363
 
""" % (tree.bzrdir.root_transport.base,
1364
 
       tree.branch.repository._format.get_format_description(),
1365
 
       ), out)
1366
 
        self.assertEqual('', err)
1367
 
        tree.unlock()
 
1465
        if sys.platform == 'win32':
 
1466
            self.knownFailure('Win32 cannot run "bzr info"'
 
1467
                              ' when the tree is locked.')
 
1468
 
 
1469
    def test_info_stacked(self):
 
1470
        # We have a mainline
 
1471
        trunk_tree = self.make_branch_and_tree('mainline',
 
1472
            format='1.6')
 
1473
        trunk_tree.commit('mainline')
 
1474
        # and a branch from it which is stacked
 
1475
        new_dir = trunk_tree.bzrdir.sprout('newbranch', stacked=True)
 
1476
        out, err = self.run_bzr('info newbranch')
 
1477
        self.assertEqual(
 
1478
"""Standalone tree (format: 1.6)
 
1479
Location:
 
1480
  branch root: newbranch
 
1481
 
 
1482
Related branches:
 
1483
  parent branch: mainline
 
1484
     stacked on: mainline
 
1485
""", out)
 
1486
        self.assertEqual("", err)
 
1487
 
 
1488
    def test_info_revinfo_optional(self):
 
1489
        tree = self.make_branch_and_tree('.')
 
1490
        def last_revision_info(self):
 
1491
            raise errors.UnsupportedOperation(last_revision_info, self)
 
1492
        self.overrideAttr(
 
1493
            branch.Branch, "last_revision_info", last_revision_info)
 
1494
        out, err = self.run_bzr('info -v .')
 
1495
        self.assertEqual(
 
1496
"""Standalone tree (format: 2a)
 
1497
Location:
 
1498
  branch root: .
 
1499
 
 
1500
Format:
 
1501
       control: Meta directory format 1
 
1502
  working tree: Working tree format 6
 
1503
        branch: Branch format 7
 
1504
    repository: Repository format 2a - rich roots, group compression and chk inventories
 
1505
 
 
1506
Control directory:
 
1507
         1 branches
 
1508
 
 
1509
In the working tree:
 
1510
         0 unchanged
 
1511
         0 modified
 
1512
         0 added
 
1513
         0 removed
 
1514
         0 renamed
 
1515
         0 unknown
 
1516
         0 ignored
 
1517
         0 versioned subdirectories
 
1518
""", out)
 
1519
        self.assertEqual("", err)
 
1520
 
 
1521
    def test_info_shows_colocated_branches(self):
 
1522
        bzrdir = self.make_branch('.', format='development-colo').bzrdir
 
1523
        bzrdir.create_branch(name="colo1")
 
1524
        bzrdir.create_branch(name="colo2")
 
1525
        bzrdir.create_branch(name="colo3")
 
1526
        out, err = self.run_bzr('info -v .')
 
1527
        self.assertEqualDiff(
 
1528
"""Standalone branch (format: development-colo)
 
1529
Location:
 
1530
  branch root: .
 
1531
 
 
1532
Format:
 
1533
       control: Meta directory format 1 with support for colocated branches
 
1534
        branch: Branch format 7
 
1535
    repository: Repository format 2a - rich roots, group compression and chk inventories
 
1536
 
 
1537
Control directory:
 
1538
         4 branches
 
1539
 
 
1540
Branch history:
 
1541
         0 revisions
 
1542
 
 
1543
Repository:
 
1544
         0 revisions
 
1545
""", out)
 
1546
        self.assertEqual("", err)
 
1547
 
 
1548
 
 
1549
class TestSmartServerInfo(tests.TestCaseWithTransport):
 
1550
 
 
1551
    def test_simple_branch_info(self):
 
1552
        self.setup_smart_server_with_call_log()
 
1553
        t = self.make_branch_and_tree('branch')
 
1554
        self.build_tree_contents([('branch/foo', 'thecontents')])
 
1555
        t.add("foo")
 
1556
        t.commit("message")
 
1557
        self.reset_smart_call_log()
 
1558
        out, err = self.run_bzr(['info', self.get_url('branch')])
 
1559
        # This figure represent the amount of work to perform this use case. It
 
1560
        # is entirely ok to reduce this number if a test fails due to rpc_count
 
1561
        # being too low. If rpc_count increases, more network roundtrips have
 
1562
        # become necessary for this use case. Please do not adjust this number
 
1563
        # upwards without agreement from bzr's network support maintainers.
 
1564
        self.assertLength(10, self.hpss_calls)
 
1565
        self.assertLength(1, self.hpss_connections)
 
1566
        self.assertThat(self.hpss_calls, ContainsNoVfsCalls)
 
1567
 
 
1568
    def test_verbose_branch_info(self):
 
1569
        self.setup_smart_server_with_call_log()
 
1570
        t = self.make_branch_and_tree('branch')
 
1571
        self.build_tree_contents([('branch/foo', 'thecontents')])
 
1572
        t.add("foo")
 
1573
        t.commit("message")
 
1574
        self.reset_smart_call_log()
 
1575
        out, err = self.run_bzr(['info', '-v', self.get_url('branch')])
 
1576
        # This figure represent the amount of work to perform this use case. It
 
1577
        # is entirely ok to reduce this number if a test fails due to rpc_count
 
1578
        # being too low. If rpc_count increases, more network roundtrips have
 
1579
        # become necessary for this use case. Please do not adjust this number
 
1580
        # upwards without agreement from bzr's network support maintainers.
 
1581
        self.assertLength(14, self.hpss_calls)
 
1582
        self.assertLength(1, self.hpss_connections)
 
1583
        self.assertThat(self.hpss_calls, ContainsNoVfsCalls)