« back to all changes in this revision
Viewing changes to bzrlib/tests/test_config.py
- browse files at revision 5394
- compare with another revision
- download diff
- download tarball
- view history from revision 5394
- Committer: Canonical.com Patch Queue Manager
- Date: 2010-08-29 22:14:42 UTC
- mfrom: (5340.9.2 python_2.7_tuned_gzip_614476)
- Revision ID: pqm@pqm.ubuntu.com-20100829221442-f5573xyzlm7gr7t6
(gz) Adapt tuned_gzip to changes to gzip module crc handling in Python 2.7
(Martin [gz])
(Martin [gz])
- files removed:
- bzrlib/tests/test_test_server.py
- files modified:
- Makefile
added
removed
bzrlib/tests/test_config.py
19
19
from cStringIO import StringIO
20
20
import os
21
21
import sys
22
import threading
23
22
24
23
#import bzrlib specific imports here
25
24
from bzrlib import (
40
39
from bzrlib.util.configobj import configobj
41
40
42
41
43
def lockable_config_scenarios():
44
return [
45
('global',
46
{'config_class': config.GlobalConfig,
47
'config_args': [],
48
'config_section': 'DEFAULT'}),
49
('locations',
50
{'config_class': config.LocationConfig,
51
'config_args': ['.'],
52
'config_section': '.'}),]
53
54
55
def load_tests(standard_tests, module, loader):
56
suite = loader.suiteClass()
57
58
lc_tests, remaining_tests = tests.split_suite_by_condition(
59
standard_tests, tests.condition_isinstance((
60
TestLockableConfig,
61
)))
62
tests.multiply_tests(lc_tests, lockable_config_scenarios(), suite)
63
suite.addTest(remaining_tests)
64
return suite
65
66
67
42
sample_long_alias="log -r-15..-1 --line"
68
43
sample_config_text = u"""
69
44
[DEFAULT]
155
130
self._calls.append(('keys',))
156
131
return []
157
132
158
def reload(self):
159
self._calls.append(('reload',))
160
161
133
def write(self, arg):
162
134
self._calls.append(('write',))
163
135
379
351
self.assertEqual(config.config_filename(),
380
352
self.bzr_home + '/bazaar.conf')
381
353
354
def test_branches_config_filename(self):
355
self.assertEqual(config.branches_config_filename(),
356
self.bzr_home + '/branches.conf')
357
382
358
def test_locations_config_filename(self):
383
359
self.assertEqual(config.locations_config_filename(),
384
360
self.bzr_home + '/locations.conf')
395
371
class TestIniConfig(tests.TestCaseInTempDir):
396
372
397
373
def make_config_parser(self, s):
398
conf = config.IniBasedConfig.from_string(s)
399
return conf, conf._get_parser()
374
conf = config.IniBasedConfig(None)
375
parser = conf._get_parser(file=StringIO(s.encode('utf-8')))
376
return conf, parser
400
377
401
378
402
379
class TestIniConfigBuilding(TestIniConfig):
403
380
404
381
def test_contructs(self):
405
my_config = config.IniBasedConfig()
382
my_config = config.IniBasedConfig("nothing")
406
383
407
384
def test_from_fp(self):
408
my_config = config.IniBasedConfig.from_string(sample_config_text)
409
self.assertIsInstance(my_config._get_parser(), configobj.ConfigObj)
385
config_file = StringIO(sample_config_text.encode('utf-8'))
386
my_config = config.IniBasedConfig(None)
387
self.failUnless(
388
isinstance(my_config._get_parser(file=config_file),
389
configobj.ConfigObj))
410
390
411
391
def test_cached(self):
412
my_config = config.IniBasedConfig.from_string(sample_config_text)
413
parser = my_config._get_parser()
392
config_file = StringIO(sample_config_text.encode('utf-8'))
393
my_config = config.IniBasedConfig(None)
394
parser = my_config._get_parser(file=config_file)
414
395
self.failUnless(my_config._get_parser() is parser)
415
396
416
397
def _dummy_chown(self, path, uid, gid):
417
398
self.path, self.uid, self.gid = path, uid, gid
418
399
419
400
def test_ini_config_ownership(self):
420
"""Ensure that chown is happening during _write_config_file"""
401
"""Ensure that chown is happening during _write_config_file.
402
"""
421
403
self.requireFeature(features.chown_feature)
422
404
self.overrideAttr(os, 'chown', self._dummy_chown)
423
405
self.path = self.uid = self.gid = None
424
conf = config.IniBasedConfig(file_name='./foo.conf')
406
def get_filename():
407
return 'foo.conf'
408
conf = config.IniBasedConfig(get_filename)
425
409
conf._write_config_file()
426
self.assertEquals(self.path, './foo.conf')
410
self.assertEquals(self.path, 'foo.conf')
427
411
self.assertTrue(isinstance(self.uid, int))
428
412
self.assertTrue(isinstance(self.gid, int))
429
413
430
def test_get_filename_parameter_is_deprecated_(self):
431
conf = self.callDeprecated([
432
'IniBasedConfig.__init__(get_filename) was deprecated in 2.3.'
433
' Use file_name instead.'],
434
config.IniBasedConfig, lambda: 'ini.conf')
435
self.assertEqual('ini.conf', conf.file_name)
436
437
def test_get_parser_file_parameter_is_deprecated_(self):
438
config_file = StringIO(sample_config_text.encode('utf-8'))
439
conf = config.IniBasedConfig.from_string(sample_config_text)
440
conf = self.callDeprecated([
441
'IniBasedConfig._get_parser(file=xxx) was deprecated in 2.3.'
442
' Use IniBasedConfig(_content=xxx) instead.'],
443
conf._get_parser, file=config_file)
444
445
class TestIniConfigSaving(tests.TestCaseInTempDir):
446
447
def test_cant_save_without_a_file_name(self):
448
conf = config.IniBasedConfig()
449
self.assertRaises(AssertionError, conf._write_config_file)
450
451
def test_saved_with_content(self):
452
content = 'foo = bar\n'
453
conf = config.IniBasedConfig.from_string(
454
content, file_name='./test.conf', save=True)
455
self.assertFileEqual(content, 'test.conf')
456
457
458
class TestIniBaseConfigOnDisk(tests.TestCaseInTempDir):
459
460
def test_cannot_reload_without_name(self):
461
conf = config.IniBasedConfig.from_string(sample_config_text)
462
self.assertRaises(AssertionError, conf.reload)
463
464
def test_reload_see_new_value(self):
465
c1 = config.IniBasedConfig.from_string('editor=vim\n',
466
file_name='./test/conf')
467
c1._write_config_file()
468
c2 = config.IniBasedConfig.from_string('editor=emacs\n',
469
file_name='./test/conf')
470
c2._write_config_file()
471
self.assertEqual('vim', c1.get_user_option('editor'))
472
self.assertEqual('emacs', c2.get_user_option('editor'))
473
# Make sure we get the Right value
474
c1.reload()
475
self.assertEqual('emacs', c1.get_user_option('editor'))
476
477
478
class TestLockableConfig(tests.TestCaseInTempDir):
479
480
# Set by load_tests
481
config_class = None
482
config_args = None
483
config_section = None
484
485
def setUp(self):
486
super(TestLockableConfig, self).setUp()
487
self._content = '[%s]\none=1\ntwo=2\n' % (self.config_section,)
488
self.config = self.create_config(self._content)
489
490
def get_existing_config(self):
491
return self.config_class(*self.config_args)
492
493
def create_config(self, content):
494
kwargs = dict(save=True)
495
c = self.config_class.from_string(content, *self.config_args, **kwargs)
496
return c
497
498
def test_simple_read_access(self):
499
self.assertEquals('1', self.config.get_user_option('one'))
500
501
def test_simple_write_access(self):
502
self.config.set_user_option('one', 'one')
503
self.assertEquals('one', self.config.get_user_option('one'))
504
505
def test_listen_to_the_last_speaker(self):
506
c1 = self.config
507
c2 = self.get_existing_config()
508
c1.set_user_option('one', 'ONE')
509
c2.set_user_option('two', 'TWO')
510
self.assertEquals('ONE', c1.get_user_option('one'))
511
self.assertEquals('TWO', c2.get_user_option('two'))
512
# The second update respect the first one
513
self.assertEquals('ONE', c2.get_user_option('one'))
514
515
def test_last_speaker_wins(self):
516
# If the same config is not shared, the same variable modified twice
517
# can only see a single result.
518
c1 = self.config
519
c2 = self.get_existing_config()
520
c1.set_user_option('one', 'c1')
521
c2.set_user_option('one', 'c2')
522
self.assertEquals('c2', c2._get_user_option('one'))
523
# The first modification is still available until another refresh
524
# occur
525
self.assertEquals('c1', c1._get_user_option('one'))
526
c1.set_user_option('two', 'done')
527
self.assertEquals('c2', c1._get_user_option('one'))
528
529
def test_writes_are_serialized(self):
530
c1 = self.config
531
c2 = self.get_existing_config()
532
533
# We spawn a thread that will pause *during* the write
534
before_writing = threading.Event()
535
after_writing = threading.Event()
536
writing_done = threading.Event()
537
c1_orig = c1._write_config_file
538
def c1_write_config_file():
539
before_writing.set()
540
c1_orig()
541
# The lock is held we wait for the main thread to decide when to
542
# continue
543
after_writing.wait()
544
c1._write_config_file = c1_write_config_file
545
def c1_set_option():
546
c1.set_user_option('one', 'c1')
547
writing_done.set()
548
t1 = threading.Thread(target=c1_set_option)
549
# Collect the thread after the test
550
self.addCleanup(t1.join)
551
# Be ready to unblock the thread if the test goes wrong
552
self.addCleanup(after_writing.set)
553
t1.start()
554
before_writing.wait()
555
self.assertTrue(c1._lock.is_held)
556
self.assertRaises(errors.LockContention,
557
c2.set_user_option, 'one', 'c2')
558
self.assertEquals('c1', c1.get_user_option('one'))
559
# Let the lock be released
560
after_writing.set()
561
writing_done.wait()
562
c2.set_user_option('one', 'c2')
563
self.assertEquals('c2', c2.get_user_option('one'))
564
565
def test_read_while_writing(self):
566
c1 = self.config
567
# We spawn a thread that will pause *during* the write
568
ready_to_write = threading.Event()
569
do_writing = threading.Event()
570
writing_done = threading.Event()
571
c1_orig = c1._write_config_file
572
def c1_write_config_file():
573
ready_to_write.set()
574
# The lock is held we wait for the main thread to decide when to
575
# continue
576
do_writing.wait()
577
c1_orig()
578
writing_done.set()
579
c1._write_config_file = c1_write_config_file
580
def c1_set_option():
581
c1.set_user_option('one', 'c1')
582
t1 = threading.Thread(target=c1_set_option)
583
# Collect the thread after the test
584
self.addCleanup(t1.join)
585
# Be ready to unblock the thread if the test goes wrong
586
self.addCleanup(do_writing.set)
587
t1.start()
588
# Ensure the thread is ready to write
589
ready_to_write.wait()
590
self.assertTrue(c1._lock.is_held)
591
self.assertEquals('c1', c1.get_user_option('one'))
592
# If we read during the write, we get the old value
593
c2 = self.get_existing_config()
594
self.assertEquals('1', c2.get_user_option('one'))
595
# Let the writing occur and ensure it occurred
596
do_writing.set()
597
writing_done.wait()
598
# Now we get the updated value
599
c3 = self.get_existing_config()
600
self.assertEquals('c1', c3.get_user_option('one'))
601
602
603
414
class TestGetUserOptionAs(TestIniConfig):
604
415
605
416
def test_get_user_option_as_bool(self):
711
522
branch = self.make_branch('branch')
712
523
self.assertEqual('branch', branch.nick)
713
524
525
locations = config.locations_config_filename()
526
config.ensure_config_dir_exists()
714
527
local_url = urlutils.local_path_to_url('branch')
715
conf = config.LocationConfig.from_string(
716
'[%s]\nnickname = foobar' % (local_url,),
717
local_url, save=True)
528
open(locations, 'wb').write('[%s]\nnickname = foobar'
529
% (local_url,))
718
530
self.assertEqual('foobar', branch.nick)
719
531
720
532
def test_config_local_path(self):
722
534
branch = self.make_branch('branch')
723
535
self.assertEqual('branch', branch.nick)
724
536
725
local_path = osutils.getcwd().encode('utf8')
726
conf = config.LocationConfig.from_string(
727
'[%s/branch]\nnickname = barry' % (local_path,),
728
'branch', save=True)
537
locations = config.locations_config_filename()
538
config.ensure_config_dir_exists()
539
open(locations, 'wb').write('[%s/branch]\nnickname = barry'
540
% (osutils.getcwd().encode('utf8'),))
729
541
self.assertEqual('barry', branch.nick)
730
542
731
543
def test_config_creates_local(self):
732
544
"""Creating a new entry in config uses a local path."""
733
545
branch = self.make_branch('branch', format='knit')
734
546
branch.set_push_location('http://foobar')
547
locations = config.locations_config_filename()
735
548
local_path = osutils.getcwd().encode('utf8')
736
549
# Surprisingly ConfigObj doesn't create a trailing newline
737
self.check_file_contents(config.locations_config_filename(),
550
self.check_file_contents(locations,
738
551
'[%s/branch]\n'
739
552
'push_location = http://foobar\n'
740
553
'push_location:policy = norecurse\n'
745
558
self.assertEqual('!repo', b.get_config().get_nickname())
746
559
747
560
def test_warn_if_masked(self):
561
_warning = trace.warning
748
562
warnings = []
749
563
def warning(*args):
750
564
warnings.append(args[0] % args[1:])
751
self.overrideAttr(trace, 'warning', warning)
752
565
753
566
def set_option(store, warn_masked=True):
754
567
warnings[:] = []
760
573
else:
761
574
self.assertEqual(1, len(warnings))
762
575
self.assertEqual(warning, warnings[0])
763
branch = self.make_branch('.')
764
conf = branch.get_config()
765
set_option(config.STORE_GLOBAL)
766
assertWarning(None)
767
set_option(config.STORE_BRANCH)
768
assertWarning(None)
769
set_option(config.STORE_GLOBAL)
770
assertWarning('Value "4" is masked by "3" from branch.conf')
771
set_option(config.STORE_GLOBAL, warn_masked=False)
772
assertWarning(None)
773
set_option(config.STORE_LOCATION)
774
assertWarning(None)
775
set_option(config.STORE_BRANCH)
776
assertWarning('Value "3" is masked by "0" from locations.conf')
777
set_option(config.STORE_BRANCH, warn_masked=False)
778
assertWarning(None)
576
trace.warning = warning
577
try:
578
branch = self.make_branch('.')
579
conf = branch.get_config()
580
set_option(config.STORE_GLOBAL)
581
assertWarning(None)
582
set_option(config.STORE_BRANCH)
583
assertWarning(None)
584
set_option(config.STORE_GLOBAL)
585
assertWarning('Value "4" is masked by "3" from branch.conf')
586
set_option(config.STORE_GLOBAL, warn_masked=False)
587
assertWarning(None)
588
set_option(config.STORE_LOCATION)
589
assertWarning(None)
590
set_option(config.STORE_BRANCH)
591
assertWarning('Value "3" is masked by "0" from locations.conf')
592
set_option(config.STORE_BRANCH, warn_masked=False)
593
assertWarning(None)
594
finally:
595
trace.warning = _warning
779
596
780
597
781
598
class TestGlobalConfigItems(tests.TestCase):
782
599
783
600
def test_user_id(self):
784
my_config = config.GlobalConfig.from_string(sample_config_text)
601
config_file = StringIO(sample_config_text.encode('utf-8'))
602
my_config = config.GlobalConfig()
603
my_config._parser = my_config._get_parser(file=config_file)
785
604
self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
786
605
my_config._get_user_id())
787
606
788
607
def test_absent_user_id(self):
608
config_file = StringIO("")
789
609
my_config = config.GlobalConfig()
610
my_config._parser = my_config._get_parser(file=config_file)
790
611
self.assertEqual(None, my_config._get_user_id())
791
612
792
613
def test_configured_editor(self):
793
my_config = config.GlobalConfig.from_string(sample_config_text)
614
config_file = StringIO(sample_config_text.encode('utf-8'))
615
my_config = config.GlobalConfig()
616
my_config._parser = my_config._get_parser(file=config_file)
794
617
self.assertEqual("vim", my_config.get_editor())
795
618
796
619
def test_signatures_always(self):
797
my_config = config.GlobalConfig.from_string(sample_always_signatures)
620
config_file = StringIO(sample_always_signatures)
621
my_config = config.GlobalConfig()
622
my_config._parser = my_config._get_parser(file=config_file)
798
623
self.assertEqual(config.CHECK_NEVER,
799
624
my_config.signature_checking())
800
625
self.assertEqual(config.SIGN_ALWAYS,
802
627
self.assertEqual(True, my_config.signature_needed())
803
628
804
629
def test_signatures_if_possible(self):
805
my_config = config.GlobalConfig.from_string(sample_maybe_signatures)
630
config_file = StringIO(sample_maybe_signatures)
631
my_config = config.GlobalConfig()
632
my_config._parser = my_config._get_parser(file=config_file)
806
633
self.assertEqual(config.CHECK_NEVER,
807
634
my_config.signature_checking())
808
635
self.assertEqual(config.SIGN_WHEN_REQUIRED,
810
637
self.assertEqual(False, my_config.signature_needed())
811
638
812
639
def test_signatures_ignore(self):
813
my_config = config.GlobalConfig.from_string(sample_ignore_signatures)
640
config_file = StringIO(sample_ignore_signatures)
641
my_config = config.GlobalConfig()
642
my_config._parser = my_config._get_parser(file=config_file)
814
643
self.assertEqual(config.CHECK_ALWAYS,
815
644
my_config.signature_checking())
816
645
self.assertEqual(config.SIGN_NEVER,
818
647
self.assertEqual(False, my_config.signature_needed())
819
648
820
649
def _get_sample_config(self):
821
my_config = config.GlobalConfig.from_string(sample_config_text)
650
config_file = StringIO(sample_config_text.encode('utf-8'))
651
my_config = config.GlobalConfig()
652
my_config._parser = my_config._get_parser(file=config_file)
822
653
return my_config
823
654
824
655
def test_gpg_signing_command(self):
827
658
self.assertEqual(False, my_config.signature_needed())
828
659
829
660
def _get_empty_config(self):
661
config_file = StringIO("")
830
662
my_config = config.GlobalConfig()
663
my_config._parser = my_config._get_parser(file=config_file)
831
664
return my_config
832
665
833
666
def test_gpg_signing_command_unset(self):
928
761
self.assertEqual(parser._calls,
929
762
[('__init__', config.locations_config_filename(),
930
763
'utf-8')])
764
config.ensure_config_dir_exists()
765
#os.mkdir(config.config_dir())
766
f = file(config.branches_config_filename(), 'wb')
767
f.write('')
768
f.close()
769
oldparserclass = config.ConfigObj
770
config.ConfigObj = InstrumentedConfigObj
771
try:
772
my_config = config.LocationConfig('http://www.example.com')
773
parser = my_config._get_parser()
774
finally:
775
config.ConfigObj = oldparserclass
931
776
932
777
def test_get_global_config(self):
933
778
my_config = config.BranchConfig(FakeBranch('http://example.com'))
1162
1007
self.my_config.post_commit())
1163
1008
1164
1009
def get_branch_config(self, location, global_config=None):
1165
my_branch = FakeBranch(location)
1166
1010
if global_config is None:
1167
global_config = sample_config_text
1168
1169
my_global_config = config.GlobalConfig.from_string(global_config,
1170
save=True)
1171
my_location_config = config.LocationConfig.from_string(
1172
sample_branches_text, my_branch.base, save=True)
1173
my_config = config.BranchConfig(my_branch)
1174
self.my_config = my_config
1175
self.my_location_config = my_config._get_location_config()
1011
global_file = StringIO(sample_config_text.encode('utf-8'))
1012
else:
1013
global_file = StringIO(global_config.encode('utf-8'))
1014
branches_file = StringIO(sample_branches_text.encode('utf-8'))
1015
self.my_config = config.BranchConfig(FakeBranch(location))
1016
# Force location config to use specified file
1017
self.my_location_config = self.my_config._get_location_config()
1018
self.my_location_config._get_parser(branches_file)
1019
# Force global config to use specified file
1020
self.my_config._get_global_config()._get_parser(global_file)
1176
1021
1177
1022
def test_set_user_setting_sets_and_saves(self):
1178
1023
self.get_branch_config('/a/c')
1179
1024
record = InstrumentedConfigObj("foo")
1180
1025
self.my_location_config._parser = record
1181
1026
1182
self.callDeprecated(['The recurse option is deprecated as of '
1183
'0.14. The section "/a/c" has been '
1184
'converted to use policies.'],
1185
self.my_config.set_user_option,
1186
'foo', 'bar', store=config.STORE_LOCATION)
1187
self.assertEqual([('reload',),
1188
('__contains__', '/a/c'),
1027
real_mkdir = os.mkdir
1028
self.created = False
1029
def checked_mkdir(path, mode=0777):
1030
self.log('making directory: %s', path)
1031
real_mkdir(path, mode)
1032
self.created = True
1033
1034
os.mkdir = checked_mkdir
1035
try:
1036
self.callDeprecated(['The recurse option is deprecated as of '
1037
'0.14. The section "/a/c" has been '
1038
'converted to use policies.'],
1039
self.my_config.set_user_option,
1040
'foo', 'bar', store=config.STORE_LOCATION)
1041
finally:
1042
os.mkdir = real_mkdir
1043
1044
self.failUnless(self.created, 'Failed to create ~/.bazaar')
1045
self.assertEqual([('__contains__', '/a/c'),
1189
1046
('__contains__', '/a/c/'),
1190
1047
('__setitem__', '/a/c', {}),
1191
1048
('__getitem__', '/a/c'),
1234
1091
option = exact
1235
1092
"""
1236
1093
1094
1237
1095
class TestBranchConfigItems(tests.TestCaseInTempDir):
1238
1096
1239
1097
def get_branch_config(self, global_config=None, location=None,
1240
1098
location_config=None, branch_data_config=None):
1241
my_branch = FakeBranch(location)
1099
my_config = config.BranchConfig(FakeBranch(location))
1242
1100
if global_config is not None:
1243
my_global_config = config.GlobalConfig.from_string(global_config,
1244
save=True)
1101
global_file = StringIO(global_config.encode('utf-8'))
1102
my_config._get_global_config()._get_parser(global_file)
1103
self.my_location_config = my_config._get_location_config()
1245
1104
if location_config is not None:
1246
my_location_config = config.LocationConfig.from_string(
1247
location_config, my_branch.base, save=True)
1248
my_config = config.BranchConfig(my_branch)
1105
location_file = StringIO(location_config.encode('utf-8'))
1106
self.my_location_config._get_parser(location_file)
1249
1107
if branch_data_config is not None:
1250
1108
my_config.branch.control_files.files['branch.conf'] = \
1251
1109
branch_data_config
1265
1123
my_config.username())
1266
1124
1267
1125
def test_not_set_in_branch(self):
1268
my_config = self.get_branch_config(global_config=sample_config_text)
1126
my_config = self.get_branch_config(sample_config_text)
1269
1127
self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
1270
1128
my_config._get_user_id())
1271
1129
my_config.branch.control_files.files['email'] = "John"
1295
1153
1296
1154
def test_gpg_signing_command(self):
1297
1155
my_config = self.get_branch_config(
1298
global_config=sample_config_text,
1299
1156
# branch data cannot set gpg_signing_command
1300
1157
branch_data_config="gpg_signing_command=pgp")
1158
config_file = StringIO(sample_config_text.encode('utf-8'))
1159
my_config._get_global_config()._get_parser(config_file)
1301
1160
self.assertEqual('gnome-gpg', my_config.gpg_signing_command())
1302
1161
1303
1162
def test_get_user_option_global(self):
1304
my_config = self.get_branch_config(global_config=sample_config_text)
1163
branch = FakeBranch()
1164
my_config = config.BranchConfig(branch)
1165
config_file = StringIO(sample_config_text.encode('utf-8'))
1166
(my_config._get_global_config()._get_parser(config_file))
1305
1167
self.assertEqual('something',
1306
1168
my_config.get_user_option('user_global_option'))
1307
1169
1308
1170
def test_post_commit_default(self):
1309
my_config = self.get_branch_config(global_config=sample_config_text,
1310
location='/a/c',
1311
location_config=sample_branches_text)
1171
branch = FakeBranch()
1172
my_config = self.get_branch_config(sample_config_text, '/a/c',
1173
sample_branches_text)
1312
1174
self.assertEqual(my_config.branch.base, '/a/c')
1313
1175
self.assertEqual('bzrlib.tests.test_config.post_commit',
1314
1176
my_config.post_commit())
1315
1177
my_config.set_user_option('post_commit', 'rmtree_root')
1316
# post-commit is ignored when present in branch data
1178
# post-commit is ignored when bresent in branch data
1317
1179
self.assertEqual('bzrlib.tests.test_config.post_commit',
1318
1180
my_config.post_commit())
1319
1181
my_config.set_user_option('post_commit', 'rmtree_root',
1321
1183
self.assertEqual('rmtree_root', my_config.post_commit())
1322
1184
1323
1185
def test_config_precedence(self):
1324
# FIXME: eager test, luckily no persitent config file makes it fail
1325
# -- vila 20100716
1326
1186
my_config = self.get_branch_config(global_config=precedence_global)
1327
1187
self.assertEqual(my_config.get_user_option('option'), 'global')
1328
1188
my_config = self.get_branch_config(global_config=precedence_global,
1329
branch_data_config=precedence_branch)
1189
branch_data_config=precedence_branch)
1330
1190
self.assertEqual(my_config.get_user_option('option'), 'branch')
1331
my_config = self.get_branch_config(
1332
global_config=precedence_global,
1333
branch_data_config=precedence_branch,
1334
location_config=precedence_location)
1191
my_config = self.get_branch_config(global_config=precedence_global,
1192
branch_data_config=precedence_branch,
1193
location_config=precedence_location)
1335
1194
self.assertEqual(my_config.get_user_option('option'), 'recurse')
1336
my_config = self.get_branch_config(
1337
global_config=precedence_global,
1338
branch_data_config=precedence_branch,
1339
location_config=precedence_location,
1340
location='http://example.com/specific')
1195
my_config = self.get_branch_config(global_config=precedence_global,
1196
branch_data_config=precedence_branch,
1197
location_config=precedence_location,
1198
location='http://example.com/specific')
1341
1199
self.assertEqual(my_config.get_user_option('option'), 'exact')
1342
1200
1343
1201
def test_get_mail_client(self):
Loggerhead is a web-based interface for Breezy
Version: 2.0.1