← 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: Canonical.com Patch Queue Manager
  • Date: 2007-11-04 18:51:39 UTC
  • mfrom: (2961.1.1 trunk)
  • Revision ID: pqm@pqm.ubuntu.com-20071104185139-kaio3sneodg2kp71
Authentication ring implementation (read-only)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_info.py
17
17
 
18
18
"""Tests for the info command of bzr."""
19
19
 
 
20
import os
20
21
import sys
21
22
 
 
23
import bzrlib
22
24
from bzrlib import (
23
 
    branch,
24
25
    bzrdir,
25
26
    errors,
26
 
    info,
27
27
    osutils,
28
 
    upgrade,
 
28
    repository,
29
29
    urlutils,
30
30
    )
31
31
from bzrlib.osutils import format_date
89
89
 
90
90
Repository:
91
91
         0 revisions
 
92
         0 KiB
92
93
""", out)
93
94
        self.assertEqual('', err)
94
95
        tree1.commit('commit one')
146
147
 
147
148
Repository:
148
149
         1 revision
 
150
         %d KiB
149
151
""" % (datestring_first, datestring_first,
 
152
       # poking at _revision_store isn't all that clean, but neither is
 
153
       # having the ui test dependent on the exact overhead of a given store.
 
154
       branch2.repository._revision_store.total_size(
 
155
        branch2.repository.get_transaction())[1] / 1024,
150
156
       ), out)
151
157
        self.assertEqual('', err)
152
158
 
154
160
        # (creates backup as unknown)
155
161
        branch1.bzrdir.sprout('bound')
156
162
        knit1_format = bzrdir.format_registry.make_bzrdir('knit')
157
 
        upgrade.upgrade('bound', knit1_format)
158
 
        branch3 = bzrdir.BzrDir.open('bound').open_branch()
 
163
        bzrlib.upgrade.upgrade('bound', knit1_format)
 
164
        branch3 = bzrlib.bzrdir.BzrDir.open('bound').open_branch()
159
165
        branch3.bind(branch1)
160
166
        bound_tree = branch3.bzrdir.open_workingtree()
161
167
        out, err = self.run_bzr('info -v bound')
193
199
 
194
200
Repository:
195
201
         1 revision
 
202
         %d KiB
196
203
""" % (bound_tree._format.get_format_description(),
197
204
       branch3._format.get_format_description(),
198
205
       branch3.repository._format.get_format_description(),
199
206
       datestring_first, datestring_first,
 
207
       # poking at _revision_store isn't all that clean, but neither is
 
208
       # having the ui test dependent on the exact overhead of a given store.
 
209
       branch3.repository._revision_store.total_size(
 
210
        branch3.repository.get_transaction())[1] / 1024,
200
211
       ), out)
201
212
        self.assertEqual('', err)
202
213
 
203
214
        # Checkout standalone (same as above, but does not have parent set)
204
 
        branch4 = bzrdir.BzrDir.create_branch_convenience('checkout',
 
215
        branch4 = bzrlib.bzrdir.BzrDir.create_branch_convenience('checkout',
205
216
            format=knit1_format)
206
217
        branch4.bind(branch1)
207
218
        branch4.bzrdir.open_workingtree().update()
237
248
 
238
249
Repository:
239
250
         1 revision
 
251
         %d KiB
240
252
""" % (branch4.repository._format.get_format_description(),
241
253
       datestring_first, datestring_first,
 
254
       # poking at _revision_store isn't all that clean, but neither is
 
255
       # having the ui test dependent on the exact overhead of a given store.
 
256
       branch4.repository._revision_store.total_size(
 
257
        branch4.repository.get_transaction())[1] / 1024,
242
258
       ), out)
243
259
        self.assertEqual('', err)
244
260
 
247
263
        branch5 = tree5.branch
248
264
        out, err = self.run_bzr('info -v lightcheckout')
249
265
        self.assertEqualDiff(
250
 
"""Lightweight checkout (format: 1.6 or 1.6.1-rich-root \
251
 
or dirstate or dirstate-tags or \
252
 
pack-0.92 or rich-root or rich-root-pack)
 
266
"""Lightweight checkout (format: dirstate or dirstate-tags or knitpack-experimental)
253
267
Location:
254
268
  light checkout root: lightcheckout
255
269
   checkout of branch: standalone
279
293
 
280
294
Repository:
281
295
         1 revision
 
296
         0 KiB
282
297
""" % (datestring_first, datestring_first,), out)
283
298
        self.assertEqual('', err)
284
299
 
325
340
 
326
341
Repository:
327
342
         1 revision
 
343
         0 KiB
328
344
""" % (datestring_first, datestring_first,
329
345
       ), out)
330
346
        self.assertEqual('', err)
367
383
 
368
384
Repository:
369
385
         1 revision
 
386
         %d KiB
370
387
""" % (branch3.repository._format.get_format_description(),
371
388
       datestring_first, datestring_first,
 
389
       # poking at _revision_store isn't all that clean, but neither is
 
390
       # having the ui test dependent on the exact overhead of a given store.
 
391
       branch3.repository._revision_store.total_size(
 
392
        branch3.repository.get_transaction())[1] / 1024,
372
393
       ), out)
373
394
        self.assertEqual('', err)
374
395
 
407
428
 
408
429
Repository:
409
430
         1 revision
 
431
         %d KiB
410
432
""" % (branch4.repository._format.get_format_description(),
411
433
       datestring_first, datestring_first,
 
434
       # poking at _revision_store isn't all that clean, but neither is
 
435
       # having the ui test dependent on the exact overhead of a given store.
 
436
       branch4.repository._revision_store.total_size(
 
437
        branch4.repository.get_transaction())[1] / 1024,
412
438
       ), out)
413
439
        self.assertEqual('', err)
414
440
 
415
441
        # Out of date lightweight checkout
416
442
        out, err = self.run_bzr('info lightcheckout --verbose')
417
443
        self.assertEqualDiff(
418
 
"""Lightweight checkout (format: 1.6 or 1.6.1-rich-root or \
419
 
dirstate or dirstate-tags or \
420
 
pack-0.92 or rich-root or rich-root-pack)
 
444
"""Lightweight checkout (format: dirstate or dirstate-tags or knitpack-experimental)
421
445
Location:
422
446
  light checkout root: lightcheckout
423
447
   checkout of branch: standalone
449
473
 
450
474
Repository:
451
475
         2 revisions
 
476
         0 KiB
452
477
""" % (datestring_first, datestring_last,), out)
453
478
        self.assertEqual('', err)
454
479
 
459
484
        repo = branch.repository
460
485
        out, err = self.run_bzr('info branch -v')
461
486
        self.assertEqualDiff(
462
 
"""Standalone branch (format: %s)
 
487
"""Standalone branch (format: dirstate-tags)
463
488
Location:
464
489
  branch root: branch
465
490
 
474
499
 
475
500
Repository:
476
501
         0 revisions
477
 
""" % (info.describe_format(repo.bzrdir, repo, branch, None),
478
 
       format.get_branch_format().get_format_description(),
 
502
         0 KiB
 
503
""" % (format.get_branch_format().get_format_description(),
479
504
       format.repository_format.get_format_description(),
480
505
       ), out)
481
506
        self.assertEqual('', err)
499
524
 
500
525
Repository:
501
526
         0 revisions
 
527
         0 KiB
502
528
""" % ('repo', format.repository_format.get_format_description(),
503
529
       ), out)
504
530
        self.assertEqual('', err)
525
551
 
526
552
Repository:
527
553
         0 revisions
 
554
         0 KiB
528
555
""" % (format.get_branch_format().get_format_description(),
529
556
       format.repository_format.get_format_description(),
530
557
       ), out)
552
579
        datestring_first = format_date(rev.timestamp, rev.timezone)
553
580
        out, err = self.run_bzr('info tree/lightcheckout --verbose')
554
581
        self.assertEqualDiff(
555
 
"""Lightweight checkout (format: 1.6 or 1.6.1-rich-root or \
556
 
dirstate or dirstate-tags or \
557
 
pack-0.92 or rich-root or rich-root-pack)
 
582
"""Lightweight checkout (format: dirstate or dirstate-tags or knitpack-experimental)
558
583
Location:
559
584
  light checkout root: tree/lightcheckout
560
585
   checkout of branch: repo/branch
585
610
 
586
611
Repository:
587
612
         1 revision
 
613
         %d KiB
588
614
""" % (format.get_branch_format().get_format_description(),
589
615
       format.repository_format.get_format_description(),
590
616
       datestring_first, datestring_first,
 
617
       # poking at _revision_store isn't all that clean, but neither is
 
618
       # having the ui test dependent on the exact overhead of a given store.
 
619
       repo._revision_store.total_size(repo.get_transaction())[1] / 1024,
591
620
       ), out)
592
621
        self.assertEqual('', err)
593
622
 
623
652
 
624
653
Repository:
625
654
         0 revisions
 
655
         0 KiB
626
656
""" % (format.get_branch_format().get_format_description(),
627
657
       format.repository_format.get_format_description(),
628
658
       ), out)
664
694
 
665
695
Repository:
666
696
         1 revision
 
697
         %d KiB
667
698
""" % (format.get_branch_format().get_format_description(),
668
699
       format.repository_format.get_format_description(),
669
700
       datestring_first, datestring_first,
 
701
       # poking at _revision_store isn't all that clean, but neither is
 
702
       # having the ui test dependent on the exact overhead of a given store.
 
703
       repo._revision_store.total_size(repo.get_transaction())[1] / 1024,
670
704
       ), out)
671
705
        self.assertEqual('', err)
672
706
        tree3.commit('commit two')
676
710
        datestring_last = format_date(rev.timestamp, rev.timezone)
677
711
        out, err = self.run_bzr('info tree/lightcheckout --verbose')
678
712
        self.assertEqualDiff(
679
 
"""Lightweight checkout (format: 1.6 or 1.6.1-rich-root or \
680
 
dirstate or dirstate-tags or \
681
 
pack-0.92 or rich-root or rich-root-pack)
 
713
"""Lightweight checkout (format: dirstate or dirstate-tags or knitpack-experimental)
682
714
Location:
683
715
  light checkout root: tree/lightcheckout
684
716
   checkout of branch: repo/branch
711
743
 
712
744
Repository:
713
745
         2 revisions
 
746
         %d KiB
714
747
""" % (format.get_branch_format().get_format_description(),
715
748
       format.repository_format.get_format_description(),
716
749
       datestring_first, datestring_last,
 
750
       # poking at _revision_store isn't all that clean, but neither is
 
751
       # having the ui test dependent on the exact overhead of a given store.
 
752
       repo._revision_store.total_size(repo.get_transaction())[1] / 1024,
717
753
       ), out)
718
754
        self.assertEqual('', err)
719
755
 
739
775
 
740
776
Repository:
741
777
         2 revisions
 
778
         %d KiB
742
779
""" % (format.get_branch_format().get_format_description(),
743
780
       format.repository_format.get_format_description(),
744
781
       datestring_first, datestring_last,
 
782
       # poking at _revision_store isn't all that clean, but neither is
 
783
       # having the ui test dependent on the exact overhead of a given store.
 
784
       repo._revision_store.total_size(repo.get_transaction())[1] / 1024,
745
785
       ), out)
746
786
        self.assertEqual('', err)
747
787
 
758
798
 
759
799
Repository:
760
800
         2 revisions
 
801
         %d KiB
761
802
""" % (format.repository_format.get_format_description(),
 
803
       # poking at _revision_store isn't all that clean, but neither is
 
804
       # having the ui test dependent on the exact overhead of a given store.
 
805
       repo._revision_store.total_size(repo.get_transaction())[1] / 1024,
762
806
       ), out)
763
807
        self.assertEqual('', err)
764
808
 
783
827
 
784
828
Repository:
785
829
         0 revisions
 
830
         0 KiB
786
831
""" % (format.repository_format.get_format_description(),
787
832
       ), out)
788
833
        self.assertEqual('', err)
823
868
 
824
869
Repository:
825
870
         0 revisions
 
871
         0 KiB
826
872
""" % (format.get_branch_format().get_format_description(),
827
873
       format.repository_format.get_format_description(),
828
874
       ), out)
867
913
 
868
914
Repository:
869
915
         1 revision
 
916
         %d KiB
870
917
""" % (format.get_branch_format().get_format_description(),
871
918
       format.repository_format.get_format_description(),
872
919
       datestring_first, datestring_first,
 
920
       # poking at _revision_store isn't all that clean, but neither is
 
921
       # having the ui test dependent on the exact overhead of a given store.
 
922
       repo._revision_store.total_size(repo.get_transaction())[1] / 1024,
873
923
       ), out)
874
924
        self.assertEqual('', err)
875
925
 
906
956
 
907
957
Repository:
908
958
         1 revision
 
959
         %d KiB
909
960
""" % (format.get_branch_format().get_format_description(),
910
961
       format.repository_format.get_format_description(),
 
962
       # poking at _revision_store isn't all that clean, but neither is
 
963
       # having the ui test dependent on the exact overhead of a given store.
 
964
       repo._revision_store.total_size(repo.get_transaction())[1] / 1024,
911
965
       ), out)
912
966
        self.assertEqual('', err)
913
967
 
949
1003
 
950
1004
Repository:
951
1005
         1 revision
 
1006
         %d KiB
952
1007
""" % (format.get_branch_format().get_format_description(),
953
1008
       format.repository_format.get_format_description(),
954
1009
       datestring_first, datestring_first,
 
1010
       # poking at _revision_store isn't all that clean, but neither is
 
1011
       # having the ui test dependent on the exact overhead of a given store.
 
1012
       repo._revision_store.total_size(repo.get_transaction())[1] / 1024,
955
1013
       ), out)
956
1014
        self.assertEqual('', err)
957
1015
 
970
1028
 
971
1029
Repository:
972
1030
         1 revision
 
1031
         %d KiB
973
1032
""" % (format.repository_format.get_format_description(),
 
1033
       # poking at _revision_store isn't all that clean, but neither is
 
1034
       # having the ui test dependent on the exact overhead of a given store.
 
1035
       repo._revision_store.total_size(repo.get_transaction())[1] / 1024,
974
1036
       ),
975
1037
       out)
976
1038
        self.assertEqual('', err)
996
1058
 
997
1059
Repository:
998
1060
         0 revisions
 
1061
         0 KiB
999
1062
""" % (format.repository_format.get_format_description(),
1000
1063
       ), out)
1001
1064
        self.assertEqual('', err)
1033
1096
 
1034
1097
Repository:
1035
1098
         0 revisions
 
1099
         0 KiB
1036
1100
""" % (format.get_branch_format().get_format_description(),
1037
1101
       format.repository_format.get_format_description(),
1038
1102
       ), out)
1039
1103
        self.assertEqual('', err)
1040
1104
 
1041
 
    def assertCheckoutStatusOutput(self,
 
1105
    def assertCheckoutStatusOutput(self, 
1042
1106
        command_string, lco_tree, shared_repo=None,
1043
1107
        repo_branch=None,
1044
1108
        tree_locked=False,
1063
1127
        :param tree_locked: If true, expect the tree to be locked.
1064
1128
        :param branch_locked: If true, expect the branch to be locked.
1065
1129
        :param repo_locked: If true, expect the repository to be locked.
1066
 
            Note that the lco_tree.branch.repository is inspected, and if is not
1067
 
            actually locked then this parameter is overridden. This is because
1068
 
            pack repositories do not have any public API for obtaining an
1069
 
            exclusive repository wide lock.
1070
1130
        :param verbose: If true, expect verbose output
1071
1131
        """
1072
1132
        def friendly_location(url):
1076
1136
            except errors.PathNotChild:
1077
1137
                return path
1078
1138
 
1079
 
        if tree_locked:
1080
 
            # We expect this to fail because of locking errors.
1081
 
            # (A write-locked file cannot be read-locked
1082
 
            # in the different process -- either on win32 or on linux).
 
1139
        if tree_locked and sys.platform == 'win32':
 
1140
            # We expect this to fail because of locking errors. (A write-locked
 
1141
            # file cannot be read-locked in the same process).
1083
1142
            # This should be removed when the locking errors are fixed.
1084
 
            self.expectFailure('OS locks are exclusive '
1085
 
                'for different processes (Bug #174055)',
1086
 
                self.run_bzr_subprocess,
1087
 
                'info ' + command_string)
 
1143
            self.run_bzr_error([], 'info ' + command_string)
 
1144
            return
1088
1145
        out, err = self.run_bzr('info %s' % command_string)
1089
1146
        description = {
1090
1147
            (True, True): 'Lightweight checkout',
1092
1149
            (False, True): 'Lightweight checkout',
1093
1150
            (False, False): 'Checkout',
1094
1151
            }[(shared_repo is not None, light_checkout)]
1095
 
        format = {True: '1.6 or 1.6.1-rich-root'
1096
 
                        ' or dirstate or dirstate-tags or pack-0.92'
1097
 
                        ' or rich-root or rich-root-pack',
 
1152
        format = {True: 'dirstate or dirstate-tags or knitpack-experimental',
1098
1153
                  False: 'dirstate'}[light_checkout]
1099
 
        if repo_locked:
1100
 
            repo_locked = lco_tree.branch.repository.get_physical_lock_status()
1101
1154
        if repo_locked or branch_locked or tree_locked:
1102
1155
            def locked_message(a_bool):
1103
1156
                if a_bool:
1169
1222
%s
1170
1223
Repository:
1171
1224
         0 revisions
 
1225
         0 KiB
1172
1226
""" %  (description,
1173
1227
        format,
1174
1228
        tree_data,
1185
1239
        transport = self.get_transport()
1186
1240
        # Create shared repository with a branch
1187
1241
        repo = self.make_repository('repo', shared=True,
1188
 
                                    format=bzrdir.BzrDirMetaFormat1())
 
1242
                                    format=bzrlib.bzrdir.BzrDirMetaFormat1())
1189
1243
        repo.set_make_working_trees(False)
1190
1244
        repo.bzrdir.root_transport.mkdir('branch')
1191
1245
        repo_branch = repo.bzrdir.create_branch_convenience('repo/branch',
1192
 
                                    format=bzrdir.BzrDirMetaFormat1())
 
1246
                                    format=bzrlib.bzrdir.BzrDirMetaFormat1())
1193
1247
        # Do a heavy checkout
1194
1248
        transport.mkdir('tree')
1195
1249
        transport.mkdir('tree/checkout')
1196
 
        co_branch = bzrdir.BzrDir.create_branch_convenience('tree/checkout',
1197
 
            format=bzrdir.BzrDirMetaFormat1())
 
1250
        co_branch = bzrlib.bzrdir.BzrDir.create_branch_convenience('tree/checkout',
 
1251
            format=bzrlib.bzrdir.BzrDirMetaFormat1())
1198
1252
        co_branch.bind(repo_branch)
1199
1253
        # Do a light checkout of the heavy one
1200
1254
        transport.mkdir('tree/lightcheckout')
1201
 
        lco_dir = bzrdir.BzrDirMetaFormat1().initialize('tree/lightcheckout')
1202
 
        branch.BranchReferenceFormat().initialize(lco_dir, co_branch)
 
1255
        lco_dir = bzrlib.bzrdir.BzrDirMetaFormat1().initialize('tree/lightcheckout')
 
1256
        bzrlib.branch.BranchReferenceFormat().initialize(lco_dir, co_branch)
1203
1257
        lco_dir.create_workingtree()
1204
1258
        lco_tree = lco_dir.open_workingtree()
1205
1259
 
1298
1352
            raise TestSkipped("don't use oslocks on win32 in unix manner")
1299
1353
 
1300
1354
        tree = self.make_branch_and_tree('branch',
1301
 
                                         format=bzrdir.BzrDirFormat6())
 
1355
                                         format=bzrlib.bzrdir.BzrDirFormat6())
1302
1356
 
1303
1357
        # Test all permutations of locking the working tree, branch and repository
1304
1358
        # XXX: Well not yet, as we can't query oslocks yet. Currently, it's
1335
1389
 
1336
1390
Repository:
1337
1391
         0 revisions
 
1392
         0 KiB
1338
1393
""" % ('branch', tree.branch.repository._format.get_format_description(),
1339
1394
       ), out)
1340
1395
        self.assertEqual('', err)
1368
1423
 
1369
1424
Repository:
1370
1425
         0 revisions
 
1426
         0 KiB
1371
1427
""" % ('branch', tree.branch.repository._format.get_format_description(),
1372
1428
       ), out)
1373
1429
        self.assertEqual('', err)
1374
1430
        tree.unlock()
1375
 
 
1376
 
    def test_info_stacked(self):
1377
 
        # We have a mainline
1378
 
        trunk_tree = self.make_branch_and_tree('mainline',
1379
 
            format='development1')
1380
 
        trunk_tree.commit('mainline')
1381
 
        # and a branch from it which is stacked
1382
 
        new_dir = trunk_tree.bzrdir.sprout('newbranch', stacked=True)
1383
 
        out, err = self.run_bzr('info newbranch')
1384
 
        self.assertEqual(
1385
 
"""Standalone tree (format: development1)
1386
 
Location:
1387
 
  branch root: newbranch
1388
 
 
1389
 
Related branches:
1390
 
  parent branch: mainline
1391
 
     stacked on: mainline
1392
 
""", out)
1393
 
        self.assertEqual("", err)