725
406
# This is testing the correct file names are provided.
726
407
# TODO: consolidate with the test for GlobalConfigs filename checks.
728
# replace the class that is constructed, to check its parameters
409
# replace the class that is constructured, to check its parameters
729
410
oldparserclass = config.ConfigObj
730
411
config.ConfigObj = InstrumentedConfigObj
412
my_config = config.LocationConfig('http://www.example.com')
732
my_config = config.LocationConfig('http://www.example.com')
733
414
parser = my_config._get_parser()
735
416
config.ConfigObj = oldparserclass
736
417
self.failUnless(isinstance(parser, InstrumentedConfigObj))
737
418
self.assertEqual(parser._calls,
738
[('__init__', config.locations_config_filename(),
740
config.ensure_config_dir_exists()
741
#os.mkdir(config.config_dir())
742
f = file(config.branches_config_filename(), 'wb')
745
oldparserclass = config.ConfigObj
746
config.ConfigObj = InstrumentedConfigObj
748
my_config = config.LocationConfig('http://www.example.com')
749
parser = my_config._get_parser()
751
config.ConfigObj = oldparserclass
419
[('__init__', config.branches_config_filename())])
753
421
def test_get_global_config(self):
754
my_config = config.BranchConfig(FakeBranch('http://example.com'))
422
my_config = config.LocationConfig('http://example.com')
755
423
global_config = my_config._get_global_config()
756
424
self.failUnless(isinstance(global_config, config.GlobalConfig))
757
425
self.failUnless(global_config is my_config._get_global_config())
759
def test__get_matching_sections_no_match(self):
760
self.get_branch_config('/')
761
self.assertEqual([], self.my_location_config._get_matching_sections())
763
def test__get_matching_sections_exact(self):
764
self.get_branch_config('http://www.example.com')
765
self.assertEqual([('http://www.example.com', '')],
766
self.my_location_config._get_matching_sections())
768
def test__get_matching_sections_suffix_does_not(self):
769
self.get_branch_config('http://www.example.com-com')
770
self.assertEqual([], self.my_location_config._get_matching_sections())
772
def test__get_matching_sections_subdir_recursive(self):
773
self.get_branch_config('http://www.example.com/com')
774
self.assertEqual([('http://www.example.com', 'com')],
775
self.my_location_config._get_matching_sections())
777
def test__get_matching_sections_ignoreparent(self):
778
self.get_branch_config('http://www.example.com/ignoreparent')
779
self.assertEqual([('http://www.example.com/ignoreparent', '')],
780
self.my_location_config._get_matching_sections())
782
def test__get_matching_sections_ignoreparent_subdir(self):
783
self.get_branch_config(
784
'http://www.example.com/ignoreparent/childbranch')
785
self.assertEqual([('http://www.example.com/ignoreparent',
787
self.my_location_config._get_matching_sections())
789
def test__get_matching_sections_subdir_trailing_slash(self):
790
self.get_branch_config('/b')
791
self.assertEqual([('/b/', '')],
792
self.my_location_config._get_matching_sections())
794
def test__get_matching_sections_subdir_child(self):
795
self.get_branch_config('/a/foo')
796
self.assertEqual([('/a/*', ''), ('/a/', 'foo')],
797
self.my_location_config._get_matching_sections())
799
def test__get_matching_sections_subdir_child_child(self):
800
self.get_branch_config('/a/foo/bar')
801
self.assertEqual([('/a/*', 'bar'), ('/a/', 'foo/bar')],
802
self.my_location_config._get_matching_sections())
804
def test__get_matching_sections_trailing_slash_with_children(self):
805
self.get_branch_config('/a/')
806
self.assertEqual([('/a/', '')],
807
self.my_location_config._get_matching_sections())
809
def test__get_matching_sections_explicit_over_glob(self):
810
# XXX: 2006-09-08 jamesh
811
# This test only passes because ord('c') > ord('*'). If there
812
# was a config section for '/a/?', it would get precedence
814
self.get_branch_config('/a/c')
815
self.assertEqual([('/a/c', ''), ('/a/*', ''), ('/a/', 'c')],
816
self.my_location_config._get_matching_sections())
818
def test__get_option_policy_normal(self):
819
self.get_branch_config('http://www.example.com')
821
self.my_location_config._get_config_policy(
822
'http://www.example.com', 'normal_option'),
825
def test__get_option_policy_norecurse(self):
826
self.get_branch_config('http://www.example.com')
828
self.my_location_config._get_option_policy(
829
'http://www.example.com', 'norecurse_option'),
830
config.POLICY_NORECURSE)
831
# Test old recurse=False setting:
833
self.my_location_config._get_option_policy(
834
'http://www.example.com/norecurse', 'normal_option'),
835
config.POLICY_NORECURSE)
837
def test__get_option_policy_normal(self):
838
self.get_branch_config('http://www.example.com')
840
self.my_location_config._get_option_policy(
841
'http://www.example.com', 'appendpath_option'),
842
config.POLICY_APPENDPATH)
427
def test__get_section_no_match(self):
428
self.get_location_config('/')
429
self.assertEqual(None, self.my_config._get_section())
431
def test__get_section_exact(self):
432
self.get_location_config('http://www.example.com')
433
self.assertEqual('http://www.example.com',
434
self.my_config._get_section())
436
def test__get_section_suffix_does_not(self):
437
self.get_location_config('http://www.example.com-com')
438
self.assertEqual(None, self.my_config._get_section())
440
def test__get_section_subdir_recursive(self):
441
self.get_location_config('http://www.example.com/com')
442
self.assertEqual('http://www.example.com',
443
self.my_config._get_section())
445
def test__get_section_subdir_matches(self):
446
self.get_location_config('http://www.example.com/useglobal')
447
self.assertEqual('http://www.example.com/useglobal',
448
self.my_config._get_section())
450
def test__get_section_subdir_nonrecursive(self):
451
self.get_location_config(
452
'http://www.example.com/useglobal/childbranch')
453
self.assertEqual('http://www.example.com',
454
self.my_config._get_section())
456
def test__get_section_subdir_trailing_slash(self):
457
self.get_location_config('/b')
458
self.assertEqual('/b/', self.my_config._get_section())
460
def test__get_section_subdir_child(self):
461
self.get_location_config('/a/foo')
462
self.assertEqual('/a/*', self.my_config._get_section())
464
def test__get_section_subdir_child_child(self):
465
self.get_location_config('/a/foo/bar')
466
self.assertEqual('/a/', self.my_config._get_section())
468
def test__get_section_trailing_slash_with_children(self):
469
self.get_location_config('/a/')
470
self.assertEqual('/a/', self.my_config._get_section())
472
def test__get_section_explicit_over_glob(self):
473
self.get_location_config('/a/c')
474
self.assertEqual('/a/c', self.my_config._get_section())
476
def get_location_config(self, location, global_config=None):
477
if global_config is None:
478
global_file = StringIO(sample_config_text)
480
global_file = StringIO(global_config)
481
branches_file = StringIO(sample_branches_text)
482
self.my_config = config.LocationConfig(location)
483
self.my_config._get_parser(branches_file)
484
self.my_config._get_global_config()._get_parser(global_file)
844
486
def test_location_without_username(self):
845
self.get_branch_config('http://www.example.com/ignoreparent')
846
self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
487
self.get_location_config('http://www.example.com/useglobal')
488
self.assertEqual('Robert Collins <robertc@example.com>',
847
489
self.my_config.username())
849
491
def test_location_not_listed(self):
850
"""Test that the global username is used when no location matches"""
851
self.get_branch_config('/home/robertc/sources')
852
self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
492
self.get_location_config('/home/robertc/sources')
493
self.assertEqual('Robert Collins <robertc@example.com>',
853
494
self.my_config.username())
855
496
def test_overriding_location(self):
856
self.get_branch_config('http://www.example.com/foo')
497
self.get_location_config('http://www.example.com/foo')
857
498
self.assertEqual('Robert Collins <robertc@example.org>',
858
499
self.my_config.username())
860
501
def test_signatures_not_set(self):
861
self.get_branch_config('http://www.example.com',
502
self.get_location_config('http://www.example.com',
862
503
global_config=sample_ignore_signatures)
863
self.assertEqual(config.CHECK_ALWAYS,
504
self.assertEqual(config.CHECK_NEVER,
864
505
self.my_config.signature_checking())
865
self.assertEqual(config.SIGN_NEVER,
866
self.my_config.signing_policy())
868
507
def test_signatures_never(self):
869
self.get_branch_config('/a/c')
508
self.get_location_config('/a/c')
870
509
self.assertEqual(config.CHECK_NEVER,
871
510
self.my_config.signature_checking())
873
512
def test_signatures_when_available(self):
874
self.get_branch_config('/a/', global_config=sample_ignore_signatures)
513
self.get_location_config('/a/', global_config=sample_ignore_signatures)
875
514
self.assertEqual(config.CHECK_IF_POSSIBLE,
876
515
self.my_config.signature_checking())
878
517
def test_signatures_always(self):
879
self.get_branch_config('/b')
518
self.get_location_config('/b')
880
519
self.assertEqual(config.CHECK_ALWAYS,
881
520
self.my_config.signature_checking())
883
522
def test_gpg_signing_command(self):
884
self.get_branch_config('/b')
523
self.get_location_config('/b')
885
524
self.assertEqual("gnome-gpg", self.my_config.gpg_signing_command())
887
526
def test_gpg_signing_command_missing(self):
888
self.get_branch_config('/a')
527
self.get_location_config('/a')
889
528
self.assertEqual("false", self.my_config.gpg_signing_command())
891
530
def test_get_user_option_global(self):
892
self.get_branch_config('/a')
531
self.get_location_config('/a')
893
532
self.assertEqual('something',
894
533
self.my_config.get_user_option('user_global_option'))
896
535
def test_get_user_option_local(self):
897
self.get_branch_config('/a')
536
self.get_location_config('/a')
898
537
self.assertEqual('local',
899
538
self.my_config.get_user_option('user_local_option'))
901
def test_get_user_option_appendpath(self):
902
# returned as is for the base path:
903
self.get_branch_config('http://www.example.com')
904
self.assertEqual('append',
905
self.my_config.get_user_option('appendpath_option'))
906
# Extra path components get appended:
907
self.get_branch_config('http://www.example.com/a/b/c')
908
self.assertEqual('append/a/b/c',
909
self.my_config.get_user_option('appendpath_option'))
910
# Overriden for http://www.example.com/dir, where it is a
912
self.get_branch_config('http://www.example.com/dir/a/b/c')
913
self.assertEqual('normal',
914
self.my_config.get_user_option('appendpath_option'))
916
def test_get_user_option_norecurse(self):
917
self.get_branch_config('http://www.example.com')
918
self.assertEqual('norecurse',
919
self.my_config.get_user_option('norecurse_option'))
920
self.get_branch_config('http://www.example.com/dir')
921
self.assertEqual(None,
922
self.my_config.get_user_option('norecurse_option'))
923
# http://www.example.com/norecurse is a recurse=False section
924
# that redefines normal_option. Subdirectories do not pick up
926
self.get_branch_config('http://www.example.com/norecurse')
927
self.assertEqual('norecurse',
928
self.my_config.get_user_option('normal_option'))
929
self.get_branch_config('http://www.example.com/norecurse/subdir')
930
self.assertEqual('normal',
931
self.my_config.get_user_option('normal_option'))
933
def test_set_user_option_norecurse(self):
934
self.get_branch_config('http://www.example.com')
935
self.my_config.set_user_option('foo', 'bar',
936
store=config.STORE_LOCATION_NORECURSE)
938
self.my_location_config._get_option_policy(
939
'http://www.example.com', 'foo'),
940
config.POLICY_NORECURSE)
942
def test_set_user_option_appendpath(self):
943
self.get_branch_config('http://www.example.com')
944
self.my_config.set_user_option('foo', 'bar',
945
store=config.STORE_LOCATION_APPENDPATH)
947
self.my_location_config._get_option_policy(
948
'http://www.example.com', 'foo'),
949
config.POLICY_APPENDPATH)
951
def test_set_user_option_change_policy(self):
952
self.get_branch_config('http://www.example.com')
953
self.my_config.set_user_option('norecurse_option', 'normal',
954
store=config.STORE_LOCATION)
956
self.my_location_config._get_option_policy(
957
'http://www.example.com', 'norecurse_option'),
960
def test_set_user_option_recurse_false_section(self):
961
# The following section has recurse=False set. The test is to
962
# make sure that a normal option can be added to the section,
963
# converting recurse=False to the norecurse policy.
964
self.get_branch_config('http://www.example.com/norecurse')
965
self.callDeprecated(['The recurse option is deprecated as of 0.14. '
966
'The section "http://www.example.com/norecurse" '
967
'has been converted to use policies.'],
968
self.my_config.set_user_option,
969
'foo', 'bar', store=config.STORE_LOCATION)
971
self.my_location_config._get_option_policy(
972
'http://www.example.com/norecurse', 'foo'),
974
# The previously existing option is still norecurse:
976
self.my_location_config._get_option_policy(
977
'http://www.example.com/norecurse', 'normal_option'),
978
config.POLICY_NORECURSE)
980
540
def test_post_commit_default(self):
981
self.get_branch_config('/a/c')
541
self.get_location_config('/a/c')
982
542
self.assertEqual('bzrlib.tests.test_config.post_commit',
983
543
self.my_config.post_commit())
985
def get_branch_config(self, location, global_config=None):
546
class TestLocationConfig(TestCaseInTempDir):
548
def get_location_config(self, location, global_config=None):
986
549
if global_config is None:
987
550
global_file = StringIO(sample_config_text.encode('utf-8'))
989
552
global_file = StringIO(global_config.encode('utf-8'))
990
553
branches_file = StringIO(sample_branches_text.encode('utf-8'))
991
self.my_config = config.BranchConfig(FakeBranch(location))
992
# Force location config to use specified file
993
self.my_location_config = self.my_config._get_location_config()
994
self.my_location_config._get_parser(branches_file)
995
# Force global config to use specified file
554
self.my_config = config.LocationConfig(location)
555
self.my_config._get_parser(branches_file)
996
556
self.my_config._get_global_config()._get_parser(global_file)
998
558
def test_set_user_setting_sets_and_saves(self):
999
self.get_branch_config('/a/c')
559
self.get_location_config('/a/c')
1000
560
record = InstrumentedConfigObj("foo")
1001
self.my_location_config._parser = record
561
self.my_config._parser = record
1003
563
real_mkdir = os.mkdir
1004
564
self.created = False
1023
579
('__setitem__', '/a/c', {}),
1024
580
('__getitem__', '/a/c'),
1025
581
('__setitem__', 'foo', 'bar'),
1026
('__getitem__', '/a/c'),
1027
('as_bool', 'recurse'),
1028
('__getitem__', '/a/c'),
1029
('__delitem__', 'recurse'),
1030
('__getitem__', '/a/c'),
1032
('__getitem__', '/a/c'),
1033
('__contains__', 'foo:policy'),
1035
583
record._calls[1:])
1037
def test_set_user_setting_sets_and_saves2(self):
1038
self.get_branch_config('/a/c')
1039
self.assertIs(self.my_config.get_user_option('foo'), None)
1040
self.my_config.set_user_option('foo', 'bar')
1042
self.my_config.branch.control_files.files['branch.conf'].strip(),
1044
self.assertEqual(self.my_config.get_user_option('foo'), 'bar')
1045
self.my_config.set_user_option('foo', 'baz',
1046
store=config.STORE_LOCATION)
1047
self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
1048
self.my_config.set_user_option('foo', 'qux')
1049
self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
1051
def test_get_bzr_remote_path(self):
1052
my_config = config.LocationConfig('/a/c')
1053
self.assertEqual('bzr', my_config.get_bzr_remote_path())
1054
my_config.set_user_option('bzr_remote_path', '/path-bzr')
1055
self.assertEqual('/path-bzr', my_config.get_bzr_remote_path())
1056
os.environ['BZR_REMOTE_PATH'] = '/environ-bzr'
1057
self.assertEqual('/environ-bzr', my_config.get_bzr_remote_path())
1060
precedence_global = 'option = global'
1061
precedence_branch = 'option = branch'
1062
precedence_location = """
1066
[http://example.com/specific]
1071
class TestBranchConfigItems(tests.TestCaseInTempDir):
1073
def get_branch_config(self, global_config=None, location=None,
1074
location_config=None, branch_data_config=None):
1075
my_config = config.BranchConfig(FakeBranch(location))
1076
if global_config is not None:
1077
global_file = StringIO(global_config.encode('utf-8'))
1078
my_config._get_global_config()._get_parser(global_file)
1079
self.my_location_config = my_config._get_location_config()
1080
if location_config is not None:
1081
location_file = StringIO(location_config.encode('utf-8'))
1082
self.my_location_config._get_parser(location_file)
1083
if branch_data_config is not None:
1084
my_config.branch.control_files.files['branch.conf'] = \
586
class TestBranchConfigItems(TestCase):
1088
588
def test_user_id(self):
1089
branch = FakeBranch(user_id='Robert Collins <robertc@example.net>')
589
branch = FakeBranch()
1090
590
my_config = config.BranchConfig(branch)
1091
591
self.assertEqual("Robert Collins <robertc@example.net>",
1092
my_config.username())
1093
my_config.branch.control_files.files['email'] = "John"
1094
my_config.set_user_option('email',
1095
"Robert Collins <robertc@example.org>")
1096
self.assertEqual("John", my_config.username())
1097
del my_config.branch.control_files.files['email']
1098
self.assertEqual("Robert Collins <robertc@example.org>",
1099
my_config.username())
592
my_config._get_user_id())
593
branch.control_files.email = "John"
594
self.assertEqual("John", my_config._get_user_id())
1101
596
def test_not_set_in_branch(self):
1102
my_config = self.get_branch_config(sample_config_text)
597
branch = FakeBranch()
598
my_config = config.BranchConfig(branch)
599
branch.control_files.email = None
600
config_file = StringIO(sample_config_text.encode('utf-8'))
601
(my_config._get_location_config().
602
_get_global_config()._get_parser(config_file))
1103
603
self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
1104
604
my_config._get_user_id())
1105
my_config.branch.control_files.files['email'] = "John"
605
branch.control_files.email = "John"
1106
606
self.assertEqual("John", my_config._get_user_id())
1108
def test_BZR_EMAIL_OVERRIDES(self):
1109
os.environ['BZR_EMAIL'] = "Robert Collins <robertc@example.org>"
608
def test_BZREMAIL_OVERRIDES(self):
609
os.environ['BZREMAIL'] = "Robert Collins <robertc@example.org>"
1110
610
branch = FakeBranch()
1111
611
my_config = config.BranchConfig(branch)
1112
612
self.assertEqual("Robert Collins <robertc@example.org>",
1113
613
my_config.username())
1115
615
def test_signatures_forced(self):
1116
my_config = self.get_branch_config(
1117
global_config=sample_always_signatures)
1118
self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
1119
self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
1120
self.assertTrue(my_config.signature_needed())
1122
def test_signatures_forced_branch(self):
1123
my_config = self.get_branch_config(
1124
global_config=sample_ignore_signatures,
1125
branch_data_config=sample_always_signatures)
1126
self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
1127
self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
1128
self.assertTrue(my_config.signature_needed())
616
branch = FakeBranch()
617
my_config = config.BranchConfig(branch)
618
config_file = StringIO(sample_always_signatures)
619
(my_config._get_location_config().
620
_get_global_config()._get_parser(config_file))
621
self.assertEqual(config.CHECK_ALWAYS, my_config.signature_checking())
1130
623
def test_gpg_signing_command(self):
1131
my_config = self.get_branch_config(
1132
# branch data cannot set gpg_signing_command
1133
branch_data_config="gpg_signing_command=pgp")
624
branch = FakeBranch()
625
my_config = config.BranchConfig(branch)
1134
626
config_file = StringIO(sample_config_text.encode('utf-8'))
1135
my_config._get_global_config()._get_parser(config_file)
627
(my_config._get_location_config().
628
_get_global_config()._get_parser(config_file))
1136
629
self.assertEqual('gnome-gpg', my_config.gpg_signing_command())
1138
631
def test_get_user_option_global(self):
1139
632
branch = FakeBranch()
1140
633
my_config = config.BranchConfig(branch)
1141
634
config_file = StringIO(sample_config_text.encode('utf-8'))
1142
(my_config._get_global_config()._get_parser(config_file))
635
(my_config._get_location_config().
636
_get_global_config()._get_parser(config_file))
1143
637
self.assertEqual('something',
1144
638
my_config.get_user_option('user_global_option'))
1146
640
def test_post_commit_default(self):
1147
641
branch = FakeBranch()
1148
my_config = self.get_branch_config(sample_config_text, '/a/c',
1149
sample_branches_text)
1150
self.assertEqual(my_config.branch.base, '/a/c')
1151
self.assertEqual('bzrlib.tests.test_config.post_commit',
1152
my_config.post_commit())
1153
my_config.set_user_option('post_commit', 'rmtree_root')
1154
# post-commit is ignored when bresent in branch data
1155
self.assertEqual('bzrlib.tests.test_config.post_commit',
1156
my_config.post_commit())
1157
my_config.set_user_option('post_commit', 'rmtree_root',
1158
store=config.STORE_LOCATION)
1159
self.assertEqual('rmtree_root', my_config.post_commit())
1161
def test_config_precedence(self):
1162
my_config = self.get_branch_config(global_config=precedence_global)
1163
self.assertEqual(my_config.get_user_option('option'), 'global')
1164
my_config = self.get_branch_config(global_config=precedence_global,
1165
branch_data_config=precedence_branch)
1166
self.assertEqual(my_config.get_user_option('option'), 'branch')
1167
my_config = self.get_branch_config(global_config=precedence_global,
1168
branch_data_config=precedence_branch,
1169
location_config=precedence_location)
1170
self.assertEqual(my_config.get_user_option('option'), 'recurse')
1171
my_config = self.get_branch_config(global_config=precedence_global,
1172
branch_data_config=precedence_branch,
1173
location_config=precedence_location,
1174
location='http://example.com/specific')
1175
self.assertEqual(my_config.get_user_option('option'), 'exact')
1177
def test_get_mail_client(self):
1178
config = self.get_branch_config()
1179
client = config.get_mail_client()
1180
self.assertIsInstance(client, mail_client.DefaultMail)
1183
config.set_user_option('mail_client', 'evolution')
1184
client = config.get_mail_client()
1185
self.assertIsInstance(client, mail_client.Evolution)
1187
config.set_user_option('mail_client', 'kmail')
1188
client = config.get_mail_client()
1189
self.assertIsInstance(client, mail_client.KMail)
1191
config.set_user_option('mail_client', 'mutt')
1192
client = config.get_mail_client()
1193
self.assertIsInstance(client, mail_client.Mutt)
1195
config.set_user_option('mail_client', 'thunderbird')
1196
client = config.get_mail_client()
1197
self.assertIsInstance(client, mail_client.Thunderbird)
1200
config.set_user_option('mail_client', 'default')
1201
client = config.get_mail_client()
1202
self.assertIsInstance(client, mail_client.DefaultMail)
1204
config.set_user_option('mail_client', 'editor')
1205
client = config.get_mail_client()
1206
self.assertIsInstance(client, mail_client.Editor)
1208
config.set_user_option('mail_client', 'mapi')
1209
client = config.get_mail_client()
1210
self.assertIsInstance(client, mail_client.MAPIClient)
1212
config.set_user_option('mail_client', 'xdg-email')
1213
client = config.get_mail_client()
1214
self.assertIsInstance(client, mail_client.XDGEmail)
1216
config.set_user_option('mail_client', 'firebird')
1217
self.assertRaises(errors.UnknownMailClient, config.get_mail_client)
1220
class TestMailAddressExtraction(tests.TestCase):
643
my_config = config.BranchConfig(branch)
644
config_file = StringIO(sample_config_text.encode('utf-8'))
645
(my_config._get_location_config().
646
_get_global_config()._get_parser(config_file))
647
branch_file = StringIO(sample_branches_text)
648
my_config._get_location_config()._get_parser(branch_file)
649
self.assertEqual('bzrlib.tests.test_config.post_commit',
650
my_config.post_commit())
653
class TestMailAddressExtraction(TestCase):
1222
655
def test_extract_email_address(self):
1223
656
self.assertEqual('jane@test.com',
1224
657
config.extract_email_address('Jane <jane@test.com>'))
1225
self.assertRaises(errors.NoEmailInUsername,
658
self.assertRaises(errors.BzrError,
1226
659
config.extract_email_address, 'Jane Tester')
1228
def test_parse_username(self):
1229
self.assertEqual(('', 'jdoe@example.com'),
1230
config.parse_username('jdoe@example.com'))
1231
self.assertEqual(('', 'jdoe@example.com'),
1232
config.parse_username('<jdoe@example.com>'))
1233
self.assertEqual(('John Doe', 'jdoe@example.com'),
1234
config.parse_username('John Doe <jdoe@example.com>'))
1235
self.assertEqual(('John Doe', ''),
1236
config.parse_username('John Doe'))
1237
self.assertEqual(('John Doe', 'jdoe@example.com'),
1238
config.parse_username('John Doe jdoe@example.com'))
1240
class TestTreeConfig(tests.TestCaseWithTransport):
1242
def test_get_value(self):
1243
"""Test that retreiving a value from a section is possible"""
1244
branch = self.make_branch('.')
1245
tree_config = config.TreeConfig(branch)
1246
tree_config.set_option('value', 'key', 'SECTION')
1247
tree_config.set_option('value2', 'key2')
1248
tree_config.set_option('value3-top', 'key3')
1249
tree_config.set_option('value3-section', 'key3', 'SECTION')
1250
value = tree_config.get_option('key', 'SECTION')
1251
self.assertEqual(value, 'value')
1252
value = tree_config.get_option('key2')
1253
self.assertEqual(value, 'value2')
1254
self.assertEqual(tree_config.get_option('non-existant'), None)
1255
value = tree_config.get_option('non-existant', 'SECTION')
1256
self.assertEqual(value, None)
1257
value = tree_config.get_option('non-existant', default='default')
1258
self.assertEqual(value, 'default')
1259
self.assertEqual(tree_config.get_option('key2', 'NOSECTION'), None)
1260
value = tree_config.get_option('key2', 'NOSECTION', default='default')
1261
self.assertEqual(value, 'default')
1262
value = tree_config.get_option('key3')
1263
self.assertEqual(value, 'value3-top')
1264
value = tree_config.get_option('key3', 'SECTION')
1265
self.assertEqual(value, 'value3-section')
1268
class TestTransportConfig(tests.TestCaseWithTransport):
1270
def test_get_value(self):
1271
"""Test that retreiving a value from a section is possible"""
1272
bzrdir_config = config.TransportConfig(transport.get_transport('.'),
1274
bzrdir_config.set_option('value', 'key', 'SECTION')
1275
bzrdir_config.set_option('value2', 'key2')
1276
bzrdir_config.set_option('value3-top', 'key3')
1277
bzrdir_config.set_option('value3-section', 'key3', 'SECTION')
1278
value = bzrdir_config.get_option('key', 'SECTION')
1279
self.assertEqual(value, 'value')
1280
value = bzrdir_config.get_option('key2')
1281
self.assertEqual(value, 'value2')
1282
self.assertEqual(bzrdir_config.get_option('non-existant'), None)
1283
value = bzrdir_config.get_option('non-existant', 'SECTION')
1284
self.assertEqual(value, None)
1285
value = bzrdir_config.get_option('non-existant', default='default')
1286
self.assertEqual(value, 'default')
1287
self.assertEqual(bzrdir_config.get_option('key2', 'NOSECTION'), None)
1288
value = bzrdir_config.get_option('key2', 'NOSECTION',
1290
self.assertEqual(value, 'default')
1291
value = bzrdir_config.get_option('key3')
1292
self.assertEqual(value, 'value3-top')
1293
value = bzrdir_config.get_option('key3', 'SECTION')
1294
self.assertEqual(value, 'value3-section')
1296
def test_set_unset_default_stack_on(self):
1297
my_dir = self.make_bzrdir('.')
1298
bzrdir_config = config.BzrDirConfig(my_dir)
1299
self.assertIs(None, bzrdir_config.get_default_stack_on())
1300
bzrdir_config.set_default_stack_on('Foo')
1301
self.assertEqual('Foo', bzrdir_config._config.get_option(
1302
'default_stack_on'))
1303
self.assertEqual('Foo', bzrdir_config.get_default_stack_on())
1304
bzrdir_config.set_default_stack_on(None)
1305
self.assertIs(None, bzrdir_config.get_default_stack_on())
1308
class TestAuthenticationConfigFile(tests.TestCase):
1309
"""Test the authentication.conf file matching"""
1311
def _got_user_passwd(self, expected_user, expected_password,
1312
config, *args, **kwargs):
1313
credentials = config.get_credentials(*args, **kwargs)
1314
if credentials is None:
1318
user = credentials['user']
1319
password = credentials['password']
1320
self.assertEquals(expected_user, user)
1321
self.assertEquals(expected_password, password)
1323
def test_empty_config(self):
1324
conf = config.AuthenticationConfig(_file=StringIO())
1325
self.assertEquals({}, conf._get_config())
1326
self._got_user_passwd(None, None, conf, 'http', 'foo.net')
1328
def test_missing_auth_section_header(self):
1329
conf = config.AuthenticationConfig(_file=StringIO('foo = bar'))
1330
self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1332
def test_auth_section_header_not_closed(self):
1333
conf = config.AuthenticationConfig(_file=StringIO('[DEF'))
1334
self.assertRaises(errors.ParseConfigError, conf._get_config)
1336
def test_auth_value_not_boolean(self):
1337
conf = config.AuthenticationConfig(_file=StringIO(
1341
verify_certificates=askme # Error: Not a boolean
1343
self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1345
def test_auth_value_not_int(self):
1346
conf = config.AuthenticationConfig(_file=StringIO(
1350
port=port # Error: Not an int
1352
self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1354
def test_unknown_password_encoding(self):
1355
conf = config.AuthenticationConfig(_file=StringIO(
1359
password_encoding=unknown
1361
self.assertRaises(ValueError, conf.get_password,
1362
'ftp', 'foo.net', 'joe')
1364
def test_credentials_for_scheme_host(self):
1365
conf = config.AuthenticationConfig(_file=StringIO(
1366
"""# Identity on foo.net
1371
password=secret-pass
1374
self._got_user_passwd('joe', 'secret-pass', conf, 'ftp', 'foo.net')
1376
self._got_user_passwd(None, None, conf, 'http', 'foo.net')
1378
self._got_user_passwd(None, None, conf, 'ftp', 'bar.net')
1380
def test_credentials_for_host_port(self):
1381
conf = config.AuthenticationConfig(_file=StringIO(
1382
"""# Identity on foo.net
1388
password=secret-pass
1391
self._got_user_passwd('joe', 'secret-pass',
1392
conf, 'ftp', 'foo.net', port=10021)
1394
self._got_user_passwd(None, None, conf, 'ftp', 'foo.net')
1396
def test_for_matching_host(self):
1397
conf = config.AuthenticationConfig(_file=StringIO(
1398
"""# Identity on foo.net
1404
[sourceforge domain]
1411
self._got_user_passwd('georges', 'bendover',
1412
conf, 'bzr', 'foo.bzr.sf.net')
1414
self._got_user_passwd(None, None,
1415
conf, 'bzr', 'bbzr.sf.net')
1417
def test_for_matching_host_None(self):
1418
conf = config.AuthenticationConfig(_file=StringIO(
1419
"""# Identity on foo.net
1429
self._got_user_passwd('joe', 'joepass',
1430
conf, 'bzr', 'quux.net')
1431
# no host but different scheme
1432
self._got_user_passwd('georges', 'bendover',
1433
conf, 'ftp', 'quux.net')
1435
def test_credentials_for_path(self):
1436
conf = config.AuthenticationConfig(_file=StringIO(
1452
self._got_user_passwd(None, None,
1453
conf, 'http', host='bar.org', path='/dir3')
1455
self._got_user_passwd('georges', 'bendover',
1456
conf, 'http', host='bar.org', path='/dir2')
1458
self._got_user_passwd('jim', 'jimpass',
1459
conf, 'http', host='bar.org',path='/dir1/subdir')
1461
def test_credentials_for_user(self):
1462
conf = config.AuthenticationConfig(_file=StringIO(
1471
self._got_user_passwd('jim', 'jimpass',
1472
conf, 'http', 'bar.org')
1474
self._got_user_passwd('jim', 'jimpass',
1475
conf, 'http', 'bar.org', user='jim')
1476
# Don't get a different user if one is specified
1477
self._got_user_passwd(None, None,
1478
conf, 'http', 'bar.org', user='georges')
1480
def test_credentials_for_user_without_password(self):
1481
conf = config.AuthenticationConfig(_file=StringIO(
1488
# Get user but no password
1489
self._got_user_passwd('jim', None,
1490
conf, 'http', 'bar.org')
1492
def test_verify_certificates(self):
1493
conf = config.AuthenticationConfig(_file=StringIO(
1500
verify_certificates=False
1507
credentials = conf.get_credentials('https', 'bar.org')
1508
self.assertEquals(False, credentials.get('verify_certificates'))
1509
credentials = conf.get_credentials('https', 'foo.net')
1510
self.assertEquals(True, credentials.get('verify_certificates'))
1513
class TestAuthenticationStorage(tests.TestCaseInTempDir):
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',
1522
CREDENTIALS = {'name': 'name', 'user': 'user', 'password': 'password',
1523
'verify_certificates': False, 'scheme': 'scheme',
1524
'host': 'host', 'port': 99, 'path': '/foo',
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)
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)
1544
class TestAuthenticationConfig(tests.TestCase):
1545
"""Test AuthenticationConfig behaviour"""
1547
def _check_default_password_prompt(self, expected_prompt_format, scheme,
1548
host=None, port=None, realm=None,
1552
user, password = 'jim', 'precious'
1553
expected_prompt = expected_prompt_format % {
1554
'scheme': scheme, 'host': host, 'port': port,
1555
'user': user, 'realm': realm}
1557
stdout = tests.StringIOWrapper()
1558
stderr = tests.StringIOWrapper()
1559
ui.ui_factory = tests.TestUIFactory(stdin=password + '\n',
1560
stdout=stdout, stderr=stderr)
1561
# We use an empty conf so that the user is always prompted
1562
conf = config.AuthenticationConfig()
1563
self.assertEquals(password,
1564
conf.get_password(scheme, host, user, port=port,
1565
realm=realm, path=path))
1566
self.assertEquals(expected_prompt, stderr.getvalue())
1567
self.assertEquals('', stdout.getvalue())
1569
def _check_default_username_prompt(self, expected_prompt_format, scheme,
1570
host=None, port=None, realm=None,
1575
expected_prompt = expected_prompt_format % {
1576
'scheme': scheme, 'host': host, 'port': port,
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())
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)
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"))
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)
1612
# SMTP port handling is a bit special (it's handled if embedded in the
1614
# FIXME: should we: forbid that, extend it to other schemes, leave
1615
# things as they are that's fine thank you ?
1616
self._check_default_password_prompt('SMTP %(user)s@%(host)s password: ',
1618
self._check_default_password_prompt('SMTP %(user)s@%(host)s password: ',
1619
'smtp', host='bar.org:10025')
1620
self._check_default_password_prompt(
1621
'SMTP %(user)s@%(host)s:%(port)d password: ',
1624
def test_ssh_password_emits_warning(self):
1625
conf = config.AuthenticationConfig(_file=StringIO(
1633
entered_password = 'typed-by-hand'
1634
stdout = tests.StringIOWrapper()
1635
stderr = tests.StringIOWrapper()
1636
ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1637
stdout=stdout, stderr=stderr)
1639
# Since the password defined in the authentication config is ignored,
1640
# the user is prompted
1641
self.assertEquals(entered_password,
1642
conf.get_password('ssh', 'bar.org', user='jim'))
1643
self.assertContainsRe(
1645
'password ignored in section \[ssh with password\]')
1647
def test_ssh_without_password_doesnt_emit_warning(self):
1648
conf = config.AuthenticationConfig(_file=StringIO(
1655
entered_password = 'typed-by-hand'
1656
stdout = tests.StringIOWrapper()
1657
stderr = tests.StringIOWrapper()
1658
ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1662
# Since the password defined in the authentication config is ignored,
1663
# the user is prompted
1664
self.assertEquals(entered_password,
1665
conf.get_password('ssh', 'bar.org', user='jim'))
1666
# No warning shoud be emitted since there is no password. We are only
1668
self.assertNotContainsRe(
1670
'password ignored in section \[ssh with password\]')
1672
def test_uses_fallback_stores(self):
1673
self._old_cs_registry = config.credential_store_registry
1675
config.credential_store_registry = self._old_cs_registry
1676
self.addCleanup(restore)
1677
config.credential_store_registry = config.CredentialStoreRegistry()
1678
store = StubCredentialStore()
1679
store.add_credentials("http", "example.com", "joe", "secret")
1680
config.credential_store_registry.register("stub", store, fallback=True)
1681
conf = config.AuthenticationConfig(_file=StringIO())
1682
creds = conf.get_credentials("http", "example.com")
1683
self.assertEquals("joe", creds["user"])
1684
self.assertEquals("secret", creds["password"])
1687
class StubCredentialStore(config.CredentialStore):
1693
def add_credentials(self, scheme, host, user, password=None):
1694
self._username[(scheme, host)] = user
1695
self._password[(scheme, host)] = password
1697
def get_credentials(self, scheme, host, port=None, user=None,
1698
path=None, realm=None):
1699
key = (scheme, host)
1700
if not key in self._username:
1702
return { "scheme": scheme, "host": host, "port": port,
1703
"user": self._username[key], "password": self._password[key]}
1706
class CountingCredentialStore(config.CredentialStore):
1711
def get_credentials(self, scheme, host, port=None, user=None,
1712
path=None, realm=None):
1717
class TestCredentialStoreRegistry(tests.TestCase):
1719
def _get_cs_registry(self):
1720
return config.credential_store_registry
1722
def test_default_credential_store(self):
1723
r = self._get_cs_registry()
1724
default = r.get_credential_store(None)
1725
self.assertIsInstance(default, config.PlainTextCredentialStore)
1727
def test_unknown_credential_store(self):
1728
r = self._get_cs_registry()
1729
# It's hard to imagine someone creating a credential store named
1730
# 'unknown' so we use that as an never registered key.
1731
self.assertRaises(KeyError, r.get_credential_store, 'unknown')
1733
def test_fallback_none_registered(self):
1734
r = config.CredentialStoreRegistry()
1735
self.assertEquals(None,
1736
r.get_fallback_credentials("http", "example.com"))
1738
def test_register(self):
1739
r = config.CredentialStoreRegistry()
1740
r.register("stub", StubCredentialStore(), fallback=False)
1741
r.register("another", StubCredentialStore(), fallback=True)
1742
self.assertEquals(["another", "stub"], r.keys())
1744
def test_register_lazy(self):
1745
r = config.CredentialStoreRegistry()
1746
r.register_lazy("stub", "bzrlib.tests.test_config",
1747
"StubCredentialStore", fallback=False)
1748
self.assertEquals(["stub"], r.keys())
1749
self.assertIsInstance(r.get_credential_store("stub"),
1750
StubCredentialStore)
1752
def test_is_fallback(self):
1753
r = config.CredentialStoreRegistry()
1754
r.register("stub1", None, fallback=False)
1755
r.register("stub2", None, fallback=True)
1756
self.assertEquals(False, r.is_fallback("stub1"))
1757
self.assertEquals(True, r.is_fallback("stub2"))
1759
def test_no_fallback(self):
1760
r = config.CredentialStoreRegistry()
1761
store = CountingCredentialStore()
1762
r.register("count", store, fallback=False)
1763
self.assertEquals(None,
1764
r.get_fallback_credentials("http", "example.com"))
1765
self.assertEquals(0, store._calls)
1767
def test_fallback_credentials(self):
1768
r = config.CredentialStoreRegistry()
1769
store = StubCredentialStore()
1770
store.add_credentials("http", "example.com",
1771
"somebody", "geheim")
1772
r.register("stub", store, fallback=True)
1773
creds = r.get_fallback_credentials("http", "example.com")
1774
self.assertEquals("somebody", creds["user"])
1775
self.assertEquals("geheim", creds["password"])
1777
def test_fallback_first_wins(self):
1778
r = config.CredentialStoreRegistry()
1779
stub1 = StubCredentialStore()
1780
stub1.add_credentials("http", "example.com",
1781
"somebody", "stub1")
1782
r.register("stub1", stub1, fallback=True)
1783
stub2 = StubCredentialStore()
1784
stub2.add_credentials("http", "example.com",
1785
"somebody", "stub2")
1786
r.register("stub2", stub1, fallback=True)
1787
creds = r.get_fallback_credentials("http", "example.com")
1788
self.assertEquals("somebody", creds["user"])
1789
self.assertEquals("stub1", creds["password"])
1792
class TestPlainTextCredentialStore(tests.TestCase):
1794
def test_decode_password(self):
1795
r = config.credential_store_registry
1796
plain_text = r.get_credential_store()
1797
decoded = plain_text.decode_password(dict(password='secret'))
1798
self.assertEquals('secret', decoded)
1801
# FIXME: Once we have a way to declare authentication to all test servers, we
1802
# can implement generic tests.
1803
# test_user_password_in_url
1804
# test_user_in_url_password_from_config
1805
# test_user_in_url_password_prompted
1806
# test_user_in_config
1807
# test_user_getpass.getuser
1808
# test_user_prompted ?
1809
class TestAuthenticationRing(tests.TestCaseWithTransport):
added
removed
bzrlib/tests/test_config.py
