← 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: Canonical.com Patch Queue Manager
  • Date: 2006-09-17 21:19:56 UTC
  • mfrom: (1997.1.6 bind-does-not-push-or-pull)
  • Revision ID: pqm@pqm.ubuntu.com-20060917211956-6e30d07da410fd1a
(Robert Collins) Change the Branch bind method to just bind rather than binding and pushing (fixes #43744 and #39542)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_config.py
23
23
import sys
24
24
 
25
25
#import bzrlib specific imports here
26
 
import bzrlib.config as config
27
 
import bzrlib.errors as errors
28
 
from bzrlib.tests import TestCase, TestCaseInTempDir
 
26
from bzrlib import (
 
27
    config,
 
28
    errors,
 
29
    osutils,
 
30
    urlutils,
 
31
    )
 
32
from bzrlib.branch import Branch
 
33
from bzrlib.bzrdir import BzrDir
 
34
from bzrlib.tests import TestCase, TestCaseInTempDir, TestCaseWithTransport
29
35
 
30
36
 
31
37
sample_long_alias="log -r-15..-1 --line"
102
108
 
103
109
class FakeBranch(object):
104
110
 
105
 
    def __init__(self):
106
 
        self.base = "http://example.com/branches/demo"
107
 
        self.control_files = FakeControlFiles()
 
111
    def __init__(self, base=None, user_id=None):
 
112
        if base is None:
 
113
            self.base = "http://example.com/branches/demo"
 
114
        else:
 
115
            self.base = base
 
116
        self.control_files = FakeControlFiles(user_id=user_id)
 
117
 
 
118
    def lock_write(self):
 
119
        pass
 
120
 
 
121
    def unlock(self):
 
122
        pass
108
123
 
109
124
 
110
125
class FakeControlFiles(object):
111
126
 
112
 
    def __init__(self):
113
 
        self.email = 'Robert Collins <robertc@example.net>\n'
 
127
    def __init__(self, user_id=None):
 
128
        self.email = user_id
 
129
        self.files = {}
114
130
 
115
131
    def get_utf8(self, filename):
116
132
        if filename != 'email':
119
135
            return StringIO(self.email)
120
136
        raise errors.NoSuchFile(filename)
121
137
 
 
138
    def get(self, filename):
 
139
        try:
 
140
            return StringIO(self.files[filename])
 
141
        except KeyError:
 
142
            raise errors.NoSuchFile(filename)
 
143
 
 
144
    def put(self, filename, fileobj):
 
145
        self.files[filename] = fileobj.read()
 
146
 
122
147
 
123
148
class InstrumentedConfig(config.Config):
124
149
    """An instrumented config that supplies stubs for template methods."""
254
279
            self.assertEqual(config.branches_config_filename(),
255
280
                             '/home/bogus/.bazaar/branches.conf')
256
281
 
 
282
    def test_locations_config_filename(self):
 
283
        if sys.platform == 'win32':
 
284
            self.assertEqual(config.locations_config_filename(), 
 
285
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/locations.conf')
 
286
        else:
 
287
            self.assertEqual(config.locations_config_filename(),
 
288
                             '/home/bogus/.bazaar/locations.conf')
 
289
 
257
290
class TestIniConfig(TestCase):
258
291
 
259
292
    def test_contructs(self):
292
325
                                          'utf-8')])
293
326
 
294
327
 
295
 
class TestBranchConfig(TestCaseInTempDir):
 
328
class TestBranchConfig(TestCaseWithTransport):
296
329
 
297
330
    def test_constructs(self):
298
331
        branch = FakeBranch()
306
339
        self.assertEqual(branch.base, location_config.location)
307
340
        self.failUnless(location_config is my_config._get_location_config())
308
341
 
 
342
    def test_get_config(self):
 
343
        """The Branch.get_config method works properly"""
 
344
        b = BzrDir.create_standalone_workingtree('.').branch
 
345
        my_config = b.get_config()
 
346
        self.assertIs(my_config.get_user_option('wacky'), None)
 
347
        my_config.set_user_option('wacky', 'unlikely')
 
348
        self.assertEqual(my_config.get_user_option('wacky'), 'unlikely')
 
349
 
 
350
        # Ensure we get the same thing if we start again
 
351
        b2 = Branch.open('.')
 
352
        my_config2 = b2.get_config()
 
353
        self.assertEqual(my_config2.get_user_option('wacky'), 'unlikely')
 
354
 
 
355
    def test_has_explicit_nickname(self):
 
356
        b = self.make_branch('.')
 
357
        self.assertFalse(b.get_config().has_explicit_nickname())
 
358
        b.nick = 'foo'
 
359
        self.assertTrue(b.get_config().has_explicit_nickname())
 
360
 
 
361
    def test_config_url(self):
 
362
        """The Branch.get_config will use section that uses a local url"""
 
363
        branch = self.make_branch('branch')
 
364
        self.assertEqual('branch', branch.nick)
 
365
 
 
366
        locations = config.locations_config_filename()
 
367
        config.ensure_config_dir_exists()
 
368
        local_url = urlutils.local_path_to_url('branch')
 
369
        open(locations, 'wb').write('[%s]\nnickname = foobar' 
 
370
                                    % (local_url,))
 
371
        self.assertEqual('foobar', branch.nick)
 
372
 
 
373
    def test_config_local_path(self):
 
374
        """The Branch.get_config will use a local system path"""
 
375
        branch = self.make_branch('branch')
 
376
        self.assertEqual('branch', branch.nick)
 
377
 
 
378
        locations = config.locations_config_filename()
 
379
        config.ensure_config_dir_exists()
 
380
        open(locations, 'wb').write('[%s/branch]\nnickname = barry' 
 
381
                                    % (osutils.getcwd().encode('utf8'),))
 
382
        self.assertEqual('barry', branch.nick)
 
383
 
 
384
    def test_config_creates_local(self):
 
385
        """Creating a new entry in config uses a local path."""
 
386
        branch = self.make_branch('branch')
 
387
        branch.set_push_location('http://foobar')
 
388
        locations = config.locations_config_filename()
 
389
        local_path = osutils.getcwd().encode('utf8')
 
390
        # Surprisingly ConfigObj doesn't create a trailing newline
 
391
        self.check_file_contents(locations,
 
392
            '[%s/branch]\npush_location = http://foobar' % (local_path,))
 
393
 
309
394
 
310
395
class TestGlobalConfigItems(TestCase):
311
396
 
422
507
        # replace the class that is constructured, to check its parameters
423
508
        oldparserclass = config.ConfigObj
424
509
        config.ConfigObj = InstrumentedConfigObj
425
 
        my_config = config.LocationConfig('http://www.example.com')
426
510
        try:
 
511
            my_config = config.LocationConfig('http://www.example.com')
427
512
            parser = my_config._get_parser()
428
513
        finally:
429
514
            config.ConfigObj = oldparserclass
430
515
        self.failUnless(isinstance(parser, InstrumentedConfigObj))
431
516
        self.assertEqual(parser._calls,
432
 
                         [('__init__', config.branches_config_filename(),
 
517
                         [('__init__', config.locations_config_filename(),
433
518
                           'utf-8')])
 
519
        config.ensure_config_dir_exists()
 
520
        #os.mkdir(config.config_dir())
 
521
        f = file(config.branches_config_filename(), 'wb')
 
522
        f.write('')
 
523
        f.close()
 
524
        oldparserclass = config.ConfigObj
 
525
        config.ConfigObj = InstrumentedConfigObj
 
526
        try:
 
527
            my_config = config.LocationConfig('http://www.example.com')
 
528
            parser = my_config._get_parser()
 
529
        finally:
 
530
            config.ConfigObj = oldparserclass
434
531
 
435
532
    def test_get_global_config(self):
436
 
        my_config = config.LocationConfig('http://example.com')
 
533
        my_config = config.BranchConfig(FakeBranch('http://example.com'))
437
534
        global_config = my_config._get_global_config()
438
535
        self.failUnless(isinstance(global_config, config.GlobalConfig))
439
536
        self.failUnless(global_config is my_config._get_global_config())
440
537
 
441
538
    def test__get_section_no_match(self):
442
 
        self.get_location_config('/')
443
 
        self.assertEqual(None, self.my_config._get_section())
 
539
        self.get_branch_config('/')
 
540
        self.assertEqual(None, self.my_location_config._get_section())
444
541
        
445
542
    def test__get_section_exact(self):
446
 
        self.get_location_config('http://www.example.com')
 
543
        self.get_branch_config('http://www.example.com')
447
544
        self.assertEqual('http://www.example.com',
448
 
                         self.my_config._get_section())
 
545
                         self.my_location_config._get_section())
449
546
   
450
547
    def test__get_section_suffix_does_not(self):
451
 
        self.get_location_config('http://www.example.com-com')
452
 
        self.assertEqual(None, self.my_config._get_section())
 
548
        self.get_branch_config('http://www.example.com-com')
 
549
        self.assertEqual(None, self.my_location_config._get_section())
453
550
 
454
551
    def test__get_section_subdir_recursive(self):
455
 
        self.get_location_config('http://www.example.com/com')
 
552
        self.get_branch_config('http://www.example.com/com')
456
553
        self.assertEqual('http://www.example.com',
457
 
                         self.my_config._get_section())
 
554
                         self.my_location_config._get_section())
458
555
 
459
556
    def test__get_section_subdir_matches(self):
460
 
        self.get_location_config('http://www.example.com/useglobal')
 
557
        self.get_branch_config('http://www.example.com/useglobal')
461
558
        self.assertEqual('http://www.example.com/useglobal',
462
 
                         self.my_config._get_section())
 
559
                         self.my_location_config._get_section())
463
560
 
464
561
    def test__get_section_subdir_nonrecursive(self):
465
 
        self.get_location_config(
 
562
        self.get_branch_config(
466
563
            'http://www.example.com/useglobal/childbranch')
467
564
        self.assertEqual('http://www.example.com',
468
 
                         self.my_config._get_section())
 
565
                         self.my_location_config._get_section())
469
566
 
470
567
    def test__get_section_subdir_trailing_slash(self):
471
 
        self.get_location_config('/b')
472
 
        self.assertEqual('/b/', self.my_config._get_section())
 
568
        self.get_branch_config('/b')
 
569
        self.assertEqual('/b/', self.my_location_config._get_section())
473
570
 
474
571
    def test__get_section_subdir_child(self):
475
 
        self.get_location_config('/a/foo')
476
 
        self.assertEqual('/a/*', self.my_config._get_section())
 
572
        self.get_branch_config('/a/foo')
 
573
        self.assertEqual('/a/*', self.my_location_config._get_section())
477
574
 
478
575
    def test__get_section_subdir_child_child(self):
479
 
        self.get_location_config('/a/foo/bar')
480
 
        self.assertEqual('/a/', self.my_config._get_section())
 
576
        self.get_branch_config('/a/foo/bar')
 
577
        self.assertEqual('/a/', self.my_location_config._get_section())
481
578
 
482
579
    def test__get_section_trailing_slash_with_children(self):
483
 
        self.get_location_config('/a/')
484
 
        self.assertEqual('/a/', self.my_config._get_section())
 
580
        self.get_branch_config('/a/')
 
581
        self.assertEqual('/a/', self.my_location_config._get_section())
485
582
 
486
583
    def test__get_section_explicit_over_glob(self):
487
 
        self.get_location_config('/a/c')
488
 
        self.assertEqual('/a/c', self.my_config._get_section())
 
584
        self.get_branch_config('/a/c')
 
585
        self.assertEqual('/a/c', self.my_location_config._get_section())
489
586
 
490
587
 
491
588
    def test_location_without_username(self):
492
 
        self.get_location_config('http://www.example.com/useglobal')
 
589
        self.get_branch_config('http://www.example.com/useglobal')
493
590
        self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
494
591
                         self.my_config.username())
495
592
 
496
593
    def test_location_not_listed(self):
497
594
        """Test that the global username is used when no location matches"""
498
 
        self.get_location_config('/home/robertc/sources')
 
595
        self.get_branch_config('/home/robertc/sources')
499
596
        self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
500
597
                         self.my_config.username())
501
598
 
502
599
    def test_overriding_location(self):
503
 
        self.get_location_config('http://www.example.com/foo')
 
600
        self.get_branch_config('http://www.example.com/foo')
504
601
        self.assertEqual('Robert Collins <robertc@example.org>',
505
602
                         self.my_config.username())
506
603
 
507
604
    def test_signatures_not_set(self):
508
 
        self.get_location_config('http://www.example.com',
 
605
        self.get_branch_config('http://www.example.com',
509
606
                                 global_config=sample_ignore_signatures)
510
607
        self.assertEqual(config.CHECK_ALWAYS,
511
608
                         self.my_config.signature_checking())
513
610
                         self.my_config.signing_policy())
514
611
 
515
612
    def test_signatures_never(self):
516
 
        self.get_location_config('/a/c')
 
613
        self.get_branch_config('/a/c')
517
614
        self.assertEqual(config.CHECK_NEVER,
518
615
                         self.my_config.signature_checking())
519
616
        
520
617
    def test_signatures_when_available(self):
521
 
        self.get_location_config('/a/', global_config=sample_ignore_signatures)
 
618
        self.get_branch_config('/a/', global_config=sample_ignore_signatures)
522
619
        self.assertEqual(config.CHECK_IF_POSSIBLE,
523
620
                         self.my_config.signature_checking())
524
621
        
525
622
    def test_signatures_always(self):
526
 
        self.get_location_config('/b')
 
623
        self.get_branch_config('/b')
527
624
        self.assertEqual(config.CHECK_ALWAYS,
528
625
                         self.my_config.signature_checking())
529
626
        
530
627
    def test_gpg_signing_command(self):
531
 
        self.get_location_config('/b')
 
628
        self.get_branch_config('/b')
532
629
        self.assertEqual("gnome-gpg", self.my_config.gpg_signing_command())
533
630
 
534
631
    def test_gpg_signing_command_missing(self):
535
 
        self.get_location_config('/a')
 
632
        self.get_branch_config('/a')
536
633
        self.assertEqual("false", self.my_config.gpg_signing_command())
537
634
 
538
635
    def test_get_user_option_global(self):
539
 
        self.get_location_config('/a')
 
636
        self.get_branch_config('/a')
540
637
        self.assertEqual('something',
541
638
                         self.my_config.get_user_option('user_global_option'))
542
639
 
543
640
    def test_get_user_option_local(self):
544
 
        self.get_location_config('/a')
 
641
        self.get_branch_config('/a')
545
642
        self.assertEqual('local',
546
643
                         self.my_config.get_user_option('user_local_option'))
547
644
        
548
645
    def test_post_commit_default(self):
549
 
        self.get_location_config('/a/c')
 
646
        self.get_branch_config('/a/c')
550
647
        self.assertEqual('bzrlib.tests.test_config.post_commit',
551
648
                         self.my_config.post_commit())
552
649
 
553
 
    def get_location_config(self, location, global_config=None):
 
650
    def get_branch_config(self, location, global_config=None):
554
651
        if global_config is None:
555
652
            global_file = StringIO(sample_config_text.encode('utf-8'))
556
653
        else:
557
654
            global_file = StringIO(global_config.encode('utf-8'))
558
655
        branches_file = StringIO(sample_branches_text.encode('utf-8'))
559
 
        self.my_config = config.LocationConfig(location)
560
 
        self.my_config._get_parser(branches_file)
 
656
        self.my_config = config.BranchConfig(FakeBranch(location))
 
657
        # Force location config to use specified file
 
658
        self.my_location_config = self.my_config._get_location_config()
 
659
        self.my_location_config._get_parser(branches_file)
 
660
        # Force global config to use specified file
561
661
        self.my_config._get_global_config()._get_parser(global_file)
562
662
 
563
663
    def test_set_user_setting_sets_and_saves(self):
564
 
        self.get_location_config('/a/c')
 
664
        self.get_branch_config('/a/c')
565
665
        record = InstrumentedConfigObj("foo")
566
 
        self.my_config._parser = record
 
666
        self.my_location_config._parser = record
567
667
 
568
668
        real_mkdir = os.mkdir
569
669
        self.created = False
574
674
 
575
675
        os.mkdir = checked_mkdir
576
676
        try:
577
 
            self.my_config.set_user_option('foo', 'bar')
 
677
            self.my_config.set_user_option('foo', 'bar', local=True)
578
678
        finally:
579
679
            os.mkdir = real_mkdir
580
680
 
587
687
                          ('write',)],
588
688
                         record._calls[1:])
589
689
 
590
 
 
591
 
class TestBranchConfigItems(TestCase):
 
690
    def test_set_user_setting_sets_and_saves2(self):
 
691
        self.get_branch_config('/a/c')
 
692
        self.assertIs(self.my_config.get_user_option('foo'), None)
 
693
        self.my_config.set_user_option('foo', 'bar')
 
694
        self.assertEqual(
 
695
            self.my_config.branch.control_files.files['branch.conf'], 
 
696
            'foo = bar')
 
697
        self.assertEqual(self.my_config.get_user_option('foo'), 'bar')
 
698
        self.my_config.set_user_option('foo', 'baz', local=True)
 
699
        self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
 
700
        self.my_config.set_user_option('foo', 'qux')
 
701
        self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
 
702
        
 
703
 
 
704
precedence_global = 'option = global'
 
705
precedence_branch = 'option = branch'
 
706
precedence_location = """
 
707
[http://]
 
708
recurse = true
 
709
option = recurse
 
710
[http://example.com/specific]
 
711
option = exact
 
712
"""
 
713
 
 
714
 
 
715
class TestBranchConfigItems(TestCaseInTempDir):
 
716
 
 
717
    def get_branch_config(self, global_config=None, location=None, 
 
718
                          location_config=None, branch_data_config=None):
 
719
        my_config = config.BranchConfig(FakeBranch(location))
 
720
        if global_config is not None:
 
721
            global_file = StringIO(global_config.encode('utf-8'))
 
722
            my_config._get_global_config()._get_parser(global_file)
 
723
        self.my_location_config = my_config._get_location_config()
 
724
        if location_config is not None:
 
725
            location_file = StringIO(location_config.encode('utf-8'))
 
726
            self.my_location_config._get_parser(location_file)
 
727
        if branch_data_config is not None:
 
728
            my_config.branch.control_files.files['branch.conf'] = \
 
729
                branch_data_config
 
730
        return my_config
592
731
 
593
732
    def test_user_id(self):
594
 
        branch = FakeBranch()
 
733
        branch = FakeBranch(user_id='Robert Collins <robertc@example.net>')
595
734
        my_config = config.BranchConfig(branch)
596
735
        self.assertEqual("Robert Collins <robertc@example.net>",
597
 
                         my_config._get_user_id())
 
736
                         my_config.username())
598
737
        branch.control_files.email = "John"
599
 
        self.assertEqual("John", my_config._get_user_id())
 
738
        my_config.set_user_option('email', 
 
739
                                  "Robert Collins <robertc@example.org>")
 
740
        self.assertEqual("John", my_config.username())
 
741
        branch.control_files.email = None
 
742
        self.assertEqual("Robert Collins <robertc@example.org>",
 
743
                         my_config.username())
600
744
 
601
745
    def test_not_set_in_branch(self):
602
 
        branch = FakeBranch()
603
 
        my_config = config.BranchConfig(branch)
604
 
        branch.control_files.email = None
605
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
606
 
        (my_config._get_location_config().
607
 
            _get_global_config()._get_parser(config_file))
 
746
        my_config = self.get_branch_config(sample_config_text)
 
747
        my_config.branch.control_files.email = None
608
748
        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
609
749
                         my_config._get_user_id())
610
 
        branch.control_files.email = "John"
 
750
        my_config.branch.control_files.email = "John"
611
751
        self.assertEqual("John", my_config._get_user_id())
612
752
 
613
 
    def test_BZREMAIL_OVERRIDES(self):
614
 
        os.environ['BZREMAIL'] = "Robert Collins <robertc@example.org>"
 
753
    def test_BZR_EMAIL_OVERRIDES(self):
 
754
        os.environ['BZR_EMAIL'] = "Robert Collins <robertc@example.org>"
615
755
        branch = FakeBranch()
616
756
        my_config = config.BranchConfig(branch)
617
757
        self.assertEqual("Robert Collins <robertc@example.org>",
618
758
                         my_config.username())
619
759
    
620
760
    def test_signatures_forced(self):
621
 
        branch = FakeBranch()
622
 
        my_config = config.BranchConfig(branch)
623
 
        config_file = StringIO(sample_always_signatures)
624
 
        (my_config._get_location_config().
625
 
            _get_global_config()._get_parser(config_file))
 
761
        my_config = self.get_branch_config(
 
762
            global_config=sample_always_signatures)
 
763
        self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
 
764
        self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
 
765
        self.assertTrue(my_config.signature_needed())
 
766
 
 
767
    def test_signatures_forced_branch(self):
 
768
        my_config = self.get_branch_config(
 
769
            global_config=sample_ignore_signatures,
 
770
            branch_data_config=sample_always_signatures)
626
771
        self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
627
772
        self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
628
773
        self.assertTrue(my_config.signature_needed())
629
774
 
630
775
    def test_gpg_signing_command(self):
631
 
        branch = FakeBranch()
632
 
        my_config = config.BranchConfig(branch)
 
776
        my_config = self.get_branch_config(
 
777
            # branch data cannot set gpg_signing_command
 
778
            branch_data_config="gpg_signing_command=pgp")
633
779
        config_file = StringIO(sample_config_text.encode('utf-8'))
634
 
        (my_config._get_location_config().
635
 
            _get_global_config()._get_parser(config_file))
 
780
        my_config._get_global_config()._get_parser(config_file)
636
781
        self.assertEqual('gnome-gpg', my_config.gpg_signing_command())
637
782
 
638
783
    def test_get_user_option_global(self):
639
784
        branch = FakeBranch()
640
785
        my_config = config.BranchConfig(branch)
641
786
        config_file = StringIO(sample_config_text.encode('utf-8'))
642
 
        (my_config._get_location_config().
643
 
            _get_global_config()._get_parser(config_file))
 
787
        (my_config._get_global_config()._get_parser(config_file))
644
788
        self.assertEqual('something',
645
789
                         my_config.get_user_option('user_global_option'))
646
790
 
647
791
    def test_post_commit_default(self):
648
792
        branch = FakeBranch()
649
 
        branch.base='/a/c'
650
 
        my_config = config.BranchConfig(branch)
651
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
652
 
        (my_config._get_location_config().
653
 
            _get_global_config()._get_parser(config_file))
654
 
        branch_file = StringIO(sample_branches_text)
655
 
        my_config._get_location_config()._get_parser(branch_file)
656
 
        self.assertEqual('bzrlib.tests.test_config.post_commit',
657
 
                         my_config.post_commit())
 
793
        my_config = self.get_branch_config(sample_config_text, '/a/c',
 
794
                                           sample_branches_text)
 
795
        self.assertEqual(my_config.branch.base, '/a/c')
 
796
        self.assertEqual('bzrlib.tests.test_config.post_commit',
 
797
                         my_config.post_commit())
 
798
        my_config.set_user_option('post_commit', 'rmtree_root')
 
799
        # post-commit is ignored when bresent in branch data
 
800
        self.assertEqual('bzrlib.tests.test_config.post_commit',
 
801
                         my_config.post_commit())
 
802
        my_config.set_user_option('post_commit', 'rmtree_root', local=True)
 
803
        self.assertEqual('rmtree_root', my_config.post_commit())
 
804
 
 
805
    def test_config_precedence(self):
 
806
        my_config = self.get_branch_config(global_config=precedence_global)
 
807
        self.assertEqual(my_config.get_user_option('option'), 'global')
 
808
        my_config = self.get_branch_config(global_config=precedence_global, 
 
809
                                      branch_data_config=precedence_branch)
 
810
        self.assertEqual(my_config.get_user_option('option'), 'branch')
 
811
        my_config = self.get_branch_config(global_config=precedence_global, 
 
812
                                      branch_data_config=precedence_branch,
 
813
                                      location_config=precedence_location)
 
814
        self.assertEqual(my_config.get_user_option('option'), 'recurse')
 
815
        my_config = self.get_branch_config(global_config=precedence_global, 
 
816
                                      branch_data_config=precedence_branch,
 
817
                                      location_config=precedence_location,
 
818
                                      location='http://example.com/specific')
 
819
        self.assertEqual(my_config.get_user_option('option'), 'exact')
658
820
 
659
821
 
660
822
class TestMailAddressExtraction(TestCase):