← 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: Andrew Bennetts
  • Date: 2009-12-03 02:24:54 UTC
  • mfrom: (4634.101.4 2.0)
  • mto: This revision was merged to the branch mainline in revision 4857.
  • Revision ID: andrew.bennetts@canonical.com-20091203022454-m2gyhbcdqi1t7ujz
Merge lp:bzr/2.0 into lp:bzr.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_info.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
17
17
 
18
18
"""Tests for the info command of bzr."""
19
19
 
20
 
import shutil
21
20
import sys
22
21
 
23
22
from bzrlib import (
24
23
    branch,
25
24
    bzrdir,
26
 
    controldir,
27
25
    errors,
28
26
    info,
29
27
    osutils,
30
 
    tests,
31
28
    upgrade,
32
29
    urlutils,
33
30
    )
34
 
from bzrlib.tests.matchers import ContainsNoVfsCalls
35
 
from bzrlib.transport import memory
36
 
 
37
 
 
38
 
class TestInfo(tests.TestCaseWithTransport):
 
31
from bzrlib.osutils import format_date
 
32
from bzrlib.tests import TestSkipped, MemoryServer
 
33
from bzrlib.tests.blackbox import ExternalBase
 
34
 
 
35
 
 
36
class TestInfo(ExternalBase):
39
37
 
40
38
    def setUp(self):
41
 
        super(TestInfo, self).setUp()
42
 
        self._repo_strings = "2a"
 
39
        ExternalBase.setUp(self)
 
40
        self._repo_strings = "2a or development-subtree"
43
41
 
44
42
    def test_info_non_existing(self):
45
 
        self.vfs_transport_factory = memory.MemoryServer
 
43
        self.vfs_transport_factory = MemoryServer
46
44
        location = self.get_url()
47
45
        out, err = self.run_bzr('info '+location, retcode=3)
48
46
        self.assertEqual(out, '')
49
47
        self.assertEqual(err, 'bzr: ERROR: Not a branch: "%s".\n' % location)
50
48
 
51
 
    def test_info_empty_controldir(self):
52
 
        self.make_bzrdir('ctrl')
53
 
        out, err = self.run_bzr('info ctrl')
54
 
        self.assertEquals(out,
55
 
            'Empty control directory (format: 2a or pack-0.92)\n'
56
 
            'Location:\n'
57
 
            '  control directory: ctrl\n')
58
 
        self.assertEquals(err, '')
59
 
 
60
 
    def test_info_dangling_branch_reference(self):
61
 
        br = self.make_branch('target')
62
 
        br.create_checkout('from', lightweight=True)
63
 
        shutil.rmtree('target')
64
 
        out, err = self.run_bzr('info from')
65
 
        self.assertEquals(out,
66
 
            'Dangling branch reference (format: 2a or pack-0.92)\n'
67
 
            'Location:\n'
68
 
            '   control directory: from\n'
69
 
            '  checkout of branch: target\n')
70
 
        self.assertEquals(err, '')
71
 
 
72
49
    def test_info_standalone(self):
73
50
        transport = self.get_transport()
74
51
 
75
52
        # Create initial standalone branch
76
 
        tree1 = self.make_branch_and_tree('standalone', 'knit')
 
53
        tree1 = self.make_branch_and_tree('standalone', 'weave')
77
54
        self.build_tree(['standalone/a'])
78
55
        tree1.add('a')
79
56
        branch1 = tree1.branch
80
57
 
81
58
        out, err = self.run_bzr('info standalone')
82
59
        self.assertEqualDiff(
83
 
"""Standalone tree (format: knit)
 
60
"""Standalone tree (format: weave)
84
61
Location:
85
62
  branch root: standalone
86
63
""", out)
89
66
        # Standalone branch - verbose mode
90
67
        out, err = self.run_bzr('info standalone -v')
91
68
        self.assertEqualDiff(
92
 
"""Standalone tree (format: knit)
 
69
"""Standalone tree (format: weave)
93
70
Location:
94
71
  branch root: standalone
95
72
 
96
73
Format:
97
 
       control: Meta directory format 1
98
 
  working tree: Working tree format 3
99
 
        branch: Branch format 5
100
 
    repository: Knit repository format 1
 
74
       control: All-in-one format 6
 
75
  working tree: Working tree format 2
 
76
        branch: Branch format 4
 
77
    repository: Weave repository format 6
101
78
 
102
79
In the working tree:
103
80
         0 unchanged
120
97
        # Standalone branch - really verbose mode
121
98
        out, err = self.run_bzr('info standalone -vv')
122
99
        self.assertEqualDiff(
123
 
"""Standalone tree (format: knit)
 
100
"""Standalone tree (format: weave)
124
101
Location:
125
102
  branch root: standalone
126
103
 
127
104
Format:
128
 
       control: Meta directory format 1
129
 
  working tree: Working tree format 3
130
 
        branch: Branch format 5
131
 
    repository: Knit repository format 1
 
105
       control: All-in-one format 6
 
106
  working tree: Working tree format 2
 
107
        branch: Branch format 4
 
108
    repository: Weave repository format 6
132
109
 
133
110
In the working tree:
134
111
         0 unchanged
149
126
""", out)
150
127
        self.assertEqual('', err)
151
128
        tree1.commit('commit one')
152
 
        rev = branch1.repository.get_revision(branch1.last_revision())
153
 
        datestring_first = osutils.format_date(rev.timestamp, rev.timezone)
 
129
        rev = branch1.repository.get_revision(branch1.revision_history()[0])
 
130
        datestring_first = format_date(rev.timestamp, rev.timezone)
154
131
 
155
132
        # Branch standalone with push location
156
133
        branch2 = branch1.bzrdir.sprout('branch').open_branch()
158
135
 
159
136
        out, err = self.run_bzr('info branch')
160
137
        self.assertEqualDiff(
161
 
"""Standalone tree (format: knit)
 
138
"""Standalone tree (format: weave)
162
139
Location:
163
140
  branch root: branch
164
141
 
170
147
 
171
148
        out, err = self.run_bzr('info branch --verbose')
172
149
        self.assertEqualDiff(
173
 
"""Standalone tree (format: knit)
 
150
"""Standalone tree (format: weave)
174
151
Location:
175
152
  branch root: branch
176
153
 
179
156
  parent branch: standalone
180
157
 
181
158
Format:
182
 
       control: Meta directory format 1
183
 
  working tree: Working tree format 3
184
 
        branch: Branch format 5
185
 
    repository: Knit repository format 1
 
159
       control: All-in-one format 6
 
160
  working tree: Working tree format 2
 
161
        branch: Branch format 4
 
162
    repository: Weave repository format 6
186
163
 
187
164
In the working tree:
188
165
         1 unchanged
211
188
        branch1.bzrdir.sprout('bound')
212
189
        knit1_format = bzrdir.format_registry.make_bzrdir('knit')
213
190
        upgrade.upgrade('bound', knit1_format)
214
 
        branch3 = controldir.ControlDir.open('bound').open_branch()
 
191
        branch3 = bzrdir.BzrDir.open('bound').open_branch()
215
192
        branch3.bind(branch1)
216
193
        bound_tree = branch3.bzrdir.open_workingtree()
217
194
        out, err = self.run_bzr('info -v bound')
236
213
         0 added
237
214
         0 removed
238
215
         0 renamed
239
 
         0 unknown
 
216
         1 unknown
240
217
         0 ignored
241
218
         0 versioned subdirectories
242
219
 
256
233
        self.assertEqual('', err)
257
234
 
258
235
        # Checkout standalone (same as above, but does not have parent set)
259
 
        branch4 = controldir.ControlDir.create_branch_convenience('checkout',
 
236
        branch4 = bzrdir.BzrDir.create_branch_convenience('checkout',
260
237
            format=knit1_format)
261
238
        branch4.bind(branch1)
262
239
        branch4.bzrdir.open_workingtree().update()
300
277
        tree5 = branch1.create_checkout('lightcheckout', lightweight=True)
301
278
        branch5 = tree5.branch
302
279
        out, err = self.run_bzr('info -v lightcheckout')
303
 
        if "metaweave" in bzrdir.format_registry:
304
 
            format_description = "knit or metaweave"
305
 
        else:
306
 
            format_description = "knit"
307
280
        self.assertEqualDiff(
308
281
"""Lightweight checkout (format: %s)
309
282
Location:
312
285
 
313
286
Format:
314
287
       control: Meta directory format 1
315
 
  working tree: Working tree format 3
316
 
        branch: Branch format 5
317
 
    repository: Knit repository format 1
 
288
  working tree: Working tree format 6
 
289
        branch: Branch format 4
 
290
    repository: Weave repository format 6
318
291
 
319
292
In the working tree:
320
293
         1 unchanged
334
307
 
335
308
Repository:
336
309
         1 revision
337
 
""" % (format_description, datestring_first, datestring_first,), out)
 
310
""" % (self._repo_strings, datestring_first, datestring_first,), out)
338
311
        self.assertEqual('', err)
339
312
 
340
313
        # Update initial standalone branch
341
314
        self.build_tree(['standalone/b'])
342
315
        tree1.add('b')
343
316
        tree1.commit('commit two')
344
 
        rev = branch1.repository.get_revision(branch1.last_revision())
345
 
        datestring_last = osutils.format_date(rev.timestamp, rev.timezone)
 
317
        rev = branch1.repository.get_revision(branch1.revision_history()[-1])
 
318
        datestring_last = format_date(rev.timestamp, rev.timezone)
346
319
 
347
320
        # Out of date branched standalone branch will not be detected
348
321
        out, err = self.run_bzr('info -v branch')
349
322
        self.assertEqualDiff(
350
 
"""Standalone tree (format: knit)
 
323
"""Standalone tree (format: weave)
351
324
Location:
352
325
  branch root: branch
353
326
 
356
329
  parent branch: standalone
357
330
 
358
331
Format:
359
 
       control: Meta directory format 1
360
 
  working tree: Working tree format 3
361
 
        branch: Branch format 5
362
 
    repository: Knit repository format 1
 
332
       control: All-in-one format 6
 
333
  working tree: Working tree format 2
 
334
        branch: Branch format 4
 
335
    repository: Weave repository format 6
363
336
 
364
337
In the working tree:
365
338
         1 unchanged
408
381
         0 added
409
382
         0 removed
410
383
         0 renamed
411
 
         0 unknown
 
384
         1 unknown
412
385
         0 ignored
413
386
         0 versioned subdirectories
414
387
 
474
447
 
475
448
Format:
476
449
       control: Meta directory format 1
477
 
  working tree: Working tree format 3
478
 
        branch: Branch format 5
479
 
    repository: Knit repository format 1
 
450
  working tree: Working tree format 6
 
451
        branch: Branch format 4
 
452
    repository: Weave repository format 6
480
453
 
481
454
Working tree is out of date: missing 1 revision.
482
455
 
498
471
 
499
472
Repository:
500
473
         2 revisions
501
 
""" % (format_description, datestring_first, datestring_last,), out)
 
474
""" % (self._repo_strings, datestring_first, datestring_last,), out)
502
475
        self.assertEqual('', err)
503
476
 
504
477
    def test_info_standalone_no_tree(self):
553
526
 
554
527
        # Create branch inside shared repository
555
528
        repo.bzrdir.root_transport.mkdir('branch')
556
 
        branch1 = controldir.ControlDir.create_branch_convenience(
557
 
            'repo/branch', format=format)
 
529
        branch1 = repo.bzrdir.create_branch_convenience('repo/branch',
 
530
            format=format)
558
531
        out, err = self.run_bzr('info -v repo/branch')
559
532
        self.assertEqualDiff(
560
533
"""Repository branch (format: dirstate or knit)
595
568
        self.build_tree(['tree/lightcheckout/a'])
596
569
        tree2.add('a')
597
570
        tree2.commit('commit one')
598
 
        rev = repo.get_revision(branch2.last_revision())
599
 
        datestring_first = osutils.format_date(rev.timestamp, rev.timezone)
 
571
        rev = repo.get_revision(branch2.revision_history()[0])
 
572
        datestring_first = format_date(rev.timestamp, rev.timezone)
600
573
        out, err = self.run_bzr('info tree/lightcheckout --verbose')
601
574
        self.assertEqualDiff(
602
575
"""Lightweight checkout (format: %s)
714
687
        tree3.commit('commit two')
715
688
 
716
689
        # Out of date lightweight checkout
717
 
        rev = repo.get_revision(branch1.last_revision())
718
 
        datestring_last = osutils.format_date(rev.timestamp, rev.timezone)
 
690
        rev = repo.get_revision(branch1.revision_history()[-1])
 
691
        datestring_last = format_date(rev.timestamp, rev.timezone)
719
692
        out, err = self.run_bzr('info tree/lightcheckout --verbose')
720
693
        self.assertEqualDiff(
721
694
"""Lightweight checkout (format: %s)
827
800
 
828
801
        # Create two branches
829
802
        repo.bzrdir.root_transport.mkdir('branch1')
830
 
        branch1 = controldir.ControlDir.create_branch_convenience('repo/branch1',
 
803
        branch1 = repo.bzrdir.create_branch_convenience('repo/branch1',
831
804
            format=format)
832
805
        branch2 = branch1.bzrdir.sprout('repo/branch2').open_branch()
833
806
 
870
843
        tree1 = branch1.bzrdir.open_workingtree()
871
844
        tree1.add('a')
872
845
        tree1.commit('commit one')
873
 
        rev = repo.get_revision(branch1.last_revision())
874
 
        datestring_first = osutils.format_date(rev.timestamp, rev.timezone)
 
846
        rev = repo.get_revision(branch1.revision_history()[0])
 
847
        datestring_first = format_date(rev.timestamp, rev.timezone)
875
848
        out, err = self.run_bzr('info -v repo/branch1')
876
849
        self.assertEqualDiff(
877
850
"""Repository tree (format: knit)
1245
1218
                                    format=bzrdir.BzrDirMetaFormat1())
1246
1219
        repo.set_make_working_trees(False)
1247
1220
        repo.bzrdir.root_transport.mkdir('branch')
1248
 
        repo_branch = controldir.ControlDir.create_branch_convenience(
1249
 
            'repo/branch', format=bzrdir.BzrDirMetaFormat1())
 
1221
        repo_branch = repo.bzrdir.create_branch_convenience('repo/branch',
 
1222
                                    format=bzrdir.BzrDirMetaFormat1())
1250
1223
        # Do a heavy checkout
1251
1224
        transport.mkdir('tree')
1252
1225
        transport.mkdir('tree/checkout')
1253
 
        co_branch = controldir.ControlDir.create_branch_convenience(
1254
 
            'tree/checkout', format=bzrdir.BzrDirMetaFormat1())
 
1226
        co_branch = bzrdir.BzrDir.create_branch_convenience('tree/checkout',
 
1227
            format=bzrdir.BzrDirMetaFormat1())
1255
1228
        co_branch.bind(repo_branch)
1256
1229
        # Do a light checkout of the heavy one
1257
1230
        transport.mkdir('tree/lightcheckout')
1258
1231
        lco_dir = bzrdir.BzrDirMetaFormat1().initialize('tree/lightcheckout')
1259
 
        branch.BranchReferenceFormat().initialize(lco_dir,
1260
 
            target_branch=co_branch)
 
1232
        branch.BranchReferenceFormat().initialize(lco_dir, co_branch)
1261
1233
        lco_dir.create_workingtree()
1262
1234
        lco_tree = lco_dir.open_workingtree()
1263
1235
 
1351
1323
            self.knownFailure('Win32 cannot run "bzr info"'
1352
1324
                              ' when the tree is locked.')
1353
1325
 
 
1326
    def test_info_locking_oslocks(self):
 
1327
        if sys.platform == "win32":
 
1328
            raise TestSkipped("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()
 
1334
 
 
1335
        tree = self.make_branch_and_tree('branch',
 
1336
                                         format=bzrdir.BzrDirFormat6())
 
1337
 
 
1338
        # Test all permutations of locking the working tree, branch and repository
 
1339
        # XXX: Well not yet, as we can't query oslocks yet. Currently, it's
 
1340
        # implemented by raising NotImplementedError and get_physical_lock_status()
 
1341
        # always returns false. This makes bzr info hide the lock status.  (Olaf)
 
1342
        # W B R
 
1343
 
 
1344
        # U U U
 
1345
        out, err = self.run_bzr('info -v branch')
 
1346
        self.assertEqualDiff(
 
1347
"""Standalone tree (format: weave)
 
1348
Location:
 
1349
  branch root: %s
 
1350
 
 
1351
Format:
 
1352
       control: All-in-one format 6
 
1353
  working tree: Working tree format 2
 
1354
        branch: Branch format 4
 
1355
    repository: %s
 
1356
 
 
1357
In the working tree:
 
1358
         0 unchanged
 
1359
         0 modified
 
1360
         0 added
 
1361
         0 removed
 
1362
         0 renamed
 
1363
         0 unknown
 
1364
         0 ignored
 
1365
         0 versioned subdirectories
 
1366
 
 
1367
Branch history:
 
1368
         0 revisions
 
1369
 
 
1370
Repository:
 
1371
         0 revisions
 
1372
""" % ('branch', tree.branch.repository._format.get_format_description(),
 
1373
       ), out)
 
1374
        self.assertEqual('', err)
 
1375
        # L L L
 
1376
        tree.lock_write()
 
1377
        out, err = self.run_bzr('info -v branch')
 
1378
        self.assertEqualDiff(
 
1379
"""Standalone tree (format: weave)
 
1380
Location:
 
1381
  branch root: %s
 
1382
 
 
1383
Format:
 
1384
       control: All-in-one format 6
 
1385
  working tree: Working tree format 2
 
1386
        branch: Branch format 4
 
1387
    repository: %s
 
1388
 
 
1389
In the working tree:
 
1390
         0 unchanged
 
1391
         0 modified
 
1392
         0 added
 
1393
         0 removed
 
1394
         0 renamed
 
1395
         0 unknown
 
1396
         0 ignored
 
1397
         0 versioned subdirectories
 
1398
 
 
1399
Branch history:
 
1400
         0 revisions
 
1401
 
 
1402
Repository:
 
1403
         0 revisions
 
1404
""" % ('branch', tree.branch.repository._format.get_format_description(),
 
1405
       ), out)
 
1406
        self.assertEqual('', err)
 
1407
        tree.unlock()
 
1408
 
1354
1409
    def test_info_stacked(self):
1355
1410
        # We have a mainline
1356
1411
        trunk_tree = self.make_branch_and_tree('mainline',
1369
1424
     stacked on: mainline
1370
1425
""", out)
1371
1426
        self.assertEqual("", err)
1372
 
 
1373
 
    def test_info_revinfo_optional(self):
1374
 
        tree = self.make_branch_and_tree('.')
1375
 
        def last_revision_info(self):
1376
 
            raise errors.UnsupportedOperation(last_revision_info, self)
1377
 
        self.overrideAttr(
1378
 
            branch.Branch, "last_revision_info", last_revision_info)
1379
 
        out, err = self.run_bzr('info -v .')
1380
 
        self.assertEqual(
1381
 
"""Standalone tree (format: 2a)
1382
 
Location:
1383
 
  branch root: .
1384
 
 
1385
 
Format:
1386
 
       control: Meta directory format 1
1387
 
  working tree: Working tree format 6
1388
 
        branch: Branch format 7
1389
 
    repository: Repository format 2a - rich roots, group compression and chk inventories
1390
 
 
1391
 
In the working tree:
1392
 
         0 unchanged
1393
 
         0 modified
1394
 
         0 added
1395
 
         0 removed
1396
 
         0 renamed
1397
 
         0 unknown
1398
 
         0 ignored
1399
 
         0 versioned subdirectories
1400
 
""", out)
1401
 
        self.assertEqual("", err)
1402
 
 
1403
 
    def test_info_shows_colocated_branches(self):
1404
 
        bzrdir = self.make_branch('.', format='development-colo').bzrdir
1405
 
        bzrdir.create_branch(name="colo1")
1406
 
        bzrdir.create_branch(name="colo2")
1407
 
        bzrdir.create_branch(name="colo3")
1408
 
        out, err = self.run_bzr('info -v .')
1409
 
        self.assertEqualDiff(
1410
 
"""Standalone branch (format: development-colo)
1411
 
Location:
1412
 
  branch root: .
1413
 
 
1414
 
Format:
1415
 
       control: Meta directory format 1 with support for colocated branches
1416
 
        branch: Branch format 7
1417
 
    repository: Repository format 2a - rich roots, group compression and chk inventories
1418
 
 
1419
 
Control directory:
1420
 
         4 branches
1421
 
 
1422
 
Branch history:
1423
 
         0 revisions
1424
 
 
1425
 
Repository:
1426
 
         0 revisions
1427
 
""", out)
1428
 
        self.assertEqual("", err)
1429
 
 
1430
 
 
1431
 
class TestSmartServerInfo(tests.TestCaseWithTransport):
1432
 
 
1433
 
    def test_simple_branch_info(self):
1434
 
        self.setup_smart_server_with_call_log()
1435
 
        t = self.make_branch_and_tree('branch')
1436
 
        self.build_tree_contents([('branch/foo', 'thecontents')])
1437
 
        t.add("foo")
1438
 
        t.commit("message")
1439
 
        self.reset_smart_call_log()
1440
 
        out, err = self.run_bzr(['info', self.get_url('branch')])
1441
 
        # This figure represent the amount of work to perform this use case. It
1442
 
        # is entirely ok to reduce this number if a test fails due to rpc_count
1443
 
        # being too low. If rpc_count increases, more network roundtrips have
1444
 
        # become necessary for this use case. Please do not adjust this number
1445
 
        # upwards without agreement from bzr's network support maintainers.
1446
 
        self.assertLength(12, self.hpss_calls)
1447
 
        self.assertThat(self.hpss_calls, ContainsNoVfsCalls)
1448
 
 
1449
 
    def test_verbose_branch_info(self):
1450
 
        self.setup_smart_server_with_call_log()
1451
 
        t = self.make_branch_and_tree('branch')
1452
 
        self.build_tree_contents([('branch/foo', 'thecontents')])
1453
 
        t.add("foo")
1454
 
        t.commit("message")
1455
 
        self.reset_smart_call_log()
1456
 
        out, err = self.run_bzr(['info', '-v', self.get_url('branch')])
1457
 
        # This figure represent the amount of work to perform this use case. It
1458
 
        # is entirely ok to reduce this number if a test fails due to rpc_count
1459
 
        # being too low. If rpc_count increases, more network roundtrips have
1460
 
        # become necessary for this use case. Please do not adjust this number
1461
 
        # upwards without agreement from bzr's network support maintainers.
1462
 
        self.assertLength(16, self.hpss_calls)
1463
 
        self.assertThat(self.hpss_calls, ContainsNoVfsCalls)