← 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: Gary van der Merwe
  • Date: 2010-08-02 19:56:52 UTC
  • mfrom: (5050.3.18 2.2)
  • mto: (5050.3.19 2.2)
  • mto: This revision was merged to the branch mainline in revision 5371.
  • Revision ID: garyvdm@gmail.com-20100802195652-o1ppjemhwrr98i61
Merge lp:bzr/2.2.

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 (
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)
779
 
 
780
 
 
781
 
class TestGlobalConfigItems(tests.TestCaseInTempDir):
 
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
 
596
 
 
597
 
 
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):