← 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: Vincent Ladeuil
  • Date: 2008-08-26 08:25:27 UTC
  • mto: (3668.1.1 trunk) (3703.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 3669.
  • Revision ID: v.ladeuil+lp@free.fr-20080826082527-109yyxzc0u24oeel
Fix all calls to tempfile.mkdtemp to osutils.mkdtemp.

* bzrlib/transform.py:
(TransformPreview.__init__): Use osutils.mkdtemp instead of
tempfile.mkdtemp.

* bzrlib/tests/test_whitebox.py:
(MoreTests.test_relpath): Use osutils.mkdtemp instead of
tempfile.mkdtemp.

* bzrlib/tests/test_setup.py:
(TestSetup.test_build_and_install): Use osutils.mkdtemp instead of
tempfile.mkdtemp.

* bzrlib/tests/test_bundle.py:
(BundleTester.get_checkout): Use osutils.mkdtemp instead of
tempfile.mkdtemp.

* bzrlib/tests/blackbox/test_outside_wt.py:
(TestOutsideWT.test_cwd_log,
TestOutsideWT.test_diff_outside_tree): Use osutils.mkdtemp instead
of tempfile.mkdtemp.

* bzrlib/smart/repository.py:
(SmartServerRepositoryTarball._copy_to_tempdir): Use
osutils.mkdtemp instead of tempfile.mkdtemp.
(SmartServerRepositoryTarball._tarfile_response): Line too long.

* bzrlib/remote.py:
(RemoteRepository._copy_repository_tarball): Use osutils.mkdtemp
instead of tempfile.mkdtemp.

* bzrlib/osutils.py:
(_mac_mkdtemp): Add docstring.

* bzrlib/mail_client.py:
(ExternalMailClient.compose): Use osutils.mkdtemp instead of
tempfile.mkdtemp.

* bzrlib/diff.py:
(DiffFromTool.__init__): Use osutils.mkdtemp instead of
tempfile.mkdtemp.

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,
43
43
[DEFAULT]
44
44
email=Erik B\u00e5gfors <erik@bagfors.nu>
45
45
editor=vim
46
 
change_editor=vimdiff -of @new_path @old_path
47
46
gpg_signing_command=gnome-gpg
48
47
log_format=short
49
48
user_global_option=something
151
150
        self._transport = self.control_files = \
152
151
            FakeControlFilesAndTransport(user_id=user_id)
153
152
 
154
 
    def _get_config(self):
155
 
        return config.TransportConfig(self._transport, 'branch.conf')
156
 
 
157
153
    def lock_write(self):
158
154
        pass
159
155
 
210
206
        self._calls.append('_get_signature_checking')
211
207
        return self._signatures
212
208
 
213
 
    def _get_change_editor(self):
214
 
        self._calls.append('_get_change_editor')
215
 
        return 'vimdiff -fo @new_path @old_path'
216
 
 
217
209
 
218
210
bool_config = """[DEFAULT]
219
211
active = true
320
312
        my_config = config.Config()
321
313
        self.assertEqual('long', my_config.log_format())
322
314
 
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
315
 
332
316
class TestConfigPath(tests.TestCase):
333
317
 
334
318
    def setUp(self):
335
319
        super(TestConfigPath, self).setUp()
336
320
        os.environ['HOME'] = '/home/bogus'
337
 
        os.environ['XDG_CACHE_DIR'] = ''
338
321
        if sys.platform == 'win32':
339
322
            os.environ['BZR_HOME'] = \
340
323
                r'C:\Documents and Settings\bogus\Application Data'
362
345
        self.assertEqual(config.authentication_config_filename(),
363
346
                         self.bzr_home + '/authentication.conf')
364
347
 
365
 
    def test_xdg_cache_dir(self):
366
 
        self.assertEqual(config.xdg_cache_dir(),
367
 
            '/home/bogus/.cache')
368
 
 
369
348
 
370
349
class TestIniConfig(tests.TestCase):
371
350
 
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
351
    def test_contructs(self):
381
352
        my_config = config.IniBasedConfig("nothing")
382
353
 
394
365
        self.failUnless(my_config._get_parser() is parser)
395
366
 
396
367
 
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
368
class TestGetConfig(tests.TestCase):
445
369
 
446
370
    def test_constructs(self):
501
425
        locations = config.locations_config_filename()
502
426
        config.ensure_config_dir_exists()
503
427
        local_url = urlutils.local_path_to_url('branch')
504
 
        open(locations, 'wb').write('[%s]\nnickname = foobar'
 
428
        open(locations, 'wb').write('[%s]\nnickname = foobar' 
505
429
                                    % (local_url,))
506
430
        self.assertEqual('foobar', branch.nick)
507
431
 
512
436
 
513
437
        locations = config.locations_config_filename()
514
438
        config.ensure_config_dir_exists()
515
 
        open(locations, 'wb').write('[%s/branch]\nnickname = barry'
 
439
        open(locations, 'wb').write('[%s/branch]\nnickname = barry' 
516
440
                                    % (osutils.getcwd().encode('utf8'),))
517
441
        self.assertEqual('barry', branch.nick)
518
442
 
680
604
        my_config = self._get_sample_config()
681
605
        self.assertEqual(sample_long_alias, my_config.get_alias('ll'))
682
606
 
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
607
 
696
608
class TestGlobalConfigSavingOptions(tests.TestCaseInTempDir):
697
609
 
1295
1207
 
1296
1208
    def test_set_unset_default_stack_on(self):
1297
1209
        my_dir = self.make_bzrdir('.')
1298
 
        bzrdir_config = config.BzrDirConfig(my_dir)
 
1210
        bzrdir_config = config.BzrDirConfig(my_dir.transport)
1299
1211
        self.assertIs(None, bzrdir_config.get_default_stack_on())
1300
1212
        bzrdir_config.set_default_stack_on('Foo')
1301
1213
        self.assertEqual('Foo', bzrdir_config._config.get_option(
1351
1263
"""))
1352
1264
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1353
1265
 
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
1266
    def test_credentials_for_scheme_host(self):
1365
1267
        conf = config.AuthenticationConfig(_file=StringIO(
1366
1268
                """# Identity on foo.net
1510
1412
        self.assertEquals(True, credentials.get('verify_certificates'))
1511
1413
 
1512
1414
 
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
1415
class TestAuthenticationConfig(tests.TestCase):
1545
1416
    """Test AuthenticationConfig behaviour"""
1546
1417
 
1547
 
    def _check_default_password_prompt(self, expected_prompt_format, scheme,
1548
 
                                       host=None, port=None, realm=None,
1549
 
                                       path=None):
 
1418
    def _check_default_prompt(self, expected_prompt_format, scheme,
 
1419
                              host=None, port=None, realm=None, path=None):
1550
1420
        if host is None:
1551
1421
            host = 'bar.org'
1552
1422
        user, password = 'jim', 'precious'
1555
1425
            'user': user, 'realm': realm}
1556
1426
 
1557
1427
        stdout = tests.StringIOWrapper()
1558
 
        stderr = tests.StringIOWrapper()
1559
1428
        ui.ui_factory = tests.TestUIFactory(stdin=password + '\n',
1560
 
                                            stdout=stdout, stderr=stderr)
 
1429
                                            stdout=stdout)
1561
1430
        # We use an empty conf so that the user is always prompted
1562
1431
        conf = config.AuthenticationConfig()
1563
1432
        self.assertEquals(password,
1564
1433
                          conf.get_password(scheme, host, user, port=port,
1565
1434
                                            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)
 
1435
        self.assertEquals(stdout.getvalue(), expected_prompt)
 
1436
 
 
1437
    def test_default_prompts(self):
 
1438
        # HTTP prompts can't be tested here, see test_http.py
 
1439
        self._check_default_prompt('FTP %(user)s@%(host)s password: ', 'ftp')
 
1440
        self._check_default_prompt('FTP %(user)s@%(host)s:%(port)d password: ',
 
1441
                                   'ftp', port=10020)
 
1442
 
 
1443
        self._check_default_prompt('SSH %(user)s@%(host)s:%(port)d password: ',
 
1444
                                   'ssh', port=12345)
1612
1445
        # SMTP port handling is a bit special (it's handled if embedded in the
1613
1446
        # host too)
1614
1447
        # FIXME: should we: forbid that, extend it to other schemes, leave
1615
1448
        # 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(
 
1449
        self._check_default_prompt('SMTP %(user)s@%(host)s password: ',
 
1450
                                   'smtp')
 
1451
        self._check_default_prompt('SMTP %(user)s@%(host)s password: ',
 
1452
                                   'smtp', host='bar.org:10025')
 
1453
        self._check_default_prompt(
1621
1454
            'SMTP %(user)s@%(host)s:%(port)d password: ',
1622
1455
            'smtp', port=10025)
1623
1456
 
1632
1465
"""))
1633
1466
        entered_password = 'typed-by-hand'
1634
1467
        stdout = tests.StringIOWrapper()
1635
 
        stderr = tests.StringIOWrapper()
1636
1468
        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1637
 
                                            stdout=stdout, stderr=stderr)
 
1469
                                            stdout=stdout)
1638
1470
 
1639
1471
        # Since the password defined in the authentication config is ignored,
1640
1472
        # the user is prompted
1641
1473
        self.assertEquals(entered_password,
1642
1474
                          conf.get_password('ssh', 'bar.org', user='jim'))
1643
1475
        self.assertContainsRe(
1644
 
            self.get_log(),
 
1476
            self._get_log(keep_log_file=True),
1645
1477
            'password ignored in section \[ssh with password\]')
1646
1478
 
1647
1479
    def test_ssh_without_password_doesnt_emit_warning(self):
1654
1486
"""))
1655
1487
        entered_password = 'typed-by-hand'
1656
1488
        stdout = tests.StringIOWrapper()
1657
 
        stderr = tests.StringIOWrapper()
1658
1489
        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1659
 
                                            stdout=stdout,
1660
 
                                            stderr=stderr)
 
1490
                                            stdout=stdout)
1661
1491
 
1662
1492
        # Since the password defined in the authentication config is ignored,
1663
1493
        # the user is prompted
1666
1496
        # No warning shoud be emitted since there is no password. We are only
1667
1497
        # providing "user".
1668
1498
        self.assertNotContainsRe(
1669
 
            self.get_log(),
 
1499
            self._get_log(keep_log_file=True),
1670
1500
            'password ignored in section \[ssh with password\]')
1671
1501
 
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
1502
 
1798
1503
# FIXME: Once we have a way to declare authentication to all test servers, we
1799
1504
# can implement generic tests.