← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

  • Committer: Martin Pool
  • Date: 2007-07-05 00:12:25 UTC
  • mfrom: (2586 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2588.
  • Revision ID: mbp@sourcefrog.net-20070705001225-sgr71qfxpj9ghc83
merge trunk and fix run_bzr call in merge_directive tests

Show diffs side-by-side

added added

removed removed

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