658
407
# This is testing the correct file names are provided.
659
408
# TODO: consolidate with the test for GlobalConfigs filename checks.
661
# replace the class that is constructed, to check its parameters
410
# replace the class that is constructured, to check its parameters
662
411
oldparserclass = config.ConfigObj
663
412
config.ConfigObj = InstrumentedConfigObj
413
my_config = config.LocationConfig('http://www.example.com')
665
my_config = config.LocationConfig('http://www.example.com')
666
415
parser = my_config._get_parser()
668
417
config.ConfigObj = oldparserclass
669
418
self.failUnless(isinstance(parser, InstrumentedConfigObj))
670
419
self.assertEqual(parser._calls,
671
[('__init__', config.locations_config_filename(),
420
[('__init__', config.branches_config_filename(),
673
config.ensure_config_dir_exists()
674
#os.mkdir(config.config_dir())
675
f = file(config.branches_config_filename(), 'wb')
678
oldparserclass = config.ConfigObj
679
config.ConfigObj = InstrumentedConfigObj
681
my_config = config.LocationConfig('http://www.example.com')
682
parser = my_config._get_parser()
684
config.ConfigObj = oldparserclass
686
423
def test_get_global_config(self):
687
my_config = config.BranchConfig(FakeBranch('http://example.com'))
424
my_config = config.LocationConfig('http://example.com')
688
425
global_config = my_config._get_global_config()
689
426
self.failUnless(isinstance(global_config, config.GlobalConfig))
690
427
self.failUnless(global_config is my_config._get_global_config())
692
def test__get_matching_sections_no_match(self):
693
self.get_branch_config('/')
694
self.assertEqual([], self.my_location_config._get_matching_sections())
696
def test__get_matching_sections_exact(self):
697
self.get_branch_config('http://www.example.com')
698
self.assertEqual([('http://www.example.com', '')],
699
self.my_location_config._get_matching_sections())
701
def test__get_matching_sections_suffix_does_not(self):
702
self.get_branch_config('http://www.example.com-com')
703
self.assertEqual([], self.my_location_config._get_matching_sections())
705
def test__get_matching_sections_subdir_recursive(self):
706
self.get_branch_config('http://www.example.com/com')
707
self.assertEqual([('http://www.example.com', 'com')],
708
self.my_location_config._get_matching_sections())
710
def test__get_matching_sections_ignoreparent(self):
711
self.get_branch_config('http://www.example.com/ignoreparent')
712
self.assertEqual([('http://www.example.com/ignoreparent', '')],
713
self.my_location_config._get_matching_sections())
715
def test__get_matching_sections_ignoreparent_subdir(self):
716
self.get_branch_config(
717
'http://www.example.com/ignoreparent/childbranch')
718
self.assertEqual([('http://www.example.com/ignoreparent',
720
self.my_location_config._get_matching_sections())
722
def test__get_matching_sections_subdir_trailing_slash(self):
723
self.get_branch_config('/b')
724
self.assertEqual([('/b/', '')],
725
self.my_location_config._get_matching_sections())
727
def test__get_matching_sections_subdir_child(self):
728
self.get_branch_config('/a/foo')
729
self.assertEqual([('/a/*', ''), ('/a/', 'foo')],
730
self.my_location_config._get_matching_sections())
732
def test__get_matching_sections_subdir_child_child(self):
733
self.get_branch_config('/a/foo/bar')
734
self.assertEqual([('/a/*', 'bar'), ('/a/', 'foo/bar')],
735
self.my_location_config._get_matching_sections())
737
def test__get_matching_sections_trailing_slash_with_children(self):
738
self.get_branch_config('/a/')
739
self.assertEqual([('/a/', '')],
740
self.my_location_config._get_matching_sections())
742
def test__get_matching_sections_explicit_over_glob(self):
743
# XXX: 2006-09-08 jamesh
744
# This test only passes because ord('c') > ord('*'). If there
745
# was a config section for '/a/?', it would get precedence
747
self.get_branch_config('/a/c')
748
self.assertEqual([('/a/c', ''), ('/a/*', ''), ('/a/', 'c')],
749
self.my_location_config._get_matching_sections())
751
def test__get_option_policy_normal(self):
752
self.get_branch_config('http://www.example.com')
754
self.my_location_config._get_config_policy(
755
'http://www.example.com', 'normal_option'),
758
def test__get_option_policy_norecurse(self):
759
self.get_branch_config('http://www.example.com')
761
self.my_location_config._get_option_policy(
762
'http://www.example.com', 'norecurse_option'),
763
config.POLICY_NORECURSE)
764
# Test old recurse=False setting:
766
self.my_location_config._get_option_policy(
767
'http://www.example.com/norecurse', 'normal_option'),
768
config.POLICY_NORECURSE)
770
def test__get_option_policy_normal(self):
771
self.get_branch_config('http://www.example.com')
773
self.my_location_config._get_option_policy(
774
'http://www.example.com', 'appendpath_option'),
775
config.POLICY_APPENDPATH)
429
def test__get_section_no_match(self):
430
self.get_location_config('/')
431
self.assertEqual(None, self.my_config._get_section())
433
def test__get_section_exact(self):
434
self.get_location_config('http://www.example.com')
435
self.assertEqual('http://www.example.com',
436
self.my_config._get_section())
438
def test__get_section_suffix_does_not(self):
439
self.get_location_config('http://www.example.com-com')
440
self.assertEqual(None, self.my_config._get_section())
442
def test__get_section_subdir_recursive(self):
443
self.get_location_config('http://www.example.com/com')
444
self.assertEqual('http://www.example.com',
445
self.my_config._get_section())
447
def test__get_section_subdir_matches(self):
448
self.get_location_config('http://www.example.com/useglobal')
449
self.assertEqual('http://www.example.com/useglobal',
450
self.my_config._get_section())
452
def test__get_section_subdir_nonrecursive(self):
453
self.get_location_config(
454
'http://www.example.com/useglobal/childbranch')
455
self.assertEqual('http://www.example.com',
456
self.my_config._get_section())
458
def test__get_section_subdir_trailing_slash(self):
459
self.get_location_config('/b')
460
self.assertEqual('/b/', self.my_config._get_section())
462
def test__get_section_subdir_child(self):
463
self.get_location_config('/a/foo')
464
self.assertEqual('/a/*', self.my_config._get_section())
466
def test__get_section_subdir_child_child(self):
467
self.get_location_config('/a/foo/bar')
468
self.assertEqual('/a/', self.my_config._get_section())
470
def test__get_section_trailing_slash_with_children(self):
471
self.get_location_config('/a/')
472
self.assertEqual('/a/', self.my_config._get_section())
474
def test__get_section_explicit_over_glob(self):
475
self.get_location_config('/a/c')
476
self.assertEqual('/a/c', self.my_config._get_section())
777
479
def test_location_without_username(self):
778
self.get_branch_config('http://www.example.com/ignoreparent')
480
self.get_location_config('http://www.example.com/useglobal')
779
481
self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
780
482
self.my_config.username())
782
484
def test_location_not_listed(self):
783
485
"""Test that the global username is used when no location matches"""
784
self.get_branch_config('/home/robertc/sources')
486
self.get_location_config('/home/robertc/sources')
785
487
self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
786
488
self.my_config.username())
788
490
def test_overriding_location(self):
789
self.get_branch_config('http://www.example.com/foo')
491
self.get_location_config('http://www.example.com/foo')
790
492
self.assertEqual('Robert Collins <robertc@example.org>',
791
493
self.my_config.username())
793
495
def test_signatures_not_set(self):
794
self.get_branch_config('http://www.example.com',
496
self.get_location_config('http://www.example.com',
795
497
global_config=sample_ignore_signatures)
796
self.assertEqual(config.CHECK_ALWAYS,
498
self.assertEqual(config.CHECK_NEVER,
797
499
self.my_config.signature_checking())
798
self.assertEqual(config.SIGN_NEVER,
799
self.my_config.signing_policy())
801
501
def test_signatures_never(self):
802
self.get_branch_config('/a/c')
502
self.get_location_config('/a/c')
803
503
self.assertEqual(config.CHECK_NEVER,
804
504
self.my_config.signature_checking())
806
506
def test_signatures_when_available(self):
807
self.get_branch_config('/a/', global_config=sample_ignore_signatures)
507
self.get_location_config('/a/', global_config=sample_ignore_signatures)
808
508
self.assertEqual(config.CHECK_IF_POSSIBLE,
809
509
self.my_config.signature_checking())
811
511
def test_signatures_always(self):
812
self.get_branch_config('/b')
512
self.get_location_config('/b')
813
513
self.assertEqual(config.CHECK_ALWAYS,
814
514
self.my_config.signature_checking())
816
516
def test_gpg_signing_command(self):
817
self.get_branch_config('/b')
517
self.get_location_config('/b')
818
518
self.assertEqual("gnome-gpg", self.my_config.gpg_signing_command())
820
520
def test_gpg_signing_command_missing(self):
821
self.get_branch_config('/a')
521
self.get_location_config('/a')
822
522
self.assertEqual("false", self.my_config.gpg_signing_command())
824
524
def test_get_user_option_global(self):
825
self.get_branch_config('/a')
525
self.get_location_config('/a')
826
526
self.assertEqual('something',
827
527
self.my_config.get_user_option('user_global_option'))
829
529
def test_get_user_option_local(self):
830
self.get_branch_config('/a')
530
self.get_location_config('/a')
831
531
self.assertEqual('local',
832
532
self.my_config.get_user_option('user_local_option'))
834
def test_get_user_option_appendpath(self):
835
# returned as is for the base path:
836
self.get_branch_config('http://www.example.com')
837
self.assertEqual('append',
838
self.my_config.get_user_option('appendpath_option'))
839
# Extra path components get appended:
840
self.get_branch_config('http://www.example.com/a/b/c')
841
self.assertEqual('append/a/b/c',
842
self.my_config.get_user_option('appendpath_option'))
843
# Overriden for http://www.example.com/dir, where it is a
845
self.get_branch_config('http://www.example.com/dir/a/b/c')
846
self.assertEqual('normal',
847
self.my_config.get_user_option('appendpath_option'))
849
def test_get_user_option_norecurse(self):
850
self.get_branch_config('http://www.example.com')
851
self.assertEqual('norecurse',
852
self.my_config.get_user_option('norecurse_option'))
853
self.get_branch_config('http://www.example.com/dir')
854
self.assertEqual(None,
855
self.my_config.get_user_option('norecurse_option'))
856
# http://www.example.com/norecurse is a recurse=False section
857
# that redefines normal_option. Subdirectories do not pick up
859
self.get_branch_config('http://www.example.com/norecurse')
860
self.assertEqual('norecurse',
861
self.my_config.get_user_option('normal_option'))
862
self.get_branch_config('http://www.example.com/norecurse/subdir')
863
self.assertEqual('normal',
864
self.my_config.get_user_option('normal_option'))
866
def test_set_user_option_norecurse(self):
867
self.get_branch_config('http://www.example.com')
868
self.my_config.set_user_option('foo', 'bar',
869
store=config.STORE_LOCATION_NORECURSE)
871
self.my_location_config._get_option_policy(
872
'http://www.example.com', 'foo'),
873
config.POLICY_NORECURSE)
875
def test_set_user_option_appendpath(self):
876
self.get_branch_config('http://www.example.com')
877
self.my_config.set_user_option('foo', 'bar',
878
store=config.STORE_LOCATION_APPENDPATH)
880
self.my_location_config._get_option_policy(
881
'http://www.example.com', 'foo'),
882
config.POLICY_APPENDPATH)
884
def test_set_user_option_change_policy(self):
885
self.get_branch_config('http://www.example.com')
886
self.my_config.set_user_option('norecurse_option', 'normal',
887
store=config.STORE_LOCATION)
889
self.my_location_config._get_option_policy(
890
'http://www.example.com', 'norecurse_option'),
893
def test_set_user_option_recurse_false_section(self):
894
# The following section has recurse=False set. The test is to
895
# make sure that a normal option can be added to the section,
896
# converting recurse=False to the norecurse policy.
897
self.get_branch_config('http://www.example.com/norecurse')
898
self.callDeprecated(['The recurse option is deprecated as of 0.14. '
899
'The section "http://www.example.com/norecurse" '
900
'has been converted to use policies.'],
901
self.my_config.set_user_option,
902
'foo', 'bar', store=config.STORE_LOCATION)
904
self.my_location_config._get_option_policy(
905
'http://www.example.com/norecurse', 'foo'),
907
# The previously existing option is still norecurse:
909
self.my_location_config._get_option_policy(
910
'http://www.example.com/norecurse', 'normal_option'),
911
config.POLICY_NORECURSE)
913
534
def test_post_commit_default(self):
914
self.get_branch_config('/a/c')
535
self.get_location_config('/a/c')
915
536
self.assertEqual('bzrlib.tests.test_config.post_commit',
916
537
self.my_config.post_commit())
918
def get_branch_config(self, location, global_config=None):
539
def get_location_config(self, location, global_config=None):
919
540
if global_config is None:
920
541
global_file = StringIO(sample_config_text.encode('utf-8'))
922
543
global_file = StringIO(global_config.encode('utf-8'))
923
544
branches_file = StringIO(sample_branches_text.encode('utf-8'))
924
self.my_config = config.BranchConfig(FakeBranch(location))
925
# Force location config to use specified file
926
self.my_location_config = self.my_config._get_location_config()
927
self.my_location_config._get_parser(branches_file)
928
# Force global config to use specified file
545
self.my_config = config.LocationConfig(location)
546
self.my_config._get_parser(branches_file)
929
547
self.my_config._get_global_config()._get_parser(global_file)
931
549
def test_set_user_setting_sets_and_saves(self):
932
self.get_branch_config('/a/c')
550
self.get_location_config('/a/c')
933
551
record = InstrumentedConfigObj("foo")
934
self.my_location_config._parser = record
552
self.my_config._parser = record
936
554
real_mkdir = os.mkdir
937
555
self.created = False
956
570
('__setitem__', '/a/c', {}),
957
571
('__getitem__', '/a/c'),
958
572
('__setitem__', 'foo', 'bar'),
959
('__getitem__', '/a/c'),
960
('as_bool', 'recurse'),
961
('__getitem__', '/a/c'),
962
('__delitem__', 'recurse'),
963
('__getitem__', '/a/c'),
965
('__getitem__', '/a/c'),
966
('__contains__', 'foo:policy'),
968
574
record._calls[1:])
970
def test_set_user_setting_sets_and_saves2(self):
971
self.get_branch_config('/a/c')
972
self.assertIs(self.my_config.get_user_option('foo'), None)
973
self.my_config.set_user_option('foo', 'bar')
975
self.my_config.branch.control_files.files['branch.conf'].strip(),
977
self.assertEqual(self.my_config.get_user_option('foo'), 'bar')
978
self.my_config.set_user_option('foo', 'baz',
979
store=config.STORE_LOCATION)
980
self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
981
self.my_config.set_user_option('foo', 'qux')
982
self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
984
def test_get_bzr_remote_path(self):
985
my_config = config.LocationConfig('/a/c')
986
self.assertEqual('bzr', my_config.get_bzr_remote_path())
987
my_config.set_user_option('bzr_remote_path', '/path-bzr')
988
self.assertEqual('/path-bzr', my_config.get_bzr_remote_path())
989
os.environ['BZR_REMOTE_PATH'] = '/environ-bzr'
990
self.assertEqual('/environ-bzr', my_config.get_bzr_remote_path())
993
precedence_global = 'option = global'
994
precedence_branch = 'option = branch'
995
precedence_location = """
999
[http://example.com/specific]
1004
class TestBranchConfigItems(tests.TestCaseInTempDir):
1006
def get_branch_config(self, global_config=None, location=None,
1007
location_config=None, branch_data_config=None):
1008
my_config = config.BranchConfig(FakeBranch(location))
1009
if global_config is not None:
1010
global_file = StringIO(global_config.encode('utf-8'))
1011
my_config._get_global_config()._get_parser(global_file)
1012
self.my_location_config = my_config._get_location_config()
1013
if location_config is not None:
1014
location_file = StringIO(location_config.encode('utf-8'))
1015
self.my_location_config._get_parser(location_file)
1016
if branch_data_config is not None:
1017
my_config.branch.control_files.files['branch.conf'] = \
577
class TestBranchConfigItems(TestCase):
1021
579
def test_user_id(self):
1022
branch = FakeBranch(user_id='Robert Collins <robertc@example.net>')
580
branch = FakeBranch()
1023
581
my_config = config.BranchConfig(branch)
1024
582
self.assertEqual("Robert Collins <robertc@example.net>",
1025
my_config.username())
1026
my_config.branch.control_files.files['email'] = "John"
1027
my_config.set_user_option('email',
1028
"Robert Collins <robertc@example.org>")
1029
self.assertEqual("John", my_config.username())
1030
del my_config.branch.control_files.files['email']
1031
self.assertEqual("Robert Collins <robertc@example.org>",
1032
my_config.username())
583
my_config._get_user_id())
584
branch.control_files.email = "John"
585
self.assertEqual("John", my_config._get_user_id())
1034
587
def test_not_set_in_branch(self):
1035
my_config = self.get_branch_config(sample_config_text)
588
branch = FakeBranch()
589
my_config = config.BranchConfig(branch)
590
branch.control_files.email = None
591
config_file = StringIO(sample_config_text.encode('utf-8'))
592
(my_config._get_location_config().
593
_get_global_config()._get_parser(config_file))
1036
594
self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
1037
595
my_config._get_user_id())
1038
my_config.branch.control_files.files['email'] = "John"
596
branch.control_files.email = "John"
1039
597
self.assertEqual("John", my_config._get_user_id())
1041
def test_BZR_EMAIL_OVERRIDES(self):
1042
os.environ['BZR_EMAIL'] = "Robert Collins <robertc@example.org>"
599
def test_BZREMAIL_OVERRIDES(self):
600
os.environ['BZREMAIL'] = "Robert Collins <robertc@example.org>"
1043
601
branch = FakeBranch()
1044
602
my_config = config.BranchConfig(branch)
1045
603
self.assertEqual("Robert Collins <robertc@example.org>",
1046
604
my_config.username())
1048
606
def test_signatures_forced(self):
1049
my_config = self.get_branch_config(
1050
global_config=sample_always_signatures)
1051
self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
1052
self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
1053
self.assertTrue(my_config.signature_needed())
1055
def test_signatures_forced_branch(self):
1056
my_config = self.get_branch_config(
1057
global_config=sample_ignore_signatures,
1058
branch_data_config=sample_always_signatures)
1059
self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
1060
self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
1061
self.assertTrue(my_config.signature_needed())
607
branch = FakeBranch()
608
my_config = config.BranchConfig(branch)
609
config_file = StringIO(sample_always_signatures)
610
(my_config._get_location_config().
611
_get_global_config()._get_parser(config_file))
612
self.assertEqual(config.CHECK_ALWAYS, my_config.signature_checking())
1063
614
def test_gpg_signing_command(self):
1064
my_config = self.get_branch_config(
1065
# branch data cannot set gpg_signing_command
1066
branch_data_config="gpg_signing_command=pgp")
615
branch = FakeBranch()
616
my_config = config.BranchConfig(branch)
1067
617
config_file = StringIO(sample_config_text.encode('utf-8'))
1068
my_config._get_global_config()._get_parser(config_file)
618
(my_config._get_location_config().
619
_get_global_config()._get_parser(config_file))
1069
620
self.assertEqual('gnome-gpg', my_config.gpg_signing_command())
1071
622
def test_get_user_option_global(self):
1072
623
branch = FakeBranch()
1073
624
my_config = config.BranchConfig(branch)
1074
625
config_file = StringIO(sample_config_text.encode('utf-8'))
1075
(my_config._get_global_config()._get_parser(config_file))
626
(my_config._get_location_config().
627
_get_global_config()._get_parser(config_file))
1076
628
self.assertEqual('something',
1077
629
my_config.get_user_option('user_global_option'))
1079
631
def test_post_commit_default(self):
1080
632
branch = FakeBranch()
1081
my_config = self.get_branch_config(sample_config_text, '/a/c',
1082
sample_branches_text)
1083
self.assertEqual(my_config.branch.base, '/a/c')
1084
self.assertEqual('bzrlib.tests.test_config.post_commit',
1085
my_config.post_commit())
1086
my_config.set_user_option('post_commit', 'rmtree_root')
1087
# post-commit is ignored when bresent in branch data
1088
self.assertEqual('bzrlib.tests.test_config.post_commit',
1089
my_config.post_commit())
1090
my_config.set_user_option('post_commit', 'rmtree_root',
1091
store=config.STORE_LOCATION)
1092
self.assertEqual('rmtree_root', my_config.post_commit())
1094
def test_config_precedence(self):
1095
my_config = self.get_branch_config(global_config=precedence_global)
1096
self.assertEqual(my_config.get_user_option('option'), 'global')
1097
my_config = self.get_branch_config(global_config=precedence_global,
1098
branch_data_config=precedence_branch)
1099
self.assertEqual(my_config.get_user_option('option'), 'branch')
1100
my_config = self.get_branch_config(global_config=precedence_global,
1101
branch_data_config=precedence_branch,
1102
location_config=precedence_location)
1103
self.assertEqual(my_config.get_user_option('option'), 'recurse')
1104
my_config = self.get_branch_config(global_config=precedence_global,
1105
branch_data_config=precedence_branch,
1106
location_config=precedence_location,
1107
location='http://example.com/specific')
1108
self.assertEqual(my_config.get_user_option('option'), 'exact')
1110
def test_get_mail_client(self):
1111
config = self.get_branch_config()
1112
client = config.get_mail_client()
1113
self.assertIsInstance(client, mail_client.DefaultMail)
1116
config.set_user_option('mail_client', 'evolution')
1117
client = config.get_mail_client()
1118
self.assertIsInstance(client, mail_client.Evolution)
1120
config.set_user_option('mail_client', 'kmail')
1121
client = config.get_mail_client()
1122
self.assertIsInstance(client, mail_client.KMail)
1124
config.set_user_option('mail_client', 'mutt')
1125
client = config.get_mail_client()
1126
self.assertIsInstance(client, mail_client.Mutt)
1128
config.set_user_option('mail_client', 'thunderbird')
1129
client = config.get_mail_client()
1130
self.assertIsInstance(client, mail_client.Thunderbird)
1133
config.set_user_option('mail_client', 'default')
1134
client = config.get_mail_client()
1135
self.assertIsInstance(client, mail_client.DefaultMail)
1137
config.set_user_option('mail_client', 'editor')
1138
client = config.get_mail_client()
1139
self.assertIsInstance(client, mail_client.Editor)
1141
config.set_user_option('mail_client', 'mapi')
1142
client = config.get_mail_client()
1143
self.assertIsInstance(client, mail_client.MAPIClient)
1145
config.set_user_option('mail_client', 'xdg-email')
1146
client = config.get_mail_client()
1147
self.assertIsInstance(client, mail_client.XDGEmail)
1149
config.set_user_option('mail_client', 'firebird')
1150
self.assertRaises(errors.UnknownMailClient, config.get_mail_client)
1153
class TestMailAddressExtraction(tests.TestCase):
634
my_config = config.BranchConfig(branch)
635
config_file = StringIO(sample_config_text.encode('utf-8'))
636
(my_config._get_location_config().
637
_get_global_config()._get_parser(config_file))
638
branch_file = StringIO(sample_branches_text)
639
my_config._get_location_config()._get_parser(branch_file)
640
self.assertEqual('bzrlib.tests.test_config.post_commit',
641
my_config.post_commit())
644
class TestMailAddressExtraction(TestCase):
1155
646
def test_extract_email_address(self):
1156
647
self.assertEqual('jane@test.com',
1157
648
config.extract_email_address('Jane <jane@test.com>'))
1158
self.assertRaises(errors.NoEmailInUsername,
649
self.assertRaises(errors.BzrError,
1159
650
config.extract_email_address, 'Jane Tester')
1161
def test_parse_username(self):
1162
self.assertEqual(('', 'jdoe@example.com'),
1163
config.parse_username('jdoe@example.com'))
1164
self.assertEqual(('', 'jdoe@example.com'),
1165
config.parse_username('<jdoe@example.com>'))
1166
self.assertEqual(('John Doe', 'jdoe@example.com'),
1167
config.parse_username('John Doe <jdoe@example.com>'))
1168
self.assertEqual(('John Doe', ''),
1169
config.parse_username('John Doe'))
1170
self.assertEqual(('John Doe', 'jdoe@example.com'),
1171
config.parse_username('John Doe jdoe@example.com'))
1173
class TestTreeConfig(tests.TestCaseWithTransport):
1175
def test_get_value(self):
1176
"""Test that retreiving a value from a section is possible"""
1177
branch = self.make_branch('.')
1178
tree_config = config.TreeConfig(branch)
1179
tree_config.set_option('value', 'key', 'SECTION')
1180
tree_config.set_option('value2', 'key2')
1181
tree_config.set_option('value3-top', 'key3')
1182
tree_config.set_option('value3-section', 'key3', 'SECTION')
1183
value = tree_config.get_option('key', 'SECTION')
1184
self.assertEqual(value, 'value')
1185
value = tree_config.get_option('key2')
1186
self.assertEqual(value, 'value2')
1187
self.assertEqual(tree_config.get_option('non-existant'), None)
1188
value = tree_config.get_option('non-existant', 'SECTION')
1189
self.assertEqual(value, None)
1190
value = tree_config.get_option('non-existant', default='default')
1191
self.assertEqual(value, 'default')
1192
self.assertEqual(tree_config.get_option('key2', 'NOSECTION'), None)
1193
value = tree_config.get_option('key2', 'NOSECTION', default='default')
1194
self.assertEqual(value, 'default')
1195
value = tree_config.get_option('key3')
1196
self.assertEqual(value, 'value3-top')
1197
value = tree_config.get_option('key3', 'SECTION')
1198
self.assertEqual(value, 'value3-section')
1201
class TestTransportConfig(tests.TestCaseWithTransport):
1203
def test_get_value(self):
1204
"""Test that retreiving a value from a section is possible"""
1205
bzrdir_config = config.TransportConfig(transport.get_transport('.'),
1207
bzrdir_config.set_option('value', 'key', 'SECTION')
1208
bzrdir_config.set_option('value2', 'key2')
1209
bzrdir_config.set_option('value3-top', 'key3')
1210
bzrdir_config.set_option('value3-section', 'key3', 'SECTION')
1211
value = bzrdir_config.get_option('key', 'SECTION')
1212
self.assertEqual(value, 'value')
1213
value = bzrdir_config.get_option('key2')
1214
self.assertEqual(value, 'value2')
1215
self.assertEqual(bzrdir_config.get_option('non-existant'), None)
1216
value = bzrdir_config.get_option('non-existant', 'SECTION')
1217
self.assertEqual(value, None)
1218
value = bzrdir_config.get_option('non-existant', default='default')
1219
self.assertEqual(value, 'default')
1220
self.assertEqual(bzrdir_config.get_option('key2', 'NOSECTION'), None)
1221
value = bzrdir_config.get_option('key2', 'NOSECTION',
1223
self.assertEqual(value, 'default')
1224
value = bzrdir_config.get_option('key3')
1225
self.assertEqual(value, 'value3-top')
1226
value = bzrdir_config.get_option('key3', 'SECTION')
1227
self.assertEqual(value, 'value3-section')
1229
def test_set_unset_default_stack_on(self):
1230
my_dir = self.make_bzrdir('.')
1231
bzrdir_config = config.BzrDirConfig(my_dir)
1232
self.assertIs(None, bzrdir_config.get_default_stack_on())
1233
bzrdir_config.set_default_stack_on('Foo')
1234
self.assertEqual('Foo', bzrdir_config._config.get_option(
1235
'default_stack_on'))
1236
self.assertEqual('Foo', bzrdir_config.get_default_stack_on())
1237
bzrdir_config.set_default_stack_on(None)
1238
self.assertIs(None, bzrdir_config.get_default_stack_on())
1241
class TestAuthenticationConfigFile(tests.TestCase):
1242
"""Test the authentication.conf file matching"""
1244
def _got_user_passwd(self, expected_user, expected_password,
1245
config, *args, **kwargs):
1246
credentials = config.get_credentials(*args, **kwargs)
1247
if credentials is None:
1251
user = credentials['user']
1252
password = credentials['password']
1253
self.assertEquals(expected_user, user)
1254
self.assertEquals(expected_password, password)
1256
def test_empty_config(self):
1257
conf = config.AuthenticationConfig(_file=StringIO())
1258
self.assertEquals({}, conf._get_config())
1259
self._got_user_passwd(None, None, conf, 'http', 'foo.net')
1261
def test_missing_auth_section_header(self):
1262
conf = config.AuthenticationConfig(_file=StringIO('foo = bar'))
1263
self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1265
def test_auth_section_header_not_closed(self):
1266
conf = config.AuthenticationConfig(_file=StringIO('[DEF'))
1267
self.assertRaises(errors.ParseConfigError, conf._get_config)
1269
def test_auth_value_not_boolean(self):
1270
conf = config.AuthenticationConfig(_file=StringIO(
1274
verify_certificates=askme # Error: Not a boolean
1276
self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1278
def test_auth_value_not_int(self):
1279
conf = config.AuthenticationConfig(_file=StringIO(
1283
port=port # Error: Not an int
1285
self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1287
def test_unknown_password_encoding(self):
1288
conf = config.AuthenticationConfig(_file=StringIO(
1292
password_encoding=unknown
1294
self.assertRaises(ValueError, conf.get_password,
1295
'ftp', 'foo.net', 'joe')
1297
def test_credentials_for_scheme_host(self):
1298
conf = config.AuthenticationConfig(_file=StringIO(
1299
"""# Identity on foo.net
1304
password=secret-pass
1307
self._got_user_passwd('joe', 'secret-pass', conf, 'ftp', 'foo.net')
1309
self._got_user_passwd(None, None, conf, 'http', 'foo.net')
1311
self._got_user_passwd(None, None, conf, 'ftp', 'bar.net')
1313
def test_credentials_for_host_port(self):
1314
conf = config.AuthenticationConfig(_file=StringIO(
1315
"""# Identity on foo.net
1321
password=secret-pass
1324
self._got_user_passwd('joe', 'secret-pass',
1325
conf, 'ftp', 'foo.net', port=10021)
1327
self._got_user_passwd(None, None, conf, 'ftp', 'foo.net')
1329
def test_for_matching_host(self):
1330
conf = config.AuthenticationConfig(_file=StringIO(
1331
"""# Identity on foo.net
1337
[sourceforge domain]
1344
self._got_user_passwd('georges', 'bendover',
1345
conf, 'bzr', 'foo.bzr.sf.net')
1347
self._got_user_passwd(None, None,
1348
conf, 'bzr', 'bbzr.sf.net')
1350
def test_for_matching_host_None(self):
1351
conf = config.AuthenticationConfig(_file=StringIO(
1352
"""# Identity on foo.net
1362
self._got_user_passwd('joe', 'joepass',
1363
conf, 'bzr', 'quux.net')
1364
# no host but different scheme
1365
self._got_user_passwd('georges', 'bendover',
1366
conf, 'ftp', 'quux.net')
1368
def test_credentials_for_path(self):
1369
conf = config.AuthenticationConfig(_file=StringIO(
1385
self._got_user_passwd(None, None,
1386
conf, 'http', host='bar.org', path='/dir3')
1388
self._got_user_passwd('georges', 'bendover',
1389
conf, 'http', host='bar.org', path='/dir2')
1391
self._got_user_passwd('jim', 'jimpass',
1392
conf, 'http', host='bar.org',path='/dir1/subdir')
1394
def test_credentials_for_user(self):
1395
conf = config.AuthenticationConfig(_file=StringIO(
1404
self._got_user_passwd('jim', 'jimpass',
1405
conf, 'http', 'bar.org')
1407
self._got_user_passwd('jim', 'jimpass',
1408
conf, 'http', 'bar.org', user='jim')
1409
# Don't get a different user if one is specified
1410
self._got_user_passwd(None, None,
1411
conf, 'http', 'bar.org', user='georges')
1413
def test_credentials_for_user_without_password(self):
1414
conf = config.AuthenticationConfig(_file=StringIO(
1421
# Get user but no password
1422
self._got_user_passwd('jim', None,
1423
conf, 'http', 'bar.org')
1425
def test_verify_certificates(self):
1426
conf = config.AuthenticationConfig(_file=StringIO(
1433
verify_certificates=False
1440
credentials = conf.get_credentials('https', 'bar.org')
1441
self.assertEquals(False, credentials.get('verify_certificates'))
1442
credentials = conf.get_credentials('https', 'foo.net')
1443
self.assertEquals(True, credentials.get('verify_certificates'))
1446
class TestAuthenticationStorage(tests.TestCaseInTempDir):
1448
def test_set_credentials(self):
1449
conf = config.AuthenticationConfig()
1450
conf.set_credentials('name', 'host', 'user', 'scheme', 'password',
1451
99, path='/foo', verify_certificates=False, realm='realm')
1452
credentials = conf.get_credentials(host='host', scheme='scheme',
1453
port=99, path='/foo',
1455
CREDENTIALS = {'name': 'name', 'user': 'user', 'password': 'password',
1456
'verify_certificates': False, 'scheme': 'scheme',
1457
'host': 'host', 'port': 99, 'path': '/foo',
1459
self.assertEqual(CREDENTIALS, credentials)
1460
credentials_from_disk = config.AuthenticationConfig().get_credentials(
1461
host='host', scheme='scheme', port=99, path='/foo', realm='realm')
1462
self.assertEqual(CREDENTIALS, credentials_from_disk)
1464
def test_reset_credentials_different_name(self):
1465
conf = config.AuthenticationConfig()
1466
conf.set_credentials('name', 'host', 'user', 'scheme', 'password'),
1467
conf.set_credentials('name2', 'host', 'user2', 'scheme', 'password'),
1468
self.assertIs(None, conf._get_config().get('name'))
1469
credentials = conf.get_credentials(host='host', scheme='scheme')
1470
CREDENTIALS = {'name': 'name2', 'user': 'user2', 'password':
1471
'password', 'verify_certificates': True,
1472
'scheme': 'scheme', 'host': 'host', 'port': None,
1473
'path': None, 'realm': None}
1474
self.assertEqual(CREDENTIALS, credentials)
1477
class TestAuthenticationConfig(tests.TestCase):
1478
"""Test AuthenticationConfig behaviour"""
1480
def _check_default_password_prompt(self, expected_prompt_format, scheme,
1481
host=None, port=None, realm=None,
1485
user, password = 'jim', 'precious'
1486
expected_prompt = expected_prompt_format % {
1487
'scheme': scheme, 'host': host, 'port': port,
1488
'user': user, 'realm': realm}
1490
stdout = tests.StringIOWrapper()
1491
stderr = tests.StringIOWrapper()
1492
ui.ui_factory = tests.TestUIFactory(stdin=password + '\n',
1493
stdout=stdout, stderr=stderr)
1494
# We use an empty conf so that the user is always prompted
1495
conf = config.AuthenticationConfig()
1496
self.assertEquals(password,
1497
conf.get_password(scheme, host, user, port=port,
1498
realm=realm, path=path))
1499
self.assertEquals(expected_prompt, stderr.getvalue())
1500
self.assertEquals('', stdout.getvalue())
1502
def _check_default_username_prompt(self, expected_prompt_format, scheme,
1503
host=None, port=None, realm=None,
1508
expected_prompt = expected_prompt_format % {
1509
'scheme': scheme, 'host': host, 'port': port,
1511
stdout = tests.StringIOWrapper()
1512
stderr = tests.StringIOWrapper()
1513
ui.ui_factory = tests.TestUIFactory(stdin=username+ '\n',
1514
stdout=stdout, stderr=stderr)
1515
# We use an empty conf so that the user is always prompted
1516
conf = config.AuthenticationConfig()
1517
self.assertEquals(username, conf.get_user(scheme, host, port=port,
1518
realm=realm, path=path, ask=True))
1519
self.assertEquals(expected_prompt, stderr.getvalue())
1520
self.assertEquals('', stdout.getvalue())
1522
def test_username_defaults_prompts(self):
1523
# HTTP prompts can't be tested here, see test_http.py
1524
self._check_default_username_prompt('FTP %(host)s username: ', 'ftp')
1525
self._check_default_username_prompt(
1526
'FTP %(host)s:%(port)d username: ', 'ftp', port=10020)
1527
self._check_default_username_prompt(
1528
'SSH %(host)s:%(port)d username: ', 'ssh', port=12345)
1530
def test_username_default_no_prompt(self):
1531
conf = config.AuthenticationConfig()
1532
self.assertEquals(None,
1533
conf.get_user('ftp', 'example.com'))
1534
self.assertEquals("explicitdefault",
1535
conf.get_user('ftp', 'example.com', default="explicitdefault"))
1537
def test_password_default_prompts(self):
1538
# HTTP prompts can't be tested here, see test_http.py
1539
self._check_default_password_prompt(
1540
'FTP %(user)s@%(host)s password: ', 'ftp')
1541
self._check_default_password_prompt(
1542
'FTP %(user)s@%(host)s:%(port)d password: ', 'ftp', port=10020)
1543
self._check_default_password_prompt(
1544
'SSH %(user)s@%(host)s:%(port)d password: ', 'ssh', port=12345)
1545
# SMTP port handling is a bit special (it's handled if embedded in the
1547
# FIXME: should we: forbid that, extend it to other schemes, leave
1548
# things as they are that's fine thank you ?
1549
self._check_default_password_prompt('SMTP %(user)s@%(host)s password: ',
1551
self._check_default_password_prompt('SMTP %(user)s@%(host)s password: ',
1552
'smtp', host='bar.org:10025')
1553
self._check_default_password_prompt(
1554
'SMTP %(user)s@%(host)s:%(port)d password: ',
1557
def test_ssh_password_emits_warning(self):
1558
conf = config.AuthenticationConfig(_file=StringIO(
1566
entered_password = 'typed-by-hand'
1567
stdout = tests.StringIOWrapper()
1568
stderr = tests.StringIOWrapper()
1569
ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1570
stdout=stdout, stderr=stderr)
1572
# Since the password defined in the authentication config is ignored,
1573
# the user is prompted
1574
self.assertEquals(entered_password,
1575
conf.get_password('ssh', 'bar.org', user='jim'))
1576
self.assertContainsRe(
1577
self._get_log(keep_log_file=True),
1578
'password ignored in section \[ssh with password\]')
1580
def test_ssh_without_password_doesnt_emit_warning(self):
1581
conf = config.AuthenticationConfig(_file=StringIO(
1588
entered_password = 'typed-by-hand'
1589
stdout = tests.StringIOWrapper()
1590
stderr = tests.StringIOWrapper()
1591
ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1595
# Since the password defined in the authentication config is ignored,
1596
# the user is prompted
1597
self.assertEquals(entered_password,
1598
conf.get_password('ssh', 'bar.org', user='jim'))
1599
# No warning shoud be emitted since there is no password. We are only
1601
self.assertNotContainsRe(
1602
self._get_log(keep_log_file=True),
1603
'password ignored in section \[ssh with password\]')
1605
def test_uses_fallback_stores(self):
1606
self._old_cs_registry = config.credential_store_registry
1608
config.credential_store_registry = self._old_cs_registry
1609
self.addCleanup(restore)
1610
config.credential_store_registry = config.CredentialStoreRegistry()
1611
store = StubCredentialStore()
1612
store.add_credentials("http", "example.com", "joe", "secret")
1613
config.credential_store_registry.register("stub", store, fallback=True)
1614
conf = config.AuthenticationConfig(_file=StringIO())
1615
creds = conf.get_credentials("http", "example.com")
1616
self.assertEquals("joe", creds["user"])
1617
self.assertEquals("secret", creds["password"])
1620
class StubCredentialStore(config.CredentialStore):
1626
def add_credentials(self, scheme, host, user, password=None):
1627
self._username[(scheme, host)] = user
1628
self._password[(scheme, host)] = password
1630
def get_credentials(self, scheme, host, port=None, user=None,
1631
path=None, realm=None):
1632
key = (scheme, host)
1633
if not key in self._username:
1635
return { "scheme": scheme, "host": host, "port": port,
1636
"user": self._username[key], "password": self._password[key]}
1639
class CountingCredentialStore(config.CredentialStore):
1644
def get_credentials(self, scheme, host, port=None, user=None,
1645
path=None, realm=None):
1650
class TestCredentialStoreRegistry(tests.TestCase):
1652
def _get_cs_registry(self):
1653
return config.credential_store_registry
1655
def test_default_credential_store(self):
1656
r = self._get_cs_registry()
1657
default = r.get_credential_store(None)
1658
self.assertIsInstance(default, config.PlainTextCredentialStore)
1660
def test_unknown_credential_store(self):
1661
r = self._get_cs_registry()
1662
# It's hard to imagine someone creating a credential store named
1663
# 'unknown' so we use that as an never registered key.
1664
self.assertRaises(KeyError, r.get_credential_store, 'unknown')
1666
def test_fallback_none_registered(self):
1667
r = config.CredentialStoreRegistry()
1668
self.assertEquals(None,
1669
r.get_fallback_credentials("http", "example.com"))
1671
def test_register(self):
1672
r = config.CredentialStoreRegistry()
1673
r.register("stub", StubCredentialStore(), fallback=False)
1674
r.register("another", StubCredentialStore(), fallback=True)
1675
self.assertEquals(["another", "stub"], r.keys())
1677
def test_register_lazy(self):
1678
r = config.CredentialStoreRegistry()
1679
r.register_lazy("stub", "bzrlib.tests.test_config",
1680
"StubCredentialStore", fallback=False)
1681
self.assertEquals(["stub"], r.keys())
1682
self.assertIsInstance(r.get_credential_store("stub"),
1683
StubCredentialStore)
1685
def test_is_fallback(self):
1686
r = config.CredentialStoreRegistry()
1687
r.register("stub1", None, fallback=False)
1688
r.register("stub2", None, fallback=True)
1689
self.assertEquals(False, r.is_fallback("stub1"))
1690
self.assertEquals(True, r.is_fallback("stub2"))
1692
def test_no_fallback(self):
1693
r = config.CredentialStoreRegistry()
1694
store = CountingCredentialStore()
1695
r.register("count", store, fallback=False)
1696
self.assertEquals(None,
1697
r.get_fallback_credentials("http", "example.com"))
1698
self.assertEquals(0, store._calls)
1700
def test_fallback_credentials(self):
1701
r = config.CredentialStoreRegistry()
1702
store = StubCredentialStore()
1703
store.add_credentials("http", "example.com",
1704
"somebody", "geheim")
1705
r.register("stub", store, fallback=True)
1706
creds = r.get_fallback_credentials("http", "example.com")
1707
self.assertEquals("somebody", creds["user"])
1708
self.assertEquals("geheim", creds["password"])
1710
def test_fallback_first_wins(self):
1711
r = config.CredentialStoreRegistry()
1712
stub1 = StubCredentialStore()
1713
stub1.add_credentials("http", "example.com",
1714
"somebody", "stub1")
1715
r.register("stub1", stub1, fallback=True)
1716
stub2 = StubCredentialStore()
1717
stub2.add_credentials("http", "example.com",
1718
"somebody", "stub2")
1719
r.register("stub2", stub1, fallback=True)
1720
creds = r.get_fallback_credentials("http", "example.com")
1721
self.assertEquals("somebody", creds["user"])
1722
self.assertEquals("stub1", creds["password"])
1725
class TestPlainTextCredentialStore(tests.TestCase):
1727
def test_decode_password(self):
1728
r = config.credential_store_registry
1729
plain_text = r.get_credential_store()
1730
decoded = plain_text.decode_password(dict(password='secret'))
1731
self.assertEquals('secret', decoded)
1734
# FIXME: Once we have a way to declare authentication to all test servers, we
1735
# can implement generic tests.
1736
# test_user_password_in_url
1737
# test_user_in_url_password_from_config
1738
# test_user_in_url_password_prompted
1739
# test_user_in_config
1740
# test_user_getpass.getuser
1741
# test_user_prompted ?
1742
class TestAuthenticationRing(tests.TestCaseWithTransport):
added
removed
bzrlib/tests/test_config.py
