← 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: 2007-12-11 02:07:30 UTC
  • mto: (3119.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 3120.
  • Revision ID: ian.clatworthy@internode.on.net-20071211020730-sdj4kj794dw0628e
make help topics more discoverable

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 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
225
205
 
226
206
 
227
207
class TestConfigObj(tests.TestCase):
228
 
 
229
208
    def test_get_bool(self):
230
209
        co = config.ConfigObj(StringIO(bool_config))
231
210
        self.assertIs(co.get_bool('DEFAULT', 'active'), True)
233
212
        self.assertIs(co.get_bool('UPPERCASE', 'active'), True)
234
213
        self.assertIs(co.get_bool('UPPERCASE', 'nonactive'), False)
235
214
 
236
 
    def test_hash_sign_in_value(self):
237
 
        """
238
 
        Before 4.5.0, ConfigObj did not quote # signs in values, so they'd be
239
 
        treated as comments when read in again. (#86838)
240
 
        """
241
 
        co = config.ConfigObj()
242
 
        co['test'] = 'foo#bar'
243
 
        lines = co.write()
244
 
        self.assertEqual(lines, ['test = "foo#bar"'])
245
 
        co2 = config.ConfigObj(lines)
246
 
        self.assertEqual(co2['test'], 'foo#bar')
247
 
 
248
215
 
249
216
erroneous_config = """[section] # line 1
250
217
good=good # line 2
320
287
        my_config = config.Config()
321
288
        self.assertEqual('long', my_config.log_format())
322
289
 
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
290
 
332
291
class TestConfigPath(tests.TestCase):
333
292
 
334
293
    def setUp(self):
335
294
        super(TestConfigPath, self).setUp()
336
295
        os.environ['HOME'] = '/home/bogus'
337
 
        os.environ['XDG_CACHE_DIR'] = ''
338
296
        if sys.platform == 'win32':
339
297
            os.environ['BZR_HOME'] = \
340
298
                r'C:\Documents and Settings\bogus\Application Data'
362
320
        self.assertEqual(config.authentication_config_filename(),
363
321
                         self.bzr_home + '/authentication.conf')
364
322
 
365
 
    def test_xdg_cache_dir(self):
366
 
        self.assertEqual(config.xdg_cache_dir(),
367
 
            '/home/bogus/.cache')
368
 
 
369
323
 
370
324
class TestIniConfig(tests.TestCase):
371
325
 
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
326
    def test_contructs(self):
381
327
        my_config = config.IniBasedConfig("nothing")
382
328
 
394
340
        self.failUnless(my_config._get_parser() is parser)
395
341
 
396
342
 
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
 
        warnings = []
410
 
        def warning(*args):
411
 
            warnings.append(args[0] % args[1:])
412
 
        self.overrideAttr(trace, 'warning', warning)
413
 
        msg = 'Value "%s" is not a boolean for "%s"'
414
 
        self.assertIs(None, get_bool('an_invalid_bool'))
415
 
        self.assertEquals(msg % ('maybe', 'an_invalid_bool'), warnings[0])
416
 
        warnings = []
417
 
        self.assertIs(None, get_bool('not_defined_in_this_config'))
418
 
        self.assertEquals([], warnings)
419
 
 
420
 
    def test_get_user_option_as_list(self):
421
 
        conf, parser = self.make_config_parser("""
422
 
a_list = a,b,c
423
 
length_1 = 1,
424
 
one_item = x
425
 
""")
426
 
        get_list = conf.get_user_option_as_list
427
 
        self.assertEqual(['a', 'b', 'c'], get_list('a_list'))
428
 
        self.assertEqual(['1'], get_list('length_1'))
429
 
        self.assertEqual('x', conf.get_user_option('one_item'))
430
 
        # automatically cast to list
431
 
        self.assertEqual(['x'], get_list('one_item'))
432
 
 
433
 
 
434
 
class TestSupressWarning(TestIniConfig):
435
 
 
436
 
    def make_warnings_config(self, s):
437
 
        conf, parser = self.make_config_parser(s)
438
 
        return conf.suppress_warning
439
 
 
440
 
    def test_suppress_warning_unknown(self):
441
 
        suppress_warning = self.make_warnings_config('')
442
 
        self.assertEqual(False, suppress_warning('unknown_warning'))
443
 
 
444
 
    def test_suppress_warning_known(self):
445
 
        suppress_warning = self.make_warnings_config('suppress_warnings=a,b')
446
 
        self.assertEqual(False, suppress_warning('c'))
447
 
        self.assertEqual(True, suppress_warning('a'))
448
 
        self.assertEqual(True, suppress_warning('b'))
449
 
 
450
 
 
451
343
class TestGetConfig(tests.TestCase):
452
344
 
453
345
    def test_constructs(self):
508
400
        locations = config.locations_config_filename()
509
401
        config.ensure_config_dir_exists()
510
402
        local_url = urlutils.local_path_to_url('branch')
511
 
        open(locations, 'wb').write('[%s]\nnickname = foobar'
 
403
        open(locations, 'wb').write('[%s]\nnickname = foobar' 
512
404
                                    % (local_url,))
513
405
        self.assertEqual('foobar', branch.nick)
514
406
 
519
411
 
520
412
        locations = config.locations_config_filename()
521
413
        config.ensure_config_dir_exists()
522
 
        open(locations, 'wb').write('[%s/branch]\nnickname = barry'
 
414
        open(locations, 'wb').write('[%s/branch]\nnickname = barry' 
523
415
                                    % (osutils.getcwd().encode('utf8'),))
524
416
        self.assertEqual('barry', branch.nick)
525
417
 
533
425
        self.check_file_contents(locations,
534
426
                                 '[%s/branch]\n'
535
427
                                 'push_location = http://foobar\n'
536
 
                                 'push_location:policy = norecurse\n'
 
428
                                 'push_location:policy = norecurse'
537
429
                                 % (local_path,))
538
430
 
539
431
    def test_autonick_urlencoded(self):
671
563
        my_config = self._get_sample_config()
672
564
        self.assertEqual('help', my_config.get_alias('h'))
673
565
 
674
 
    def test_get_aliases(self):
675
 
        my_config = self._get_sample_config()
676
 
        aliases = my_config.get_aliases()
677
 
        self.assertEqual(2, len(aliases))
678
 
        sorted_keys = sorted(aliases)
679
 
        self.assertEqual('help', aliases[sorted_keys[0]])
680
 
        self.assertEqual(sample_long_alias, aliases[sorted_keys[1]])
681
 
 
682
566
    def test_get_no_alias(self):
683
567
        my_config = self._get_sample_config()
684
568
        self.assertEqual(None, my_config.get_alias('foo'))
687
571
        my_config = self._get_sample_config()
688
572
        self.assertEqual(sample_long_alias, my_config.get_alias('ll'))
689
573
 
690
 
    def test_get_change_editor(self):
691
 
        my_config = self._get_sample_config()
692
 
        change_editor = my_config.get_change_editor('old', 'new')
693
 
        self.assertIs(diff.DiffFromTool, change_editor.__class__)
694
 
        self.assertEqual('vimdiff -of @new_path @old_path',
695
 
                         ' '.join(change_editor.command_template))
696
 
 
697
 
    def test_get_no_change_editor(self):
698
 
        my_config = self._get_empty_config()
699
 
        change_editor = my_config.get_change_editor('old', 'new')
700
 
        self.assertIs(None, change_editor)
701
 
 
702
 
 
703
 
class TestGlobalConfigSavingOptions(tests.TestCaseInTempDir):
704
 
 
705
 
    def test_empty(self):
706
 
        my_config = config.GlobalConfig()
707
 
        self.assertEqual(0, len(my_config.get_aliases()))
708
 
 
709
 
    def test_set_alias(self):
710
 
        my_config = config.GlobalConfig()
711
 
        alias_value = 'commit --strict'
712
 
        my_config.set_alias('commit', alias_value)
713
 
        new_config = config.GlobalConfig()
714
 
        self.assertEqual(alias_value, new_config.get_alias('commit'))
715
 
 
716
 
    def test_remove_alias(self):
717
 
        my_config = config.GlobalConfig()
718
 
        my_config.set_alias('commit', 'commit --strict')
719
 
        # Now remove the alias again.
720
 
        my_config.unset_alias('commit')
721
 
        new_config = config.GlobalConfig()
722
 
        self.assertIs(None, new_config.get_alias('commit'))
723
 
 
724
574
 
725
575
class TestLocationConfig(tests.TestCaseInTempDir):
726
576
 
1046
896
        self.assertIs(self.my_config.get_user_option('foo'), None)
1047
897
        self.my_config.set_user_option('foo', 'bar')
1048
898
        self.assertEqual(
1049
 
            self.my_config.branch.control_files.files['branch.conf'].strip(),
 
899
            self.my_config.branch.control_files.files['branch.conf'],
1050
900
            'foo = bar')
1051
901
        self.assertEqual(self.my_config.get_user_option('foo'), 'bar')
1052
902
        self.my_config.set_user_option('foo', 'baz',
1097
947
        my_config = config.BranchConfig(branch)
1098
948
        self.assertEqual("Robert Collins <robertc@example.net>",
1099
949
                         my_config.username())
1100
 
        my_config.branch.control_files.files['email'] = "John"
 
950
        branch.control_files.email = "John"
1101
951
        my_config.set_user_option('email',
1102
952
                                  "Robert Collins <robertc@example.org>")
1103
953
        self.assertEqual("John", my_config.username())
1104
 
        del my_config.branch.control_files.files['email']
 
954
        branch.control_files.email = None
1105
955
        self.assertEqual("Robert Collins <robertc@example.org>",
1106
956
                         my_config.username())
1107
957
 
1108
958
    def test_not_set_in_branch(self):
1109
959
        my_config = self.get_branch_config(sample_config_text)
 
960
        my_config.branch.control_files.email = None
1110
961
        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
1111
962
                         my_config._get_user_id())
1112
 
        my_config.branch.control_files.files['email'] = "John"
 
963
        my_config.branch.control_files.email = "John"
1113
964
        self.assertEqual("John", my_config._get_user_id())
1114
965
 
1115
966
    def test_BZR_EMAIL_OVERRIDES(self):
1272
1123
        self.assertEqual(value, 'value3-section')
1273
1124
 
1274
1125
 
1275
 
class TestTransportConfig(tests.TestCaseWithTransport):
1276
 
 
1277
 
    def test_get_value(self):
1278
 
        """Test that retreiving a value from a section is possible"""
1279
 
        bzrdir_config = config.TransportConfig(transport.get_transport('.'),
1280
 
                                               'control.conf')
1281
 
        bzrdir_config.set_option('value', 'key', 'SECTION')
1282
 
        bzrdir_config.set_option('value2', 'key2')
1283
 
        bzrdir_config.set_option('value3-top', 'key3')
1284
 
        bzrdir_config.set_option('value3-section', 'key3', 'SECTION')
1285
 
        value = bzrdir_config.get_option('key', 'SECTION')
1286
 
        self.assertEqual(value, 'value')
1287
 
        value = bzrdir_config.get_option('key2')
1288
 
        self.assertEqual(value, 'value2')
1289
 
        self.assertEqual(bzrdir_config.get_option('non-existant'), None)
1290
 
        value = bzrdir_config.get_option('non-existant', 'SECTION')
1291
 
        self.assertEqual(value, None)
1292
 
        value = bzrdir_config.get_option('non-existant', default='default')
1293
 
        self.assertEqual(value, 'default')
1294
 
        self.assertEqual(bzrdir_config.get_option('key2', 'NOSECTION'), None)
1295
 
        value = bzrdir_config.get_option('key2', 'NOSECTION',
1296
 
                                         default='default')
1297
 
        self.assertEqual(value, 'default')
1298
 
        value = bzrdir_config.get_option('key3')
1299
 
        self.assertEqual(value, 'value3-top')
1300
 
        value = bzrdir_config.get_option('key3', 'SECTION')
1301
 
        self.assertEqual(value, 'value3-section')
1302
 
 
1303
 
    def test_set_unset_default_stack_on(self):
1304
 
        my_dir = self.make_bzrdir('.')
1305
 
        bzrdir_config = config.BzrDirConfig(my_dir)
1306
 
        self.assertIs(None, bzrdir_config.get_default_stack_on())
1307
 
        bzrdir_config.set_default_stack_on('Foo')
1308
 
        self.assertEqual('Foo', bzrdir_config._config.get_option(
1309
 
                         'default_stack_on'))
1310
 
        self.assertEqual('Foo', bzrdir_config.get_default_stack_on())
1311
 
        bzrdir_config.set_default_stack_on(None)
1312
 
        self.assertIs(None, bzrdir_config.get_default_stack_on())
1313
 
 
1314
 
 
1315
1126
class TestAuthenticationConfigFile(tests.TestCase):
1316
1127
    """Test the authentication.conf file matching"""
1317
1128
 
1332
1143
        self.assertEquals({}, conf._get_config())
1333
1144
        self._got_user_passwd(None, None, conf, 'http', 'foo.net')
1334
1145
 
1335
 
    def test_missing_auth_section_header(self):
1336
 
        conf = config.AuthenticationConfig(_file=StringIO('foo = bar'))
1337
 
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1338
 
 
1339
 
    def test_auth_section_header_not_closed(self):
 
1146
    def test_broken_config(self):
1340
1147
        conf = config.AuthenticationConfig(_file=StringIO('[DEF'))
1341
1148
        self.assertRaises(errors.ParseConfigError, conf._get_config)
1342
1149
 
1343
 
    def test_auth_value_not_boolean(self):
1344
1150
        conf = config.AuthenticationConfig(_file=StringIO(
1345
1151
                """[broken]
1346
1152
scheme=ftp
1348
1154
verify_certificates=askme # Error: Not a boolean
1349
1155
"""))
1350
1156
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1351
 
 
1352
 
    def test_auth_value_not_int(self):
1353
1157
        conf = config.AuthenticationConfig(_file=StringIO(
1354
1158
                """[broken]
1355
1159
scheme=ftp
1358
1162
"""))
1359
1163
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1360
1164
 
1361
 
    def test_unknown_password_encoding(self):
1362
 
        conf = config.AuthenticationConfig(_file=StringIO(
1363
 
                """[broken]
1364
 
scheme=ftp
1365
 
user=joe
1366
 
password_encoding=unknown
1367
 
"""))
1368
 
        self.assertRaises(ValueError, conf.get_password,
1369
 
                          'ftp', 'foo.net', 'joe')
1370
 
 
1371
1165
    def test_credentials_for_scheme_host(self):
1372
1166
        conf = config.AuthenticationConfig(_file=StringIO(
1373
1167
                """# Identity on foo.net
1484
1278
        self._got_user_passwd(None, None,
1485
1279
                              conf, 'http', 'bar.org', user='georges')
1486
1280
 
1487
 
    def test_credentials_for_user_without_password(self):
1488
 
        conf = config.AuthenticationConfig(_file=StringIO(
1489
 
                """
1490
 
[without password]
1491
 
scheme=http
1492
 
host=bar.org
1493
 
user=jim
1494
 
"""))
1495
 
        # Get user but no password
1496
 
        self._got_user_passwd('jim', None,
1497
 
                              conf, 'http', 'bar.org')
1498
 
 
1499
1281
    def test_verify_certificates(self):
1500
1282
        conf = config.AuthenticationConfig(_file=StringIO(
1501
1283
                """
1517
1299
        self.assertEquals(True, credentials.get('verify_certificates'))
1518
1300
 
1519
1301
 
1520
 
class TestAuthenticationStorage(tests.TestCaseInTempDir):
1521
 
 
1522
 
    def test_set_credentials(self):
1523
 
        conf = config.AuthenticationConfig()
1524
 
        conf.set_credentials('name', 'host', 'user', 'scheme', 'password',
1525
 
        99, path='/foo', verify_certificates=False, realm='realm')
1526
 
        credentials = conf.get_credentials(host='host', scheme='scheme',
1527
 
                                           port=99, path='/foo',
1528
 
                                           realm='realm')
1529
 
        CREDENTIALS = {'name': 'name', 'user': 'user', 'password': 'password',
1530
 
                       'verify_certificates': False, 'scheme': 'scheme', 
1531
 
                       'host': 'host', 'port': 99, 'path': '/foo', 
1532
 
                       'realm': 'realm'}
1533
 
        self.assertEqual(CREDENTIALS, credentials)
1534
 
        credentials_from_disk = config.AuthenticationConfig().get_credentials(
1535
 
            host='host', scheme='scheme', port=99, path='/foo', realm='realm')
1536
 
        self.assertEqual(CREDENTIALS, credentials_from_disk)
1537
 
 
1538
 
    def test_reset_credentials_different_name(self):
1539
 
        conf = config.AuthenticationConfig()
1540
 
        conf.set_credentials('name', 'host', 'user', 'scheme', 'password'),
1541
 
        conf.set_credentials('name2', 'host', 'user2', 'scheme', 'password'),
1542
 
        self.assertIs(None, conf._get_config().get('name'))
1543
 
        credentials = conf.get_credentials(host='host', scheme='scheme')
1544
 
        CREDENTIALS = {'name': 'name2', 'user': 'user2', 'password':
1545
 
                       'password', 'verify_certificates': True, 
1546
 
                       'scheme': 'scheme', 'host': 'host', 'port': None, 
1547
 
                       'path': None, 'realm': None}
1548
 
        self.assertEqual(CREDENTIALS, credentials)
1549
 
 
1550
 
 
1551
1302
class TestAuthenticationConfig(tests.TestCase):
1552
1303
    """Test AuthenticationConfig behaviour"""
1553
1304
 
1554
 
    def _check_default_password_prompt(self, expected_prompt_format, scheme,
1555
 
                                       host=None, port=None, realm=None,
1556
 
                                       path=None):
 
1305
    def _check_default_prompt(self, expected_prompt_format, scheme,
 
1306
                              host=None, port=None, realm=None, path=None):
1557
1307
        if host is None:
1558
1308
            host = 'bar.org'
1559
1309
        user, password = 'jim', 'precious'
1562
1312
            'user': user, 'realm': realm}
1563
1313
 
1564
1314
        stdout = tests.StringIOWrapper()
1565
 
        stderr = tests.StringIOWrapper()
1566
1315
        ui.ui_factory = tests.TestUIFactory(stdin=password + '\n',
1567
 
                                            stdout=stdout, stderr=stderr)
 
1316
                                            stdout=stdout)
1568
1317
        # We use an empty conf so that the user is always prompted
1569
1318
        conf = config.AuthenticationConfig()
1570
1319
        self.assertEquals(password,
1571
1320
                          conf.get_password(scheme, host, user, port=port,
1572
1321
                                            realm=realm, path=path))
1573
 
        self.assertEquals(expected_prompt, stderr.getvalue())
1574
 
        self.assertEquals('', stdout.getvalue())
1575
 
 
1576
 
    def _check_default_username_prompt(self, expected_prompt_format, scheme,
1577
 
                                       host=None, port=None, realm=None,
1578
 
                                       path=None):
1579
 
        if host is None:
1580
 
            host = 'bar.org'
1581
 
        username = 'jim'
1582
 
        expected_prompt = expected_prompt_format % {
1583
 
            'scheme': scheme, 'host': host, 'port': port,
1584
 
            'realm': realm}
1585
 
        stdout = tests.StringIOWrapper()
1586
 
        stderr = tests.StringIOWrapper()
1587
 
        ui.ui_factory = tests.TestUIFactory(stdin=username+ '\n',
1588
 
                                            stdout=stdout, stderr=stderr)
1589
 
        # We use an empty conf so that the user is always prompted
1590
 
        conf = config.AuthenticationConfig()
1591
 
        self.assertEquals(username, conf.get_user(scheme, host, port=port,
1592
 
                          realm=realm, path=path, ask=True))
1593
 
        self.assertEquals(expected_prompt, stderr.getvalue())
1594
 
        self.assertEquals('', stdout.getvalue())
1595
 
 
1596
 
    def test_username_defaults_prompts(self):
1597
 
        # HTTP prompts can't be tested here, see test_http.py
1598
 
        self._check_default_username_prompt('FTP %(host)s username: ', 'ftp')
1599
 
        self._check_default_username_prompt(
1600
 
            'FTP %(host)s:%(port)d username: ', 'ftp', port=10020)
1601
 
        self._check_default_username_prompt(
1602
 
            'SSH %(host)s:%(port)d username: ', 'ssh', port=12345)
1603
 
 
1604
 
    def test_username_default_no_prompt(self):
1605
 
        conf = config.AuthenticationConfig()
1606
 
        self.assertEquals(None,
1607
 
            conf.get_user('ftp', 'example.com'))
1608
 
        self.assertEquals("explicitdefault",
1609
 
            conf.get_user('ftp', 'example.com', default="explicitdefault"))
1610
 
 
1611
 
    def test_password_default_prompts(self):
1612
 
        # HTTP prompts can't be tested here, see test_http.py
1613
 
        self._check_default_password_prompt(
1614
 
            'FTP %(user)s@%(host)s password: ', 'ftp')
1615
 
        self._check_default_password_prompt(
1616
 
            'FTP %(user)s@%(host)s:%(port)d password: ', 'ftp', port=10020)
1617
 
        self._check_default_password_prompt(
1618
 
            'SSH %(user)s@%(host)s:%(port)d password: ', 'ssh', port=12345)
 
1322
        self.assertEquals(stdout.getvalue(), expected_prompt)
 
1323
 
 
1324
    def test_default_prompts(self):
 
1325
        # HTTP prompts can't be tested here, see test_http.py
 
1326
        self._check_default_prompt('FTP %(user)s@%(host)s password: ', 'ftp')
 
1327
        self._check_default_prompt('FTP %(user)s@%(host)s:%(port)d password: ',
 
1328
                                   'ftp', port=10020)
 
1329
 
 
1330
        self._check_default_prompt('SSH %(user)s@%(host)s:%(port)d password: ',
 
1331
                                   'ssh', port=12345)
1619
1332
        # SMTP port handling is a bit special (it's handled if embedded in the
1620
1333
        # host too)
1621
1334
        # FIXME: should we: forbid that, extend it to other schemes, leave
1622
1335
        # things as they are that's fine thank you ?
1623
 
        self._check_default_password_prompt('SMTP %(user)s@%(host)s password: ',
1624
 
                                            'smtp')
1625
 
        self._check_default_password_prompt('SMTP %(user)s@%(host)s password: ',
1626
 
                                            'smtp', host='bar.org:10025')
1627
 
        self._check_default_password_prompt(
 
1336
        self._check_default_prompt('SMTP %(user)s@%(host)s password: ',
 
1337
                                   'smtp')
 
1338
        self._check_default_prompt('SMTP %(user)s@%(host)s password: ',
 
1339
                                   'smtp', host='bar.org:10025')
 
1340
        self._check_default_prompt(
1628
1341
            'SMTP %(user)s@%(host)s:%(port)d password: ',
1629
1342
            'smtp', port=10025)
1630
1343
 
1631
 
    def test_ssh_password_emits_warning(self):
1632
 
        conf = config.AuthenticationConfig(_file=StringIO(
1633
 
                """
1634
 
[ssh with password]
1635
 
scheme=ssh
1636
 
host=bar.org
1637
 
user=jim
1638
 
password=jimpass
1639
 
"""))
1640
 
        entered_password = 'typed-by-hand'
1641
 
        stdout = tests.StringIOWrapper()
1642
 
        stderr = tests.StringIOWrapper()
1643
 
        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1644
 
                                            stdout=stdout, stderr=stderr)
1645
 
 
1646
 
        # Since the password defined in the authentication config is ignored,
1647
 
        # the user is prompted
1648
 
        self.assertEquals(entered_password,
1649
 
                          conf.get_password('ssh', 'bar.org', user='jim'))
1650
 
        self.assertContainsRe(
1651
 
            self.get_log(),
1652
 
            'password ignored in section \[ssh with password\]')
1653
 
 
1654
 
    def test_ssh_without_password_doesnt_emit_warning(self):
1655
 
        conf = config.AuthenticationConfig(_file=StringIO(
1656
 
                """
1657
 
[ssh with password]
1658
 
scheme=ssh
1659
 
host=bar.org
1660
 
user=jim
1661
 
"""))
1662
 
        entered_password = 'typed-by-hand'
1663
 
        stdout = tests.StringIOWrapper()
1664
 
        stderr = tests.StringIOWrapper()
1665
 
        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1666
 
                                            stdout=stdout,
1667
 
                                            stderr=stderr)
1668
 
 
1669
 
        # Since the password defined in the authentication config is ignored,
1670
 
        # the user is prompted
1671
 
        self.assertEquals(entered_password,
1672
 
                          conf.get_password('ssh', 'bar.org', user='jim'))
1673
 
        # No warning shoud be emitted since there is no password. We are only
1674
 
        # providing "user".
1675
 
        self.assertNotContainsRe(
1676
 
            self.get_log(),
1677
 
            'password ignored in section \[ssh with password\]')
1678
 
 
1679
 
    def test_uses_fallback_stores(self):
1680
 
        self.overrideAttr(config, 'credential_store_registry',
1681
 
                          config.CredentialStoreRegistry())
1682
 
        store = StubCredentialStore()
1683
 
        store.add_credentials("http", "example.com", "joe", "secret")
1684
 
        config.credential_store_registry.register("stub", store, fallback=True)
1685
 
        conf = config.AuthenticationConfig(_file=StringIO())
1686
 
        creds = conf.get_credentials("http", "example.com")
1687
 
        self.assertEquals("joe", creds["user"])
1688
 
        self.assertEquals("secret", creds["password"])
1689
 
 
1690
 
 
1691
 
class StubCredentialStore(config.CredentialStore):
1692
 
 
1693
 
    def __init__(self):
1694
 
        self._username = {}
1695
 
        self._password = {}
1696
 
 
1697
 
    def add_credentials(self, scheme, host, user, password=None):
1698
 
        self._username[(scheme, host)] = user
1699
 
        self._password[(scheme, host)] = password
1700
 
 
1701
 
    def get_credentials(self, scheme, host, port=None, user=None,
1702
 
        path=None, realm=None):
1703
 
        key = (scheme, host)
1704
 
        if not key in self._username:
1705
 
            return None
1706
 
        return { "scheme": scheme, "host": host, "port": port,
1707
 
                "user": self._username[key], "password": self._password[key]}
1708
 
 
1709
 
 
1710
 
class CountingCredentialStore(config.CredentialStore):
1711
 
 
1712
 
    def __init__(self):
1713
 
        self._calls = 0
1714
 
 
1715
 
    def get_credentials(self, scheme, host, port=None, user=None,
1716
 
        path=None, realm=None):
1717
 
        self._calls += 1
1718
 
        return None
1719
 
 
1720
 
 
1721
 
class TestCredentialStoreRegistry(tests.TestCase):
1722
 
 
1723
 
    def _get_cs_registry(self):
1724
 
        return config.credential_store_registry
1725
 
 
1726
 
    def test_default_credential_store(self):
1727
 
        r = self._get_cs_registry()
1728
 
        default = r.get_credential_store(None)
1729
 
        self.assertIsInstance(default, config.PlainTextCredentialStore)
1730
 
 
1731
 
    def test_unknown_credential_store(self):
1732
 
        r = self._get_cs_registry()
1733
 
        # It's hard to imagine someone creating a credential store named
1734
 
        # 'unknown' so we use that as an never registered key.
1735
 
        self.assertRaises(KeyError, r.get_credential_store, 'unknown')
1736
 
 
1737
 
    def test_fallback_none_registered(self):
1738
 
        r = config.CredentialStoreRegistry()
1739
 
        self.assertEquals(None,
1740
 
                          r.get_fallback_credentials("http", "example.com"))
1741
 
 
1742
 
    def test_register(self):
1743
 
        r = config.CredentialStoreRegistry()
1744
 
        r.register("stub", StubCredentialStore(), fallback=False)
1745
 
        r.register("another", StubCredentialStore(), fallback=True)
1746
 
        self.assertEquals(["another", "stub"], r.keys())
1747
 
 
1748
 
    def test_register_lazy(self):
1749
 
        r = config.CredentialStoreRegistry()
1750
 
        r.register_lazy("stub", "bzrlib.tests.test_config",
1751
 
                        "StubCredentialStore", fallback=False)
1752
 
        self.assertEquals(["stub"], r.keys())
1753
 
        self.assertIsInstance(r.get_credential_store("stub"),
1754
 
                              StubCredentialStore)
1755
 
 
1756
 
    def test_is_fallback(self):
1757
 
        r = config.CredentialStoreRegistry()
1758
 
        r.register("stub1", None, fallback=False)
1759
 
        r.register("stub2", None, fallback=True)
1760
 
        self.assertEquals(False, r.is_fallback("stub1"))
1761
 
        self.assertEquals(True, r.is_fallback("stub2"))
1762
 
 
1763
 
    def test_no_fallback(self):
1764
 
        r = config.CredentialStoreRegistry()
1765
 
        store = CountingCredentialStore()
1766
 
        r.register("count", store, fallback=False)
1767
 
        self.assertEquals(None,
1768
 
                          r.get_fallback_credentials("http", "example.com"))
1769
 
        self.assertEquals(0, store._calls)
1770
 
 
1771
 
    def test_fallback_credentials(self):
1772
 
        r = config.CredentialStoreRegistry()
1773
 
        store = StubCredentialStore()
1774
 
        store.add_credentials("http", "example.com",
1775
 
                              "somebody", "geheim")
1776
 
        r.register("stub", store, fallback=True)
1777
 
        creds = r.get_fallback_credentials("http", "example.com")
1778
 
        self.assertEquals("somebody", creds["user"])
1779
 
        self.assertEquals("geheim", creds["password"])
1780
 
 
1781
 
    def test_fallback_first_wins(self):
1782
 
        r = config.CredentialStoreRegistry()
1783
 
        stub1 = StubCredentialStore()
1784
 
        stub1.add_credentials("http", "example.com",
1785
 
                              "somebody", "stub1")
1786
 
        r.register("stub1", stub1, fallback=True)
1787
 
        stub2 = StubCredentialStore()
1788
 
        stub2.add_credentials("http", "example.com",
1789
 
                              "somebody", "stub2")
1790
 
        r.register("stub2", stub1, fallback=True)
1791
 
        creds = r.get_fallback_credentials("http", "example.com")
1792
 
        self.assertEquals("somebody", creds["user"])
1793
 
        self.assertEquals("stub1", creds["password"])
1794
 
 
1795
 
 
1796
 
class TestPlainTextCredentialStore(tests.TestCase):
1797
 
 
1798
 
    def test_decode_password(self):
1799
 
        r = config.credential_store_registry
1800
 
        plain_text = r.get_credential_store()
1801
 
        decoded = plain_text.decode_password(dict(password='secret'))
1802
 
        self.assertEquals('secret', decoded)
1803
 
 
1804
1344
 
1805
1345
# FIXME: Once we have a way to declare authentication to all test servers, we
1806
1346
# can implement generic tests.