/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

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

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

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