/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_config.py

  • Committer: Martin Pool
  • Date: 2006-10-06 02:04:17 UTC
  • mfrom: (1908.10.1 bench_usecases.merge2)
  • mto: This revision was merged to the branch mainline in revision 2068.
  • Revision ID: mbp@sourcefrog.net-20061006020417-4949ca86f4417a4d
merge additional fix from cfbolz

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_config.py
1
 
# Copyright (C) 2005 by Canonical Ltd
 
1
# Copyright (C) 2005, 2006 by Canonical Ltd
2
2
#   Authors: Robert Collins <robert.collins@canonical.com>
3
3
#
4
4
# This program is free software; you can redistribute it and/or modify
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"
41
47
 
42
48
 
43
49
sample_always_signatures = ("[DEFAULT]\n"
44
 
                            "check_signatures=require\n")
 
50
                            "check_signatures=ignore\n"
 
51
                            "create_signatures=always")
45
52
 
46
53
 
47
54
sample_ignore_signatures = ("[DEFAULT]\n"
48
 
                            "check_signatures=ignore\n")
 
55
                            "check_signatures=require\n"
 
56
                            "create_signatures=never")
49
57
 
50
58
 
51
59
sample_maybe_signatures = ("[DEFAULT]\n"
52
 
                            "check_signatures=check-available\n")
 
60
                            "check_signatures=ignore\n"
 
61
                            "create_signatures=when-required")
53
62
 
54
63
 
55
64
sample_branches_text = ("[http://www.example.com]\n"
99
108
 
100
109
class FakeBranch(object):
101
110
 
102
 
    def __init__(self):
103
 
        self.base = "http://example.com/branches/demo"
104
 
        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
105
123
 
106
124
 
107
125
class FakeControlFiles(object):
108
126
 
109
 
    def __init__(self):
110
 
        self.email = 'Robert Collins <robertc@example.net>\n'
 
127
    def __init__(self, user_id=None):
 
128
        self.email = user_id
 
129
        self.files = {}
111
130
 
112
131
    def get_utf8(self, filename):
113
132
        if filename != 'email':
116
135
            return StringIO(self.email)
117
136
        raise errors.NoSuchFile(filename)
118
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
 
119
147
 
120
148
class InstrumentedConfig(config.Config):
121
149
    """An instrumented config that supplies stubs for template methods."""
172
200
 
173
201
    def test_signatures_default(self):
174
202
        my_config = config.Config()
 
203
        self.assertFalse(my_config.signature_needed())
175
204
        self.assertEqual(config.CHECK_IF_POSSIBLE,
176
205
                         my_config.signature_checking())
 
206
        self.assertEqual(config.SIGN_WHEN_REQUIRED,
 
207
                         my_config.signing_policy())
177
208
 
178
209
    def test_signatures_template_method(self):
179
210
        my_config = InstrumentedConfig()
248
279
            self.assertEqual(config.branches_config_filename(),
249
280
                             '/home/bogus/.bazaar/branches.conf')
250
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
 
251
290
class TestIniConfig(TestCase):
252
291
 
253
292
    def test_contructs(self):
286
325
                                          'utf-8')])
287
326
 
288
327
 
289
 
class TestBranchConfig(TestCaseInTempDir):
 
328
class TestBranchConfig(TestCaseWithTransport):
290
329
 
291
330
    def test_constructs(self):
292
331
        branch = FakeBranch()
300
339
        self.assertEqual(branch.base, location_config.location)
301
340
        self.failUnless(location_config is my_config._get_location_config())
302
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
 
303
394
 
304
395
class TestGlobalConfigItems(TestCase):
305
396
 
326
417
        config_file = StringIO(sample_always_signatures)
327
418
        my_config = config.GlobalConfig()
328
419
        my_config._parser = my_config._get_parser(file=config_file)
329
 
        self.assertEqual(config.CHECK_ALWAYS,
 
420
        self.assertEqual(config.CHECK_NEVER,
330
421
                         my_config.signature_checking())
 
422
        self.assertEqual(config.SIGN_ALWAYS,
 
423
                         my_config.signing_policy())
331
424
        self.assertEqual(True, my_config.signature_needed())
332
425
 
333
426
    def test_signatures_if_possible(self):
334
427
        config_file = StringIO(sample_maybe_signatures)
335
428
        my_config = config.GlobalConfig()
336
429
        my_config._parser = my_config._get_parser(file=config_file)
337
 
        self.assertEqual(config.CHECK_IF_POSSIBLE,
 
430
        self.assertEqual(config.CHECK_NEVER,
338
431
                         my_config.signature_checking())
 
432
        self.assertEqual(config.SIGN_WHEN_REQUIRED,
 
433
                         my_config.signing_policy())
339
434
        self.assertEqual(False, my_config.signature_needed())
340
435
 
341
436
    def test_signatures_ignore(self):
342
437
        config_file = StringIO(sample_ignore_signatures)
343
438
        my_config = config.GlobalConfig()
344
439
        my_config._parser = my_config._get_parser(file=config_file)
345
 
        self.assertEqual(config.CHECK_NEVER,
 
440
        self.assertEqual(config.CHECK_ALWAYS,
346
441
                         my_config.signature_checking())
 
442
        self.assertEqual(config.SIGN_NEVER,
 
443
                         my_config.signing_policy())
347
444
        self.assertEqual(False, my_config.signature_needed())
348
445
 
349
446
    def _get_sample_config(self):
396
493
        my_config = self._get_sample_config()
397
494
        self.assertEqual(sample_long_alias, my_config.get_alias('ll'))
398
495
 
399
 
class TestLocationConfig(TestCase):
 
496
 
 
497
class TestLocationConfig(TestCaseInTempDir):
400
498
 
401
499
    def test_constructs(self):
402
500
        my_config = config.LocationConfig('http://example.com')
409
507
        # replace the class that is constructured, to check its parameters
410
508
        oldparserclass = config.ConfigObj
411
509
        config.ConfigObj = InstrumentedConfigObj
412
 
        my_config = config.LocationConfig('http://www.example.com')
413
510
        try:
 
511
            my_config = config.LocationConfig('http://www.example.com')
414
512
            parser = my_config._get_parser()
415
513
        finally:
416
514
            config.ConfigObj = oldparserclass
417
515
        self.failUnless(isinstance(parser, InstrumentedConfigObj))
418
516
        self.assertEqual(parser._calls,
419
 
                         [('__init__', config.branches_config_filename())])
 
517
                         [('__init__', config.locations_config_filename(),
 
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
420
531
 
421
532
    def test_get_global_config(self):
422
 
        my_config = config.LocationConfig('http://example.com')
 
533
        my_config = config.BranchConfig(FakeBranch('http://example.com'))
423
534
        global_config = my_config._get_global_config()
424
535
        self.failUnless(isinstance(global_config, config.GlobalConfig))
425
536
        self.failUnless(global_config is my_config._get_global_config())
426
537
 
427
538
    def test__get_section_no_match(self):
428
 
        self.get_location_config('/')
429
 
        self.assertEqual(None, self.my_config._get_section())
 
539
        self.get_branch_config('/')
 
540
        self.assertEqual(None, self.my_location_config._get_section())
430
541
        
431
542
    def test__get_section_exact(self):
432
 
        self.get_location_config('http://www.example.com')
 
543
        self.get_branch_config('http://www.example.com')
433
544
        self.assertEqual('http://www.example.com',
434
 
                         self.my_config._get_section())
 
545
                         self.my_location_config._get_section())
435
546
   
436
547
    def test__get_section_suffix_does_not(self):
437
 
        self.get_location_config('http://www.example.com-com')
438
 
        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())
439
550
 
440
551
    def test__get_section_subdir_recursive(self):
441
 
        self.get_location_config('http://www.example.com/com')
 
552
        self.get_branch_config('http://www.example.com/com')
442
553
        self.assertEqual('http://www.example.com',
443
 
                         self.my_config._get_section())
 
554
                         self.my_location_config._get_section())
444
555
 
445
556
    def test__get_section_subdir_matches(self):
446
 
        self.get_location_config('http://www.example.com/useglobal')
 
557
        self.get_branch_config('http://www.example.com/useglobal')
447
558
        self.assertEqual('http://www.example.com/useglobal',
448
 
                         self.my_config._get_section())
 
559
                         self.my_location_config._get_section())
449
560
 
450
561
    def test__get_section_subdir_nonrecursive(self):
451
 
        self.get_location_config(
 
562
        self.get_branch_config(
452
563
            'http://www.example.com/useglobal/childbranch')
453
564
        self.assertEqual('http://www.example.com',
454
 
                         self.my_config._get_section())
 
565
                         self.my_location_config._get_section())
455
566
 
456
567
    def test__get_section_subdir_trailing_slash(self):
457
 
        self.get_location_config('/b')
458
 
        self.assertEqual('/b/', self.my_config._get_section())
 
568
        self.get_branch_config('/b')
 
569
        self.assertEqual('/b/', self.my_location_config._get_section())
459
570
 
460
571
    def test__get_section_subdir_child(self):
461
 
        self.get_location_config('/a/foo')
462
 
        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())
463
574
 
464
575
    def test__get_section_subdir_child_child(self):
465
 
        self.get_location_config('/a/foo/bar')
466
 
        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())
467
578
 
468
579
    def test__get_section_trailing_slash_with_children(self):
469
 
        self.get_location_config('/a/')
470
 
        self.assertEqual('/a/', self.my_config._get_section())
 
580
        self.get_branch_config('/a/')
 
581
        self.assertEqual('/a/', self.my_location_config._get_section())
471
582
 
472
583
    def test__get_section_explicit_over_glob(self):
473
 
        self.get_location_config('/a/c')
474
 
        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())
475
586
 
476
 
    def get_location_config(self, location, global_config=None):
477
 
        if global_config is None:
478
 
            global_file = StringIO(sample_config_text)
479
 
        else:
480
 
            global_file = StringIO(global_config)
481
 
        branches_file = StringIO(sample_branches_text)
482
 
        self.my_config = config.LocationConfig(location)
483
 
        self.my_config._get_parser(branches_file)
484
 
        self.my_config._get_global_config()._get_parser(global_file)
485
587
 
486
588
    def test_location_without_username(self):
487
 
        self.get_location_config('http://www.example.com/useglobal')
488
 
        self.assertEqual('Robert Collins <robertc@example.com>',
 
589
        self.get_branch_config('http://www.example.com/useglobal')
 
590
        self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
489
591
                         self.my_config.username())
490
592
 
491
593
    def test_location_not_listed(self):
492
 
        self.get_location_config('/home/robertc/sources')
493
 
        self.assertEqual('Robert Collins <robertc@example.com>',
 
594
        """Test that the global username is used when no location matches"""
 
595
        self.get_branch_config('/home/robertc/sources')
 
596
        self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
494
597
                         self.my_config.username())
495
598
 
496
599
    def test_overriding_location(self):
497
 
        self.get_location_config('http://www.example.com/foo')
 
600
        self.get_branch_config('http://www.example.com/foo')
498
601
        self.assertEqual('Robert Collins <robertc@example.org>',
499
602
                         self.my_config.username())
500
603
 
501
604
    def test_signatures_not_set(self):
502
 
        self.get_location_config('http://www.example.com',
 
605
        self.get_branch_config('http://www.example.com',
503
606
                                 global_config=sample_ignore_signatures)
504
 
        self.assertEqual(config.CHECK_NEVER,
 
607
        self.assertEqual(config.CHECK_ALWAYS,
505
608
                         self.my_config.signature_checking())
 
609
        self.assertEqual(config.SIGN_NEVER,
 
610
                         self.my_config.signing_policy())
506
611
 
507
612
    def test_signatures_never(self):
508
 
        self.get_location_config('/a/c')
 
613
        self.get_branch_config('/a/c')
509
614
        self.assertEqual(config.CHECK_NEVER,
510
615
                         self.my_config.signature_checking())
511
616
        
512
617
    def test_signatures_when_available(self):
513
 
        self.get_location_config('/a/', global_config=sample_ignore_signatures)
 
618
        self.get_branch_config('/a/', global_config=sample_ignore_signatures)
514
619
        self.assertEqual(config.CHECK_IF_POSSIBLE,
515
620
                         self.my_config.signature_checking())
516
621
        
517
622
    def test_signatures_always(self):
518
 
        self.get_location_config('/b')
 
623
        self.get_branch_config('/b')
519
624
        self.assertEqual(config.CHECK_ALWAYS,
520
625
                         self.my_config.signature_checking())
521
626
        
522
627
    def test_gpg_signing_command(self):
523
 
        self.get_location_config('/b')
 
628
        self.get_branch_config('/b')
524
629
        self.assertEqual("gnome-gpg", self.my_config.gpg_signing_command())
525
630
 
526
631
    def test_gpg_signing_command_missing(self):
527
 
        self.get_location_config('/a')
 
632
        self.get_branch_config('/a')
528
633
        self.assertEqual("false", self.my_config.gpg_signing_command())
529
634
 
530
635
    def test_get_user_option_global(self):
531
 
        self.get_location_config('/a')
 
636
        self.get_branch_config('/a')
532
637
        self.assertEqual('something',
533
638
                         self.my_config.get_user_option('user_global_option'))
534
639
 
535
640
    def test_get_user_option_local(self):
536
 
        self.get_location_config('/a')
 
641
        self.get_branch_config('/a')
537
642
        self.assertEqual('local',
538
643
                         self.my_config.get_user_option('user_local_option'))
539
644
        
540
645
    def test_post_commit_default(self):
541
 
        self.get_location_config('/a/c')
 
646
        self.get_branch_config('/a/c')
542
647
        self.assertEqual('bzrlib.tests.test_config.post_commit',
543
648
                         self.my_config.post_commit())
544
649
 
545
 
 
546
 
class TestLocationConfig(TestCaseInTempDir):
547
 
 
548
 
    def get_location_config(self, location, global_config=None):
 
650
    def get_branch_config(self, location, global_config=None):
549
651
        if global_config is None:
550
652
            global_file = StringIO(sample_config_text.encode('utf-8'))
551
653
        else:
552
654
            global_file = StringIO(global_config.encode('utf-8'))
553
655
        branches_file = StringIO(sample_branches_text.encode('utf-8'))
554
 
        self.my_config = config.LocationConfig(location)
555
 
        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
556
661
        self.my_config._get_global_config()._get_parser(global_file)
557
662
 
558
663
    def test_set_user_setting_sets_and_saves(self):
559
 
        self.get_location_config('/a/c')
 
664
        self.get_branch_config('/a/c')
560
665
        record = InstrumentedConfigObj("foo")
561
 
        self.my_config._parser = record
 
666
        self.my_location_config._parser = record
562
667
 
563
668
        real_mkdir = os.mkdir
564
669
        self.created = False
569
674
 
570
675
        os.mkdir = checked_mkdir
571
676
        try:
572
 
            self.my_config.set_user_option('foo', 'bar')
 
677
            self.my_config.set_user_option('foo', 'bar', local=True)
573
678
        finally:
574
679
            os.mkdir = real_mkdir
575
680
 
582
687
                          ('write',)],
583
688
                         record._calls[1:])
584
689
 
585
 
 
586
 
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
587
731
 
588
732
    def test_user_id(self):
589
 
        branch = FakeBranch()
 
733
        branch = FakeBranch(user_id='Robert Collins <robertc@example.net>')
590
734
        my_config = config.BranchConfig(branch)
591
735
        self.assertEqual("Robert Collins <robertc@example.net>",
592
 
                         my_config._get_user_id())
 
736
                         my_config.username())
593
737
        branch.control_files.email = "John"
594
 
        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())
595
744
 
596
745
    def test_not_set_in_branch(self):
597
 
        branch = FakeBranch()
598
 
        my_config = config.BranchConfig(branch)
599
 
        branch.control_files.email = None
600
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
601
 
        (my_config._get_location_config().
602
 
            _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
603
748
        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
604
749
                         my_config._get_user_id())
605
 
        branch.control_files.email = "John"
 
750
        my_config.branch.control_files.email = "John"
606
751
        self.assertEqual("John", my_config._get_user_id())
607
752
 
608
 
    def test_BZREMAIL_OVERRIDES(self):
609
 
        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>"
610
755
        branch = FakeBranch()
611
756
        my_config = config.BranchConfig(branch)
612
757
        self.assertEqual("Robert Collins <robertc@example.org>",
613
758
                         my_config.username())
614
759
    
615
760
    def test_signatures_forced(self):
616
 
        branch = FakeBranch()
617
 
        my_config = config.BranchConfig(branch)
618
 
        config_file = StringIO(sample_always_signatures)
619
 
        (my_config._get_location_config().
620
 
            _get_global_config()._get_parser(config_file))
621
 
        self.assertEqual(config.CHECK_ALWAYS, my_config.signature_checking())
 
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)
 
771
        self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
 
772
        self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
 
773
        self.assertTrue(my_config.signature_needed())
622
774
 
623
775
    def test_gpg_signing_command(self):
624
 
        branch = FakeBranch()
625
 
        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")
626
779
        config_file = StringIO(sample_config_text.encode('utf-8'))
627
 
        (my_config._get_location_config().
628
 
            _get_global_config()._get_parser(config_file))
 
780
        my_config._get_global_config()._get_parser(config_file)
629
781
        self.assertEqual('gnome-gpg', my_config.gpg_signing_command())
630
782
 
631
783
    def test_get_user_option_global(self):
632
784
        branch = FakeBranch()
633
785
        my_config = config.BranchConfig(branch)
634
786
        config_file = StringIO(sample_config_text.encode('utf-8'))
635
 
        (my_config._get_location_config().
636
 
            _get_global_config()._get_parser(config_file))
 
787
        (my_config._get_global_config()._get_parser(config_file))
637
788
        self.assertEqual('something',
638
789
                         my_config.get_user_option('user_global_option'))
639
790
 
640
791
    def test_post_commit_default(self):
641
792
        branch = FakeBranch()
642
 
        branch.base='/a/c'
643
 
        my_config = config.BranchConfig(branch)
644
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
645
 
        (my_config._get_location_config().
646
 
            _get_global_config()._get_parser(config_file))
647
 
        branch_file = StringIO(sample_branches_text)
648
 
        my_config._get_location_config()._get_parser(branch_file)
649
 
        self.assertEqual('bzrlib.tests.test_config.post_commit',
650
 
                         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')
651
820
 
652
821
 
653
822
class TestMailAddressExtraction(TestCase):