← 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: 2011-09-22 14:12:18 UTC
  • mfrom: (6155.3.1 jam)
  • Revision ID: pqm@pqm.ubuntu.com-20110922141218-86s4uu6nqvourw4f
(jameinel) Cleanup comments bzrlib/smart/__init__.py (John A Meinel)

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