316
170
my_config = config.Config()
317
171
self.assertEqual(None, my_config.post_commit())
319
def test_log_format_default(self):
320
my_config = config.Config()
321
self.assertEqual('long', my_config.log_format())
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)
332
class TestConfigPath(tests.TestCase):
174
class TestConfigPath(TestCase):
335
177
super(TestConfigPath, self).setUp()
178
self.old_home = os.environ.get('HOME', None)
179
self.old_appdata = os.environ.get('APPDATA', None)
336
180
os.environ['HOME'] = '/home/bogus'
337
os.environ['XDG_CACHE_DIR'] = ''
338
if sys.platform == 'win32':
339
os.environ['BZR_HOME'] = \
340
r'C:\Documents and Settings\bogus\Application Data'
342
'C:/Documents and Settings/bogus/Application Data/bazaar/2.0'
344
self.bzr_home = '/home/bogus/.bazaar'
181
os.environ['APPDATA'] = \
182
r'C:\Documents and Settings\bogus\Application Data'
185
if self.old_home is None:
186
del os.environ['HOME']
188
os.environ['HOME'] = self.old_home
189
if self.old_appdata is None:
190
del os.environ['APPDATA']
192
os.environ['APPDATA'] = self.old_appdata
193
super(TestConfigPath, self).tearDown()
346
195
def test_config_dir(self):
347
self.assertEqual(config.config_dir(), self.bzr_home)
196
if sys.platform == 'win32':
197
self.assertEqual(config.config_dir(),
198
'C:/Documents and Settings/bogus/Application Data/bazaar/2.0')
200
self.assertEqual(config.config_dir(), '/home/bogus/.bazaar')
349
202
def test_config_filename(self):
350
self.assertEqual(config.config_filename(),
351
self.bzr_home + '/bazaar.conf')
203
if sys.platform == 'win32':
204
self.assertEqual(config.config_filename(),
205
'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/bazaar.conf')
207
self.assertEqual(config.config_filename(),
208
'/home/bogus/.bazaar/bazaar.conf')
353
210
def test_branches_config_filename(self):
354
self.assertEqual(config.branches_config_filename(),
355
self.bzr_home + '/branches.conf')
357
def test_locations_config_filename(self):
358
self.assertEqual(config.locations_config_filename(),
359
self.bzr_home + '/locations.conf')
361
def test_authentication_config_filename(self):
362
self.assertEqual(config.authentication_config_filename(),
363
self.bzr_home + '/authentication.conf')
365
def test_xdg_cache_dir(self):
366
self.assertEqual(config.xdg_cache_dir(),
367
'/home/bogus/.cache')
370
class TestIniConfig(tests.TestCase):
372
def make_config_parser(self, s):
373
conf = config.IniBasedConfig(None)
374
parser = conf._get_parser(file=StringIO(s.encode('utf-8')))
378
class TestIniConfigBuilding(TestIniConfig):
211
if sys.platform == 'win32':
212
self.assertEqual(config.branches_config_filename(),
213
'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/branches.conf')
215
self.assertEqual(config.branches_config_filename(),
216
'/home/bogus/.bazaar/branches.conf')
218
class TestIniConfig(TestCase):
380
220
def test_contructs(self):
381
221
my_config = config.IniBasedConfig("nothing")
383
223
def test_from_fp(self):
384
config_file = StringIO(sample_config_text.encode('utf-8'))
224
config_file = StringIO(sample_config_text)
385
225
my_config = config.IniBasedConfig(None)
387
227
isinstance(my_config._get_parser(file=config_file),
388
configobj.ConfigObj))
390
230
def test_cached(self):
391
config_file = StringIO(sample_config_text.encode('utf-8'))
231
config_file = StringIO(sample_config_text)
392
232
my_config = config.IniBasedConfig(None)
393
233
parser = my_config._get_parser(file=config_file)
394
234
self.failUnless(my_config._get_parser() is parser)
397
class TestGetUserOptionAs(TestIniConfig):
399
def test_get_user_option_as_bool(self):
400
conf, parser = self.make_config_parser("""
403
an_invalid_bool = maybe
404
a_list = hmm, who knows ? # This is interpreted as a list !
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'))
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])
417
self.assertIs(None, get_bool('not_defined_in_this_config'))
418
self.assertEquals([], warnings)
420
def test_get_user_option_as_list(self):
421
conf, parser = self.make_config_parser("""
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'))
434
class TestSupressWarning(TestIniConfig):
436
def make_warnings_config(self, s):
437
conf, parser = self.make_config_parser(s)
438
return conf.suppress_warning
440
def test_suppress_warning_unknown(self):
441
suppress_warning = self.make_warnings_config('')
442
self.assertEqual(False, suppress_warning('unknown_warning'))
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'))
451
class TestGetConfig(tests.TestCase):
237
class TestGetConfig(TestCase):
453
239
def test_constructs(self):
454
240
my_config = config.GlobalConfig()
456
242
def test_calls_read_filenames(self):
457
# replace the class that is constructed, to check its parameters
243
# replace the class that is constructured, to check its parameters
458
244
oldparserclass = config.ConfigObj
459
245
config.ConfigObj = InstrumentedConfigObj
460
246
my_config = config.GlobalConfig()
732
357
# This is testing the correct file names are provided.
733
358
# TODO: consolidate with the test for GlobalConfigs filename checks.
735
# replace the class that is constructed, to check its parameters
360
# replace the class that is constructured, to check its parameters
736
361
oldparserclass = config.ConfigObj
737
362
config.ConfigObj = InstrumentedConfigObj
363
my_config = config.LocationConfig('http://www.example.com')
739
my_config = config.LocationConfig('http://www.example.com')
740
365
parser = my_config._get_parser()
742
367
config.ConfigObj = oldparserclass
743
368
self.failUnless(isinstance(parser, InstrumentedConfigObj))
744
369
self.assertEqual(parser._calls,
745
[('__init__', config.locations_config_filename(),
747
config.ensure_config_dir_exists()
748
#os.mkdir(config.config_dir())
749
f = file(config.branches_config_filename(), 'wb')
752
oldparserclass = config.ConfigObj
753
config.ConfigObj = InstrumentedConfigObj
755
my_config = config.LocationConfig('http://www.example.com')
756
parser = my_config._get_parser()
758
config.ConfigObj = oldparserclass
370
[('__init__', config.branches_config_filename())])
760
372
def test_get_global_config(self):
761
my_config = config.BranchConfig(FakeBranch('http://example.com'))
373
my_config = config.LocationConfig('http://example.com')
762
374
global_config = my_config._get_global_config()
763
375
self.failUnless(isinstance(global_config, config.GlobalConfig))
764
376
self.failUnless(global_config is my_config._get_global_config())
766
def test__get_matching_sections_no_match(self):
767
self.get_branch_config('/')
768
self.assertEqual([], self.my_location_config._get_matching_sections())
770
def test__get_matching_sections_exact(self):
771
self.get_branch_config('http://www.example.com')
772
self.assertEqual([('http://www.example.com', '')],
773
self.my_location_config._get_matching_sections())
775
def test__get_matching_sections_suffix_does_not(self):
776
self.get_branch_config('http://www.example.com-com')
777
self.assertEqual([], self.my_location_config._get_matching_sections())
779
def test__get_matching_sections_subdir_recursive(self):
780
self.get_branch_config('http://www.example.com/com')
781
self.assertEqual([('http://www.example.com', 'com')],
782
self.my_location_config._get_matching_sections())
784
def test__get_matching_sections_ignoreparent(self):
785
self.get_branch_config('http://www.example.com/ignoreparent')
786
self.assertEqual([('http://www.example.com/ignoreparent', '')],
787
self.my_location_config._get_matching_sections())
789
def test__get_matching_sections_ignoreparent_subdir(self):
790
self.get_branch_config(
791
'http://www.example.com/ignoreparent/childbranch')
792
self.assertEqual([('http://www.example.com/ignoreparent',
794
self.my_location_config._get_matching_sections())
796
def test__get_matching_sections_subdir_trailing_slash(self):
797
self.get_branch_config('/b')
798
self.assertEqual([('/b/', '')],
799
self.my_location_config._get_matching_sections())
801
def test__get_matching_sections_subdir_child(self):
802
self.get_branch_config('/a/foo')
803
self.assertEqual([('/a/*', ''), ('/a/', 'foo')],
804
self.my_location_config._get_matching_sections())
806
def test__get_matching_sections_subdir_child_child(self):
807
self.get_branch_config('/a/foo/bar')
808
self.assertEqual([('/a/*', 'bar'), ('/a/', 'foo/bar')],
809
self.my_location_config._get_matching_sections())
811
def test__get_matching_sections_trailing_slash_with_children(self):
812
self.get_branch_config('/a/')
813
self.assertEqual([('/a/', '')],
814
self.my_location_config._get_matching_sections())
816
def test__get_matching_sections_explicit_over_glob(self):
817
# XXX: 2006-09-08 jamesh
818
# This test only passes because ord('c') > ord('*'). If there
819
# was a config section for '/a/?', it would get precedence
821
self.get_branch_config('/a/c')
822
self.assertEqual([('/a/c', ''), ('/a/*', ''), ('/a/', 'c')],
823
self.my_location_config._get_matching_sections())
825
def test__get_option_policy_normal(self):
826
self.get_branch_config('http://www.example.com')
828
self.my_location_config._get_config_policy(
829
'http://www.example.com', 'normal_option'),
832
def test__get_option_policy_norecurse(self):
833
self.get_branch_config('http://www.example.com')
835
self.my_location_config._get_option_policy(
836
'http://www.example.com', 'norecurse_option'),
837
config.POLICY_NORECURSE)
838
# Test old recurse=False setting:
840
self.my_location_config._get_option_policy(
841
'http://www.example.com/norecurse', 'normal_option'),
842
config.POLICY_NORECURSE)
844
def test__get_option_policy_normal(self):
845
self.get_branch_config('http://www.example.com')
847
self.my_location_config._get_option_policy(
848
'http://www.example.com', 'appendpath_option'),
849
config.POLICY_APPENDPATH)
378
def test__get_section_no_match(self):
379
self.get_location_config('/')
380
self.assertEqual(None, self.my_config._get_section())
382
def test__get_section_exact(self):
383
self.get_location_config('http://www.example.com')
384
self.assertEqual('http://www.example.com',
385
self.my_config._get_section())
387
def test__get_section_suffix_does_not(self):
388
self.get_location_config('http://www.example.com-com')
389
self.assertEqual(None, self.my_config._get_section())
391
def test__get_section_subdir_recursive(self):
392
self.get_location_config('http://www.example.com/com')
393
self.assertEqual('http://www.example.com',
394
self.my_config._get_section())
396
def test__get_section_subdir_matches(self):
397
self.get_location_config('http://www.example.com/useglobal')
398
self.assertEqual('http://www.example.com/useglobal',
399
self.my_config._get_section())
401
def test__get_section_subdir_nonrecursive(self):
402
self.get_location_config(
403
'http://www.example.com/useglobal/childbranch')
404
self.assertEqual('http://www.example.com',
405
self.my_config._get_section())
407
def test__get_section_subdir_trailing_slash(self):
408
self.get_location_config('/b')
409
self.assertEqual('/b/', self.my_config._get_section())
411
def test__get_section_subdir_child(self):
412
self.get_location_config('/a/foo')
413
self.assertEqual('/a/*', self.my_config._get_section())
415
def test__get_section_subdir_child_child(self):
416
self.get_location_config('/a/foo/bar')
417
self.assertEqual('/a/', self.my_config._get_section())
419
def test__get_section_trailing_slash_with_children(self):
420
self.get_location_config('/a/')
421
self.assertEqual('/a/', self.my_config._get_section())
423
def test__get_section_explicit_over_glob(self):
424
self.get_location_config('/a/c')
425
self.assertEqual('/a/c', self.my_config._get_section())
427
def get_location_config(self, location, global_config=None):
428
if global_config is None:
429
global_file = StringIO(sample_config_text)
431
global_file = StringIO(global_config)
432
branches_file = StringIO(sample_branches_text)
433
self.my_config = config.LocationConfig(location)
434
self.my_config._get_parser(branches_file)
435
self.my_config._get_global_config()._get_parser(global_file)
851
437
def test_location_without_username(self):
852
self.get_branch_config('http://www.example.com/ignoreparent')
853
self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
438
self.get_location_config('http://www.example.com/useglobal')
439
self.assertEqual('Robert Collins <robertc@example.com>',
854
440
self.my_config.username())
856
442
def test_location_not_listed(self):
857
"""Test that the global username is used when no location matches"""
858
self.get_branch_config('/home/robertc/sources')
859
self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
443
self.get_location_config('/home/robertc/sources')
444
self.assertEqual('Robert Collins <robertc@example.com>',
860
445
self.my_config.username())
862
447
def test_overriding_location(self):
863
self.get_branch_config('http://www.example.com/foo')
448
self.get_location_config('http://www.example.com/foo')
864
449
self.assertEqual('Robert Collins <robertc@example.org>',
865
450
self.my_config.username())
867
452
def test_signatures_not_set(self):
868
self.get_branch_config('http://www.example.com',
453
self.get_location_config('http://www.example.com',
869
454
global_config=sample_ignore_signatures)
870
self.assertEqual(config.CHECK_ALWAYS,
455
self.assertEqual(config.CHECK_NEVER,
871
456
self.my_config.signature_checking())
872
self.assertEqual(config.SIGN_NEVER,
873
self.my_config.signing_policy())
875
458
def test_signatures_never(self):
876
self.get_branch_config('/a/c')
459
self.get_location_config('/a/c')
877
460
self.assertEqual(config.CHECK_NEVER,
878
461
self.my_config.signature_checking())
880
463
def test_signatures_when_available(self):
881
self.get_branch_config('/a/', global_config=sample_ignore_signatures)
464
self.get_location_config('/a/', global_config=sample_ignore_signatures)
882
465
self.assertEqual(config.CHECK_IF_POSSIBLE,
883
466
self.my_config.signature_checking())
885
468
def test_signatures_always(self):
886
self.get_branch_config('/b')
469
self.get_location_config('/b')
887
470
self.assertEqual(config.CHECK_ALWAYS,
888
471
self.my_config.signature_checking())
890
473
def test_gpg_signing_command(self):
891
self.get_branch_config('/b')
474
self.get_location_config('/b')
892
475
self.assertEqual("gnome-gpg", self.my_config.gpg_signing_command())
894
477
def test_gpg_signing_command_missing(self):
895
self.get_branch_config('/a')
478
self.get_location_config('/a')
896
479
self.assertEqual("false", self.my_config.gpg_signing_command())
898
481
def test_get_user_option_global(self):
899
self.get_branch_config('/a')
482
self.get_location_config('/a')
900
483
self.assertEqual('something',
901
484
self.my_config.get_user_option('user_global_option'))
903
486
def test_get_user_option_local(self):
904
self.get_branch_config('/a')
487
self.get_location_config('/a')
905
488
self.assertEqual('local',
906
489
self.my_config.get_user_option('user_local_option'))
908
def test_get_user_option_appendpath(self):
909
# returned as is for the base path:
910
self.get_branch_config('http://www.example.com')
911
self.assertEqual('append',
912
self.my_config.get_user_option('appendpath_option'))
913
# Extra path components get appended:
914
self.get_branch_config('http://www.example.com/a/b/c')
915
self.assertEqual('append/a/b/c',
916
self.my_config.get_user_option('appendpath_option'))
917
# Overriden for http://www.example.com/dir, where it is a
919
self.get_branch_config('http://www.example.com/dir/a/b/c')
920
self.assertEqual('normal',
921
self.my_config.get_user_option('appendpath_option'))
923
def test_get_user_option_norecurse(self):
924
self.get_branch_config('http://www.example.com')
925
self.assertEqual('norecurse',
926
self.my_config.get_user_option('norecurse_option'))
927
self.get_branch_config('http://www.example.com/dir')
928
self.assertEqual(None,
929
self.my_config.get_user_option('norecurse_option'))
930
# http://www.example.com/norecurse is a recurse=False section
931
# that redefines normal_option. Subdirectories do not pick up
933
self.get_branch_config('http://www.example.com/norecurse')
934
self.assertEqual('norecurse',
935
self.my_config.get_user_option('normal_option'))
936
self.get_branch_config('http://www.example.com/norecurse/subdir')
937
self.assertEqual('normal',
938
self.my_config.get_user_option('normal_option'))
940
def test_set_user_option_norecurse(self):
941
self.get_branch_config('http://www.example.com')
942
self.my_config.set_user_option('foo', 'bar',
943
store=config.STORE_LOCATION_NORECURSE)
945
self.my_location_config._get_option_policy(
946
'http://www.example.com', 'foo'),
947
config.POLICY_NORECURSE)
949
def test_set_user_option_appendpath(self):
950
self.get_branch_config('http://www.example.com')
951
self.my_config.set_user_option('foo', 'bar',
952
store=config.STORE_LOCATION_APPENDPATH)
954
self.my_location_config._get_option_policy(
955
'http://www.example.com', 'foo'),
956
config.POLICY_APPENDPATH)
958
def test_set_user_option_change_policy(self):
959
self.get_branch_config('http://www.example.com')
960
self.my_config.set_user_option('norecurse_option', 'normal',
961
store=config.STORE_LOCATION)
963
self.my_location_config._get_option_policy(
964
'http://www.example.com', 'norecurse_option'),
967
def test_set_user_option_recurse_false_section(self):
968
# The following section has recurse=False set. The test is to
969
# make sure that a normal option can be added to the section,
970
# converting recurse=False to the norecurse policy.
971
self.get_branch_config('http://www.example.com/norecurse')
972
self.callDeprecated(['The recurse option is deprecated as of 0.14. '
973
'The section "http://www.example.com/norecurse" '
974
'has been converted to use policies.'],
975
self.my_config.set_user_option,
976
'foo', 'bar', store=config.STORE_LOCATION)
978
self.my_location_config._get_option_policy(
979
'http://www.example.com/norecurse', 'foo'),
981
# The previously existing option is still norecurse:
983
self.my_location_config._get_option_policy(
984
'http://www.example.com/norecurse', 'normal_option'),
985
config.POLICY_NORECURSE)
987
491
def test_post_commit_default(self):
988
self.get_branch_config('/a/c')
492
self.get_location_config('/a/c')
989
493
self.assertEqual('bzrlib.tests.test_config.post_commit',
990
494
self.my_config.post_commit())
992
def get_branch_config(self, location, global_config=None):
497
class TestLocationConfig(TestCaseInTempDir):
499
def get_location_config(self, location, global_config=None):
993
500
if global_config is None:
994
global_file = StringIO(sample_config_text.encode('utf-8'))
501
global_file = StringIO(sample_config_text)
996
global_file = StringIO(global_config.encode('utf-8'))
997
branches_file = StringIO(sample_branches_text.encode('utf-8'))
998
self.my_config = config.BranchConfig(FakeBranch(location))
999
# Force location config to use specified file
1000
self.my_location_config = self.my_config._get_location_config()
1001
self.my_location_config._get_parser(branches_file)
1002
# Force global config to use specified file
503
global_file = StringIO(global_config)
504
branches_file = StringIO(sample_branches_text)
505
self.my_config = config.LocationConfig(location)
506
self.my_config._get_parser(branches_file)
1003
507
self.my_config._get_global_config()._get_parser(global_file)
1005
509
def test_set_user_setting_sets_and_saves(self):
1006
self.get_branch_config('/a/c')
510
self.get_location_config('/a/c')
1007
511
record = InstrumentedConfigObj("foo")
1008
self.my_location_config._parser = record
512
self.my_config._parser = record
1010
514
real_mkdir = os.mkdir
1011
515
self.created = False
1030
530
('__setitem__', '/a/c', {}),
1031
531
('__getitem__', '/a/c'),
1032
532
('__setitem__', 'foo', 'bar'),
1033
('__getitem__', '/a/c'),
1034
('as_bool', 'recurse'),
1035
('__getitem__', '/a/c'),
1036
('__delitem__', 'recurse'),
1037
('__getitem__', '/a/c'),
1039
('__getitem__', '/a/c'),
1040
('__contains__', 'foo:policy'),
1042
534
record._calls[1:])
1044
def test_set_user_setting_sets_and_saves2(self):
1045
self.get_branch_config('/a/c')
1046
self.assertIs(self.my_config.get_user_option('foo'), None)
1047
self.my_config.set_user_option('foo', 'bar')
1049
self.my_config.branch.control_files.files['branch.conf'].strip(),
1051
self.assertEqual(self.my_config.get_user_option('foo'), 'bar')
1052
self.my_config.set_user_option('foo', 'baz',
1053
store=config.STORE_LOCATION)
1054
self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
1055
self.my_config.set_user_option('foo', 'qux')
1056
self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
1058
def test_get_bzr_remote_path(self):
1059
my_config = config.LocationConfig('/a/c')
1060
self.assertEqual('bzr', my_config.get_bzr_remote_path())
1061
my_config.set_user_option('bzr_remote_path', '/path-bzr')
1062
self.assertEqual('/path-bzr', my_config.get_bzr_remote_path())
1063
os.environ['BZR_REMOTE_PATH'] = '/environ-bzr'
1064
self.assertEqual('/environ-bzr', my_config.get_bzr_remote_path())
1067
precedence_global = 'option = global'
1068
precedence_branch = 'option = branch'
1069
precedence_location = """
1073
[http://example.com/specific]
1078
class TestBranchConfigItems(tests.TestCaseInTempDir):
1080
def get_branch_config(self, global_config=None, location=None,
1081
location_config=None, branch_data_config=None):
1082
my_config = config.BranchConfig(FakeBranch(location))
1083
if global_config is not None:
1084
global_file = StringIO(global_config.encode('utf-8'))
1085
my_config._get_global_config()._get_parser(global_file)
1086
self.my_location_config = my_config._get_location_config()
1087
if location_config is not None:
1088
location_file = StringIO(location_config.encode('utf-8'))
1089
self.my_location_config._get_parser(location_file)
1090
if branch_data_config is not None:
1091
my_config.branch.control_files.files['branch.conf'] = \
537
class TestBranchConfigItems(TestCase):
1095
539
def test_user_id(self):
1096
branch = FakeBranch(user_id='Robert Collins <robertc@example.net>')
540
branch = FakeBranch()
1097
541
my_config = config.BranchConfig(branch)
1098
542
self.assertEqual("Robert Collins <robertc@example.net>",
1099
my_config.username())
1100
my_config.branch.control_files.files['email'] = "John"
1101
my_config.set_user_option('email',
1102
"Robert Collins <robertc@example.org>")
1103
self.assertEqual("John", my_config.username())
1104
del my_config.branch.control_files.files['email']
1105
self.assertEqual("Robert Collins <robertc@example.org>",
1106
my_config.username())
543
my_config._get_user_id())
544
branch.email = "John"
545
self.assertEqual("John", my_config._get_user_id())
1108
547
def test_not_set_in_branch(self):
1109
my_config = self.get_branch_config(sample_config_text)
1110
self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
548
branch = FakeBranch()
549
my_config = config.BranchConfig(branch)
551
config_file = StringIO(sample_config_text)
552
(my_config._get_location_config().
553
_get_global_config()._get_parser(config_file))
554
self.assertEqual("Robert Collins <robertc@example.com>",
1111
555
my_config._get_user_id())
1112
my_config.branch.control_files.files['email'] = "John"
556
branch.email = "John"
1113
557
self.assertEqual("John", my_config._get_user_id())
1115
def test_BZR_EMAIL_OVERRIDES(self):
1116
os.environ['BZR_EMAIL'] = "Robert Collins <robertc@example.org>"
559
def test_BZREMAIL_OVERRIDES(self):
560
os.environ['BZREMAIL'] = "Robert Collins <robertc@example.org>"
1117
561
branch = FakeBranch()
1118
562
my_config = config.BranchConfig(branch)
1119
563
self.assertEqual("Robert Collins <robertc@example.org>",
1120
564
my_config.username())
1122
566
def test_signatures_forced(self):
1123
my_config = self.get_branch_config(
1124
global_config=sample_always_signatures)
1125
self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
1126
self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
1127
self.assertTrue(my_config.signature_needed())
1129
def test_signatures_forced_branch(self):
1130
my_config = self.get_branch_config(
1131
global_config=sample_ignore_signatures,
1132
branch_data_config=sample_always_signatures)
1133
self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
1134
self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
1135
self.assertTrue(my_config.signature_needed())
567
branch = FakeBranch()
568
my_config = config.BranchConfig(branch)
569
config_file = StringIO(sample_always_signatures)
570
(my_config._get_location_config().
571
_get_global_config()._get_parser(config_file))
572
self.assertEqual(config.CHECK_ALWAYS, my_config.signature_checking())
1137
574
def test_gpg_signing_command(self):
1138
my_config = self.get_branch_config(
1139
# branch data cannot set gpg_signing_command
1140
branch_data_config="gpg_signing_command=pgp")
1141
config_file = StringIO(sample_config_text.encode('utf-8'))
1142
my_config._get_global_config()._get_parser(config_file)
575
branch = FakeBranch()
576
my_config = config.BranchConfig(branch)
577
config_file = StringIO(sample_config_text)
578
(my_config._get_location_config().
579
_get_global_config()._get_parser(config_file))
1143
580
self.assertEqual('gnome-gpg', my_config.gpg_signing_command())
1145
582
def test_get_user_option_global(self):
1146
583
branch = FakeBranch()
1147
584
my_config = config.BranchConfig(branch)
1148
config_file = StringIO(sample_config_text.encode('utf-8'))
1149
(my_config._get_global_config()._get_parser(config_file))
585
config_file = StringIO(sample_config_text)
586
(my_config._get_location_config().
587
_get_global_config()._get_parser(config_file))
1150
588
self.assertEqual('something',
1151
589
my_config.get_user_option('user_global_option'))
1153
591
def test_post_commit_default(self):
1154
592
branch = FakeBranch()
1155
my_config = self.get_branch_config(sample_config_text, '/a/c',
1156
sample_branches_text)
1157
self.assertEqual(my_config.branch.base, '/a/c')
1158
self.assertEqual('bzrlib.tests.test_config.post_commit',
1159
my_config.post_commit())
1160
my_config.set_user_option('post_commit', 'rmtree_root')
1161
# post-commit is ignored when bresent in branch data
1162
self.assertEqual('bzrlib.tests.test_config.post_commit',
1163
my_config.post_commit())
1164
my_config.set_user_option('post_commit', 'rmtree_root',
1165
store=config.STORE_LOCATION)
1166
self.assertEqual('rmtree_root', my_config.post_commit())
1168
def test_config_precedence(self):
1169
my_config = self.get_branch_config(global_config=precedence_global)
1170
self.assertEqual(my_config.get_user_option('option'), 'global')
1171
my_config = self.get_branch_config(global_config=precedence_global,
1172
branch_data_config=precedence_branch)
1173
self.assertEqual(my_config.get_user_option('option'), 'branch')
1174
my_config = self.get_branch_config(global_config=precedence_global,
1175
branch_data_config=precedence_branch,
1176
location_config=precedence_location)
1177
self.assertEqual(my_config.get_user_option('option'), 'recurse')
1178
my_config = self.get_branch_config(global_config=precedence_global,
1179
branch_data_config=precedence_branch,
1180
location_config=precedence_location,
1181
location='http://example.com/specific')
1182
self.assertEqual(my_config.get_user_option('option'), 'exact')
1184
def test_get_mail_client(self):
1185
config = self.get_branch_config()
1186
client = config.get_mail_client()
1187
self.assertIsInstance(client, mail_client.DefaultMail)
1190
config.set_user_option('mail_client', 'evolution')
1191
client = config.get_mail_client()
1192
self.assertIsInstance(client, mail_client.Evolution)
1194
config.set_user_option('mail_client', 'kmail')
1195
client = config.get_mail_client()
1196
self.assertIsInstance(client, mail_client.KMail)
1198
config.set_user_option('mail_client', 'mutt')
1199
client = config.get_mail_client()
1200
self.assertIsInstance(client, mail_client.Mutt)
1202
config.set_user_option('mail_client', 'thunderbird')
1203
client = config.get_mail_client()
1204
self.assertIsInstance(client, mail_client.Thunderbird)
1207
config.set_user_option('mail_client', 'default')
1208
client = config.get_mail_client()
1209
self.assertIsInstance(client, mail_client.DefaultMail)
1211
config.set_user_option('mail_client', 'editor')
1212
client = config.get_mail_client()
1213
self.assertIsInstance(client, mail_client.Editor)
1215
config.set_user_option('mail_client', 'mapi')
1216
client = config.get_mail_client()
1217
self.assertIsInstance(client, mail_client.MAPIClient)
1219
config.set_user_option('mail_client', 'xdg-email')
1220
client = config.get_mail_client()
1221
self.assertIsInstance(client, mail_client.XDGEmail)
1223
config.set_user_option('mail_client', 'firebird')
1224
self.assertRaises(errors.UnknownMailClient, config.get_mail_client)
1227
class TestMailAddressExtraction(tests.TestCase):
594
my_config = config.BranchConfig(branch)
595
config_file = StringIO(sample_config_text)
596
(my_config._get_location_config().
597
_get_global_config()._get_parser(config_file))
598
branch_file = StringIO(sample_branches_text)
599
my_config._get_location_config()._get_parser(branch_file)
600
self.assertEqual('bzrlib.tests.test_config.post_commit',
601
my_config.post_commit())
604
class TestMailAddressExtraction(TestCase):
1229
606
def test_extract_email_address(self):
1230
607
self.assertEqual('jane@test.com',
1231
608
config.extract_email_address('Jane <jane@test.com>'))
1232
self.assertRaises(errors.NoEmailInUsername,
609
self.assertRaises(errors.BzrError,
1233
610
config.extract_email_address, 'Jane Tester')
1235
def test_parse_username(self):
1236
self.assertEqual(('', 'jdoe@example.com'),
1237
config.parse_username('jdoe@example.com'))
1238
self.assertEqual(('', 'jdoe@example.com'),
1239
config.parse_username('<jdoe@example.com>'))
1240
self.assertEqual(('John Doe', 'jdoe@example.com'),
1241
config.parse_username('John Doe <jdoe@example.com>'))
1242
self.assertEqual(('John Doe', ''),
1243
config.parse_username('John Doe'))
1244
self.assertEqual(('John Doe', 'jdoe@example.com'),
1245
config.parse_username('John Doe jdoe@example.com'))
1247
class TestTreeConfig(tests.TestCaseWithTransport):
1249
def test_get_value(self):
1250
"""Test that retreiving a value from a section is possible"""
1251
branch = self.make_branch('.')
1252
tree_config = config.TreeConfig(branch)
1253
tree_config.set_option('value', 'key', 'SECTION')
1254
tree_config.set_option('value2', 'key2')
1255
tree_config.set_option('value3-top', 'key3')
1256
tree_config.set_option('value3-section', 'key3', 'SECTION')
1257
value = tree_config.get_option('key', 'SECTION')
1258
self.assertEqual(value, 'value')
1259
value = tree_config.get_option('key2')
1260
self.assertEqual(value, 'value2')
1261
self.assertEqual(tree_config.get_option('non-existant'), None)
1262
value = tree_config.get_option('non-existant', 'SECTION')
1263
self.assertEqual(value, None)
1264
value = tree_config.get_option('non-existant', default='default')
1265
self.assertEqual(value, 'default')
1266
self.assertEqual(tree_config.get_option('key2', 'NOSECTION'), None)
1267
value = tree_config.get_option('key2', 'NOSECTION', default='default')
1268
self.assertEqual(value, 'default')
1269
value = tree_config.get_option('key3')
1270
self.assertEqual(value, 'value3-top')
1271
value = tree_config.get_option('key3', 'SECTION')
1272
self.assertEqual(value, 'value3-section')
1275
class TestTransportConfig(tests.TestCaseWithTransport):
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('.'),
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',
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')
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())
1315
class TestAuthenticationConfigFile(tests.TestCase):
1316
"""Test the authentication.conf file matching"""
1318
def _got_user_passwd(self, expected_user, expected_password,
1319
config, *args, **kwargs):
1320
credentials = config.get_credentials(*args, **kwargs)
1321
if credentials is None:
1325
user = credentials['user']
1326
password = credentials['password']
1327
self.assertEquals(expected_user, user)
1328
self.assertEquals(expected_password, password)
1330
def test_empty_config(self):
1331
conf = config.AuthenticationConfig(_file=StringIO())
1332
self.assertEquals({}, conf._get_config())
1333
self._got_user_passwd(None, None, conf, 'http', 'foo.net')
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')
1339
def test_auth_section_header_not_closed(self):
1340
conf = config.AuthenticationConfig(_file=StringIO('[DEF'))
1341
self.assertRaises(errors.ParseConfigError, conf._get_config)
1343
def test_auth_value_not_boolean(self):
1344
conf = config.AuthenticationConfig(_file=StringIO(
1348
verify_certificates=askme # Error: Not a boolean
1350
self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1352
def test_auth_value_not_int(self):
1353
conf = config.AuthenticationConfig(_file=StringIO(
1357
port=port # Error: Not an int
1359
self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1361
def test_unknown_password_encoding(self):
1362
conf = config.AuthenticationConfig(_file=StringIO(
1366
password_encoding=unknown
1368
self.assertRaises(ValueError, conf.get_password,
1369
'ftp', 'foo.net', 'joe')
1371
def test_credentials_for_scheme_host(self):
1372
conf = config.AuthenticationConfig(_file=StringIO(
1373
"""# Identity on foo.net
1378
password=secret-pass
1381
self._got_user_passwd('joe', 'secret-pass', conf, 'ftp', 'foo.net')
1383
self._got_user_passwd(None, None, conf, 'http', 'foo.net')
1385
self._got_user_passwd(None, None, conf, 'ftp', 'bar.net')
1387
def test_credentials_for_host_port(self):
1388
conf = config.AuthenticationConfig(_file=StringIO(
1389
"""# Identity on foo.net
1395
password=secret-pass
1398
self._got_user_passwd('joe', 'secret-pass',
1399
conf, 'ftp', 'foo.net', port=10021)
1401
self._got_user_passwd(None, None, conf, 'ftp', 'foo.net')
1403
def test_for_matching_host(self):
1404
conf = config.AuthenticationConfig(_file=StringIO(
1405
"""# Identity on foo.net
1411
[sourceforge domain]
1418
self._got_user_passwd('georges', 'bendover',
1419
conf, 'bzr', 'foo.bzr.sf.net')
1421
self._got_user_passwd(None, None,
1422
conf, 'bzr', 'bbzr.sf.net')
1424
def test_for_matching_host_None(self):
1425
conf = config.AuthenticationConfig(_file=StringIO(
1426
"""# Identity on foo.net
1436
self._got_user_passwd('joe', 'joepass',
1437
conf, 'bzr', 'quux.net')
1438
# no host but different scheme
1439
self._got_user_passwd('georges', 'bendover',
1440
conf, 'ftp', 'quux.net')
1442
def test_credentials_for_path(self):
1443
conf = config.AuthenticationConfig(_file=StringIO(
1459
self._got_user_passwd(None, None,
1460
conf, 'http', host='bar.org', path='/dir3')
1462
self._got_user_passwd('georges', 'bendover',
1463
conf, 'http', host='bar.org', path='/dir2')
1465
self._got_user_passwd('jim', 'jimpass',
1466
conf, 'http', host='bar.org',path='/dir1/subdir')
1468
def test_credentials_for_user(self):
1469
conf = config.AuthenticationConfig(_file=StringIO(
1478
self._got_user_passwd('jim', 'jimpass',
1479
conf, 'http', 'bar.org')
1481
self._got_user_passwd('jim', 'jimpass',
1482
conf, 'http', 'bar.org', user='jim')
1483
# Don't get a different user if one is specified
1484
self._got_user_passwd(None, None,
1485
conf, 'http', 'bar.org', user='georges')
1487
def test_credentials_for_user_without_password(self):
1488
conf = config.AuthenticationConfig(_file=StringIO(
1495
# Get user but no password
1496
self._got_user_passwd('jim', None,
1497
conf, 'http', 'bar.org')
1499
def test_verify_certificates(self):
1500
conf = config.AuthenticationConfig(_file=StringIO(
1507
verify_certificates=False
1514
credentials = conf.get_credentials('https', 'bar.org')
1515
self.assertEquals(False, credentials.get('verify_certificates'))
1516
credentials = conf.get_credentials('https', 'foo.net')
1517
self.assertEquals(True, credentials.get('verify_certificates'))
1520
class TestAuthenticationStorage(tests.TestCaseInTempDir):
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',
1529
CREDENTIALS = {'name': 'name', 'user': 'user', 'password': 'password',
1530
'verify_certificates': False, 'scheme': 'scheme',
1531
'host': 'host', 'port': 99, 'path': '/foo',
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)
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)
1551
class TestAuthenticationConfig(tests.TestCase):
1552
"""Test AuthenticationConfig behaviour"""
1554
def _check_default_password_prompt(self, expected_prompt_format, scheme,
1555
host=None, port=None, realm=None,
1559
user, password = 'jim', 'precious'
1560
expected_prompt = expected_prompt_format % {
1561
'scheme': scheme, 'host': host, 'port': port,
1562
'user': user, 'realm': realm}
1564
stdout = tests.StringIOWrapper()
1565
stderr = tests.StringIOWrapper()
1566
ui.ui_factory = tests.TestUIFactory(stdin=password + '\n',
1567
stdout=stdout, stderr=stderr)
1568
# We use an empty conf so that the user is always prompted
1569
conf = config.AuthenticationConfig()
1570
self.assertEquals(password,
1571
conf.get_password(scheme, host, user, port=port,
1572
realm=realm, path=path))
1573
self.assertEquals(expected_prompt, stderr.getvalue())
1574
self.assertEquals('', stdout.getvalue())
1576
def _check_default_username_prompt(self, expected_prompt_format, scheme,
1577
host=None, port=None, realm=None,
1582
expected_prompt = expected_prompt_format % {
1583
'scheme': scheme, 'host': host, 'port': port,
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())
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)
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"))
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)
1619
# SMTP port handling is a bit special (it's handled if embedded in the
1621
# FIXME: should we: forbid that, extend it to other schemes, leave
1622
# things as they are that's fine thank you ?
1623
self._check_default_password_prompt('SMTP %(user)s@%(host)s password: ',
1625
self._check_default_password_prompt('SMTP %(user)s@%(host)s password: ',
1626
'smtp', host='bar.org:10025')
1627
self._check_default_password_prompt(
1628
'SMTP %(user)s@%(host)s:%(port)d password: ',
1631
def test_ssh_password_emits_warning(self):
1632
conf = config.AuthenticationConfig(_file=StringIO(
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)
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(
1652
'password ignored in section \[ssh with password\]')
1654
def test_ssh_without_password_doesnt_emit_warning(self):
1655
conf = config.AuthenticationConfig(_file=StringIO(
1662
entered_password = 'typed-by-hand'
1663
stdout = tests.StringIOWrapper()
1664
stderr = tests.StringIOWrapper()
1665
ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
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
1675
self.assertNotContainsRe(
1677
'password ignored in section \[ssh with password\]')
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"])
1691
class StubCredentialStore(config.CredentialStore):
1697
def add_credentials(self, scheme, host, user, password=None):
1698
self._username[(scheme, host)] = user
1699
self._password[(scheme, host)] = password
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:
1706
return { "scheme": scheme, "host": host, "port": port,
1707
"user": self._username[key], "password": self._password[key]}
1710
class CountingCredentialStore(config.CredentialStore):
1715
def get_credentials(self, scheme, host, port=None, user=None,
1716
path=None, realm=None):
1721
class TestCredentialStoreRegistry(tests.TestCase):
1723
def _get_cs_registry(self):
1724
return config.credential_store_registry
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)
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')
1737
def test_fallback_none_registered(self):
1738
r = config.CredentialStoreRegistry()
1739
self.assertEquals(None,
1740
r.get_fallback_credentials("http", "example.com"))
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())
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)
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"))
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)
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"])
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"])
1796
class TestPlainTextCredentialStore(tests.TestCase):
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)
1805
# FIXME: Once we have a way to declare authentication to all test servers, we
1806
# can implement generic tests.
1807
# test_user_password_in_url
1808
# test_user_in_url_password_from_config
1809
# test_user_in_url_password_prompted
1810
# test_user_in_config
1811
# test_user_getpass.getuser
1812
# test_user_prompted ?
1813
class TestAuthenticationRing(tests.TestCaseWithTransport):
added
removed
bzrlib/tests/test_config.py
