← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_config.py

  • Committer: Martin von Gagern
  • Date: 2010-04-20 08:47:38 UTC
  • mfrom: (5167 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5195.
  • Revision ID: martin.vgagern@gmx.net-20100420084738-ygymnqmdllzrhpfn
merge trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
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 (
36
35
    trace,
37
36
    transport,
38
37
    )
39
 
from bzrlib.tests import features
40
38
from bzrlib.util.configobj import configobj
41
39
 
42
40
 
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
41
sample_long_alias="log -r-15..-1 --line"
68
42
sample_config_text = u"""
69
43
[DEFAULT]
155
129
        self._calls.append(('keys',))
156
130
        return []
157
131
 
158
 
    def reload(self):
159
 
        self._calls.append(('reload',))
160
 
 
161
132
    def write(self, arg):
162
133
        self._calls.append(('write',))
163
134
 
379
350
        self.assertEqual(config.config_filename(),
380
351
                         self.bzr_home + '/bazaar.conf')
381
352
 
 
353
    def test_branches_config_filename(self):
 
354
        self.assertEqual(config.branches_config_filename(),
 
355
                         self.bzr_home + '/branches.conf')
 
356
 
382
357
    def test_locations_config_filename(self):
383
358
        self.assertEqual(config.locations_config_filename(),
384
359
                         self.bzr_home + '/locations.conf')
392
367
            '/home/bogus/.cache')
393
368
 
394
369
 
395
 
class TestIniConfig(tests.TestCaseInTempDir):
 
370
class TestIniConfig(tests.TestCase):
396
371
 
397
372
    def make_config_parser(self, s):
398
 
        conf = config.IniBasedConfig.from_string(s)
399
 
        return conf, conf._get_parser()
 
373
        conf = config.IniBasedConfig(None)
 
374
        parser = conf._get_parser(file=StringIO(s.encode('utf-8')))
 
375
        return conf, parser
400
376
 
401
377
 
402
378
class TestIniConfigBuilding(TestIniConfig):
403
379
 
404
380
    def test_contructs(self):
405
 
        my_config = config.IniBasedConfig()
 
381
        my_config = config.IniBasedConfig("nothing")
406
382
 
407
383
    def test_from_fp(self):
408
 
        my_config = config.IniBasedConfig.from_string(sample_config_text)
409
 
        self.assertIsInstance(my_config._get_parser(), configobj.ConfigObj)
 
384
        config_file = StringIO(sample_config_text.encode('utf-8'))
 
385
        my_config = config.IniBasedConfig(None)
 
386
        self.failUnless(
 
387
            isinstance(my_config._get_parser(file=config_file),
 
388
                        configobj.ConfigObj))
410
389
 
411
390
    def test_cached(self):
412
 
        my_config = config.IniBasedConfig.from_string(sample_config_text)
413
 
        parser = my_config._get_parser()
 
391
        config_file = StringIO(sample_config_text.encode('utf-8'))
 
392
        my_config = config.IniBasedConfig(None)
 
393
        parser = my_config._get_parser(file=config_file)
414
394
        self.failUnless(my_config._get_parser() is parser)
415
395
 
416
 
    def _dummy_chown(self, path, uid, gid):
417
 
        self.path, self.uid, self.gid = path, uid, gid
418
 
 
419
 
    def test_ini_config_ownership(self):
420
 
        """Ensure that chown is happening during _write_config_file"""
421
 
        self.requireFeature(features.chown_feature)
422
 
        self.overrideAttr(os, 'chown', self._dummy_chown)
423
 
        self.path = self.uid = self.gid = None
424
 
        conf = config.IniBasedConfig(file_name='./foo.conf')
425
 
        conf._write_config_file()
426
 
        self.assertEquals(self.path, './foo.conf')
427
 
        self.assertTrue(isinstance(self.uid, int))
428
 
        self.assertTrue(isinstance(self.gid, int))
429
 
 
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
396
 
603
397
class TestGetUserOptionAs(TestIniConfig):
604
398
 
612
406
        get_bool = conf.get_user_option_as_bool
613
407
        self.assertEqual(True, get_bool('a_true_bool'))
614
408
        self.assertEqual(False, get_bool('a_false_bool'))
615
 
        warnings = []
616
 
        def warning(*args):
617
 
            warnings.append(args[0] % args[1:])
618
 
        self.overrideAttr(trace, 'warning', warning)
619
 
        msg = 'Value "%s" is not a boolean for "%s"'
620
409
        self.assertIs(None, get_bool('an_invalid_bool'))
621
 
        self.assertEquals(msg % ('maybe', 'an_invalid_bool'), warnings[0])
622
 
        warnings = []
623
410
        self.assertIs(None, get_bool('not_defined_in_this_config'))
624
 
        self.assertEquals([], warnings)
 
411
 
625
412
 
626
413
    def test_get_user_option_as_list(self):
627
414
        conf, parser = self.make_config_parser("""
711
498
        branch = self.make_branch('branch')
712
499
        self.assertEqual('branch', branch.nick)
713
500
 
 
501
        locations = config.locations_config_filename()
 
502
        config.ensure_config_dir_exists()
714
503
        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)
 
504
        open(locations, 'wb').write('[%s]\nnickname = foobar'
 
505
                                    % (local_url,))
718
506
        self.assertEqual('foobar', branch.nick)
719
507
 
720
508
    def test_config_local_path(self):
722
510
        branch = self.make_branch('branch')
723
511
        self.assertEqual('branch', branch.nick)
724
512
 
725
 
        local_path = osutils.getcwd().encode('utf8')
726
 
        conf = config.LocationConfig.from_string(
727
 
            '[%s/branch]\nnickname = barry' % (local_path,),
728
 
            'branch',  save=True)
 
513
        locations = config.locations_config_filename()
 
514
        config.ensure_config_dir_exists()
 
515
        open(locations, 'wb').write('[%s/branch]\nnickname = barry'
 
516
                                    % (osutils.getcwd().encode('utf8'),))
729
517
        self.assertEqual('barry', branch.nick)
730
518
 
731
519
    def test_config_creates_local(self):
732
520
        """Creating a new entry in config uses a local path."""
733
521
        branch = self.make_branch('branch', format='knit')
734
522
        branch.set_push_location('http://foobar')
 
523
        locations = config.locations_config_filename()
735
524
        local_path = osutils.getcwd().encode('utf8')
736
525
        # Surprisingly ConfigObj doesn't create a trailing newline
737
 
        self.check_file_contents(config.locations_config_filename(),
 
526
        self.check_file_contents(locations,
738
527
                                 '[%s/branch]\n'
739
528
                                 'push_location = http://foobar\n'
740
529
                                 'push_location:policy = norecurse\n'
745
534
        self.assertEqual('!repo', b.get_config().get_nickname())
746
535
 
747
536
    def test_warn_if_masked(self):
 
537
        _warning = trace.warning
748
538
        warnings = []
749
539
        def warning(*args):
750
540
            warnings.append(args[0] % args[1:])
751
 
        self.overrideAttr(trace, 'warning', warning)
752
541
 
753
542
        def set_option(store, warn_masked=True):
754
543
            warnings[:] = []
760
549
            else:
761
550
                self.assertEqual(1, len(warnings))
762
551
                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)
 
552
        trace.warning = warning
 
553
        try:
 
554
            branch = self.make_branch('.')
 
555
            conf = branch.get_config()
 
556
            set_option(config.STORE_GLOBAL)
 
557
            assertWarning(None)
 
558
            set_option(config.STORE_BRANCH)
 
559
            assertWarning(None)
 
560
            set_option(config.STORE_GLOBAL)
 
561
            assertWarning('Value "4" is masked by "3" from branch.conf')
 
562
            set_option(config.STORE_GLOBAL, warn_masked=False)
 
563
            assertWarning(None)
 
564
            set_option(config.STORE_LOCATION)
 
565
            assertWarning(None)
 
566
            set_option(config.STORE_BRANCH)
 
567
            assertWarning('Value "3" is masked by "0" from locations.conf')
 
568
            set_option(config.STORE_BRANCH, warn_masked=False)
 
569
            assertWarning(None)
 
570
        finally:
 
571
            trace.warning = _warning
779
572
 
780
573
 
781
574
class TestGlobalConfigItems(tests.TestCase):
782
575
 
783
576
    def test_user_id(self):
784
 
        my_config = config.GlobalConfig.from_string(sample_config_text)
 
577
        config_file = StringIO(sample_config_text.encode('utf-8'))
 
578
        my_config = config.GlobalConfig()
 
579
        my_config._parser = my_config._get_parser(file=config_file)
785
580
        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
786
581
                         my_config._get_user_id())
787
582
 
788
583
    def test_absent_user_id(self):
 
584
        config_file = StringIO("")
789
585
        my_config = config.GlobalConfig()
 
586
        my_config._parser = my_config._get_parser(file=config_file)
790
587
        self.assertEqual(None, my_config._get_user_id())
791
588
 
792
589
    def test_configured_editor(self):
793
 
        my_config = config.GlobalConfig.from_string(sample_config_text)
 
590
        config_file = StringIO(sample_config_text.encode('utf-8'))
 
591
        my_config = config.GlobalConfig()
 
592
        my_config._parser = my_config._get_parser(file=config_file)
794
593
        self.assertEqual("vim", my_config.get_editor())
795
594
 
796
595
    def test_signatures_always(self):
797
 
        my_config = config.GlobalConfig.from_string(sample_always_signatures)
 
596
        config_file = StringIO(sample_always_signatures)
 
597
        my_config = config.GlobalConfig()
 
598
        my_config._parser = my_config._get_parser(file=config_file)
798
599
        self.assertEqual(config.CHECK_NEVER,
799
600
                         my_config.signature_checking())
800
601
        self.assertEqual(config.SIGN_ALWAYS,
802
603
        self.assertEqual(True, my_config.signature_needed())
803
604
 
804
605
    def test_signatures_if_possible(self):
805
 
        my_config = config.GlobalConfig.from_string(sample_maybe_signatures)
 
606
        config_file = StringIO(sample_maybe_signatures)
 
607
        my_config = config.GlobalConfig()
 
608
        my_config._parser = my_config._get_parser(file=config_file)
806
609
        self.assertEqual(config.CHECK_NEVER,
807
610
                         my_config.signature_checking())
808
611
        self.assertEqual(config.SIGN_WHEN_REQUIRED,
810
613
        self.assertEqual(False, my_config.signature_needed())
811
614
 
812
615
    def test_signatures_ignore(self):
813
 
        my_config = config.GlobalConfig.from_string(sample_ignore_signatures)
 
616
        config_file = StringIO(sample_ignore_signatures)
 
617
        my_config = config.GlobalConfig()
 
618
        my_config._parser = my_config._get_parser(file=config_file)
814
619
        self.assertEqual(config.CHECK_ALWAYS,
815
620
                         my_config.signature_checking())
816
621
        self.assertEqual(config.SIGN_NEVER,
818
623
        self.assertEqual(False, my_config.signature_needed())
819
624
 
820
625
    def _get_sample_config(self):
821
 
        my_config = config.GlobalConfig.from_string(sample_config_text)
 
626
        config_file = StringIO(sample_config_text.encode('utf-8'))
 
627
        my_config = config.GlobalConfig()
 
628
        my_config._parser = my_config._get_parser(file=config_file)
822
629
        return my_config
823
630
 
824
631
    def test_gpg_signing_command(self):
827
634
        self.assertEqual(False, my_config.signature_needed())
828
635
 
829
636
    def _get_empty_config(self):
 
637
        config_file = StringIO("")
830
638
        my_config = config.GlobalConfig()
 
639
        my_config._parser = my_config._get_parser(file=config_file)
831
640
        return my_config
832
641
 
833
642
    def test_gpg_signing_command_unset(self):
928
737
        self.assertEqual(parser._calls,
929
738
                         [('__init__', config.locations_config_filename(),
930
739
                           'utf-8')])
 
740
        config.ensure_config_dir_exists()
 
741
        #os.mkdir(config.config_dir())
 
742
        f = file(config.branches_config_filename(), 'wb')
 
743
        f.write('')
 
744
        f.close()
 
745
        oldparserclass = config.ConfigObj
 
746
        config.ConfigObj = InstrumentedConfigObj
 
747
        try:
 
748
            my_config = config.LocationConfig('http://www.example.com')
 
749
            parser = my_config._get_parser()
 
750
        finally:
 
751
            config.ConfigObj = oldparserclass
931
752
 
932
753
    def test_get_global_config(self):
933
754
        my_config = config.BranchConfig(FakeBranch('http://example.com'))
1162
983
                         self.my_config.post_commit())
1163
984
 
1164
985
    def get_branch_config(self, location, global_config=None):
1165
 
        my_branch = FakeBranch(location)
1166
986
        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()
 
987
            global_file = StringIO(sample_config_text.encode('utf-8'))
 
988
        else:
 
989
            global_file = StringIO(global_config.encode('utf-8'))
 
990
        branches_file = StringIO(sample_branches_text.encode('utf-8'))
 
991
        self.my_config = config.BranchConfig(FakeBranch(location))
 
992
        # Force location config to use specified file
 
993
        self.my_location_config = self.my_config._get_location_config()
 
994
        self.my_location_config._get_parser(branches_file)
 
995
        # Force global config to use specified file
 
996
        self.my_config._get_global_config()._get_parser(global_file)
1176
997
 
1177
998
    def test_set_user_setting_sets_and_saves(self):
1178
999
        self.get_branch_config('/a/c')
1179
1000
        record = InstrumentedConfigObj("foo")
1180
1001
        self.my_location_config._parser = record
1181
1002
 
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'),
 
1003
        real_mkdir = os.mkdir
 
1004
        self.created = False
 
1005
        def checked_mkdir(path, mode=0777):
 
1006
            self.log('making directory: %s', path)
 
1007
            real_mkdir(path, mode)
 
1008
            self.created = True
 
1009
 
 
1010
        os.mkdir = checked_mkdir
 
1011
        try:
 
1012
            self.callDeprecated(['The recurse option is deprecated as of '
 
1013
                                 '0.14.  The section "/a/c" has been '
 
1014
                                 'converted to use policies.'],
 
1015
                                self.my_config.set_user_option,
 
1016
                                'foo', 'bar', store=config.STORE_LOCATION)
 
1017
        finally:
 
1018
            os.mkdir = real_mkdir
 
1019
 
 
1020
        self.failUnless(self.created, 'Failed to create ~/.bazaar')
 
1021
        self.assertEqual([('__contains__', '/a/c'),
1189
1022
                          ('__contains__', '/a/c/'),
1190
1023
                          ('__setitem__', '/a/c', {}),
1191
1024
                          ('__getitem__', '/a/c'),
1234
1067
option = exact
1235
1068
"""
1236
1069
 
 
1070
 
1237
1071
class TestBranchConfigItems(tests.TestCaseInTempDir):
1238
1072
 
1239
1073
    def get_branch_config(self, global_config=None, location=None,
1240
1074
                          location_config=None, branch_data_config=None):
1241
 
        my_branch = FakeBranch(location)
 
1075
        my_config = config.BranchConfig(FakeBranch(location))
1242
1076
        if global_config is not None:
1243
 
            my_global_config = config.GlobalConfig.from_string(global_config,
1244
 
                                                               save=True)
 
1077
            global_file = StringIO(global_config.encode('utf-8'))
 
1078
            my_config._get_global_config()._get_parser(global_file)
 
1079
        self.my_location_config = my_config._get_location_config()
1245
1080
        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)
 
1081
            location_file = StringIO(location_config.encode('utf-8'))
 
1082
            self.my_location_config._get_parser(location_file)
1249
1083
        if branch_data_config is not None:
1250
1084
            my_config.branch.control_files.files['branch.conf'] = \
1251
1085
                branch_data_config
1265
1099
                         my_config.username())
1266
1100
 
1267
1101
    def test_not_set_in_branch(self):
1268
 
        my_config = self.get_branch_config(global_config=sample_config_text)
 
1102
        my_config = self.get_branch_config(sample_config_text)
1269
1103
        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
1270
1104
                         my_config._get_user_id())
1271
1105
        my_config.branch.control_files.files['email'] = "John"
1295
1129
 
1296
1130
    def test_gpg_signing_command(self):
1297
1131
        my_config = self.get_branch_config(
1298
 
            global_config=sample_config_text,
1299
1132
            # branch data cannot set gpg_signing_command
1300
1133
            branch_data_config="gpg_signing_command=pgp")
 
1134
        config_file = StringIO(sample_config_text.encode('utf-8'))
 
1135
        my_config._get_global_config()._get_parser(config_file)
1301
1136
        self.assertEqual('gnome-gpg', my_config.gpg_signing_command())
1302
1137
 
1303
1138
    def test_get_user_option_global(self):
1304
 
        my_config = self.get_branch_config(global_config=sample_config_text)
 
1139
        branch = FakeBranch()
 
1140
        my_config = config.BranchConfig(branch)
 
1141
        config_file = StringIO(sample_config_text.encode('utf-8'))
 
1142
        (my_config._get_global_config()._get_parser(config_file))
1305
1143
        self.assertEqual('something',
1306
1144
                         my_config.get_user_option('user_global_option'))
1307
1145
 
1308
1146
    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)
 
1147
        branch = FakeBranch()
 
1148
        my_config = self.get_branch_config(sample_config_text, '/a/c',
 
1149
                                           sample_branches_text)
1312
1150
        self.assertEqual(my_config.branch.base, '/a/c')
1313
1151
        self.assertEqual('bzrlib.tests.test_config.post_commit',
1314
1152
                         my_config.post_commit())
1315
1153
        my_config.set_user_option('post_commit', 'rmtree_root')
1316
 
        # post-commit is ignored when present in branch data
 
1154
        # post-commit is ignored when bresent in branch data
1317
1155
        self.assertEqual('bzrlib.tests.test_config.post_commit',
1318
1156
                         my_config.post_commit())
1319
1157
        my_config.set_user_option('post_commit', 'rmtree_root',
1321
1159
        self.assertEqual('rmtree_root', my_config.post_commit())
1322
1160
 
1323
1161
    def test_config_precedence(self):
1324
 
        # FIXME: eager test, luckily no persitent config file makes it fail
1325
 
        # -- vila 20100716
1326
1162
        my_config = self.get_branch_config(global_config=precedence_global)
1327
1163
        self.assertEqual(my_config.get_user_option('option'), 'global')
1328
1164
        my_config = self.get_branch_config(global_config=precedence_global,
1329
 
                                           branch_data_config=precedence_branch)
 
1165
                                      branch_data_config=precedence_branch)
1330
1166
        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)
 
1167
        my_config = self.get_branch_config(global_config=precedence_global,
 
1168
                                      branch_data_config=precedence_branch,
 
1169
                                      location_config=precedence_location)
1335
1170
        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')
 
1171
        my_config = self.get_branch_config(global_config=precedence_global,
 
1172
                                      branch_data_config=precedence_branch,
 
1173
                                      location_config=precedence_location,
 
1174
                                      location='http://example.com/specific')
1341
1175
        self.assertEqual(my_config.get_user_option('option'), 'exact')
1342
1176
 
1343
1177
    def test_get_mail_client(self):