← 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: Matthew Revell
  • Date: 2008-03-05 14:11:35 UTC
  • mto: This revision was merged to the branch mainline in revision 3263.
  • Revision ID: matthew.revell@canonical.com-20080305141135-96jf8j24b9crru6v
Added an admin-guide directory to doc/en and outlined headings for the admin guide in index.txt

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_config.py
1
 
# Copyright (C) 2005, 2006, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 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
12
13
#
13
14
# You should have received a copy of the GNU General Public License
14
15
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
17
 
17
18
"""Tests for finding and reading the bzr config file[s]."""
18
19
# import system imports here
25
26
    branch,
26
27
    bzrdir,
27
28
    config,
28
 
    diff,
29
29
    errors,
30
30
    osutils,
31
31
    mail_client,
33
33
    urlutils,
34
34
    tests,
35
35
    trace,
36
 
    transport,
37
36
    )
38
37
from bzrlib.util.configobj import configobj
39
38
 
43
42
[DEFAULT]
44
43
email=Erik B\u00e5gfors <erik@bagfors.nu>
45
44
editor=vim
46
 
change_editor=vimdiff -of @new_path @old_path
47
45
gpg_signing_command=gnome-gpg
48
46
log_format=short
49
47
user_global_option=something
148
146
            self.base = "http://example.com/branches/demo"
149
147
        else:
150
148
            self.base = base
151
 
        self._transport = self.control_files = \
152
 
            FakeControlFilesAndTransport(user_id=user_id)
153
 
 
154
 
    def _get_config(self):
155
 
        return config.TransportConfig(self._transport, 'branch.conf')
 
149
        self.control_files = FakeControlFiles(user_id=user_id)
156
150
 
157
151
    def lock_write(self):
158
152
        pass
161
155
        pass
162
156
 
163
157
 
164
 
class FakeControlFilesAndTransport(object):
 
158
class FakeControlFiles(object):
165
159
 
166
160
    def __init__(self, user_id=None):
 
161
        self.email = user_id
167
162
        self.files = {}
168
 
        if user_id:
169
 
            self.files['email'] = user_id
170
 
        self._transport = self
171
163
 
172
164
    def get_utf8(self, filename):
173
 
        # from LockableFiles
174
 
        raise AssertionError("get_utf8 should no longer be used")
 
165
        if filename != 'email':
 
166
            raise NotImplementedError
 
167
        if self.email is not None:
 
168
            return StringIO(self.email)
 
169
        raise errors.NoSuchFile(filename)
175
170
 
176
171
    def get(self, filename):
177
 
        # from Transport
178
172
        try:
179
173
            return StringIO(self.files[filename])
180
174
        except KeyError:
181
175
            raise errors.NoSuchFile(filename)
182
176
 
183
 
    def get_bytes(self, filename):
184
 
        # from Transport
185
 
        try:
186
 
            return self.files[filename]
187
 
        except KeyError:
188
 
            raise errors.NoSuchFile(filename)
189
 
 
190
177
    def put(self, filename, fileobj):
191
178
        self.files[filename] = fileobj.read()
192
179
 
193
 
    def put_file(self, filename, fileobj):
194
 
        return self.put(filename, fileobj)
195
 
 
196
180
 
197
181
class InstrumentedConfig(config.Config):
198
182
    """An instrumented config that supplies stubs for template methods."""
210
194
        self._calls.append('_get_signature_checking')
211
195
        return self._signatures
212
196
 
213
 
    def _get_change_editor(self):
214
 
        self._calls.append('_get_change_editor')
215
 
        return 'vimdiff -fo @new_path @old_path'
216
 
 
217
197
 
218
198
bool_config = """[DEFAULT]
219
199
active = true
320
300
        my_config = config.Config()
321
301
        self.assertEqual('long', my_config.log_format())
322
302
 
323
 
    def test_get_change_editor(self):
324
 
        my_config = InstrumentedConfig()
325
 
        change_editor = my_config.get_change_editor('old_tree', 'new_tree')
326
 
        self.assertEqual(['_get_change_editor'], my_config._calls)
327
 
        self.assertIs(diff.DiffFromTool, change_editor.__class__)
328
 
        self.assertEqual(['vimdiff', '-fo', '@new_path', '@old_path'],
329
 
                         change_editor.command_template)
330
 
 
331
303
 
332
304
class TestConfigPath(tests.TestCase):
333
305
 
334
306
    def setUp(self):
335
307
        super(TestConfigPath, self).setUp()
336
308
        os.environ['HOME'] = '/home/bogus'
337
 
        os.environ['XDG_CACHE_DIR'] = ''
338
309
        if sys.platform == 'win32':
339
310
            os.environ['BZR_HOME'] = \
340
311
                r'C:\Documents and Settings\bogus\Application Data'
362
333
        self.assertEqual(config.authentication_config_filename(),
363
334
                         self.bzr_home + '/authentication.conf')
364
335
 
365
 
    def test_xdg_cache_dir(self):
366
 
        self.assertEqual(config.xdg_cache_dir(),
367
 
            '/home/bogus/.cache')
368
 
 
369
336
 
370
337
class TestIniConfig(tests.TestCase):
371
338
 
372
 
    def make_config_parser(self, s):
373
 
        conf = config.IniBasedConfig(None)
374
 
        parser = conf._get_parser(file=StringIO(s.encode('utf-8')))
375
 
        return conf, parser
376
 
 
377
 
 
378
 
class TestIniConfigBuilding(TestIniConfig):
379
 
 
380
339
    def test_contructs(self):
381
340
        my_config = config.IniBasedConfig("nothing")
382
341
 
394
353
        self.failUnless(my_config._get_parser() is parser)
395
354
 
396
355
 
397
 
class TestGetUserOptionAs(TestIniConfig):
398
 
 
399
 
    def test_get_user_option_as_bool(self):
400
 
        conf, parser = self.make_config_parser("""
401
 
a_true_bool = true
402
 
a_false_bool = 0
403
 
an_invalid_bool = maybe
404
 
a_list = hmm, who knows ? # This is interpreted as a list !
405
 
""")
406
 
        get_bool = conf.get_user_option_as_bool
407
 
        self.assertEqual(True, get_bool('a_true_bool'))
408
 
        self.assertEqual(False, get_bool('a_false_bool'))
409
 
        self.assertIs(None, get_bool('an_invalid_bool'))
410
 
        self.assertIs(None, get_bool('not_defined_in_this_config'))
411
 
 
412
 
 
413
 
    def test_get_user_option_as_list(self):
414
 
        conf, parser = self.make_config_parser("""
415
 
a_list = a,b,c
416
 
length_1 = 1,
417
 
one_item = x
418
 
""")
419
 
        get_list = conf.get_user_option_as_list
420
 
        self.assertEqual(['a', 'b', 'c'], get_list('a_list'))
421
 
        self.assertEqual(['1'], get_list('length_1'))
422
 
        self.assertEqual('x', conf.get_user_option('one_item'))
423
 
        # automatically cast to list
424
 
        self.assertEqual(['x'], get_list('one_item'))
425
 
 
426
 
 
427
 
class TestSupressWarning(TestIniConfig):
428
 
 
429
 
    def make_warnings_config(self, s):
430
 
        conf, parser = self.make_config_parser(s)
431
 
        return conf.suppress_warning
432
 
 
433
 
    def test_suppress_warning_unknown(self):
434
 
        suppress_warning = self.make_warnings_config('')
435
 
        self.assertEqual(False, suppress_warning('unknown_warning'))
436
 
 
437
 
    def test_suppress_warning_known(self):
438
 
        suppress_warning = self.make_warnings_config('suppress_warnings=a,b')
439
 
        self.assertEqual(False, suppress_warning('c'))
440
 
        self.assertEqual(True, suppress_warning('a'))
441
 
        self.assertEqual(True, suppress_warning('b'))
442
 
 
443
 
 
444
356
class TestGetConfig(tests.TestCase):
445
357
 
446
358
    def test_constructs(self):
501
413
        locations = config.locations_config_filename()
502
414
        config.ensure_config_dir_exists()
503
415
        local_url = urlutils.local_path_to_url('branch')
504
 
        open(locations, 'wb').write('[%s]\nnickname = foobar'
 
416
        open(locations, 'wb').write('[%s]\nnickname = foobar' 
505
417
                                    % (local_url,))
506
418
        self.assertEqual('foobar', branch.nick)
507
419
 
512
424
 
513
425
        locations = config.locations_config_filename()
514
426
        config.ensure_config_dir_exists()
515
 
        open(locations, 'wb').write('[%s/branch]\nnickname = barry'
 
427
        open(locations, 'wb').write('[%s/branch]\nnickname = barry' 
516
428
                                    % (osutils.getcwd().encode('utf8'),))
517
429
        self.assertEqual('barry', branch.nick)
518
430
 
664
576
        my_config = self._get_sample_config()
665
577
        self.assertEqual('help', my_config.get_alias('h'))
666
578
 
667
 
    def test_get_aliases(self):
668
 
        my_config = self._get_sample_config()
669
 
        aliases = my_config.get_aliases()
670
 
        self.assertEqual(2, len(aliases))
671
 
        sorted_keys = sorted(aliases)
672
 
        self.assertEqual('help', aliases[sorted_keys[0]])
673
 
        self.assertEqual(sample_long_alias, aliases[sorted_keys[1]])
674
 
 
675
579
    def test_get_no_alias(self):
676
580
        my_config = self._get_sample_config()
677
581
        self.assertEqual(None, my_config.get_alias('foo'))
680
584
        my_config = self._get_sample_config()
681
585
        self.assertEqual(sample_long_alias, my_config.get_alias('ll'))
682
586
 
683
 
    def test_get_change_editor(self):
684
 
        my_config = self._get_sample_config()
685
 
        change_editor = my_config.get_change_editor('old', 'new')
686
 
        self.assertIs(diff.DiffFromTool, change_editor.__class__)
687
 
        self.assertEqual('vimdiff -of @new_path @old_path',
688
 
                         ' '.join(change_editor.command_template))
689
 
 
690
 
    def test_get_no_change_editor(self):
691
 
        my_config = self._get_empty_config()
692
 
        change_editor = my_config.get_change_editor('old', 'new')
693
 
        self.assertIs(None, change_editor)
694
 
 
695
 
 
696
 
class TestGlobalConfigSavingOptions(tests.TestCaseInTempDir):
697
 
 
698
 
    def test_empty(self):
699
 
        my_config = config.GlobalConfig()
700
 
        self.assertEqual(0, len(my_config.get_aliases()))
701
 
 
702
 
    def test_set_alias(self):
703
 
        my_config = config.GlobalConfig()
704
 
        alias_value = 'commit --strict'
705
 
        my_config.set_alias('commit', alias_value)
706
 
        new_config = config.GlobalConfig()
707
 
        self.assertEqual(alias_value, new_config.get_alias('commit'))
708
 
 
709
 
    def test_remove_alias(self):
710
 
        my_config = config.GlobalConfig()
711
 
        my_config.set_alias('commit', 'commit --strict')
712
 
        # Now remove the alias again.
713
 
        my_config.unset_alias('commit')
714
 
        new_config = config.GlobalConfig()
715
 
        self.assertIs(None, new_config.get_alias('commit'))
716
 
 
717
587
 
718
588
class TestLocationConfig(tests.TestCaseInTempDir):
719
589
 
1039
909
        self.assertIs(self.my_config.get_user_option('foo'), None)
1040
910
        self.my_config.set_user_option('foo', 'bar')
1041
911
        self.assertEqual(
1042
 
            self.my_config.branch.control_files.files['branch.conf'].strip(),
1043
 
            'foo = bar')
 
912
            self.my_config.branch.control_files.files['branch.conf'],
 
913
            'foo = bar\n')
1044
914
        self.assertEqual(self.my_config.get_user_option('foo'), 'bar')
1045
915
        self.my_config.set_user_option('foo', 'baz',
1046
916
                                       store=config.STORE_LOCATION)
1090
960
        my_config = config.BranchConfig(branch)
1091
961
        self.assertEqual("Robert Collins <robertc@example.net>",
1092
962
                         my_config.username())
1093
 
        my_config.branch.control_files.files['email'] = "John"
 
963
        branch.control_files.email = "John"
1094
964
        my_config.set_user_option('email',
1095
965
                                  "Robert Collins <robertc@example.org>")
1096
966
        self.assertEqual("John", my_config.username())
1097
 
        del my_config.branch.control_files.files['email']
 
967
        branch.control_files.email = None
1098
968
        self.assertEqual("Robert Collins <robertc@example.org>",
1099
969
                         my_config.username())
1100
970
 
1101
971
    def test_not_set_in_branch(self):
1102
972
        my_config = self.get_branch_config(sample_config_text)
 
973
        my_config.branch.control_files.email = None
1103
974
        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
1104
975
                         my_config._get_user_id())
1105
 
        my_config.branch.control_files.files['email'] = "John"
 
976
        my_config.branch.control_files.email = "John"
1106
977
        self.assertEqual("John", my_config._get_user_id())
1107
978
 
1108
979
    def test_BZR_EMAIL_OVERRIDES(self):
1265
1136
        self.assertEqual(value, 'value3-section')
1266
1137
 
1267
1138
 
1268
 
class TestTransportConfig(tests.TestCaseWithTransport):
1269
 
 
1270
 
    def test_get_value(self):
1271
 
        """Test that retreiving a value from a section is possible"""
1272
 
        bzrdir_config = config.TransportConfig(transport.get_transport('.'),
1273
 
                                               'control.conf')
1274
 
        bzrdir_config.set_option('value', 'key', 'SECTION')
1275
 
        bzrdir_config.set_option('value2', 'key2')
1276
 
        bzrdir_config.set_option('value3-top', 'key3')
1277
 
        bzrdir_config.set_option('value3-section', 'key3', 'SECTION')
1278
 
        value = bzrdir_config.get_option('key', 'SECTION')
1279
 
        self.assertEqual(value, 'value')
1280
 
        value = bzrdir_config.get_option('key2')
1281
 
        self.assertEqual(value, 'value2')
1282
 
        self.assertEqual(bzrdir_config.get_option('non-existant'), None)
1283
 
        value = bzrdir_config.get_option('non-existant', 'SECTION')
1284
 
        self.assertEqual(value, None)
1285
 
        value = bzrdir_config.get_option('non-existant', default='default')
1286
 
        self.assertEqual(value, 'default')
1287
 
        self.assertEqual(bzrdir_config.get_option('key2', 'NOSECTION'), None)
1288
 
        value = bzrdir_config.get_option('key2', 'NOSECTION',
1289
 
                                         default='default')
1290
 
        self.assertEqual(value, 'default')
1291
 
        value = bzrdir_config.get_option('key3')
1292
 
        self.assertEqual(value, 'value3-top')
1293
 
        value = bzrdir_config.get_option('key3', 'SECTION')
1294
 
        self.assertEqual(value, 'value3-section')
1295
 
 
1296
 
    def test_set_unset_default_stack_on(self):
1297
 
        my_dir = self.make_bzrdir('.')
1298
 
        bzrdir_config = config.BzrDirConfig(my_dir)
1299
 
        self.assertIs(None, bzrdir_config.get_default_stack_on())
1300
 
        bzrdir_config.set_default_stack_on('Foo')
1301
 
        self.assertEqual('Foo', bzrdir_config._config.get_option(
1302
 
                         'default_stack_on'))
1303
 
        self.assertEqual('Foo', bzrdir_config.get_default_stack_on())
1304
 
        bzrdir_config.set_default_stack_on(None)
1305
 
        self.assertIs(None, bzrdir_config.get_default_stack_on())
1306
 
 
1307
 
 
1308
1139
class TestAuthenticationConfigFile(tests.TestCase):
1309
1140
    """Test the authentication.conf file matching"""
1310
1141
 
1325
1156
        self.assertEquals({}, conf._get_config())
1326
1157
        self._got_user_passwd(None, None, conf, 'http', 'foo.net')
1327
1158
 
1328
 
    def test_missing_auth_section_header(self):
1329
 
        conf = config.AuthenticationConfig(_file=StringIO('foo = bar'))
1330
 
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1331
 
 
1332
 
    def test_auth_section_header_not_closed(self):
 
1159
    def test_broken_config(self):
1333
1160
        conf = config.AuthenticationConfig(_file=StringIO('[DEF'))
1334
1161
        self.assertRaises(errors.ParseConfigError, conf._get_config)
1335
1162
 
1336
 
    def test_auth_value_not_boolean(self):
1337
1163
        conf = config.AuthenticationConfig(_file=StringIO(
1338
1164
                """[broken]
1339
1165
scheme=ftp
1341
1167
verify_certificates=askme # Error: Not a boolean
1342
1168
"""))
1343
1169
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1344
 
 
1345
 
    def test_auth_value_not_int(self):
1346
1170
        conf = config.AuthenticationConfig(_file=StringIO(
1347
1171
                """[broken]
1348
1172
scheme=ftp
1351
1175
"""))
1352
1176
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1353
1177
 
1354
 
    def test_unknown_password_encoding(self):
1355
 
        conf = config.AuthenticationConfig(_file=StringIO(
1356
 
                """[broken]
1357
 
scheme=ftp
1358
 
user=joe
1359
 
password_encoding=unknown
1360
 
"""))
1361
 
        self.assertRaises(ValueError, conf.get_password,
1362
 
                          'ftp', 'foo.net', 'joe')
1363
 
 
1364
1178
    def test_credentials_for_scheme_host(self):
1365
1179
        conf = config.AuthenticationConfig(_file=StringIO(
1366
1180
                """# Identity on foo.net
1477
1291
        self._got_user_passwd(None, None,
1478
1292
                              conf, 'http', 'bar.org', user='georges')
1479
1293
 
1480
 
    def test_credentials_for_user_without_password(self):
1481
 
        conf = config.AuthenticationConfig(_file=StringIO(
1482
 
                """
1483
 
[without password]
1484
 
scheme=http
1485
 
host=bar.org
1486
 
user=jim
1487
 
"""))
1488
 
        # Get user but no password
1489
 
        self._got_user_passwd('jim', None,
1490
 
                              conf, 'http', 'bar.org')
1491
 
 
1492
1294
    def test_verify_certificates(self):
1493
1295
        conf = config.AuthenticationConfig(_file=StringIO(
1494
1296
                """
1510
1312
        self.assertEquals(True, credentials.get('verify_certificates'))
1511
1313
 
1512
1314
 
1513
 
class TestAuthenticationStorage(tests.TestCaseInTempDir):
1514
 
 
1515
 
    def test_set_credentials(self):
1516
 
        conf = config.AuthenticationConfig()
1517
 
        conf.set_credentials('name', 'host', 'user', 'scheme', 'password',
1518
 
        99, path='/foo', verify_certificates=False, realm='realm')
1519
 
        credentials = conf.get_credentials(host='host', scheme='scheme',
1520
 
                                           port=99, path='/foo',
1521
 
                                           realm='realm')
1522
 
        CREDENTIALS = {'name': 'name', 'user': 'user', 'password': 'password',
1523
 
                       'verify_certificates': False, 'scheme': 'scheme', 
1524
 
                       'host': 'host', 'port': 99, 'path': '/foo', 
1525
 
                       'realm': 'realm'}
1526
 
        self.assertEqual(CREDENTIALS, credentials)
1527
 
        credentials_from_disk = config.AuthenticationConfig().get_credentials(
1528
 
            host='host', scheme='scheme', port=99, path='/foo', realm='realm')
1529
 
        self.assertEqual(CREDENTIALS, credentials_from_disk)
1530
 
 
1531
 
    def test_reset_credentials_different_name(self):
1532
 
        conf = config.AuthenticationConfig()
1533
 
        conf.set_credentials('name', 'host', 'user', 'scheme', 'password'),
1534
 
        conf.set_credentials('name2', 'host', 'user2', 'scheme', 'password'),
1535
 
        self.assertIs(None, conf._get_config().get('name'))
1536
 
        credentials = conf.get_credentials(host='host', scheme='scheme')
1537
 
        CREDENTIALS = {'name': 'name2', 'user': 'user2', 'password':
1538
 
                       'password', 'verify_certificates': True, 
1539
 
                       'scheme': 'scheme', 'host': 'host', 'port': None, 
1540
 
                       'path': None, 'realm': None}
1541
 
        self.assertEqual(CREDENTIALS, credentials)
1542
 
 
1543
 
 
1544
1315
class TestAuthenticationConfig(tests.TestCase):
1545
1316
    """Test AuthenticationConfig behaviour"""
1546
1317
 
1547
 
    def _check_default_password_prompt(self, expected_prompt_format, scheme,
1548
 
                                       host=None, port=None, realm=None,
1549
 
                                       path=None):
 
1318
    def _check_default_prompt(self, expected_prompt_format, scheme,
 
1319
                              host=None, port=None, realm=None, path=None):
1550
1320
        if host is None:
1551
1321
            host = 'bar.org'
1552
1322
        user, password = 'jim', 'precious'
1555
1325
            'user': user, 'realm': realm}
1556
1326
 
1557
1327
        stdout = tests.StringIOWrapper()
1558
 
        stderr = tests.StringIOWrapper()
1559
1328
        ui.ui_factory = tests.TestUIFactory(stdin=password + '\n',
1560
 
                                            stdout=stdout, stderr=stderr)
 
1329
                                            stdout=stdout)
1561
1330
        # We use an empty conf so that the user is always prompted
1562
1331
        conf = config.AuthenticationConfig()
1563
1332
        self.assertEquals(password,
1564
1333
                          conf.get_password(scheme, host, user, port=port,
1565
1334
                                            realm=realm, path=path))
1566
 
        self.assertEquals(expected_prompt, stderr.getvalue())
1567
 
        self.assertEquals('', stdout.getvalue())
1568
 
 
1569
 
    def _check_default_username_prompt(self, expected_prompt_format, scheme,
1570
 
                                       host=None, port=None, realm=None,
1571
 
                                       path=None):
1572
 
        if host is None:
1573
 
            host = 'bar.org'
1574
 
        username = 'jim'
1575
 
        expected_prompt = expected_prompt_format % {
1576
 
            'scheme': scheme, 'host': host, 'port': port,
1577
 
            'realm': realm}
1578
 
        stdout = tests.StringIOWrapper()
1579
 
        stderr = tests.StringIOWrapper()
1580
 
        ui.ui_factory = tests.TestUIFactory(stdin=username+ '\n',
1581
 
                                            stdout=stdout, stderr=stderr)
1582
 
        # We use an empty conf so that the user is always prompted
1583
 
        conf = config.AuthenticationConfig()
1584
 
        self.assertEquals(username, conf.get_user(scheme, host, port=port,
1585
 
                          realm=realm, path=path, ask=True))
1586
 
        self.assertEquals(expected_prompt, stderr.getvalue())
1587
 
        self.assertEquals('', stdout.getvalue())
1588
 
 
1589
 
    def test_username_defaults_prompts(self):
1590
 
        # HTTP prompts can't be tested here, see test_http.py
1591
 
        self._check_default_username_prompt('FTP %(host)s username: ', 'ftp')
1592
 
        self._check_default_username_prompt(
1593
 
            'FTP %(host)s:%(port)d username: ', 'ftp', port=10020)
1594
 
        self._check_default_username_prompt(
1595
 
            'SSH %(host)s:%(port)d username: ', 'ssh', port=12345)
1596
 
 
1597
 
    def test_username_default_no_prompt(self):
1598
 
        conf = config.AuthenticationConfig()
1599
 
        self.assertEquals(None,
1600
 
            conf.get_user('ftp', 'example.com'))
1601
 
        self.assertEquals("explicitdefault",
1602
 
            conf.get_user('ftp', 'example.com', default="explicitdefault"))
1603
 
 
1604
 
    def test_password_default_prompts(self):
1605
 
        # HTTP prompts can't be tested here, see test_http.py
1606
 
        self._check_default_password_prompt(
1607
 
            'FTP %(user)s@%(host)s password: ', 'ftp')
1608
 
        self._check_default_password_prompt(
1609
 
            'FTP %(user)s@%(host)s:%(port)d password: ', 'ftp', port=10020)
1610
 
        self._check_default_password_prompt(
1611
 
            'SSH %(user)s@%(host)s:%(port)d password: ', 'ssh', port=12345)
 
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)
1612
1345
        # SMTP port handling is a bit special (it's handled if embedded in the
1613
1346
        # host too)
1614
1347
        # FIXME: should we: forbid that, extend it to other schemes, leave
1615
1348
        # things as they are that's fine thank you ?
1616
 
        self._check_default_password_prompt('SMTP %(user)s@%(host)s password: ',
1617
 
                                            'smtp')
1618
 
        self._check_default_password_prompt('SMTP %(user)s@%(host)s password: ',
1619
 
                                            'smtp', host='bar.org:10025')
1620
 
        self._check_default_password_prompt(
 
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(
1621
1354
            'SMTP %(user)s@%(host)s:%(port)d password: ',
1622
1355
            'smtp', port=10025)
1623
1356
 
1624
 
    def test_ssh_password_emits_warning(self):
1625
 
        conf = config.AuthenticationConfig(_file=StringIO(
1626
 
                """
1627
 
[ssh with password]
1628
 
scheme=ssh
1629
 
host=bar.org
1630
 
user=jim
1631
 
password=jimpass
1632
 
"""))
1633
 
        entered_password = 'typed-by-hand'
1634
 
        stdout = tests.StringIOWrapper()
1635
 
        stderr = tests.StringIOWrapper()
1636
 
        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1637
 
                                            stdout=stdout, stderr=stderr)
1638
 
 
1639
 
        # Since the password defined in the authentication config is ignored,
1640
 
        # the user is prompted
1641
 
        self.assertEquals(entered_password,
1642
 
                          conf.get_password('ssh', 'bar.org', user='jim'))
1643
 
        self.assertContainsRe(
1644
 
            self.get_log(),
1645
 
            'password ignored in section \[ssh with password\]')
1646
 
 
1647
 
    def test_ssh_without_password_doesnt_emit_warning(self):
1648
 
        conf = config.AuthenticationConfig(_file=StringIO(
1649
 
                """
1650
 
[ssh with password]
1651
 
scheme=ssh
1652
 
host=bar.org
1653
 
user=jim
1654
 
"""))
1655
 
        entered_password = 'typed-by-hand'
1656
 
        stdout = tests.StringIOWrapper()
1657
 
        stderr = tests.StringIOWrapper()
1658
 
        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1659
 
                                            stdout=stdout,
1660
 
                                            stderr=stderr)
1661
 
 
1662
 
        # Since the password defined in the authentication config is ignored,
1663
 
        # the user is prompted
1664
 
        self.assertEquals(entered_password,
1665
 
                          conf.get_password('ssh', 'bar.org', user='jim'))
1666
 
        # No warning shoud be emitted since there is no password. We are only
1667
 
        # providing "user".
1668
 
        self.assertNotContainsRe(
1669
 
            self.get_log(),
1670
 
            'password ignored in section \[ssh with password\]')
1671
 
 
1672
 
    def test_uses_fallback_stores(self):
1673
 
        self.overrideAttr(config, 'credential_store_registry',
1674
 
                          config.CredentialStoreRegistry())
1675
 
        store = StubCredentialStore()
1676
 
        store.add_credentials("http", "example.com", "joe", "secret")
1677
 
        config.credential_store_registry.register("stub", store, fallback=True)
1678
 
        conf = config.AuthenticationConfig(_file=StringIO())
1679
 
        creds = conf.get_credentials("http", "example.com")
1680
 
        self.assertEquals("joe", creds["user"])
1681
 
        self.assertEquals("secret", creds["password"])
1682
 
 
1683
 
 
1684
 
class StubCredentialStore(config.CredentialStore):
1685
 
 
1686
 
    def __init__(self):
1687
 
        self._username = {}
1688
 
        self._password = {}
1689
 
 
1690
 
    def add_credentials(self, scheme, host, user, password=None):
1691
 
        self._username[(scheme, host)] = user
1692
 
        self._password[(scheme, host)] = password
1693
 
 
1694
 
    def get_credentials(self, scheme, host, port=None, user=None,
1695
 
        path=None, realm=None):
1696
 
        key = (scheme, host)
1697
 
        if not key in self._username:
1698
 
            return None
1699
 
        return { "scheme": scheme, "host": host, "port": port,
1700
 
                "user": self._username[key], "password": self._password[key]}
1701
 
 
1702
 
 
1703
 
class CountingCredentialStore(config.CredentialStore):
1704
 
 
1705
 
    def __init__(self):
1706
 
        self._calls = 0
1707
 
 
1708
 
    def get_credentials(self, scheme, host, port=None, user=None,
1709
 
        path=None, realm=None):
1710
 
        self._calls += 1
1711
 
        return None
1712
 
 
1713
 
 
1714
 
class TestCredentialStoreRegistry(tests.TestCase):
1715
 
 
1716
 
    def _get_cs_registry(self):
1717
 
        return config.credential_store_registry
1718
 
 
1719
 
    def test_default_credential_store(self):
1720
 
        r = self._get_cs_registry()
1721
 
        default = r.get_credential_store(None)
1722
 
        self.assertIsInstance(default, config.PlainTextCredentialStore)
1723
 
 
1724
 
    def test_unknown_credential_store(self):
1725
 
        r = self._get_cs_registry()
1726
 
        # It's hard to imagine someone creating a credential store named
1727
 
        # 'unknown' so we use that as an never registered key.
1728
 
        self.assertRaises(KeyError, r.get_credential_store, 'unknown')
1729
 
 
1730
 
    def test_fallback_none_registered(self):
1731
 
        r = config.CredentialStoreRegistry()
1732
 
        self.assertEquals(None,
1733
 
                          r.get_fallback_credentials("http", "example.com"))
1734
 
 
1735
 
    def test_register(self):
1736
 
        r = config.CredentialStoreRegistry()
1737
 
        r.register("stub", StubCredentialStore(), fallback=False)
1738
 
        r.register("another", StubCredentialStore(), fallback=True)
1739
 
        self.assertEquals(["another", "stub"], r.keys())
1740
 
 
1741
 
    def test_register_lazy(self):
1742
 
        r = config.CredentialStoreRegistry()
1743
 
        r.register_lazy("stub", "bzrlib.tests.test_config",
1744
 
                        "StubCredentialStore", fallback=False)
1745
 
        self.assertEquals(["stub"], r.keys())
1746
 
        self.assertIsInstance(r.get_credential_store("stub"),
1747
 
                              StubCredentialStore)
1748
 
 
1749
 
    def test_is_fallback(self):
1750
 
        r = config.CredentialStoreRegistry()
1751
 
        r.register("stub1", None, fallback=False)
1752
 
        r.register("stub2", None, fallback=True)
1753
 
        self.assertEquals(False, r.is_fallback("stub1"))
1754
 
        self.assertEquals(True, r.is_fallback("stub2"))
1755
 
 
1756
 
    def test_no_fallback(self):
1757
 
        r = config.CredentialStoreRegistry()
1758
 
        store = CountingCredentialStore()
1759
 
        r.register("count", store, fallback=False)
1760
 
        self.assertEquals(None,
1761
 
                          r.get_fallback_credentials("http", "example.com"))
1762
 
        self.assertEquals(0, store._calls)
1763
 
 
1764
 
    def test_fallback_credentials(self):
1765
 
        r = config.CredentialStoreRegistry()
1766
 
        store = StubCredentialStore()
1767
 
        store.add_credentials("http", "example.com",
1768
 
                              "somebody", "geheim")
1769
 
        r.register("stub", store, fallback=True)
1770
 
        creds = r.get_fallback_credentials("http", "example.com")
1771
 
        self.assertEquals("somebody", creds["user"])
1772
 
        self.assertEquals("geheim", creds["password"])
1773
 
 
1774
 
    def test_fallback_first_wins(self):
1775
 
        r = config.CredentialStoreRegistry()
1776
 
        stub1 = StubCredentialStore()
1777
 
        stub1.add_credentials("http", "example.com",
1778
 
                              "somebody", "stub1")
1779
 
        r.register("stub1", stub1, fallback=True)
1780
 
        stub2 = StubCredentialStore()
1781
 
        stub2.add_credentials("http", "example.com",
1782
 
                              "somebody", "stub2")
1783
 
        r.register("stub2", stub1, fallback=True)
1784
 
        creds = r.get_fallback_credentials("http", "example.com")
1785
 
        self.assertEquals("somebody", creds["user"])
1786
 
        self.assertEquals("stub1", creds["password"])
1787
 
 
1788
 
 
1789
 
class TestPlainTextCredentialStore(tests.TestCase):
1790
 
 
1791
 
    def test_decode_password(self):
1792
 
        r = config.credential_store_registry
1793
 
        plain_text = r.get_credential_store()
1794
 
        decoded = plain_text.decode_password(dict(password='secret'))
1795
 
        self.assertEquals('secret', decoded)
1796
 
 
1797
1357
 
1798
1358
# FIXME: Once we have a way to declare authentication to all test servers, we
1799
1359
# can implement generic tests.