← 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: Ian Clatworthy
  • Date: 2009-05-19 00:20:46 UTC
  • mto: (4376.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 4377.
  • Revision ID: ian.clatworthy@canonical.com-20090519002046-qfxrlf4d73upe1h8
apply jam's review feedback

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 Canonical Ltd
 
2
#   Authors: Robert Collins <robert.collins@canonical.com>
2
3
#
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
17
18
"""Tests for finding and reading the bzr config file[s]."""
18
19
# import system imports here
19
20
from cStringIO import StringIO
 
21
import getpass
20
22
import os
21
23
import sys
22
 
import threading
23
24
 
24
25
#import bzrlib specific imports here
25
26
from bzrlib import (
26
27
    branch,
27
28
    bzrdir,
28
29
    config,
29
 
    diff,
30
30
    errors,
31
31
    osutils,
32
32
    mail_client,
36
36
    trace,
37
37
    transport,
38
38
    )
39
 
from bzrlib.tests import features
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]
70
45
email=Erik B\u00e5gfors <erik@bagfors.nu>
71
46
editor=vim
72
 
change_editor=vimdiff -of @new_path @old_path
73
47
gpg_signing_command=gnome-gpg
74
48
log_format=short
75
49
user_global_option=something
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
 
239
210
        self._calls.append('_get_signature_checking')
240
211
        return self._signatures
241
212
 
242
 
    def _get_change_editor(self):
243
 
        self._calls.append('_get_change_editor')
244
 
        return 'vimdiff -fo @new_path @old_path'
245
 
 
246
213
 
247
214
bool_config = """[DEFAULT]
248
215
active = true
349
316
        my_config = config.Config()
350
317
        self.assertEqual('long', my_config.log_format())
351
318
 
352
 
    def test_get_change_editor(self):
353
 
        my_config = InstrumentedConfig()
354
 
        change_editor = my_config.get_change_editor('old_tree', 'new_tree')
355
 
        self.assertEqual(['_get_change_editor'], my_config._calls)
356
 
        self.assertIs(diff.DiffFromTool, change_editor.__class__)
357
 
        self.assertEqual(['vimdiff', '-fo', '@new_path', '@old_path'],
358
 
                         change_editor.command_template)
359
 
 
360
319
 
361
320
class TestConfigPath(tests.TestCase):
362
321
 
363
322
    def setUp(self):
364
323
        super(TestConfigPath, self).setUp()
365
324
        os.environ['HOME'] = '/home/bogus'
366
 
        os.environ['XDG_CACHE_DIR'] = ''
367
325
        if sys.platform == 'win32':
368
326
            os.environ['BZR_HOME'] = \
369
327
                r'C:\Documents and Settings\bogus\Application Data'
379
337
        self.assertEqual(config.config_filename(),
380
338
                         self.bzr_home + '/bazaar.conf')
381
339
 
 
340
    def test_branches_config_filename(self):
 
341
        self.assertEqual(config.branches_config_filename(),
 
342
                         self.bzr_home + '/branches.conf')
 
343
 
382
344
    def test_locations_config_filename(self):
383
345
        self.assertEqual(config.locations_config_filename(),
384
346
                         self.bzr_home + '/locations.conf')
387
349
        self.assertEqual(config.authentication_config_filename(),
388
350
                         self.bzr_home + '/authentication.conf')
389
351
 
390
 
    def test_xdg_cache_dir(self):
391
 
        self.assertEqual(config.xdg_cache_dir(),
392
 
            '/home/bogus/.cache')
393
 
 
394
 
 
395
 
class TestIniConfig(tests.TestCaseInTempDir):
396
 
 
397
 
    def make_config_parser(self, s):
398
 
        conf = config.IniBasedConfig.from_string(s)
399
 
        return conf, conf._get_parser()
400
 
 
401
 
 
402
 
class TestIniConfigBuilding(TestIniConfig):
 
352
 
 
353
class TestIniConfig(tests.TestCase):
403
354
 
404
355
    def test_contructs(self):
405
 
        my_config = config.IniBasedConfig()
 
356
        my_config = config.IniBasedConfig("nothing")
406
357
 
407
358
    def test_from_fp(self):
408
 
        my_config = config.IniBasedConfig.from_string(sample_config_text)
409
 
        self.assertIsInstance(my_config._get_parser(), configobj.ConfigObj)
 
359
        config_file = StringIO(sample_config_text.encode('utf-8'))
 
360
        my_config = config.IniBasedConfig(None)
 
361
        self.failUnless(
 
362
            isinstance(my_config._get_parser(file=config_file),
 
363
                        configobj.ConfigObj))
410
364
 
411
365
    def test_cached(self):
412
 
        my_config = config.IniBasedConfig.from_string(sample_config_text)
413
 
        parser = my_config._get_parser()
 
366
        config_file = StringIO(sample_config_text.encode('utf-8'))
 
367
        my_config = config.IniBasedConfig(None)
 
368
        parser = my_config._get_parser(file=config_file)
414
369
        self.failUnless(my_config._get_parser() is parser)
415
370
 
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
 
 
603
 
class TestGetUserOptionAs(TestIniConfig):
604
 
 
605
 
    def test_get_user_option_as_bool(self):
606
 
        conf, parser = self.make_config_parser("""
607
 
a_true_bool = true
608
 
a_false_bool = 0
609
 
an_invalid_bool = maybe
610
 
a_list = hmm, who knows ? # This is interpreted as a list !
611
 
""")
612
 
        get_bool = conf.get_user_option_as_bool
613
 
        self.assertEqual(True, get_bool('a_true_bool'))
614
 
        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
 
        self.assertIs(None, get_bool('an_invalid_bool'))
621
 
        self.assertEquals(msg % ('maybe', 'an_invalid_bool'), warnings[0])
622
 
        warnings = []
623
 
        self.assertIs(None, get_bool('not_defined_in_this_config'))
624
 
        self.assertEquals([], warnings)
625
 
 
626
 
    def test_get_user_option_as_list(self):
627
 
        conf, parser = self.make_config_parser("""
628
 
a_list = a,b,c
629
 
length_1 = 1,
630
 
one_item = x
631
 
""")
632
 
        get_list = conf.get_user_option_as_list
633
 
        self.assertEqual(['a', 'b', 'c'], get_list('a_list'))
634
 
        self.assertEqual(['1'], get_list('length_1'))
635
 
        self.assertEqual('x', conf.get_user_option('one_item'))
636
 
        # automatically cast to list
637
 
        self.assertEqual(['x'], get_list('one_item'))
638
 
 
639
 
 
640
 
class TestSupressWarning(TestIniConfig):
641
 
 
642
 
    def make_warnings_config(self, s):
643
 
        conf, parser = self.make_config_parser(s)
644
 
        return conf.suppress_warning
645
 
 
646
 
    def test_suppress_warning_unknown(self):
647
 
        suppress_warning = self.make_warnings_config('')
648
 
        self.assertEqual(False, suppress_warning('unknown_warning'))
649
 
 
650
 
    def test_suppress_warning_known(self):
651
 
        suppress_warning = self.make_warnings_config('suppress_warnings=a,b')
652
 
        self.assertEqual(False, suppress_warning('c'))
653
 
        self.assertEqual(True, suppress_warning('a'))
654
 
        self.assertEqual(True, suppress_warning('b'))
655
 
 
656
371
 
657
372
class TestGetConfig(tests.TestCase):
658
373
 
711
426
        branch = self.make_branch('branch')
712
427
        self.assertEqual('branch', branch.nick)
713
428
 
 
429
        locations = config.locations_config_filename()
 
430
        config.ensure_config_dir_exists()
714
431
        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)
 
432
        open(locations, 'wb').write('[%s]\nnickname = foobar'
 
433
                                    % (local_url,))
718
434
        self.assertEqual('foobar', branch.nick)
719
435
 
720
436
    def test_config_local_path(self):
722
438
        branch = self.make_branch('branch')
723
439
        self.assertEqual('branch', branch.nick)
724
440
 
725
 
        local_path = osutils.getcwd().encode('utf8')
726
 
        conf = config.LocationConfig.from_string(
727
 
            '[%s/branch]\nnickname = barry' % (local_path,),
728
 
            'branch',  save=True)
 
441
        locations = config.locations_config_filename()
 
442
        config.ensure_config_dir_exists()
 
443
        open(locations, 'wb').write('[%s/branch]\nnickname = barry'
 
444
                                    % (osutils.getcwd().encode('utf8'),))
729
445
        self.assertEqual('barry', branch.nick)
730
446
 
731
447
    def test_config_creates_local(self):
732
448
        """Creating a new entry in config uses a local path."""
733
449
        branch = self.make_branch('branch', format='knit')
734
450
        branch.set_push_location('http://foobar')
 
451
        locations = config.locations_config_filename()
735
452
        local_path = osutils.getcwd().encode('utf8')
736
453
        # Surprisingly ConfigObj doesn't create a trailing newline
737
 
        self.check_file_contents(config.locations_config_filename(),
 
454
        self.check_file_contents(locations,
738
455
                                 '[%s/branch]\n'
739
456
                                 'push_location = http://foobar\n'
740
457
                                 'push_location:policy = norecurse\n'
745
462
        self.assertEqual('!repo', b.get_config().get_nickname())
746
463
 
747
464
    def test_warn_if_masked(self):
 
465
        _warning = trace.warning
748
466
        warnings = []
749
467
        def warning(*args):
750
468
            warnings.append(args[0] % args[1:])
751
 
        self.overrideAttr(trace, 'warning', warning)
752
469
 
753
470
        def set_option(store, warn_masked=True):
754
471
            warnings[:] = []
760
477
            else:
761
478
                self.assertEqual(1, len(warnings))
762
479
                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)
 
480
        trace.warning = warning
 
481
        try:
 
482
            branch = self.make_branch('.')
 
483
            conf = branch.get_config()
 
484
            set_option(config.STORE_GLOBAL)
 
485
            assertWarning(None)
 
486
            set_option(config.STORE_BRANCH)
 
487
            assertWarning(None)
 
488
            set_option(config.STORE_GLOBAL)
 
489
            assertWarning('Value "4" is masked by "3" from branch.conf')
 
490
            set_option(config.STORE_GLOBAL, warn_masked=False)
 
491
            assertWarning(None)
 
492
            set_option(config.STORE_LOCATION)
 
493
            assertWarning(None)
 
494
            set_option(config.STORE_BRANCH)
 
495
            assertWarning('Value "3" is masked by "0" from locations.conf')
 
496
            set_option(config.STORE_BRANCH, warn_masked=False)
 
497
            assertWarning(None)
 
498
        finally:
 
499
            trace.warning = _warning
779
500
 
780
501
 
781
502
class TestGlobalConfigItems(tests.TestCase):
782
503
 
783
504
    def test_user_id(self):
784
 
        my_config = config.GlobalConfig.from_string(sample_config_text)
 
505
        config_file = StringIO(sample_config_text.encode('utf-8'))
 
506
        my_config = config.GlobalConfig()
 
507
        my_config._parser = my_config._get_parser(file=config_file)
785
508
        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
786
509
                         my_config._get_user_id())
787
510
 
788
511
    def test_absent_user_id(self):
 
512
        config_file = StringIO("")
789
513
        my_config = config.GlobalConfig()
 
514
        my_config._parser = my_config._get_parser(file=config_file)
790
515
        self.assertEqual(None, my_config._get_user_id())
791
516
 
792
517
    def test_configured_editor(self):
793
 
        my_config = config.GlobalConfig.from_string(sample_config_text)
 
518
        config_file = StringIO(sample_config_text.encode('utf-8'))
 
519
        my_config = config.GlobalConfig()
 
520
        my_config._parser = my_config._get_parser(file=config_file)
794
521
        self.assertEqual("vim", my_config.get_editor())
795
522
 
796
523
    def test_signatures_always(self):
797
 
        my_config = config.GlobalConfig.from_string(sample_always_signatures)
 
524
        config_file = StringIO(sample_always_signatures)
 
525
        my_config = config.GlobalConfig()
 
526
        my_config._parser = my_config._get_parser(file=config_file)
798
527
        self.assertEqual(config.CHECK_NEVER,
799
528
                         my_config.signature_checking())
800
529
        self.assertEqual(config.SIGN_ALWAYS,
802
531
        self.assertEqual(True, my_config.signature_needed())
803
532
 
804
533
    def test_signatures_if_possible(self):
805
 
        my_config = config.GlobalConfig.from_string(sample_maybe_signatures)
 
534
        config_file = StringIO(sample_maybe_signatures)
 
535
        my_config = config.GlobalConfig()
 
536
        my_config._parser = my_config._get_parser(file=config_file)
806
537
        self.assertEqual(config.CHECK_NEVER,
807
538
                         my_config.signature_checking())
808
539
        self.assertEqual(config.SIGN_WHEN_REQUIRED,
810
541
        self.assertEqual(False, my_config.signature_needed())
811
542
 
812
543
    def test_signatures_ignore(self):
813
 
        my_config = config.GlobalConfig.from_string(sample_ignore_signatures)
 
544
        config_file = StringIO(sample_ignore_signatures)
 
545
        my_config = config.GlobalConfig()
 
546
        my_config._parser = my_config._get_parser(file=config_file)
814
547
        self.assertEqual(config.CHECK_ALWAYS,
815
548
                         my_config.signature_checking())
816
549
        self.assertEqual(config.SIGN_NEVER,
818
551
        self.assertEqual(False, my_config.signature_needed())
819
552
 
820
553
    def _get_sample_config(self):
821
 
        my_config = config.GlobalConfig.from_string(sample_config_text)
 
554
        config_file = StringIO(sample_config_text.encode('utf-8'))
 
555
        my_config = config.GlobalConfig()
 
556
        my_config._parser = my_config._get_parser(file=config_file)
822
557
        return my_config
823
558
 
824
559
    def test_gpg_signing_command(self):
827
562
        self.assertEqual(False, my_config.signature_needed())
828
563
 
829
564
    def _get_empty_config(self):
 
565
        config_file = StringIO("")
830
566
        my_config = config.GlobalConfig()
 
567
        my_config._parser = my_config._get_parser(file=config_file)
831
568
        return my_config
832
569
 
833
570
    def test_gpg_signing_command_unset(self):
871
608
        my_config = self._get_sample_config()
872
609
        self.assertEqual(sample_long_alias, my_config.get_alias('ll'))
873
610
 
874
 
    def test_get_change_editor(self):
875
 
        my_config = self._get_sample_config()
876
 
        change_editor = my_config.get_change_editor('old', 'new')
877
 
        self.assertIs(diff.DiffFromTool, change_editor.__class__)
878
 
        self.assertEqual('vimdiff -of @new_path @old_path',
879
 
                         ' '.join(change_editor.command_template))
880
 
 
881
 
    def test_get_no_change_editor(self):
882
 
        my_config = self._get_empty_config()
883
 
        change_editor = my_config.get_change_editor('old', 'new')
884
 
        self.assertIs(None, change_editor)
885
 
 
886
611
 
887
612
class TestGlobalConfigSavingOptions(tests.TestCaseInTempDir):
888
613
 
928
653
        self.assertEqual(parser._calls,
929
654
                         [('__init__', config.locations_config_filename(),
930
655
                           'utf-8')])
 
656
        config.ensure_config_dir_exists()
 
657
        #os.mkdir(config.config_dir())
 
658
        f = file(config.branches_config_filename(), 'wb')
 
659
        f.write('')
 
660
        f.close()
 
661
        oldparserclass = config.ConfigObj
 
662
        config.ConfigObj = InstrumentedConfigObj
 
663
        try:
 
664
            my_config = config.LocationConfig('http://www.example.com')
 
665
            parser = my_config._get_parser()
 
666
        finally:
 
667
            config.ConfigObj = oldparserclass
931
668
 
932
669
    def test_get_global_config(self):
933
670
        my_config = config.BranchConfig(FakeBranch('http://example.com'))
1162
899
                         self.my_config.post_commit())
1163
900
 
1164
901
    def get_branch_config(self, location, global_config=None):
1165
 
        my_branch = FakeBranch(location)
1166
902
        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()
 
903
            global_file = StringIO(sample_config_text.encode('utf-8'))
 
904
        else:
 
905
            global_file = StringIO(global_config.encode('utf-8'))
 
906
        branches_file = StringIO(sample_branches_text.encode('utf-8'))
 
907
        self.my_config = config.BranchConfig(FakeBranch(location))
 
908
        # Force location config to use specified file
 
909
        self.my_location_config = self.my_config._get_location_config()
 
910
        self.my_location_config._get_parser(branches_file)
 
911
        # Force global config to use specified file
 
912
        self.my_config._get_global_config()._get_parser(global_file)
1176
913
 
1177
914
    def test_set_user_setting_sets_and_saves(self):
1178
915
        self.get_branch_config('/a/c')
1179
916
        record = InstrumentedConfigObj("foo")
1180
917
        self.my_location_config._parser = record
1181
918
 
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'),
 
919
        real_mkdir = os.mkdir
 
920
        self.created = False
 
921
        def checked_mkdir(path, mode=0777):
 
922
            self.log('making directory: %s', path)
 
923
            real_mkdir(path, mode)
 
924
            self.created = True
 
925
 
 
926
        os.mkdir = checked_mkdir
 
927
        try:
 
928
            self.callDeprecated(['The recurse option is deprecated as of '
 
929
                                 '0.14.  The section "/a/c" has been '
 
930
                                 'converted to use policies.'],
 
931
                                self.my_config.set_user_option,
 
932
                                'foo', 'bar', store=config.STORE_LOCATION)
 
933
        finally:
 
934
            os.mkdir = real_mkdir
 
935
 
 
936
        self.failUnless(self.created, 'Failed to create ~/.bazaar')
 
937
        self.assertEqual([('__contains__', '/a/c'),
1189
938
                          ('__contains__', '/a/c/'),
1190
939
                          ('__setitem__', '/a/c', {}),
1191
940
                          ('__getitem__', '/a/c'),
1234
983
option = exact
1235
984
"""
1236
985
 
 
986
 
1237
987
class TestBranchConfigItems(tests.TestCaseInTempDir):
1238
988
 
1239
989
    def get_branch_config(self, global_config=None, location=None,
1240
990
                          location_config=None, branch_data_config=None):
1241
 
        my_branch = FakeBranch(location)
 
991
        my_config = config.BranchConfig(FakeBranch(location))
1242
992
        if global_config is not None:
1243
 
            my_global_config = config.GlobalConfig.from_string(global_config,
1244
 
                                                               save=True)
 
993
            global_file = StringIO(global_config.encode('utf-8'))
 
994
            my_config._get_global_config()._get_parser(global_file)
 
995
        self.my_location_config = my_config._get_location_config()
1245
996
        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)
 
997
            location_file = StringIO(location_config.encode('utf-8'))
 
998
            self.my_location_config._get_parser(location_file)
1249
999
        if branch_data_config is not None:
1250
1000
            my_config.branch.control_files.files['branch.conf'] = \
1251
1001
                branch_data_config
1265
1015
                         my_config.username())
1266
1016
 
1267
1017
    def test_not_set_in_branch(self):
1268
 
        my_config = self.get_branch_config(global_config=sample_config_text)
 
1018
        my_config = self.get_branch_config(sample_config_text)
1269
1019
        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
1270
1020
                         my_config._get_user_id())
1271
1021
        my_config.branch.control_files.files['email'] = "John"
1295
1045
 
1296
1046
    def test_gpg_signing_command(self):
1297
1047
        my_config = self.get_branch_config(
1298
 
            global_config=sample_config_text,
1299
1048
            # branch data cannot set gpg_signing_command
1300
1049
            branch_data_config="gpg_signing_command=pgp")
 
1050
        config_file = StringIO(sample_config_text.encode('utf-8'))
 
1051
        my_config._get_global_config()._get_parser(config_file)
1301
1052
        self.assertEqual('gnome-gpg', my_config.gpg_signing_command())
1302
1053
 
1303
1054
    def test_get_user_option_global(self):
1304
 
        my_config = self.get_branch_config(global_config=sample_config_text)
 
1055
        branch = FakeBranch()
 
1056
        my_config = config.BranchConfig(branch)
 
1057
        config_file = StringIO(sample_config_text.encode('utf-8'))
 
1058
        (my_config._get_global_config()._get_parser(config_file))
1305
1059
        self.assertEqual('something',
1306
1060
                         my_config.get_user_option('user_global_option'))
1307
1061
 
1308
1062
    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)
 
1063
        branch = FakeBranch()
 
1064
        my_config = self.get_branch_config(sample_config_text, '/a/c',
 
1065
                                           sample_branches_text)
1312
1066
        self.assertEqual(my_config.branch.base, '/a/c')
1313
1067
        self.assertEqual('bzrlib.tests.test_config.post_commit',
1314
1068
                         my_config.post_commit())
1315
1069
        my_config.set_user_option('post_commit', 'rmtree_root')
1316
 
        # post-commit is ignored when present in branch data
 
1070
        # post-commit is ignored when bresent in branch data
1317
1071
        self.assertEqual('bzrlib.tests.test_config.post_commit',
1318
1072
                         my_config.post_commit())
1319
1073
        my_config.set_user_option('post_commit', 'rmtree_root',
1321
1075
        self.assertEqual('rmtree_root', my_config.post_commit())
1322
1076
 
1323
1077
    def test_config_precedence(self):
1324
 
        # FIXME: eager test, luckily no persitent config file makes it fail
1325
 
        # -- vila 20100716
1326
1078
        my_config = self.get_branch_config(global_config=precedence_global)
1327
1079
        self.assertEqual(my_config.get_user_option('option'), 'global')
1328
1080
        my_config = self.get_branch_config(global_config=precedence_global,
1329
 
                                           branch_data_config=precedence_branch)
 
1081
                                      branch_data_config=precedence_branch)
1330
1082
        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)
 
1083
        my_config = self.get_branch_config(global_config=precedence_global,
 
1084
                                      branch_data_config=precedence_branch,
 
1085
                                      location_config=precedence_location)
1335
1086
        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')
 
1087
        my_config = self.get_branch_config(global_config=precedence_global,
 
1088
                                      branch_data_config=precedence_branch,
 
1089
                                      location_config=precedence_location,
 
1090
                                      location='http://example.com/specific')
1341
1091
        self.assertEqual(my_config.get_user_option('option'), 'exact')
1342
1092
 
1343
1093
    def test_get_mail_client(self):
1711
1461
    """Test AuthenticationConfig behaviour"""
1712
1462
 
1713
1463
    def _check_default_password_prompt(self, expected_prompt_format, scheme,
1714
 
                                       host=None, port=None, realm=None,
1715
 
                                       path=None):
 
1464
                              host=None, port=None, realm=None, path=None):
1716
1465
        if host is None:
1717
1466
            host = 'bar.org'
1718
1467
        user, password = 'jim', 'precious'
1721
1470
            'user': user, 'realm': realm}
1722
1471
 
1723
1472
        stdout = tests.StringIOWrapper()
1724
 
        stderr = tests.StringIOWrapper()
1725
1473
        ui.ui_factory = tests.TestUIFactory(stdin=password + '\n',
1726
 
                                            stdout=stdout, stderr=stderr)
 
1474
                                            stdout=stdout)
1727
1475
        # We use an empty conf so that the user is always prompted
1728
1476
        conf = config.AuthenticationConfig()
1729
1477
        self.assertEquals(password,
1730
1478
                          conf.get_password(scheme, host, user, port=port,
1731
1479
                                            realm=realm, path=path))
1732
 
        self.assertEquals(expected_prompt, stderr.getvalue())
1733
 
        self.assertEquals('', stdout.getvalue())
 
1480
        self.assertEquals(stdout.getvalue(), expected_prompt)
1734
1481
 
1735
1482
    def _check_default_username_prompt(self, expected_prompt_format, scheme,
1736
 
                                       host=None, port=None, realm=None,
1737
 
                                       path=None):
 
1483
                              host=None, port=None, realm=None, path=None):
1738
1484
        if host is None:
1739
1485
            host = 'bar.org'
1740
1486
        username = 'jim'
1742
1488
            'scheme': scheme, 'host': host, 'port': port,
1743
1489
            'realm': realm}
1744
1490
        stdout = tests.StringIOWrapper()
1745
 
        stderr = tests.StringIOWrapper()
1746
1491
        ui.ui_factory = tests.TestUIFactory(stdin=username+ '\n',
1747
 
                                            stdout=stdout, stderr=stderr)
 
1492
                                            stdout=stdout)
1748
1493
        # We use an empty conf so that the user is always prompted
1749
1494
        conf = config.AuthenticationConfig()
1750
1495
        self.assertEquals(username, conf.get_user(scheme, host, port=port,
1751
1496
                          realm=realm, path=path, ask=True))
1752
 
        self.assertEquals(expected_prompt, stderr.getvalue())
1753
 
        self.assertEquals('', stdout.getvalue())
 
1497
        self.assertEquals(stdout.getvalue(), expected_prompt)
1754
1498
 
1755
1499
    def test_username_defaults_prompts(self):
1756
1500
        # HTTP prompts can't be tested here, see test_http.py
1798
1542
"""))
1799
1543
        entered_password = 'typed-by-hand'
1800
1544
        stdout = tests.StringIOWrapper()
1801
 
        stderr = tests.StringIOWrapper()
1802
1545
        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1803
 
                                            stdout=stdout, stderr=stderr)
 
1546
                                            stdout=stdout)
1804
1547
 
1805
1548
        # Since the password defined in the authentication config is ignored,
1806
1549
        # the user is prompted
1807
1550
        self.assertEquals(entered_password,
1808
1551
                          conf.get_password('ssh', 'bar.org', user='jim'))
1809
1552
        self.assertContainsRe(
1810
 
            self.get_log(),
 
1553
            self._get_log(keep_log_file=True),
1811
1554
            'password ignored in section \[ssh with password\]')
1812
1555
 
1813
1556
    def test_ssh_without_password_doesnt_emit_warning(self):
1820
1563
"""))
1821
1564
        entered_password = 'typed-by-hand'
1822
1565
        stdout = tests.StringIOWrapper()
1823
 
        stderr = tests.StringIOWrapper()
1824
1566
        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1825
 
                                            stdout=stdout,
1826
 
                                            stderr=stderr)
 
1567
                                            stdout=stdout)
1827
1568
 
1828
1569
        # Since the password defined in the authentication config is ignored,
1829
1570
        # the user is prompted
1832
1573
        # No warning shoud be emitted since there is no password. We are only
1833
1574
        # providing "user".
1834
1575
        self.assertNotContainsRe(
1835
 
            self.get_log(),
 
1576
            self._get_log(keep_log_file=True),
1836
1577
            'password ignored in section \[ssh with password\]')
1837
1578
 
1838
1579
    def test_uses_fallback_stores(self):
1839
 
        self.overrideAttr(config, 'credential_store_registry',
1840
 
                          config.CredentialStoreRegistry())
 
1580
        self._old_cs_registry = config.credential_store_registry
 
1581
        def restore():
 
1582
            config.credential_store_registry = self._old_cs_registry
 
1583
        self.addCleanup(restore)
 
1584
        config.credential_store_registry = config.CredentialStoreRegistry()
1841
1585
        store = StubCredentialStore()
1842
1586
        store.add_credentials("http", "example.com", "joe", "secret")
1843
1587
        config.credential_store_registry.register("stub", store, fallback=True)