← 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: 2008-04-07 07:52:50 UTC
  • mfrom: (3340.1.1 208418-1.4)
  • Revision ID: pqm@pqm.ubuntu.com-20080407075250-phs53xnslo8boaeo
Return the correct knit serialisation method in _StreamAccess.
        (Andrew Bennetts, Martin Pool, Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_config.py
17
17
 
18
18
"""Tests for finding and reading the bzr config file[s]."""
19
19
# import system imports here
20
 
from bzrlib.util.configobj.configobj import ConfigObj, ConfigObjError
21
20
from cStringIO import StringIO
22
21
import os
23
22
import sys
24
23
 
25
24
#import bzrlib specific imports here
26
25
from bzrlib import (
 
26
    branch,
 
27
    bzrdir,
27
28
    config,
28
29
    errors,
29
30
    osutils,
 
31
    mail_client,
 
32
    ui,
30
33
    urlutils,
 
34
    tests,
 
35
    trace,
31
36
    )
32
 
from bzrlib.branch import Branch
33
 
from bzrlib.bzrdir import BzrDir
34
 
from bzrlib.tests import TestCase, TestCaseInTempDir, TestCaseWithTransport
 
37
from bzrlib.util.configobj import configobj
35
38
 
36
39
 
37
40
sample_long_alias="log -r-15..-1 --line"
177
180
 
178
181
class InstrumentedConfig(config.Config):
179
182
    """An instrumented config that supplies stubs for template methods."""
180
 
    
 
183
 
181
184
    def __init__(self):
182
185
        super(InstrumentedConfig, self).__init__()
183
186
        self._calls = []
199
202
active = True
200
203
nonactive = False
201
204
"""
202
 
class TestConfigObj(TestCase):
 
205
 
 
206
 
 
207
class TestConfigObj(tests.TestCase):
 
208
 
203
209
    def test_get_bool(self):
204
 
        from bzrlib.config import ConfigObj
205
 
        co = ConfigObj(StringIO(bool_config))
 
210
        co = config.ConfigObj(StringIO(bool_config))
206
211
        self.assertIs(co.get_bool('DEFAULT', 'active'), True)
207
212
        self.assertIs(co.get_bool('DEFAULT', 'inactive'), False)
208
213
        self.assertIs(co.get_bool('UPPERCASE', 'active'), True)
209
214
        self.assertIs(co.get_bool('UPPERCASE', 'nonactive'), False)
210
215
 
211
 
 
212
 
class TestConfig(TestCase):
 
216
    def test_hash_sign_in_value(self):
 
217
        """
 
218
        Before 4.5.0, ConfigObj did not quote # signs in values, so they'd be
 
219
        treated as comments when read in again. (#86838)
 
220
        """
 
221
        co = config.ConfigObj()
 
222
        co['test'] = 'foo#bar'
 
223
        lines = co.write()
 
224
        self.assertEqual(lines, ['test = "foo#bar"'])
 
225
        co2 = config.ConfigObj(lines)
 
226
        self.assertEqual(co2['test'], 'foo#bar')
 
227
 
 
228
 
 
229
erroneous_config = """[section] # line 1
 
230
good=good # line 2
 
231
[section] # line 3
 
232
whocares=notme # line 4
 
233
"""
 
234
 
 
235
 
 
236
class TestConfigObjErrors(tests.TestCase):
 
237
 
 
238
    def test_duplicate_section_name_error_line(self):
 
239
        try:
 
240
            co = configobj.ConfigObj(StringIO(erroneous_config),
 
241
                                     raise_errors=True)
 
242
        except config.configobj.DuplicateError, e:
 
243
            self.assertEqual(3, e.line_number)
 
244
        else:
 
245
            self.fail('Error in config file not detected')
 
246
 
 
247
 
 
248
class TestConfig(tests.TestCase):
213
249
 
214
250
    def test_constructs(self):
215
251
        config.Config()
216
 
 
 
252
 
217
253
    def test_no_default_editor(self):
218
254
        self.assertRaises(NotImplementedError, config.Config().get_editor)
219
255
 
265
301
        self.assertEqual('long', my_config.log_format())
266
302
 
267
303
 
268
 
class TestConfigPath(TestCase):
 
304
class TestConfigPath(tests.TestCase):
269
305
 
270
306
    def setUp(self):
271
307
        super(TestConfigPath, self).setUp()
273
309
        if sys.platform == 'win32':
274
310
            os.environ['BZR_HOME'] = \
275
311
                r'C:\Documents and Settings\bogus\Application Data'
 
312
            self.bzr_home = \
 
313
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0'
 
314
        else:
 
315
            self.bzr_home = '/home/bogus/.bazaar'
276
316
 
277
317
    def test_config_dir(self):
278
 
        if sys.platform == 'win32':
279
 
            self.assertEqual(config.config_dir(), 
280
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0')
281
 
        else:
282
 
            self.assertEqual(config.config_dir(), '/home/bogus/.bazaar')
 
318
        self.assertEqual(config.config_dir(), self.bzr_home)
283
319
 
284
320
    def test_config_filename(self):
285
 
        if sys.platform == 'win32':
286
 
            self.assertEqual(config.config_filename(), 
287
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/bazaar.conf')
288
 
        else:
289
 
            self.assertEqual(config.config_filename(),
290
 
                             '/home/bogus/.bazaar/bazaar.conf')
 
321
        self.assertEqual(config.config_filename(),
 
322
                         self.bzr_home + '/bazaar.conf')
291
323
 
292
324
    def test_branches_config_filename(self):
293
 
        if sys.platform == 'win32':
294
 
            self.assertEqual(config.branches_config_filename(), 
295
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/branches.conf')
296
 
        else:
297
 
            self.assertEqual(config.branches_config_filename(),
298
 
                             '/home/bogus/.bazaar/branches.conf')
 
325
        self.assertEqual(config.branches_config_filename(),
 
326
                         self.bzr_home + '/branches.conf')
299
327
 
300
328
    def test_locations_config_filename(self):
301
 
        if sys.platform == 'win32':
302
 
            self.assertEqual(config.locations_config_filename(), 
303
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/locations.conf')
304
 
        else:
305
 
            self.assertEqual(config.locations_config_filename(),
306
 
                             '/home/bogus/.bazaar/locations.conf')
307
 
 
308
 
class TestIniConfig(TestCase):
 
329
        self.assertEqual(config.locations_config_filename(),
 
330
                         self.bzr_home + '/locations.conf')
 
331
 
 
332
    def test_authentication_config_filename(self):
 
333
        self.assertEqual(config.authentication_config_filename(),
 
334
                         self.bzr_home + '/authentication.conf')
 
335
 
 
336
 
 
337
class TestIniConfig(tests.TestCase):
309
338
 
310
339
    def test_contructs(self):
311
340
        my_config = config.IniBasedConfig("nothing")
315
344
        my_config = config.IniBasedConfig(None)
316
345
        self.failUnless(
317
346
            isinstance(my_config._get_parser(file=config_file),
318
 
                        ConfigObj))
 
347
                        configobj.ConfigObj))
319
348
 
320
349
    def test_cached(self):
321
350
        config_file = StringIO(sample_config_text.encode('utf-8'))
324
353
        self.failUnless(my_config._get_parser() is parser)
325
354
 
326
355
 
327
 
class TestGetConfig(TestCase):
 
356
class TestGetConfig(tests.TestCase):
328
357
 
329
358
    def test_constructs(self):
330
359
        my_config = config.GlobalConfig()
331
360
 
332
361
    def test_calls_read_filenames(self):
333
 
        # replace the class that is constructured, to check its parameters
 
362
        # replace the class that is constructed, to check its parameters
334
363
        oldparserclass = config.ConfigObj
335
364
        config.ConfigObj = InstrumentedConfigObj
336
365
        my_config = config.GlobalConfig()
343
372
                                          'utf-8')])
344
373
 
345
374
 
346
 
class TestBranchConfig(TestCaseWithTransport):
 
375
class TestBranchConfig(tests.TestCaseWithTransport):
347
376
 
348
377
    def test_constructs(self):
349
378
        branch = FakeBranch()
359
388
 
360
389
    def test_get_config(self):
361
390
        """The Branch.get_config method works properly"""
362
 
        b = BzrDir.create_standalone_workingtree('.').branch
 
391
        b = bzrdir.BzrDir.create_standalone_workingtree('.').branch
363
392
        my_config = b.get_config()
364
393
        self.assertIs(my_config.get_user_option('wacky'), None)
365
394
        my_config.set_user_option('wacky', 'unlikely')
366
395
        self.assertEqual(my_config.get_user_option('wacky'), 'unlikely')
367
396
 
368
397
        # Ensure we get the same thing if we start again
369
 
        b2 = Branch.open('.')
 
398
        b2 = branch.Branch.open('.')
370
399
        my_config2 = b2.get_config()
371
400
        self.assertEqual(my_config2.get_user_option('wacky'), 'unlikely')
372
401
 
407
436
        local_path = osutils.getcwd().encode('utf8')
408
437
        # Surprisingly ConfigObj doesn't create a trailing newline
409
438
        self.check_file_contents(locations,
410
 
            '[%s/branch]\npush_location = http://foobar\npush_location:policy = norecurse' % (local_path,))
 
439
                                 '[%s/branch]\n'
 
440
                                 'push_location = http://foobar\n'
 
441
                                 'push_location:policy = norecurse\n'
 
442
                                 % (local_path,))
411
443
 
412
444
    def test_autonick_urlencoded(self):
413
445
        b = self.make_branch('!repo')
414
446
        self.assertEqual('!repo', b.get_config().get_nickname())
415
447
 
416
 
 
417
 
class TestGlobalConfigItems(TestCase):
 
448
    def test_warn_if_masked(self):
 
449
        _warning = trace.warning
 
450
        warnings = []
 
451
        def warning(*args):
 
452
            warnings.append(args[0] % args[1:])
 
453
 
 
454
        def set_option(store, warn_masked=True):
 
455
            warnings[:] = []
 
456
            conf.set_user_option('example_option', repr(store), store=store,
 
457
                                 warn_masked=warn_masked)
 
458
        def assertWarning(warning):
 
459
            if warning is None:
 
460
                self.assertEqual(0, len(warnings))
 
461
            else:
 
462
                self.assertEqual(1, len(warnings))
 
463
                self.assertEqual(warning, warnings[0])
 
464
        trace.warning = warning
 
465
        try:
 
466
            branch = self.make_branch('.')
 
467
            conf = branch.get_config()
 
468
            set_option(config.STORE_GLOBAL)
 
469
            assertWarning(None)
 
470
            set_option(config.STORE_BRANCH)
 
471
            assertWarning(None)
 
472
            set_option(config.STORE_GLOBAL)
 
473
            assertWarning('Value "4" is masked by "3" from branch.conf')
 
474
            set_option(config.STORE_GLOBAL, warn_masked=False)
 
475
            assertWarning(None)
 
476
            set_option(config.STORE_LOCATION)
 
477
            assertWarning(None)
 
478
            set_option(config.STORE_BRANCH)
 
479
            assertWarning('Value "3" is masked by "0" from locations.conf')
 
480
            set_option(config.STORE_BRANCH, warn_masked=False)
 
481
            assertWarning(None)
 
482
        finally:
 
483
            trace.warning = _warning
 
484
 
 
485
 
 
486
class TestGlobalConfigItems(tests.TestCase):
418
487
 
419
488
    def test_user_id(self):
420
489
        config_file = StringIO(sample_config_text.encode('utf-8'))
494
563
        my_config = self._get_sample_config()
495
564
        self.assertEqual("something",
496
565
                         my_config.get_user_option('user_global_option'))
497
 
        
 
566
 
498
567
    def test_post_commit_default(self):
499
568
        my_config = self._get_sample_config()
500
569
        self.assertEqual(None, my_config.post_commit())
516
585
        self.assertEqual(sample_long_alias, my_config.get_alias('ll'))
517
586
 
518
587
 
519
 
class TestLocationConfig(TestCaseInTempDir):
 
588
class TestLocationConfig(tests.TestCaseInTempDir):
520
589
 
521
590
    def test_constructs(self):
522
591
        my_config = config.LocationConfig('http://example.com')
526
595
        # This is testing the correct file names are provided.
527
596
        # TODO: consolidate with the test for GlobalConfigs filename checks.
528
597
        #
529
 
        # replace the class that is constructured, to check its parameters
 
598
        # replace the class that is constructed, to check its parameters
530
599
        oldparserclass = config.ConfigObj
531
600
        config.ConfigObj = InstrumentedConfigObj
532
601
        try:
560
629
    def test__get_matching_sections_no_match(self):
561
630
        self.get_branch_config('/')
562
631
        self.assertEqual([], self.my_location_config._get_matching_sections())
563
 
        
 
632
 
564
633
    def test__get_matching_sections_exact(self):
565
634
        self.get_branch_config('http://www.example.com')
566
635
        self.assertEqual([('http://www.example.com', '')],
567
636
                         self.my_location_config._get_matching_sections())
568
 
   
 
637
 
569
638
    def test__get_matching_sections_suffix_does_not(self):
570
639
        self.get_branch_config('http://www.example.com-com')
571
640
        self.assertEqual([], self.my_location_config._get_matching_sections())
583
652
    def test__get_matching_sections_ignoreparent_subdir(self):
584
653
        self.get_branch_config(
585
654
            'http://www.example.com/ignoreparent/childbranch')
586
 
        self.assertEqual([('http://www.example.com/ignoreparent', 'childbranch')],
 
655
        self.assertEqual([('http://www.example.com/ignoreparent',
 
656
                           'childbranch')],
587
657
                         self.my_location_config._get_matching_sections())
588
658
 
589
659
    def test__get_matching_sections_subdir_trailing_slash(self):
669
739
        self.get_branch_config('/a/c')
670
740
        self.assertEqual(config.CHECK_NEVER,
671
741
                         self.my_config.signature_checking())
672
 
        
 
742
 
673
743
    def test_signatures_when_available(self):
674
744
        self.get_branch_config('/a/', global_config=sample_ignore_signatures)
675
745
        self.assertEqual(config.CHECK_IF_POSSIBLE,
676
746
                         self.my_config.signature_checking())
677
 
        
 
747
 
678
748
    def test_signatures_always(self):
679
749
        self.get_branch_config('/b')
680
750
        self.assertEqual(config.CHECK_ALWAYS,
681
751
                         self.my_config.signature_checking())
682
 
        
 
752
 
683
753
    def test_gpg_signing_command(self):
684
754
        self.get_branch_config('/b')
685
755
        self.assertEqual("gnome-gpg", self.my_config.gpg_signing_command())
776
846
            self.my_location_config._get_option_policy(
777
847
            'http://www.example.com/norecurse', 'normal_option'),
778
848
            config.POLICY_NORECURSE)
779
 
        
780
849
 
781
850
    def test_post_commit_default(self):
782
851
        self.get_branch_config('/a/c')
840
909
        self.assertIs(self.my_config.get_user_option('foo'), None)
841
910
        self.my_config.set_user_option('foo', 'bar')
842
911
        self.assertEqual(
843
 
            self.my_config.branch.control_files.files['branch.conf'], 
844
 
            'foo = bar')
 
912
            self.my_config.branch.control_files.files['branch.conf'],
 
913
            'foo = bar\n')
845
914
        self.assertEqual(self.my_config.get_user_option('foo'), 'bar')
846
915
        self.my_config.set_user_option('foo', 'baz',
847
916
                                       store=config.STORE_LOCATION)
848
917
        self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
849
918
        self.my_config.set_user_option('foo', 'qux')
850
919
        self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
851
 
        
 
920
 
 
921
    def test_get_bzr_remote_path(self):
 
922
        my_config = config.LocationConfig('/a/c')
 
923
        self.assertEqual('bzr', my_config.get_bzr_remote_path())
 
924
        my_config.set_user_option('bzr_remote_path', '/path-bzr')
 
925
        self.assertEqual('/path-bzr', my_config.get_bzr_remote_path())
 
926
        os.environ['BZR_REMOTE_PATH'] = '/environ-bzr'
 
927
        self.assertEqual('/environ-bzr', my_config.get_bzr_remote_path())
 
928
 
852
929
 
853
930
precedence_global = 'option = global'
854
931
precedence_branch = 'option = branch'
861
938
"""
862
939
 
863
940
 
864
 
class TestBranchConfigItems(TestCaseInTempDir):
 
941
class TestBranchConfigItems(tests.TestCaseInTempDir):
865
942
 
866
 
    def get_branch_config(self, global_config=None, location=None, 
 
943
    def get_branch_config(self, global_config=None, location=None,
867
944
                          location_config=None, branch_data_config=None):
868
945
        my_config = config.BranchConfig(FakeBranch(location))
869
946
        if global_config is not None:
884
961
        self.assertEqual("Robert Collins <robertc@example.net>",
885
962
                         my_config.username())
886
963
        branch.control_files.email = "John"
887
 
        my_config.set_user_option('email', 
 
964
        my_config.set_user_option('email',
888
965
                                  "Robert Collins <robertc@example.org>")
889
966
        self.assertEqual("John", my_config.username())
890
967
        branch.control_files.email = None
905
982
        my_config = config.BranchConfig(branch)
906
983
        self.assertEqual("Robert Collins <robertc@example.org>",
907
984
                         my_config.username())
908
 
    
 
985
 
909
986
    def test_signatures_forced(self):
910
987
        my_config = self.get_branch_config(
911
988
            global_config=sample_always_signatures)
955
1032
    def test_config_precedence(self):
956
1033
        my_config = self.get_branch_config(global_config=precedence_global)
957
1034
        self.assertEqual(my_config.get_user_option('option'), 'global')
958
 
        my_config = self.get_branch_config(global_config=precedence_global, 
 
1035
        my_config = self.get_branch_config(global_config=precedence_global,
959
1036
                                      branch_data_config=precedence_branch)
960
1037
        self.assertEqual(my_config.get_user_option('option'), 'branch')
961
 
        my_config = self.get_branch_config(global_config=precedence_global, 
 
1038
        my_config = self.get_branch_config(global_config=precedence_global,
962
1039
                                      branch_data_config=precedence_branch,
963
1040
                                      location_config=precedence_location)
964
1041
        self.assertEqual(my_config.get_user_option('option'), 'recurse')
965
 
        my_config = self.get_branch_config(global_config=precedence_global, 
 
1042
        my_config = self.get_branch_config(global_config=precedence_global,
966
1043
                                      branch_data_config=precedence_branch,
967
1044
                                      location_config=precedence_location,
968
1045
                                      location='http://example.com/specific')
969
1046
        self.assertEqual(my_config.get_user_option('option'), 'exact')
970
1047
 
971
 
 
972
 
class TestMailAddressExtraction(TestCase):
 
1048
    def test_get_mail_client(self):
 
1049
        config = self.get_branch_config()
 
1050
        client = config.get_mail_client()
 
1051
        self.assertIsInstance(client, mail_client.DefaultMail)
 
1052
 
 
1053
        # Specific clients
 
1054
        config.set_user_option('mail_client', 'evolution')
 
1055
        client = config.get_mail_client()
 
1056
        self.assertIsInstance(client, mail_client.Evolution)
 
1057
 
 
1058
        config.set_user_option('mail_client', 'kmail')
 
1059
        client = config.get_mail_client()
 
1060
        self.assertIsInstance(client, mail_client.KMail)
 
1061
 
 
1062
        config.set_user_option('mail_client', 'mutt')
 
1063
        client = config.get_mail_client()
 
1064
        self.assertIsInstance(client, mail_client.Mutt)
 
1065
 
 
1066
        config.set_user_option('mail_client', 'thunderbird')
 
1067
        client = config.get_mail_client()
 
1068
        self.assertIsInstance(client, mail_client.Thunderbird)
 
1069
 
 
1070
        # Generic options
 
1071
        config.set_user_option('mail_client', 'default')
 
1072
        client = config.get_mail_client()
 
1073
        self.assertIsInstance(client, mail_client.DefaultMail)
 
1074
 
 
1075
        config.set_user_option('mail_client', 'editor')
 
1076
        client = config.get_mail_client()
 
1077
        self.assertIsInstance(client, mail_client.Editor)
 
1078
 
 
1079
        config.set_user_option('mail_client', 'mapi')
 
1080
        client = config.get_mail_client()
 
1081
        self.assertIsInstance(client, mail_client.MAPIClient)
 
1082
 
 
1083
        config.set_user_option('mail_client', 'xdg-email')
 
1084
        client = config.get_mail_client()
 
1085
        self.assertIsInstance(client, mail_client.XDGEmail)
 
1086
 
 
1087
        config.set_user_option('mail_client', 'firebird')
 
1088
        self.assertRaises(errors.UnknownMailClient, config.get_mail_client)
 
1089
 
 
1090
 
 
1091
class TestMailAddressExtraction(tests.TestCase):
973
1092
 
974
1093
    def test_extract_email_address(self):
975
1094
        self.assertEqual('jane@test.com',
976
1095
                         config.extract_email_address('Jane <jane@test.com>'))
977
1096
        self.assertRaises(errors.NoEmailInUsername,
978
1097
                          config.extract_email_address, 'Jane Tester')
 
1098
 
 
1099
    def test_parse_username(self):
 
1100
        self.assertEqual(('', 'jdoe@example.com'),
 
1101
                         config.parse_username('jdoe@example.com'))
 
1102
        self.assertEqual(('', 'jdoe@example.com'),
 
1103
                         config.parse_username('<jdoe@example.com>'))
 
1104
        self.assertEqual(('John Doe', 'jdoe@example.com'),
 
1105
                         config.parse_username('John Doe <jdoe@example.com>'))
 
1106
        self.assertEqual(('John Doe', ''),
 
1107
                         config.parse_username('John Doe'))
 
1108
        self.assertEqual(('John Doe', 'jdoe@example.com'),
 
1109
                         config.parse_username('John Doe jdoe@example.com'))
 
1110
 
 
1111
class TestTreeConfig(tests.TestCaseWithTransport):
 
1112
 
 
1113
    def test_get_value(self):
 
1114
        """Test that retreiving a value from a section is possible"""
 
1115
        branch = self.make_branch('.')
 
1116
        tree_config = config.TreeConfig(branch)
 
1117
        tree_config.set_option('value', 'key', 'SECTION')
 
1118
        tree_config.set_option('value2', 'key2')
 
1119
        tree_config.set_option('value3-top', 'key3')
 
1120
        tree_config.set_option('value3-section', 'key3', 'SECTION')
 
1121
        value = tree_config.get_option('key', 'SECTION')
 
1122
        self.assertEqual(value, 'value')
 
1123
        value = tree_config.get_option('key2')
 
1124
        self.assertEqual(value, 'value2')
 
1125
        self.assertEqual(tree_config.get_option('non-existant'), None)
 
1126
        value = tree_config.get_option('non-existant', 'SECTION')
 
1127
        self.assertEqual(value, None)
 
1128
        value = tree_config.get_option('non-existant', default='default')
 
1129
        self.assertEqual(value, 'default')
 
1130
        self.assertEqual(tree_config.get_option('key2', 'NOSECTION'), None)
 
1131
        value = tree_config.get_option('key2', 'NOSECTION', default='default')
 
1132
        self.assertEqual(value, 'default')
 
1133
        value = tree_config.get_option('key3')
 
1134
        self.assertEqual(value, 'value3-top')
 
1135
        value = tree_config.get_option('key3', 'SECTION')
 
1136
        self.assertEqual(value, 'value3-section')
 
1137
 
 
1138
 
 
1139
class TestAuthenticationConfigFile(tests.TestCase):
 
1140
    """Test the authentication.conf file matching"""
 
1141
 
 
1142
    def _got_user_passwd(self, expected_user, expected_password,
 
1143
                         config, *args, **kwargs):
 
1144
        credentials = config.get_credentials(*args, **kwargs)
 
1145
        if credentials is None:
 
1146
            user = None
 
1147
            password = None
 
1148
        else:
 
1149
            user = credentials['user']
 
1150
            password = credentials['password']
 
1151
        self.assertEquals(expected_user, user)
 
1152
        self.assertEquals(expected_password, password)
 
1153
 
 
1154
    def test_empty_config(self):
 
1155
        conf = config.AuthenticationConfig(_file=StringIO())
 
1156
        self.assertEquals({}, conf._get_config())
 
1157
        self._got_user_passwd(None, None, conf, 'http', 'foo.net')
 
1158
 
 
1159
    def test_broken_config(self):
 
1160
        conf = config.AuthenticationConfig(_file=StringIO('[DEF'))
 
1161
        self.assertRaises(errors.ParseConfigError, conf._get_config)
 
1162
 
 
1163
        conf = config.AuthenticationConfig(_file=StringIO(
 
1164
                """[broken]
 
1165
scheme=ftp
 
1166
user=joe
 
1167
verify_certificates=askme # Error: Not a boolean
 
1168
"""))
 
1169
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
 
1170
        conf = config.AuthenticationConfig(_file=StringIO(
 
1171
                """[broken]
 
1172
scheme=ftp
 
1173
user=joe
 
1174
port=port # Error: Not an int
 
1175
"""))
 
1176
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
 
1177
 
 
1178
    def test_credentials_for_scheme_host(self):
 
1179
        conf = config.AuthenticationConfig(_file=StringIO(
 
1180
                """# Identity on foo.net
 
1181
[ftp definition]
 
1182
scheme=ftp
 
1183
host=foo.net
 
1184
user=joe
 
1185
password=secret-pass
 
1186
"""))
 
1187
        # Basic matching
 
1188
        self._got_user_passwd('joe', 'secret-pass', conf, 'ftp', 'foo.net')
 
1189
        # different scheme
 
1190
        self._got_user_passwd(None, None, conf, 'http', 'foo.net')
 
1191
        # different host
 
1192
        self._got_user_passwd(None, None, conf, 'ftp', 'bar.net')
 
1193
 
 
1194
    def test_credentials_for_host_port(self):
 
1195
        conf = config.AuthenticationConfig(_file=StringIO(
 
1196
                """# Identity on foo.net
 
1197
[ftp definition]
 
1198
scheme=ftp
 
1199
port=10021
 
1200
host=foo.net
 
1201
user=joe
 
1202
password=secret-pass
 
1203
"""))
 
1204
        # No port
 
1205
        self._got_user_passwd('joe', 'secret-pass',
 
1206
                              conf, 'ftp', 'foo.net', port=10021)
 
1207
        # different port
 
1208
        self._got_user_passwd(None, None, conf, 'ftp', 'foo.net')
 
1209
 
 
1210
    def test_for_matching_host(self):
 
1211
        conf = config.AuthenticationConfig(_file=StringIO(
 
1212
                """# Identity on foo.net
 
1213
[sourceforge]
 
1214
scheme=bzr
 
1215
host=bzr.sf.net
 
1216
user=joe
 
1217
password=joepass
 
1218
[sourceforge domain]
 
1219
scheme=bzr
 
1220
host=.bzr.sf.net
 
1221
user=georges
 
1222
password=bendover
 
1223
"""))
 
1224
        # matching domain
 
1225
        self._got_user_passwd('georges', 'bendover',
 
1226
                              conf, 'bzr', 'foo.bzr.sf.net')
 
1227
        # phishing attempt
 
1228
        self._got_user_passwd(None, None,
 
1229
                              conf, 'bzr', 'bbzr.sf.net')
 
1230
 
 
1231
    def test_for_matching_host_None(self):
 
1232
        conf = config.AuthenticationConfig(_file=StringIO(
 
1233
                """# Identity on foo.net
 
1234
[catchup bzr]
 
1235
scheme=bzr
 
1236
user=joe
 
1237
password=joepass
 
1238
[DEFAULT]
 
1239
user=georges
 
1240
password=bendover
 
1241
"""))
 
1242
        # match no host
 
1243
        self._got_user_passwd('joe', 'joepass',
 
1244
                              conf, 'bzr', 'quux.net')
 
1245
        # no host but different scheme
 
1246
        self._got_user_passwd('georges', 'bendover',
 
1247
                              conf, 'ftp', 'quux.net')
 
1248
 
 
1249
    def test_credentials_for_path(self):
 
1250
        conf = config.AuthenticationConfig(_file=StringIO(
 
1251
                """
 
1252
[http dir1]
 
1253
scheme=http
 
1254
host=bar.org
 
1255
path=/dir1
 
1256
user=jim
 
1257
password=jimpass
 
1258
[http dir2]
 
1259
scheme=http
 
1260
host=bar.org
 
1261
path=/dir2
 
1262
user=georges
 
1263
password=bendover
 
1264
"""))
 
1265
        # no path no dice
 
1266
        self._got_user_passwd(None, None,
 
1267
                              conf, 'http', host='bar.org', path='/dir3')
 
1268
        # matching path
 
1269
        self._got_user_passwd('georges', 'bendover',
 
1270
                              conf, 'http', host='bar.org', path='/dir2')
 
1271
        # matching subdir
 
1272
        self._got_user_passwd('jim', 'jimpass',
 
1273
                              conf, 'http', host='bar.org',path='/dir1/subdir')
 
1274
 
 
1275
    def test_credentials_for_user(self):
 
1276
        conf = config.AuthenticationConfig(_file=StringIO(
 
1277
                """
 
1278
[with user]
 
1279
scheme=http
 
1280
host=bar.org
 
1281
user=jim
 
1282
password=jimpass
 
1283
"""))
 
1284
        # Get user
 
1285
        self._got_user_passwd('jim', 'jimpass',
 
1286
                              conf, 'http', 'bar.org')
 
1287
        # Get same user
 
1288
        self._got_user_passwd('jim', 'jimpass',
 
1289
                              conf, 'http', 'bar.org', user='jim')
 
1290
        # Don't get a different user if one is specified
 
1291
        self._got_user_passwd(None, None,
 
1292
                              conf, 'http', 'bar.org', user='georges')
 
1293
 
 
1294
    def test_verify_certificates(self):
 
1295
        conf = config.AuthenticationConfig(_file=StringIO(
 
1296
                """
 
1297
[self-signed]
 
1298
scheme=https
 
1299
host=bar.org
 
1300
user=jim
 
1301
password=jimpass
 
1302
verify_certificates=False
 
1303
[normal]
 
1304
scheme=https
 
1305
host=foo.net
 
1306
user=georges
 
1307
password=bendover
 
1308
"""))
 
1309
        credentials = conf.get_credentials('https', 'bar.org')
 
1310
        self.assertEquals(False, credentials.get('verify_certificates'))
 
1311
        credentials = conf.get_credentials('https', 'foo.net')
 
1312
        self.assertEquals(True, credentials.get('verify_certificates'))
 
1313
 
 
1314
 
 
1315
class TestAuthenticationConfig(tests.TestCase):
 
1316
    """Test AuthenticationConfig behaviour"""
 
1317
 
 
1318
    def _check_default_prompt(self, expected_prompt_format, scheme,
 
1319
                              host=None, port=None, realm=None, path=None):
 
1320
        if host is None:
 
1321
            host = 'bar.org'
 
1322
        user, password = 'jim', 'precious'
 
1323
        expected_prompt = expected_prompt_format % {
 
1324
            'scheme': scheme, 'host': host, 'port': port,
 
1325
            'user': user, 'realm': realm}
 
1326
 
 
1327
        stdout = tests.StringIOWrapper()
 
1328
        ui.ui_factory = tests.TestUIFactory(stdin=password + '\n',
 
1329
                                            stdout=stdout)
 
1330
        # We use an empty conf so that the user is always prompted
 
1331
        conf = config.AuthenticationConfig()
 
1332
        self.assertEquals(password,
 
1333
                          conf.get_password(scheme, host, user, port=port,
 
1334
                                            realm=realm, path=path))
 
1335
        self.assertEquals(stdout.getvalue(), expected_prompt)
 
1336
 
 
1337
    def test_default_prompts(self):
 
1338
        # HTTP prompts can't be tested here, see test_http.py
 
1339
        self._check_default_prompt('FTP %(user)s@%(host)s password: ', 'ftp')
 
1340
        self._check_default_prompt('FTP %(user)s@%(host)s:%(port)d password: ',
 
1341
                                   'ftp', port=10020)
 
1342
 
 
1343
        self._check_default_prompt('SSH %(user)s@%(host)s:%(port)d password: ',
 
1344
                                   'ssh', port=12345)
 
1345
        # SMTP port handling is a bit special (it's handled if embedded in the
 
1346
        # host too)
 
1347
        # FIXME: should we: forbid that, extend it to other schemes, leave
 
1348
        # things as they are that's fine thank you ?
 
1349
        self._check_default_prompt('SMTP %(user)s@%(host)s password: ',
 
1350
                                   'smtp')
 
1351
        self._check_default_prompt('SMTP %(user)s@%(host)s password: ',
 
1352
                                   'smtp', host='bar.org:10025')
 
1353
        self._check_default_prompt(
 
1354
            'SMTP %(user)s@%(host)s:%(port)d password: ',
 
1355
            'smtp', port=10025)
 
1356
 
 
1357
 
 
1358
# FIXME: Once we have a way to declare authentication to all test servers, we
 
1359
# can implement generic tests.
 
1360
# test_user_password_in_url
 
1361
# test_user_in_url_password_from_config
 
1362
# test_user_in_url_password_prompted
 
1363
# test_user_in_config
 
1364
# test_user_getpass.getuser
 
1365
# test_user_prompted ?
 
1366
class TestAuthenticationRing(tests.TestCaseWithTransport):
 
1367
    pass