← 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: Aaron Bentley
  • Date: 2010-01-20 07:27:49 UTC
  • mto: This revision was merged to the branch mainline in revision 5049.
  • Revision ID: aaron@aaronbentley.com-20100120072749-kb2r2shencwhekkd
It makes more sense to get the dev focus from an existing Launchpad branch
object, especially given that you need a Launchpad branch object to get it.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_config.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2008, 2009 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
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)
779
 
 
780
 
 
781
 
class TestGlobalConfigItems(tests.TestCaseInTempDir):
 
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
 
572
 
 
573
 
 
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):
1836
1670
            'password ignored in section \[ssh with password\]')
1837
1671
 
1838
1672
    def test_uses_fallback_stores(self):
1839
 
        self.overrideAttr(config, 'credential_store_registry',
1840
 
                          config.CredentialStoreRegistry())
 
1673
        self._old_cs_registry = config.credential_store_registry
 
1674
        def restore():
 
1675
            config.credential_store_registry = self._old_cs_registry
 
1676
        self.addCleanup(restore)
 
1677
        config.credential_store_registry = config.CredentialStoreRegistry()
1841
1678
        store = StubCredentialStore()
1842
1679
        store.add_credentials("http", "example.com", "joe", "secret")
1843
1680
        config.credential_store_registry.register("stub", store, fallback=True)