387
333
self.assertEqual(config.authentication_config_filename(),
388
334
self.bzr_home + '/authentication.conf')
390
def test_xdg_cache_dir(self):
391
self.assertEqual(config.xdg_cache_dir(),
392
'/home/bogus/.cache')
395
class TestIniConfig(tests.TestCaseInTempDir):
397
def make_config_parser(self, s):
398
conf = config.IniBasedConfig.from_string(s)
399
return conf, conf._get_parser()
402
class TestIniConfigBuilding(TestIniConfig):
337
class TestIniConfig(tests.TestCase):
404
339
def test_contructs(self):
405
my_config = config.IniBasedConfig()
340
my_config = config.IniBasedConfig("nothing")
407
342
def test_from_fp(self):
408
my_config = config.IniBasedConfig.from_string(sample_config_text)
409
self.assertIsInstance(my_config._get_parser(), configobj.ConfigObj)
343
config_file = StringIO(sample_config_text.encode('utf-8'))
344
my_config = config.IniBasedConfig(None)
346
isinstance(my_config._get_parser(file=config_file),
347
configobj.ConfigObj))
411
349
def test_cached(self):
412
my_config = config.IniBasedConfig.from_string(sample_config_text)
413
parser = my_config._get_parser()
350
config_file = StringIO(sample_config_text.encode('utf-8'))
351
my_config = config.IniBasedConfig(None)
352
parser = my_config._get_parser(file=config_file)
414
353
self.failUnless(my_config._get_parser() is parser)
416
def _dummy_chown(self, path, uid, gid):
417
self.path, self.uid, self.gid = path, uid, gid
419
def test_ini_config_ownership(self):
420
"""Ensure that chown is happening during _write_config_file"""
421
self.requireFeature(features.chown_feature)
422
self.overrideAttr(os, 'chown', self._dummy_chown)
423
self.path = self.uid = self.gid = None
424
conf = config.IniBasedConfig(file_name='./foo.conf')
425
conf._write_config_file()
426
self.assertEquals(self.path, './foo.conf')
427
self.assertTrue(isinstance(self.uid, int))
428
self.assertTrue(isinstance(self.gid, int))
430
def test_get_filename_parameter_is_deprecated_(self):
431
conf = self.callDeprecated([
432
'IniBasedConfig.__init__(get_filename) was deprecated in 2.3.'
433
' Use file_name instead.'],
434
config.IniBasedConfig, lambda: 'ini.conf')
435
self.assertEqual('ini.conf', conf.file_name)
437
def test_get_parser_file_parameter_is_deprecated_(self):
438
config_file = StringIO(sample_config_text.encode('utf-8'))
439
conf = config.IniBasedConfig.from_string(sample_config_text)
440
conf = self.callDeprecated([
441
'IniBasedConfig._get_parser(file=xxx) was deprecated in 2.3.'
442
' Use IniBasedConfig(_content=xxx) instead.'],
443
conf._get_parser, file=config_file)
445
class TestIniConfigSaving(tests.TestCaseInTempDir):
447
def test_cant_save_without_a_file_name(self):
448
conf = config.IniBasedConfig()
449
self.assertRaises(AssertionError, conf._write_config_file)
451
def test_saved_with_content(self):
452
content = 'foo = bar\n'
453
conf = config.IniBasedConfig.from_string(
454
content, file_name='./test.conf', save=True)
455
self.assertFileEqual(content, 'test.conf')
458
class TestIniBaseConfigOnDisk(tests.TestCaseInTempDir):
460
def test_cannot_reload_without_name(self):
461
conf = config.IniBasedConfig.from_string(sample_config_text)
462
self.assertRaises(AssertionError, conf.reload)
464
def test_reload_see_new_value(self):
465
c1 = config.IniBasedConfig.from_string('editor=vim\n',
466
file_name='./test/conf')
467
c1._write_config_file()
468
c2 = config.IniBasedConfig.from_string('editor=emacs\n',
469
file_name='./test/conf')
470
c2._write_config_file()
471
self.assertEqual('vim', c1.get_user_option('editor'))
472
self.assertEqual('emacs', c2.get_user_option('editor'))
473
# Make sure we get the Right value
475
self.assertEqual('emacs', c1.get_user_option('editor'))
478
class TestLockableConfig(tests.TestCaseInTempDir):
483
config_section = None
486
super(TestLockableConfig, self).setUp()
487
self._content = '[%s]\none=1\ntwo=2\n' % (self.config_section,)
488
self.config = self.create_config(self._content)
490
def get_existing_config(self):
491
return self.config_class(*self.config_args)
493
def create_config(self, content):
494
kwargs = dict(save=True)
495
c = self.config_class.from_string(content, *self.config_args, **kwargs)
498
def test_simple_read_access(self):
499
self.assertEquals('1', self.config.get_user_option('one'))
501
def test_simple_write_access(self):
502
self.config.set_user_option('one', 'one')
503
self.assertEquals('one', self.config.get_user_option('one'))
505
def test_listen_to_the_last_speaker(self):
507
c2 = self.get_existing_config()
508
c1.set_user_option('one', 'ONE')
509
c2.set_user_option('two', 'TWO')
510
self.assertEquals('ONE', c1.get_user_option('one'))
511
self.assertEquals('TWO', c2.get_user_option('two'))
512
# The second update respect the first one
513
self.assertEquals('ONE', c2.get_user_option('one'))
515
def test_last_speaker_wins(self):
516
# If the same config is not shared, the same variable modified twice
517
# can only see a single result.
519
c2 = self.get_existing_config()
520
c1.set_user_option('one', 'c1')
521
c2.set_user_option('one', 'c2')
522
self.assertEquals('c2', c2._get_user_option('one'))
523
# The first modification is still available until another refresh
525
self.assertEquals('c1', c1._get_user_option('one'))
526
c1.set_user_option('two', 'done')
527
self.assertEquals('c2', c1._get_user_option('one'))
529
def test_writes_are_serialized(self):
531
c2 = self.get_existing_config()
533
# We spawn a thread that will pause *during* the write
534
before_writing = threading.Event()
535
after_writing = threading.Event()
536
writing_done = threading.Event()
537
c1_orig = c1._write_config_file
538
def c1_write_config_file():
541
# The lock is held we wait for the main thread to decide when to
544
c1._write_config_file = c1_write_config_file
546
c1.set_user_option('one', 'c1')
548
t1 = threading.Thread(target=c1_set_option)
549
# Collect the thread after the test
550
self.addCleanup(t1.join)
551
# Be ready to unblock the thread if the test goes wrong
552
self.addCleanup(after_writing.set)
554
before_writing.wait()
555
self.assertTrue(c1._lock.is_held)
556
self.assertRaises(errors.LockContention,
557
c2.set_user_option, 'one', 'c2')
558
self.assertEquals('c1', c1.get_user_option('one'))
559
# Let the lock be released
562
c2.set_user_option('one', 'c2')
563
self.assertEquals('c2', c2.get_user_option('one'))
565
def test_read_while_writing(self):
567
# We spawn a thread that will pause *during* the write
568
ready_to_write = threading.Event()
569
do_writing = threading.Event()
570
writing_done = threading.Event()
571
c1_orig = c1._write_config_file
572
def c1_write_config_file():
574
# The lock is held we wait for the main thread to decide when to
579
c1._write_config_file = c1_write_config_file
581
c1.set_user_option('one', 'c1')
582
t1 = threading.Thread(target=c1_set_option)
583
# Collect the thread after the test
584
self.addCleanup(t1.join)
585
# Be ready to unblock the thread if the test goes wrong
586
self.addCleanup(do_writing.set)
588
# Ensure the thread is ready to write
589
ready_to_write.wait()
590
self.assertTrue(c1._lock.is_held)
591
self.assertEquals('c1', c1.get_user_option('one'))
592
# If we read during the write, we get the old value
593
c2 = self.get_existing_config()
594
self.assertEquals('1', c2.get_user_option('one'))
595
# Let the writing occur and ensure it occurred
598
# Now we get the updated value
599
c3 = self.get_existing_config()
600
self.assertEquals('c1', c3.get_user_option('one'))
603
class TestGetUserOptionAs(TestIniConfig):
605
def test_get_user_option_as_bool(self):
606
conf, parser = self.make_config_parser("""
609
an_invalid_bool = maybe
610
a_list = hmm, who knows ? # This is interpreted as a list !
612
get_bool = conf.get_user_option_as_bool
613
self.assertEqual(True, get_bool('a_true_bool'))
614
self.assertEqual(False, get_bool('a_false_bool'))
617
warnings.append(args[0] % args[1:])
618
self.overrideAttr(trace, 'warning', warning)
619
msg = 'Value "%s" is not a boolean for "%s"'
620
self.assertIs(None, get_bool('an_invalid_bool'))
621
self.assertEquals(msg % ('maybe', 'an_invalid_bool'), warnings[0])
623
self.assertIs(None, get_bool('not_defined_in_this_config'))
624
self.assertEquals([], warnings)
626
def test_get_user_option_as_list(self):
627
conf, parser = self.make_config_parser("""
632
get_list = conf.get_user_option_as_list
633
self.assertEqual(['a', 'b', 'c'], get_list('a_list'))
634
self.assertEqual(['1'], get_list('length_1'))
635
self.assertEqual('x', conf.get_user_option('one_item'))
636
# automatically cast to list
637
self.assertEqual(['x'], get_list('one_item'))
640
class TestSupressWarning(TestIniConfig):
642
def make_warnings_config(self, s):
643
conf, parser = self.make_config_parser(s)
644
return conf.suppress_warning
646
def test_suppress_warning_unknown(self):
647
suppress_warning = self.make_warnings_config('')
648
self.assertEqual(False, suppress_warning('unknown_warning'))
650
def test_suppress_warning_known(self):
651
suppress_warning = self.make_warnings_config('suppress_warnings=a,b')
652
self.assertEqual(False, suppress_warning('c'))
653
self.assertEqual(True, suppress_warning('a'))
654
self.assertEqual(True, suppress_warning('b'))
657
356
class TestGetConfig(tests.TestCase):
761
462
self.assertEqual(1, len(warnings))
762
463
self.assertEqual(warning, warnings[0])
763
branch = self.make_branch('.')
764
conf = branch.get_config()
765
set_option(config.STORE_GLOBAL)
767
set_option(config.STORE_BRANCH)
769
set_option(config.STORE_GLOBAL)
770
assertWarning('Value "4" is masked by "3" from branch.conf')
771
set_option(config.STORE_GLOBAL, warn_masked=False)
773
set_option(config.STORE_LOCATION)
775
set_option(config.STORE_BRANCH)
776
assertWarning('Value "3" is masked by "0" from locations.conf')
777
set_option(config.STORE_BRANCH, warn_masked=False)
464
trace.warning = warning
466
branch = self.make_branch('.')
467
conf = branch.get_config()
468
set_option(config.STORE_GLOBAL)
470
set_option(config.STORE_BRANCH)
472
set_option(config.STORE_GLOBAL)
473
assertWarning('Value "4" is masked by "3" from branch.conf')
474
set_option(config.STORE_GLOBAL, warn_masked=False)
476
set_option(config.STORE_LOCATION)
478
set_option(config.STORE_BRANCH)
479
assertWarning('Value "3" is masked by "0" from locations.conf')
480
set_option(config.STORE_BRANCH, warn_masked=False)
483
trace.warning = _warning
781
486
class TestGlobalConfigItems(tests.TestCase):
783
488
def test_user_id(self):
784
my_config = config.GlobalConfig.from_string(sample_config_text)
489
config_file = StringIO(sample_config_text.encode('utf-8'))
490
my_config = config.GlobalConfig()
491
my_config._parser = my_config._get_parser(file=config_file)
785
492
self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
786
493
my_config._get_user_id())
788
495
def test_absent_user_id(self):
496
config_file = StringIO("")
789
497
my_config = config.GlobalConfig()
498
my_config._parser = my_config._get_parser(file=config_file)
790
499
self.assertEqual(None, my_config._get_user_id())
792
501
def test_configured_editor(self):
793
my_config = config.GlobalConfig.from_string(sample_config_text)
502
config_file = StringIO(sample_config_text.encode('utf-8'))
503
my_config = config.GlobalConfig()
504
my_config._parser = my_config._get_parser(file=config_file)
794
505
self.assertEqual("vim", my_config.get_editor())
796
507
def test_signatures_always(self):
797
my_config = config.GlobalConfig.from_string(sample_always_signatures)
508
config_file = StringIO(sample_always_signatures)
509
my_config = config.GlobalConfig()
510
my_config._parser = my_config._get_parser(file=config_file)
798
511
self.assertEqual(config.CHECK_NEVER,
799
512
my_config.signature_checking())
800
513
self.assertEqual(config.SIGN_ALWAYS,
1162
853
self.my_config.post_commit())
1164
855
def get_branch_config(self, location, global_config=None):
1165
my_branch = FakeBranch(location)
1166
856
if global_config is None:
1167
global_config = sample_config_text
1169
my_global_config = config.GlobalConfig.from_string(global_config,
1171
my_location_config = config.LocationConfig.from_string(
1172
sample_branches_text, my_branch.base, save=True)
1173
my_config = config.BranchConfig(my_branch)
1174
self.my_config = my_config
1175
self.my_location_config = my_config._get_location_config()
857
global_file = StringIO(sample_config_text.encode('utf-8'))
859
global_file = StringIO(global_config.encode('utf-8'))
860
branches_file = StringIO(sample_branches_text.encode('utf-8'))
861
self.my_config = config.BranchConfig(FakeBranch(location))
862
# Force location config to use specified file
863
self.my_location_config = self.my_config._get_location_config()
864
self.my_location_config._get_parser(branches_file)
865
# Force global config to use specified file
866
self.my_config._get_global_config()._get_parser(global_file)
1177
868
def test_set_user_setting_sets_and_saves(self):
1178
869
self.get_branch_config('/a/c')
1179
870
record = InstrumentedConfigObj("foo")
1180
871
self.my_location_config._parser = record
1182
self.callDeprecated(['The recurse option is deprecated as of '
1183
'0.14. The section "/a/c" has been '
1184
'converted to use policies.'],
1185
self.my_config.set_user_option,
1186
'foo', 'bar', store=config.STORE_LOCATION)
1187
self.assertEqual([('reload',),
1188
('__contains__', '/a/c'),
873
real_mkdir = os.mkdir
875
def checked_mkdir(path, mode=0777):
876
self.log('making directory: %s', path)
877
real_mkdir(path, mode)
880
os.mkdir = checked_mkdir
882
self.callDeprecated(['The recurse option is deprecated as of '
883
'0.14. The section "/a/c" has been '
884
'converted to use policies.'],
885
self.my_config.set_user_option,
886
'foo', 'bar', store=config.STORE_LOCATION)
888
os.mkdir = real_mkdir
890
self.failUnless(self.created, 'Failed to create ~/.bazaar')
891
self.assertEqual([('__contains__', '/a/c'),
1189
892
('__contains__', '/a/c/'),
1190
893
('__setitem__', '/a/c', {}),
1191
894
('__getitem__', '/a/c'),
1431
1136
self.assertEqual(value, 'value3-section')
1434
class TestTransportConfig(tests.TestCaseWithTransport):
1436
def test_get_value(self):
1437
"""Test that retreiving a value from a section is possible"""
1438
bzrdir_config = config.TransportConfig(transport.get_transport('.'),
1440
bzrdir_config.set_option('value', 'key', 'SECTION')
1441
bzrdir_config.set_option('value2', 'key2')
1442
bzrdir_config.set_option('value3-top', 'key3')
1443
bzrdir_config.set_option('value3-section', 'key3', 'SECTION')
1444
value = bzrdir_config.get_option('key', 'SECTION')
1445
self.assertEqual(value, 'value')
1446
value = bzrdir_config.get_option('key2')
1447
self.assertEqual(value, 'value2')
1448
self.assertEqual(bzrdir_config.get_option('non-existant'), None)
1449
value = bzrdir_config.get_option('non-existant', 'SECTION')
1450
self.assertEqual(value, None)
1451
value = bzrdir_config.get_option('non-existant', default='default')
1452
self.assertEqual(value, 'default')
1453
self.assertEqual(bzrdir_config.get_option('key2', 'NOSECTION'), None)
1454
value = bzrdir_config.get_option('key2', 'NOSECTION',
1456
self.assertEqual(value, 'default')
1457
value = bzrdir_config.get_option('key3')
1458
self.assertEqual(value, 'value3-top')
1459
value = bzrdir_config.get_option('key3', 'SECTION')
1460
self.assertEqual(value, 'value3-section')
1462
def test_set_unset_default_stack_on(self):
1463
my_dir = self.make_bzrdir('.')
1464
bzrdir_config = config.BzrDirConfig(my_dir)
1465
self.assertIs(None, bzrdir_config.get_default_stack_on())
1466
bzrdir_config.set_default_stack_on('Foo')
1467
self.assertEqual('Foo', bzrdir_config._config.get_option(
1468
'default_stack_on'))
1469
self.assertEqual('Foo', bzrdir_config.get_default_stack_on())
1470
bzrdir_config.set_default_stack_on(None)
1471
self.assertIs(None, bzrdir_config.get_default_stack_on())
1474
1139
class TestAuthenticationConfigFile(tests.TestCase):
1475
1140
"""Test the authentication.conf file matching"""
1676
1312
self.assertEquals(True, credentials.get('verify_certificates'))
1679
class TestAuthenticationStorage(tests.TestCaseInTempDir):
1681
def test_set_credentials(self):
1682
conf = config.AuthenticationConfig()
1683
conf.set_credentials('name', 'host', 'user', 'scheme', 'password',
1684
99, path='/foo', verify_certificates=False, realm='realm')
1685
credentials = conf.get_credentials(host='host', scheme='scheme',
1686
port=99, path='/foo',
1688
CREDENTIALS = {'name': 'name', 'user': 'user', 'password': 'password',
1689
'verify_certificates': False, 'scheme': 'scheme',
1690
'host': 'host', 'port': 99, 'path': '/foo',
1692
self.assertEqual(CREDENTIALS, credentials)
1693
credentials_from_disk = config.AuthenticationConfig().get_credentials(
1694
host='host', scheme='scheme', port=99, path='/foo', realm='realm')
1695
self.assertEqual(CREDENTIALS, credentials_from_disk)
1697
def test_reset_credentials_different_name(self):
1698
conf = config.AuthenticationConfig()
1699
conf.set_credentials('name', 'host', 'user', 'scheme', 'password'),
1700
conf.set_credentials('name2', 'host', 'user2', 'scheme', 'password'),
1701
self.assertIs(None, conf._get_config().get('name'))
1702
credentials = conf.get_credentials(host='host', scheme='scheme')
1703
CREDENTIALS = {'name': 'name2', 'user': 'user2', 'password':
1704
'password', 'verify_certificates': True,
1705
'scheme': 'scheme', 'host': 'host', 'port': None,
1706
'path': None, 'realm': None}
1707
self.assertEqual(CREDENTIALS, credentials)
1710
1315
class TestAuthenticationConfig(tests.TestCase):
1711
1316
"""Test AuthenticationConfig behaviour"""
1713
def _check_default_password_prompt(self, expected_prompt_format, scheme,
1714
host=None, port=None, realm=None,
1318
def _check_default_prompt(self, expected_prompt_format, scheme,
1319
host=None, port=None, realm=None, path=None):
1716
1320
if host is None:
1717
1321
host = 'bar.org'
1718
1322
user, password = 'jim', 'precious'
1721
1325
'user': user, 'realm': realm}
1723
1327
stdout = tests.StringIOWrapper()
1724
stderr = tests.StringIOWrapper()
1725
1328
ui.ui_factory = tests.TestUIFactory(stdin=password + '\n',
1726
stdout=stdout, stderr=stderr)
1727
1330
# We use an empty conf so that the user is always prompted
1728
1331
conf = config.AuthenticationConfig()
1729
1332
self.assertEquals(password,
1730
1333
conf.get_password(scheme, host, user, port=port,
1731
1334
realm=realm, path=path))
1732
self.assertEquals(expected_prompt, stderr.getvalue())
1733
self.assertEquals('', stdout.getvalue())
1735
def _check_default_username_prompt(self, expected_prompt_format, scheme,
1736
host=None, port=None, realm=None,
1741
expected_prompt = expected_prompt_format % {
1742
'scheme': scheme, 'host': host, 'port': port,
1744
stdout = tests.StringIOWrapper()
1745
stderr = tests.StringIOWrapper()
1746
ui.ui_factory = tests.TestUIFactory(stdin=username+ '\n',
1747
stdout=stdout, stderr=stderr)
1748
# We use an empty conf so that the user is always prompted
1749
conf = config.AuthenticationConfig()
1750
self.assertEquals(username, conf.get_user(scheme, host, port=port,
1751
realm=realm, path=path, ask=True))
1752
self.assertEquals(expected_prompt, stderr.getvalue())
1753
self.assertEquals('', stdout.getvalue())
1755
def test_username_defaults_prompts(self):
1756
# HTTP prompts can't be tested here, see test_http.py
1757
self._check_default_username_prompt('FTP %(host)s username: ', 'ftp')
1758
self._check_default_username_prompt(
1759
'FTP %(host)s:%(port)d username: ', 'ftp', port=10020)
1760
self._check_default_username_prompt(
1761
'SSH %(host)s:%(port)d username: ', 'ssh', port=12345)
1763
def test_username_default_no_prompt(self):
1764
conf = config.AuthenticationConfig()
1765
self.assertEquals(None,
1766
conf.get_user('ftp', 'example.com'))
1767
self.assertEquals("explicitdefault",
1768
conf.get_user('ftp', 'example.com', default="explicitdefault"))
1770
def test_password_default_prompts(self):
1771
# HTTP prompts can't be tested here, see test_http.py
1772
self._check_default_password_prompt(
1773
'FTP %(user)s@%(host)s password: ', 'ftp')
1774
self._check_default_password_prompt(
1775
'FTP %(user)s@%(host)s:%(port)d password: ', 'ftp', port=10020)
1776
self._check_default_password_prompt(
1777
'SSH %(user)s@%(host)s:%(port)d password: ', 'ssh', port=12345)
1335
self.assertEquals(stdout.getvalue(), expected_prompt)
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: ',
1343
self._check_default_prompt('SSH %(user)s@%(host)s:%(port)d password: ',
1778
1345
# SMTP port handling is a bit special (it's handled if embedded in the
1780
1347
# FIXME: should we: forbid that, extend it to other schemes, leave
1781
1348
# things as they are that's fine thank you ?
1782
self._check_default_password_prompt('SMTP %(user)s@%(host)s password: ',
1784
self._check_default_password_prompt('SMTP %(user)s@%(host)s password: ',
1785
'smtp', host='bar.org:10025')
1786
self._check_default_password_prompt(
1349
self._check_default_prompt('SMTP %(user)s@%(host)s password: ',
1351
self._check_default_prompt('SMTP %(user)s@%(host)s password: ',
1352
'smtp', host='bar.org:10025')
1353
self._check_default_prompt(
1787
1354
'SMTP %(user)s@%(host)s:%(port)d password: ',
1788
1355
'smtp', port=10025)
1790
def test_ssh_password_emits_warning(self):
1791
conf = config.AuthenticationConfig(_file=StringIO(
1799
entered_password = 'typed-by-hand'
1800
stdout = tests.StringIOWrapper()
1801
stderr = tests.StringIOWrapper()
1802
ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1803
stdout=stdout, stderr=stderr)
1805
# Since the password defined in the authentication config is ignored,
1806
# the user is prompted
1807
self.assertEquals(entered_password,
1808
conf.get_password('ssh', 'bar.org', user='jim'))
1809
self.assertContainsRe(
1811
'password ignored in section \[ssh with password\]')
1813
def test_ssh_without_password_doesnt_emit_warning(self):
1814
conf = config.AuthenticationConfig(_file=StringIO(
1821
entered_password = 'typed-by-hand'
1822
stdout = tests.StringIOWrapper()
1823
stderr = tests.StringIOWrapper()
1824
ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1828
# Since the password defined in the authentication config is ignored,
1829
# the user is prompted
1830
self.assertEquals(entered_password,
1831
conf.get_password('ssh', 'bar.org', user='jim'))
1832
# No warning shoud be emitted since there is no password. We are only
1834
self.assertNotContainsRe(
1836
'password ignored in section \[ssh with password\]')
1838
def test_uses_fallback_stores(self):
1839
self.overrideAttr(config, 'credential_store_registry',
1840
config.CredentialStoreRegistry())
1841
store = StubCredentialStore()
1842
store.add_credentials("http", "example.com", "joe", "secret")
1843
config.credential_store_registry.register("stub", store, fallback=True)
1844
conf = config.AuthenticationConfig(_file=StringIO())
1845
creds = conf.get_credentials("http", "example.com")
1846
self.assertEquals("joe", creds["user"])
1847
self.assertEquals("secret", creds["password"])
1850
class StubCredentialStore(config.CredentialStore):
1856
def add_credentials(self, scheme, host, user, password=None):
1857
self._username[(scheme, host)] = user
1858
self._password[(scheme, host)] = password
1860
def get_credentials(self, scheme, host, port=None, user=None,
1861
path=None, realm=None):
1862
key = (scheme, host)
1863
if not key in self._username:
1865
return { "scheme": scheme, "host": host, "port": port,
1866
"user": self._username[key], "password": self._password[key]}
1869
class CountingCredentialStore(config.CredentialStore):
1874
def get_credentials(self, scheme, host, port=None, user=None,
1875
path=None, realm=None):
1880
class TestCredentialStoreRegistry(tests.TestCase):
1882
def _get_cs_registry(self):
1883
return config.credential_store_registry
1885
def test_default_credential_store(self):
1886
r = self._get_cs_registry()
1887
default = r.get_credential_store(None)
1888
self.assertIsInstance(default, config.PlainTextCredentialStore)
1890
def test_unknown_credential_store(self):
1891
r = self._get_cs_registry()
1892
# It's hard to imagine someone creating a credential store named
1893
# 'unknown' so we use that as an never registered key.
1894
self.assertRaises(KeyError, r.get_credential_store, 'unknown')
1896
def test_fallback_none_registered(self):
1897
r = config.CredentialStoreRegistry()
1898
self.assertEquals(None,
1899
r.get_fallback_credentials("http", "example.com"))
1901
def test_register(self):
1902
r = config.CredentialStoreRegistry()
1903
r.register("stub", StubCredentialStore(), fallback=False)
1904
r.register("another", StubCredentialStore(), fallback=True)
1905
self.assertEquals(["another", "stub"], r.keys())
1907
def test_register_lazy(self):
1908
r = config.CredentialStoreRegistry()
1909
r.register_lazy("stub", "bzrlib.tests.test_config",
1910
"StubCredentialStore", fallback=False)
1911
self.assertEquals(["stub"], r.keys())
1912
self.assertIsInstance(r.get_credential_store("stub"),
1913
StubCredentialStore)
1915
def test_is_fallback(self):
1916
r = config.CredentialStoreRegistry()
1917
r.register("stub1", None, fallback=False)
1918
r.register("stub2", None, fallback=True)
1919
self.assertEquals(False, r.is_fallback("stub1"))
1920
self.assertEquals(True, r.is_fallback("stub2"))
1922
def test_no_fallback(self):
1923
r = config.CredentialStoreRegistry()
1924
store = CountingCredentialStore()
1925
r.register("count", store, fallback=False)
1926
self.assertEquals(None,
1927
r.get_fallback_credentials("http", "example.com"))
1928
self.assertEquals(0, store._calls)
1930
def test_fallback_credentials(self):
1931
r = config.CredentialStoreRegistry()
1932
store = StubCredentialStore()
1933
store.add_credentials("http", "example.com",
1934
"somebody", "geheim")
1935
r.register("stub", store, fallback=True)
1936
creds = r.get_fallback_credentials("http", "example.com")
1937
self.assertEquals("somebody", creds["user"])
1938
self.assertEquals("geheim", creds["password"])
1940
def test_fallback_first_wins(self):
1941
r = config.CredentialStoreRegistry()
1942
stub1 = StubCredentialStore()
1943
stub1.add_credentials("http", "example.com",
1944
"somebody", "stub1")
1945
r.register("stub1", stub1, fallback=True)
1946
stub2 = StubCredentialStore()
1947
stub2.add_credentials("http", "example.com",
1948
"somebody", "stub2")
1949
r.register("stub2", stub1, fallback=True)
1950
creds = r.get_fallback_credentials("http", "example.com")
1951
self.assertEquals("somebody", creds["user"])
1952
self.assertEquals("stub1", creds["password"])
1955
class TestPlainTextCredentialStore(tests.TestCase):
1957
def test_decode_password(self):
1958
r = config.credential_store_registry
1959
plain_text = r.get_credential_store()
1960
decoded = plain_text.decode_password(dict(password='secret'))
1961
self.assertEquals('secret', decoded)
1964
1358
# FIXME: Once we have a way to declare authentication to all test servers, we
1965
1359
# can implement generic tests.
added
removed
bzrlib/tests/test_config.py
