419
637
# This is testing the correct file names are provided.
420
638
# TODO: consolidate with the test for GlobalConfigs filename checks.
422
# replace the class that is constructured, to check its parameters
640
# replace the class that is constructed, to check its parameters
423
641
oldparserclass = config.ConfigObj
424
642
config.ConfigObj = InstrumentedConfigObj
425
my_config = config.LocationConfig('http://www.example.com')
644
my_config = config.LocationConfig('http://www.example.com')
427
645
parser = my_config._get_parser()
429
647
config.ConfigObj = oldparserclass
430
648
self.failUnless(isinstance(parser, InstrumentedConfigObj))
431
649
self.assertEqual(parser._calls,
432
[('__init__', config.branches_config_filename(),
650
[('__init__', config.locations_config_filename(),
652
config.ensure_config_dir_exists()
653
#os.mkdir(config.config_dir())
654
f = file(config.branches_config_filename(), 'wb')
657
oldparserclass = config.ConfigObj
658
config.ConfigObj = InstrumentedConfigObj
660
my_config = config.LocationConfig('http://www.example.com')
661
parser = my_config._get_parser()
663
config.ConfigObj = oldparserclass
435
665
def test_get_global_config(self):
436
my_config = config.LocationConfig('http://example.com')
666
my_config = config.BranchConfig(FakeBranch('http://example.com'))
437
667
global_config = my_config._get_global_config()
438
668
self.failUnless(isinstance(global_config, config.GlobalConfig))
439
669
self.failUnless(global_config is my_config._get_global_config())
441
def test__get_section_no_match(self):
442
self.get_location_config('/')
443
self.assertEqual(None, self.my_config._get_section())
445
def test__get_section_exact(self):
446
self.get_location_config('http://www.example.com')
447
self.assertEqual('http://www.example.com',
448
self.my_config._get_section())
450
def test__get_section_suffix_does_not(self):
451
self.get_location_config('http://www.example.com-com')
452
self.assertEqual(None, self.my_config._get_section())
454
def test__get_section_subdir_recursive(self):
455
self.get_location_config('http://www.example.com/com')
456
self.assertEqual('http://www.example.com',
457
self.my_config._get_section())
459
def test__get_section_subdir_matches(self):
460
self.get_location_config('http://www.example.com/useglobal')
461
self.assertEqual('http://www.example.com/useglobal',
462
self.my_config._get_section())
464
def test__get_section_subdir_nonrecursive(self):
465
self.get_location_config(
466
'http://www.example.com/useglobal/childbranch')
467
self.assertEqual('http://www.example.com',
468
self.my_config._get_section())
470
def test__get_section_subdir_trailing_slash(self):
471
self.get_location_config('/b')
472
self.assertEqual('/b/', self.my_config._get_section())
474
def test__get_section_subdir_child(self):
475
self.get_location_config('/a/foo')
476
self.assertEqual('/a/*', self.my_config._get_section())
478
def test__get_section_subdir_child_child(self):
479
self.get_location_config('/a/foo/bar')
480
self.assertEqual('/a/', self.my_config._get_section())
482
def test__get_section_trailing_slash_with_children(self):
483
self.get_location_config('/a/')
484
self.assertEqual('/a/', self.my_config._get_section())
486
def test__get_section_explicit_over_glob(self):
487
self.get_location_config('/a/c')
488
self.assertEqual('/a/c', self.my_config._get_section())
671
def test__get_matching_sections_no_match(self):
672
self.get_branch_config('/')
673
self.assertEqual([], self.my_location_config._get_matching_sections())
675
def test__get_matching_sections_exact(self):
676
self.get_branch_config('http://www.example.com')
677
self.assertEqual([('http://www.example.com', '')],
678
self.my_location_config._get_matching_sections())
680
def test__get_matching_sections_suffix_does_not(self):
681
self.get_branch_config('http://www.example.com-com')
682
self.assertEqual([], self.my_location_config._get_matching_sections())
684
def test__get_matching_sections_subdir_recursive(self):
685
self.get_branch_config('http://www.example.com/com')
686
self.assertEqual([('http://www.example.com', 'com')],
687
self.my_location_config._get_matching_sections())
689
def test__get_matching_sections_ignoreparent(self):
690
self.get_branch_config('http://www.example.com/ignoreparent')
691
self.assertEqual([('http://www.example.com/ignoreparent', '')],
692
self.my_location_config._get_matching_sections())
694
def test__get_matching_sections_ignoreparent_subdir(self):
695
self.get_branch_config(
696
'http://www.example.com/ignoreparent/childbranch')
697
self.assertEqual([('http://www.example.com/ignoreparent',
699
self.my_location_config._get_matching_sections())
701
def test__get_matching_sections_subdir_trailing_slash(self):
702
self.get_branch_config('/b')
703
self.assertEqual([('/b/', '')],
704
self.my_location_config._get_matching_sections())
706
def test__get_matching_sections_subdir_child(self):
707
self.get_branch_config('/a/foo')
708
self.assertEqual([('/a/*', ''), ('/a/', 'foo')],
709
self.my_location_config._get_matching_sections())
711
def test__get_matching_sections_subdir_child_child(self):
712
self.get_branch_config('/a/foo/bar')
713
self.assertEqual([('/a/*', 'bar'), ('/a/', 'foo/bar')],
714
self.my_location_config._get_matching_sections())
716
def test__get_matching_sections_trailing_slash_with_children(self):
717
self.get_branch_config('/a/')
718
self.assertEqual([('/a/', '')],
719
self.my_location_config._get_matching_sections())
721
def test__get_matching_sections_explicit_over_glob(self):
722
# XXX: 2006-09-08 jamesh
723
# This test only passes because ord('c') > ord('*'). If there
724
# was a config section for '/a/?', it would get precedence
726
self.get_branch_config('/a/c')
727
self.assertEqual([('/a/c', ''), ('/a/*', ''), ('/a/', 'c')],
728
self.my_location_config._get_matching_sections())
730
def test__get_option_policy_normal(self):
731
self.get_branch_config('http://www.example.com')
733
self.my_location_config._get_config_policy(
734
'http://www.example.com', 'normal_option'),
737
def test__get_option_policy_norecurse(self):
738
self.get_branch_config('http://www.example.com')
740
self.my_location_config._get_option_policy(
741
'http://www.example.com', 'norecurse_option'),
742
config.POLICY_NORECURSE)
743
# Test old recurse=False setting:
745
self.my_location_config._get_option_policy(
746
'http://www.example.com/norecurse', 'normal_option'),
747
config.POLICY_NORECURSE)
749
def test__get_option_policy_normal(self):
750
self.get_branch_config('http://www.example.com')
752
self.my_location_config._get_option_policy(
753
'http://www.example.com', 'appendpath_option'),
754
config.POLICY_APPENDPATH)
491
756
def test_location_without_username(self):
492
self.get_location_config('http://www.example.com/useglobal')
757
self.get_branch_config('http://www.example.com/ignoreparent')
493
758
self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
494
759
self.my_config.username())
496
761
def test_location_not_listed(self):
497
762
"""Test that the global username is used when no location matches"""
498
self.get_location_config('/home/robertc/sources')
763
self.get_branch_config('/home/robertc/sources')
499
764
self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
500
765
self.my_config.username())
502
767
def test_overriding_location(self):
503
self.get_location_config('http://www.example.com/foo')
768
self.get_branch_config('http://www.example.com/foo')
504
769
self.assertEqual('Robert Collins <robertc@example.org>',
505
770
self.my_config.username())
507
772
def test_signatures_not_set(self):
508
self.get_location_config('http://www.example.com',
773
self.get_branch_config('http://www.example.com',
509
774
global_config=sample_ignore_signatures)
510
775
self.assertEqual(config.CHECK_ALWAYS,
511
776
self.my_config.signature_checking())
513
778
self.my_config.signing_policy())
515
780
def test_signatures_never(self):
516
self.get_location_config('/a/c')
781
self.get_branch_config('/a/c')
517
782
self.assertEqual(config.CHECK_NEVER,
518
783
self.my_config.signature_checking())
520
785
def test_signatures_when_available(self):
521
self.get_location_config('/a/', global_config=sample_ignore_signatures)
786
self.get_branch_config('/a/', global_config=sample_ignore_signatures)
522
787
self.assertEqual(config.CHECK_IF_POSSIBLE,
523
788
self.my_config.signature_checking())
525
790
def test_signatures_always(self):
526
self.get_location_config('/b')
791
self.get_branch_config('/b')
527
792
self.assertEqual(config.CHECK_ALWAYS,
528
793
self.my_config.signature_checking())
530
795
def test_gpg_signing_command(self):
531
self.get_location_config('/b')
796
self.get_branch_config('/b')
532
797
self.assertEqual("gnome-gpg", self.my_config.gpg_signing_command())
534
799
def test_gpg_signing_command_missing(self):
535
self.get_location_config('/a')
800
self.get_branch_config('/a')
536
801
self.assertEqual("false", self.my_config.gpg_signing_command())
538
803
def test_get_user_option_global(self):
539
self.get_location_config('/a')
804
self.get_branch_config('/a')
540
805
self.assertEqual('something',
541
806
self.my_config.get_user_option('user_global_option'))
543
808
def test_get_user_option_local(self):
544
self.get_location_config('/a')
809
self.get_branch_config('/a')
545
810
self.assertEqual('local',
546
811
self.my_config.get_user_option('user_local_option'))
813
def test_get_user_option_appendpath(self):
814
# returned as is for the base path:
815
self.get_branch_config('http://www.example.com')
816
self.assertEqual('append',
817
self.my_config.get_user_option('appendpath_option'))
818
# Extra path components get appended:
819
self.get_branch_config('http://www.example.com/a/b/c')
820
self.assertEqual('append/a/b/c',
821
self.my_config.get_user_option('appendpath_option'))
822
# Overriden for http://www.example.com/dir, where it is a
824
self.get_branch_config('http://www.example.com/dir/a/b/c')
825
self.assertEqual('normal',
826
self.my_config.get_user_option('appendpath_option'))
828
def test_get_user_option_norecurse(self):
829
self.get_branch_config('http://www.example.com')
830
self.assertEqual('norecurse',
831
self.my_config.get_user_option('norecurse_option'))
832
self.get_branch_config('http://www.example.com/dir')
833
self.assertEqual(None,
834
self.my_config.get_user_option('norecurse_option'))
835
# http://www.example.com/norecurse is a recurse=False section
836
# that redefines normal_option. Subdirectories do not pick up
838
self.get_branch_config('http://www.example.com/norecurse')
839
self.assertEqual('norecurse',
840
self.my_config.get_user_option('normal_option'))
841
self.get_branch_config('http://www.example.com/norecurse/subdir')
842
self.assertEqual('normal',
843
self.my_config.get_user_option('normal_option'))
845
def test_set_user_option_norecurse(self):
846
self.get_branch_config('http://www.example.com')
847
self.my_config.set_user_option('foo', 'bar',
848
store=config.STORE_LOCATION_NORECURSE)
850
self.my_location_config._get_option_policy(
851
'http://www.example.com', 'foo'),
852
config.POLICY_NORECURSE)
854
def test_set_user_option_appendpath(self):
855
self.get_branch_config('http://www.example.com')
856
self.my_config.set_user_option('foo', 'bar',
857
store=config.STORE_LOCATION_APPENDPATH)
859
self.my_location_config._get_option_policy(
860
'http://www.example.com', 'foo'),
861
config.POLICY_APPENDPATH)
863
def test_set_user_option_change_policy(self):
864
self.get_branch_config('http://www.example.com')
865
self.my_config.set_user_option('norecurse_option', 'normal',
866
store=config.STORE_LOCATION)
868
self.my_location_config._get_option_policy(
869
'http://www.example.com', 'norecurse_option'),
872
def test_set_user_option_recurse_false_section(self):
873
# The following section has recurse=False set. The test is to
874
# make sure that a normal option can be added to the section,
875
# converting recurse=False to the norecurse policy.
876
self.get_branch_config('http://www.example.com/norecurse')
877
self.callDeprecated(['The recurse option is deprecated as of 0.14. '
878
'The section "http://www.example.com/norecurse" '
879
'has been converted to use policies.'],
880
self.my_config.set_user_option,
881
'foo', 'bar', store=config.STORE_LOCATION)
883
self.my_location_config._get_option_policy(
884
'http://www.example.com/norecurse', 'foo'),
886
# The previously existing option is still norecurse:
888
self.my_location_config._get_option_policy(
889
'http://www.example.com/norecurse', 'normal_option'),
890
config.POLICY_NORECURSE)
548
892
def test_post_commit_default(self):
549
self.get_location_config('/a/c')
893
self.get_branch_config('/a/c')
550
894
self.assertEqual('bzrlib.tests.test_config.post_commit',
551
895
self.my_config.post_commit())
553
def get_location_config(self, location, global_config=None):
897
def get_branch_config(self, location, global_config=None):
554
898
if global_config is None:
555
899
global_file = StringIO(sample_config_text.encode('utf-8'))
557
901
global_file = StringIO(global_config.encode('utf-8'))
558
902
branches_file = StringIO(sample_branches_text.encode('utf-8'))
559
self.my_config = config.LocationConfig(location)
560
self.my_config._get_parser(branches_file)
903
self.my_config = config.BranchConfig(FakeBranch(location))
904
# Force location config to use specified file
905
self.my_location_config = self.my_config._get_location_config()
906
self.my_location_config._get_parser(branches_file)
907
# Force global config to use specified file
561
908
self.my_config._get_global_config()._get_parser(global_file)
563
910
def test_set_user_setting_sets_and_saves(self):
564
self.get_location_config('/a/c')
911
self.get_branch_config('/a/c')
565
912
record = InstrumentedConfigObj("foo")
566
self.my_config._parser = record
913
self.my_location_config._parser = record
568
915
real_mkdir = os.mkdir
569
916
self.created = False
584
935
('__setitem__', '/a/c', {}),
585
936
('__getitem__', '/a/c'),
586
937
('__setitem__', 'foo', 'bar'),
938
('__getitem__', '/a/c'),
939
('as_bool', 'recurse'),
940
('__getitem__', '/a/c'),
941
('__delitem__', 'recurse'),
942
('__getitem__', '/a/c'),
944
('__getitem__', '/a/c'),
945
('__contains__', 'foo:policy'),
588
947
record._calls[1:])
591
class TestBranchConfigItems(TestCase):
949
def test_set_user_setting_sets_and_saves2(self):
950
self.get_branch_config('/a/c')
951
self.assertIs(self.my_config.get_user_option('foo'), None)
952
self.my_config.set_user_option('foo', 'bar')
954
self.my_config.branch.control_files.files['branch.conf'].strip(),
956
self.assertEqual(self.my_config.get_user_option('foo'), 'bar')
957
self.my_config.set_user_option('foo', 'baz',
958
store=config.STORE_LOCATION)
959
self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
960
self.my_config.set_user_option('foo', 'qux')
961
self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
963
def test_get_bzr_remote_path(self):
964
my_config = config.LocationConfig('/a/c')
965
self.assertEqual('bzr', my_config.get_bzr_remote_path())
966
my_config.set_user_option('bzr_remote_path', '/path-bzr')
967
self.assertEqual('/path-bzr', my_config.get_bzr_remote_path())
968
os.environ['BZR_REMOTE_PATH'] = '/environ-bzr'
969
self.assertEqual('/environ-bzr', my_config.get_bzr_remote_path())
972
precedence_global = 'option = global'
973
precedence_branch = 'option = branch'
974
precedence_location = """
978
[http://example.com/specific]
983
class TestBranchConfigItems(tests.TestCaseInTempDir):
985
def get_branch_config(self, global_config=None, location=None,
986
location_config=None, branch_data_config=None):
987
my_config = config.BranchConfig(FakeBranch(location))
988
if global_config is not None:
989
global_file = StringIO(global_config.encode('utf-8'))
990
my_config._get_global_config()._get_parser(global_file)
991
self.my_location_config = my_config._get_location_config()
992
if location_config is not None:
993
location_file = StringIO(location_config.encode('utf-8'))
994
self.my_location_config._get_parser(location_file)
995
if branch_data_config is not None:
996
my_config.branch.control_files.files['branch.conf'] = \
593
1000
def test_user_id(self):
594
branch = FakeBranch()
1001
branch = FakeBranch(user_id='Robert Collins <robertc@example.net>')
595
1002
my_config = config.BranchConfig(branch)
596
1003
self.assertEqual("Robert Collins <robertc@example.net>",
597
my_config._get_user_id())
598
branch.control_files.email = "John"
599
self.assertEqual("John", my_config._get_user_id())
1004
my_config.username())
1005
my_config.branch.control_files.files['email'] = "John"
1006
my_config.set_user_option('email',
1007
"Robert Collins <robertc@example.org>")
1008
self.assertEqual("John", my_config.username())
1009
del my_config.branch.control_files.files['email']
1010
self.assertEqual("Robert Collins <robertc@example.org>",
1011
my_config.username())
601
1013
def test_not_set_in_branch(self):
602
branch = FakeBranch()
603
my_config = config.BranchConfig(branch)
604
branch.control_files.email = None
605
config_file = StringIO(sample_config_text.encode('utf-8'))
606
(my_config._get_location_config().
607
_get_global_config()._get_parser(config_file))
1014
my_config = self.get_branch_config(sample_config_text)
608
1015
self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
609
1016
my_config._get_user_id())
610
branch.control_files.email = "John"
1017
my_config.branch.control_files.files['email'] = "John"
611
1018
self.assertEqual("John", my_config._get_user_id())
613
def test_BZREMAIL_OVERRIDES(self):
614
os.environ['BZREMAIL'] = "Robert Collins <robertc@example.org>"
1020
def test_BZR_EMAIL_OVERRIDES(self):
1021
os.environ['BZR_EMAIL'] = "Robert Collins <robertc@example.org>"
615
1022
branch = FakeBranch()
616
1023
my_config = config.BranchConfig(branch)
617
1024
self.assertEqual("Robert Collins <robertc@example.org>",
618
1025
my_config.username())
620
1027
def test_signatures_forced(self):
621
branch = FakeBranch()
622
my_config = config.BranchConfig(branch)
623
config_file = StringIO(sample_always_signatures)
624
(my_config._get_location_config().
625
_get_global_config()._get_parser(config_file))
1028
my_config = self.get_branch_config(
1029
global_config=sample_always_signatures)
1030
self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
1031
self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
1032
self.assertTrue(my_config.signature_needed())
1034
def test_signatures_forced_branch(self):
1035
my_config = self.get_branch_config(
1036
global_config=sample_ignore_signatures,
1037
branch_data_config=sample_always_signatures)
626
1038
self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
627
1039
self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
628
1040
self.assertTrue(my_config.signature_needed())
630
1042
def test_gpg_signing_command(self):
631
branch = FakeBranch()
632
my_config = config.BranchConfig(branch)
1043
my_config = self.get_branch_config(
1044
# branch data cannot set gpg_signing_command
1045
branch_data_config="gpg_signing_command=pgp")
633
1046
config_file = StringIO(sample_config_text.encode('utf-8'))
634
(my_config._get_location_config().
635
_get_global_config()._get_parser(config_file))
1047
my_config._get_global_config()._get_parser(config_file)
636
1048
self.assertEqual('gnome-gpg', my_config.gpg_signing_command())
638
1050
def test_get_user_option_global(self):
639
1051
branch = FakeBranch()
640
1052
my_config = config.BranchConfig(branch)
641
1053
config_file = StringIO(sample_config_text.encode('utf-8'))
642
(my_config._get_location_config().
643
_get_global_config()._get_parser(config_file))
1054
(my_config._get_global_config()._get_parser(config_file))
644
1055
self.assertEqual('something',
645
1056
my_config.get_user_option('user_global_option'))
647
1058
def test_post_commit_default(self):
648
1059
branch = FakeBranch()
650
my_config = config.BranchConfig(branch)
651
config_file = StringIO(sample_config_text.encode('utf-8'))
652
(my_config._get_location_config().
653
_get_global_config()._get_parser(config_file))
654
branch_file = StringIO(sample_branches_text)
655
my_config._get_location_config()._get_parser(branch_file)
656
self.assertEqual('bzrlib.tests.test_config.post_commit',
657
my_config.post_commit())
660
class TestMailAddressExtraction(TestCase):
1060
my_config = self.get_branch_config(sample_config_text, '/a/c',
1061
sample_branches_text)
1062
self.assertEqual(my_config.branch.base, '/a/c')
1063
self.assertEqual('bzrlib.tests.test_config.post_commit',
1064
my_config.post_commit())
1065
my_config.set_user_option('post_commit', 'rmtree_root')
1066
# post-commit is ignored when bresent in branch data
1067
self.assertEqual('bzrlib.tests.test_config.post_commit',
1068
my_config.post_commit())
1069
my_config.set_user_option('post_commit', 'rmtree_root',
1070
store=config.STORE_LOCATION)
1071
self.assertEqual('rmtree_root', my_config.post_commit())
1073
def test_config_precedence(self):
1074
my_config = self.get_branch_config(global_config=precedence_global)
1075
self.assertEqual(my_config.get_user_option('option'), 'global')
1076
my_config = self.get_branch_config(global_config=precedence_global,
1077
branch_data_config=precedence_branch)
1078
self.assertEqual(my_config.get_user_option('option'), 'branch')
1079
my_config = self.get_branch_config(global_config=precedence_global,
1080
branch_data_config=precedence_branch,
1081
location_config=precedence_location)
1082
self.assertEqual(my_config.get_user_option('option'), 'recurse')
1083
my_config = self.get_branch_config(global_config=precedence_global,
1084
branch_data_config=precedence_branch,
1085
location_config=precedence_location,
1086
location='http://example.com/specific')
1087
self.assertEqual(my_config.get_user_option('option'), 'exact')
1089
def test_get_mail_client(self):
1090
config = self.get_branch_config()
1091
client = config.get_mail_client()
1092
self.assertIsInstance(client, mail_client.DefaultMail)
1095
config.set_user_option('mail_client', 'evolution')
1096
client = config.get_mail_client()
1097
self.assertIsInstance(client, mail_client.Evolution)
1099
config.set_user_option('mail_client', 'kmail')
1100
client = config.get_mail_client()
1101
self.assertIsInstance(client, mail_client.KMail)
1103
config.set_user_option('mail_client', 'mutt')
1104
client = config.get_mail_client()
1105
self.assertIsInstance(client, mail_client.Mutt)
1107
config.set_user_option('mail_client', 'thunderbird')
1108
client = config.get_mail_client()
1109
self.assertIsInstance(client, mail_client.Thunderbird)
1112
config.set_user_option('mail_client', 'default')
1113
client = config.get_mail_client()
1114
self.assertIsInstance(client, mail_client.DefaultMail)
1116
config.set_user_option('mail_client', 'editor')
1117
client = config.get_mail_client()
1118
self.assertIsInstance(client, mail_client.Editor)
1120
config.set_user_option('mail_client', 'mapi')
1121
client = config.get_mail_client()
1122
self.assertIsInstance(client, mail_client.MAPIClient)
1124
config.set_user_option('mail_client', 'xdg-email')
1125
client = config.get_mail_client()
1126
self.assertIsInstance(client, mail_client.XDGEmail)
1128
config.set_user_option('mail_client', 'firebird')
1129
self.assertRaises(errors.UnknownMailClient, config.get_mail_client)
1132
class TestMailAddressExtraction(tests.TestCase):
662
1134
def test_extract_email_address(self):
663
1135
self.assertEqual('jane@test.com',
664
1136
config.extract_email_address('Jane <jane@test.com>'))
665
self.assertRaises(errors.BzrError,
1137
self.assertRaises(errors.NoEmailInUsername,
666
1138
config.extract_email_address, 'Jane Tester')
1140
def test_parse_username(self):
1141
self.assertEqual(('', 'jdoe@example.com'),
1142
config.parse_username('jdoe@example.com'))
1143
self.assertEqual(('', 'jdoe@example.com'),
1144
config.parse_username('<jdoe@example.com>'))
1145
self.assertEqual(('John Doe', 'jdoe@example.com'),
1146
config.parse_username('John Doe <jdoe@example.com>'))
1147
self.assertEqual(('John Doe', ''),
1148
config.parse_username('John Doe'))
1149
self.assertEqual(('John Doe', 'jdoe@example.com'),
1150
config.parse_username('John Doe jdoe@example.com'))
1152
class TestTreeConfig(tests.TestCaseWithTransport):
1154
def test_get_value(self):
1155
"""Test that retreiving a value from a section is possible"""
1156
branch = self.make_branch('.')
1157
tree_config = config.TreeConfig(branch)
1158
tree_config.set_option('value', 'key', 'SECTION')
1159
tree_config.set_option('value2', 'key2')
1160
tree_config.set_option('value3-top', 'key3')
1161
tree_config.set_option('value3-section', 'key3', 'SECTION')
1162
value = tree_config.get_option('key', 'SECTION')
1163
self.assertEqual(value, 'value')
1164
value = tree_config.get_option('key2')
1165
self.assertEqual(value, 'value2')
1166
self.assertEqual(tree_config.get_option('non-existant'), None)
1167
value = tree_config.get_option('non-existant', 'SECTION')
1168
self.assertEqual(value, None)
1169
value = tree_config.get_option('non-existant', default='default')
1170
self.assertEqual(value, 'default')
1171
self.assertEqual(tree_config.get_option('key2', 'NOSECTION'), None)
1172
value = tree_config.get_option('key2', 'NOSECTION', default='default')
1173
self.assertEqual(value, 'default')
1174
value = tree_config.get_option('key3')
1175
self.assertEqual(value, 'value3-top')
1176
value = tree_config.get_option('key3', 'SECTION')
1177
self.assertEqual(value, 'value3-section')
1180
class TestTransportConfig(tests.TestCaseWithTransport):
1182
def test_get_value(self):
1183
"""Test that retreiving a value from a section is possible"""
1184
bzrdir_config = config.TransportConfig(transport.get_transport('.'),
1186
bzrdir_config.set_option('value', 'key', 'SECTION')
1187
bzrdir_config.set_option('value2', 'key2')
1188
bzrdir_config.set_option('value3-top', 'key3')
1189
bzrdir_config.set_option('value3-section', 'key3', 'SECTION')
1190
value = bzrdir_config.get_option('key', 'SECTION')
1191
self.assertEqual(value, 'value')
1192
value = bzrdir_config.get_option('key2')
1193
self.assertEqual(value, 'value2')
1194
self.assertEqual(bzrdir_config.get_option('non-existant'), None)
1195
value = bzrdir_config.get_option('non-existant', 'SECTION')
1196
self.assertEqual(value, None)
1197
value = bzrdir_config.get_option('non-existant', default='default')
1198
self.assertEqual(value, 'default')
1199
self.assertEqual(bzrdir_config.get_option('key2', 'NOSECTION'), None)
1200
value = bzrdir_config.get_option('key2', 'NOSECTION',
1202
self.assertEqual(value, 'default')
1203
value = bzrdir_config.get_option('key3')
1204
self.assertEqual(value, 'value3-top')
1205
value = bzrdir_config.get_option('key3', 'SECTION')
1206
self.assertEqual(value, 'value3-section')
1208
def test_set_unset_default_stack_on(self):
1209
my_dir = self.make_bzrdir('.')
1210
bzrdir_config = config.BzrDirConfig(my_dir.transport)
1211
self.assertIs(None, bzrdir_config.get_default_stack_on())
1212
bzrdir_config.set_default_stack_on('Foo')
1213
self.assertEqual('Foo', bzrdir_config._config.get_option(
1214
'default_stack_on'))
1215
self.assertEqual('Foo', bzrdir_config.get_default_stack_on())
1216
bzrdir_config.set_default_stack_on(None)
1217
self.assertIs(None, bzrdir_config.get_default_stack_on())
1220
class TestAuthenticationConfigFile(tests.TestCase):
1221
"""Test the authentication.conf file matching"""
1223
def _got_user_passwd(self, expected_user, expected_password,
1224
config, *args, **kwargs):
1225
credentials = config.get_credentials(*args, **kwargs)
1226
if credentials is None:
1230
user = credentials['user']
1231
password = credentials['password']
1232
self.assertEquals(expected_user, user)
1233
self.assertEquals(expected_password, password)
1235
def test_empty_config(self):
1236
conf = config.AuthenticationConfig(_file=StringIO())
1237
self.assertEquals({}, conf._get_config())
1238
self._got_user_passwd(None, None, conf, 'http', 'foo.net')
1240
def test_missing_auth_section_header(self):
1241
conf = config.AuthenticationConfig(_file=StringIO('foo = bar'))
1242
self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1244
def test_auth_section_header_not_closed(self):
1245
conf = config.AuthenticationConfig(_file=StringIO('[DEF'))
1246
self.assertRaises(errors.ParseConfigError, conf._get_config)
1248
def test_auth_value_not_boolean(self):
1249
conf = config.AuthenticationConfig(_file=StringIO(
1253
verify_certificates=askme # Error: Not a boolean
1255
self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1257
def test_auth_value_not_int(self):
1258
conf = config.AuthenticationConfig(_file=StringIO(
1262
port=port # Error: Not an int
1264
self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1266
def test_unknown_password_encoding(self):
1267
conf = config.AuthenticationConfig(_file=StringIO(
1271
password_encoding=unknown
1273
self.assertRaises(ValueError, conf.get_password,
1274
'ftp', 'foo.net', 'joe')
1276
def test_credentials_for_scheme_host(self):
1277
conf = config.AuthenticationConfig(_file=StringIO(
1278
"""# Identity on foo.net
1283
password=secret-pass
1286
self._got_user_passwd('joe', 'secret-pass', conf, 'ftp', 'foo.net')
1288
self._got_user_passwd(None, None, conf, 'http', 'foo.net')
1290
self._got_user_passwd(None, None, conf, 'ftp', 'bar.net')
1292
def test_credentials_for_host_port(self):
1293
conf = config.AuthenticationConfig(_file=StringIO(
1294
"""# Identity on foo.net
1300
password=secret-pass
1303
self._got_user_passwd('joe', 'secret-pass',
1304
conf, 'ftp', 'foo.net', port=10021)
1306
self._got_user_passwd(None, None, conf, 'ftp', 'foo.net')
1308
def test_for_matching_host(self):
1309
conf = config.AuthenticationConfig(_file=StringIO(
1310
"""# Identity on foo.net
1316
[sourceforge domain]
1323
self._got_user_passwd('georges', 'bendover',
1324
conf, 'bzr', 'foo.bzr.sf.net')
1326
self._got_user_passwd(None, None,
1327
conf, 'bzr', 'bbzr.sf.net')
1329
def test_for_matching_host_None(self):
1330
conf = config.AuthenticationConfig(_file=StringIO(
1331
"""# Identity on foo.net
1341
self._got_user_passwd('joe', 'joepass',
1342
conf, 'bzr', 'quux.net')
1343
# no host but different scheme
1344
self._got_user_passwd('georges', 'bendover',
1345
conf, 'ftp', 'quux.net')
1347
def test_credentials_for_path(self):
1348
conf = config.AuthenticationConfig(_file=StringIO(
1364
self._got_user_passwd(None, None,
1365
conf, 'http', host='bar.org', path='/dir3')
1367
self._got_user_passwd('georges', 'bendover',
1368
conf, 'http', host='bar.org', path='/dir2')
1370
self._got_user_passwd('jim', 'jimpass',
1371
conf, 'http', host='bar.org',path='/dir1/subdir')
1373
def test_credentials_for_user(self):
1374
conf = config.AuthenticationConfig(_file=StringIO(
1383
self._got_user_passwd('jim', 'jimpass',
1384
conf, 'http', 'bar.org')
1386
self._got_user_passwd('jim', 'jimpass',
1387
conf, 'http', 'bar.org', user='jim')
1388
# Don't get a different user if one is specified
1389
self._got_user_passwd(None, None,
1390
conf, 'http', 'bar.org', user='georges')
1392
def test_credentials_for_user_without_password(self):
1393
conf = config.AuthenticationConfig(_file=StringIO(
1400
# Get user but no password
1401
self._got_user_passwd('jim', None,
1402
conf, 'http', 'bar.org')
1404
def test_verify_certificates(self):
1405
conf = config.AuthenticationConfig(_file=StringIO(
1412
verify_certificates=False
1419
credentials = conf.get_credentials('https', 'bar.org')
1420
self.assertEquals(False, credentials.get('verify_certificates'))
1421
credentials = conf.get_credentials('https', 'foo.net')
1422
self.assertEquals(True, credentials.get('verify_certificates'))
1425
class TestAuthenticationStorage(tests.TestCaseInTempDir):
1427
def test_set_credentials(self):
1428
conf = config.AuthenticationConfig()
1429
conf.set_credentials('name', 'host', 'user', 'scheme', 'password',
1430
99, path='/foo', verify_certificates=False)
1431
credentials = conf.get_credentials(host='host', scheme='scheme',
1432
port=99, path='/foo')
1433
CREDENTIALS = {'name': 'name', 'user': 'user', 'password': 'password',
1434
'verify_certificates': False,}
1435
self.assertEqual(CREDENTIALS, credentials)
1436
credentials_from_disk = config.AuthenticationConfig().get_credentials(
1437
host='host', scheme='scheme', port=99, path='/foo')
1438
self.assertEqual(CREDENTIALS, credentials_from_disk)
1440
def test_reset_credentials_different_name(self):
1441
conf = config.AuthenticationConfig()
1442
conf.set_credentials('name', 'host', 'user', 'scheme', 'password'),
1443
conf.set_credentials('name2', 'host', 'user2', 'scheme', 'password'),
1444
self.assertIs(None, conf._get_config().get('name'))
1445
credentials = conf.get_credentials(host='host', scheme='scheme')
1446
CREDENTIALS = {'name': 'name2', 'user': 'user2', 'password':
1447
'password', 'verify_certificates': True}
1448
self.assertEqual(CREDENTIALS, credentials)
1451
class TestAuthenticationConfig(tests.TestCase):
1452
"""Test AuthenticationConfig behaviour"""
1454
def _check_default_prompt(self, expected_prompt_format, scheme,
1455
host=None, port=None, realm=None, path=None):
1458
user, password = 'jim', 'precious'
1459
expected_prompt = expected_prompt_format % {
1460
'scheme': scheme, 'host': host, 'port': port,
1461
'user': user, 'realm': realm}
1463
stdout = tests.StringIOWrapper()
1464
ui.ui_factory = tests.TestUIFactory(stdin=password + '\n',
1466
# We use an empty conf so that the user is always prompted
1467
conf = config.AuthenticationConfig()
1468
self.assertEquals(password,
1469
conf.get_password(scheme, host, user, port=port,
1470
realm=realm, path=path))
1471
self.assertEquals(stdout.getvalue(), expected_prompt)
1473
def test_default_prompts(self):
1474
# HTTP prompts can't be tested here, see test_http.py
1475
self._check_default_prompt('FTP %(user)s@%(host)s password: ', 'ftp')
1476
self._check_default_prompt('FTP %(user)s@%(host)s:%(port)d password: ',
1479
self._check_default_prompt('SSH %(user)s@%(host)s:%(port)d password: ',
1481
# SMTP port handling is a bit special (it's handled if embedded in the
1483
# FIXME: should we: forbid that, extend it to other schemes, leave
1484
# things as they are that's fine thank you ?
1485
self._check_default_prompt('SMTP %(user)s@%(host)s password: ',
1487
self._check_default_prompt('SMTP %(user)s@%(host)s password: ',
1488
'smtp', host='bar.org:10025')
1489
self._check_default_prompt(
1490
'SMTP %(user)s@%(host)s:%(port)d password: ',
1493
def test_ssh_password_emits_warning(self):
1494
conf = config.AuthenticationConfig(_file=StringIO(
1502
entered_password = 'typed-by-hand'
1503
stdout = tests.StringIOWrapper()
1504
ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1507
# Since the password defined in the authentication config is ignored,
1508
# the user is prompted
1509
self.assertEquals(entered_password,
1510
conf.get_password('ssh', 'bar.org', user='jim'))
1511
self.assertContainsRe(
1512
self._get_log(keep_log_file=True),
1513
'password ignored in section \[ssh with password\]')
1515
def test_ssh_without_password_doesnt_emit_warning(self):
1516
conf = config.AuthenticationConfig(_file=StringIO(
1523
entered_password = 'typed-by-hand'
1524
stdout = tests.StringIOWrapper()
1525
ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1528
# Since the password defined in the authentication config is ignored,
1529
# the user is prompted
1530
self.assertEquals(entered_password,
1531
conf.get_password('ssh', 'bar.org', user='jim'))
1532
# No warning shoud be emitted since there is no password. We are only
1534
self.assertNotContainsRe(
1535
self._get_log(keep_log_file=True),
1536
'password ignored in section \[ssh with password\]')
1539
class TestCredentialStoreRegistry(tests.TestCase):
1541
def _get_cs_registry(self):
1542
return config.credential_store_registry
1544
def test_default_credential_store(self):
1545
r = self._get_cs_registry()
1546
default = r.get_credential_store(None)
1547
self.assertIsInstance(default, config.PlainTextCredentialStore)
1549
def test_unknown_credential_store(self):
1550
r = self._get_cs_registry()
1551
# It's hard to imagine someone creating a credential store named
1552
# 'unknown' so we use that as an never registered key.
1553
self.assertRaises(KeyError, r.get_credential_store, 'unknown')
1556
class TestPlainTextCredentialStore(tests.TestCase):
1558
def test_decode_password(self):
1559
r = config.credential_store_registry
1560
plain_text = r.get_credential_store()
1561
decoded = plain_text.decode_password(dict(password='secret'))
1562
self.assertEquals('secret', decoded)
1565
# FIXME: Once we have a way to declare authentication to all test servers, we
1566
# can implement generic tests.
1567
# test_user_password_in_url
1568
# test_user_in_url_password_from_config
1569
# test_user_in_url_password_prompted
1570
# test_user_in_config
1571
# test_user_getpass.getuser
1572
# test_user_prompted ?
1573
class TestAuthenticationRing(tests.TestCaseWithTransport):
added
removed
bzrlib/tests/test_config.py
