← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_config.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-11-04 18:51:39 UTC
  • mfrom: (2961.1.1 trunk)
  • Revision ID: pqm@pqm.ubuntu.com-20071104185139-kaio3sneodg2kp71
Authentication ring implementation (read-only)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_config.py
17
17
 
18
18
"""Tests for finding and reading the bzr config file[s]."""
19
19
# import system imports here
 
20
from bzrlib.util.configobj.configobj import ConfigObj, ConfigObjError
20
21
from cStringIO import StringIO
21
22
import os
22
23
import sys
33
34
    urlutils,
34
35
    tests,
35
36
    trace,
36
 
    transport,
37
37
    )
38
 
from bzrlib.util.configobj import configobj
39
38
 
40
39
 
41
40
sample_long_alias="log -r-15..-1 --line"
147
146
            self.base = "http://example.com/branches/demo"
148
147
        else:
149
148
            self.base = base
150
 
        self._transport = self.control_files = \
151
 
            FakeControlFilesAndTransport(user_id=user_id)
 
149
        self.control_files = FakeControlFiles(user_id=user_id)
152
150
 
153
151
    def lock_write(self):
154
152
        pass
157
155
        pass
158
156
 
159
157
 
160
 
class FakeControlFilesAndTransport(object):
 
158
class FakeControlFiles(object):
161
159
 
162
160
    def __init__(self, user_id=None):
 
161
        self.email = user_id
163
162
        self.files = {}
164
 
        if user_id:
165
 
            self.files['email'] = user_id
166
 
        self._transport = self
167
163
 
168
164
    def get_utf8(self, filename):
169
 
        # from LockableFiles
170
 
        raise AssertionError("get_utf8 should no longer be used")
 
165
        if filename != 'email':
 
166
            raise NotImplementedError
 
167
        if self.email is not None:
 
168
            return StringIO(self.email)
 
169
        raise errors.NoSuchFile(filename)
171
170
 
172
171
    def get(self, filename):
173
 
        # from Transport
174
172
        try:
175
173
            return StringIO(self.files[filename])
176
174
        except KeyError:
177
175
            raise errors.NoSuchFile(filename)
178
176
 
179
 
    def get_bytes(self, filename):
180
 
        # from Transport
181
 
        try:
182
 
            return self.files[filename]
183
 
        except KeyError:
184
 
            raise errors.NoSuchFile(filename)
185
 
 
186
177
    def put(self, filename, fileobj):
187
178
        self.files[filename] = fileobj.read()
188
179
 
189
 
    def put_file(self, filename, fileobj):
190
 
        return self.put(filename, fileobj)
191
 
 
192
180
 
193
181
class InstrumentedConfig(config.Config):
194
182
    """An instrumented config that supplies stubs for template methods."""
195
 
 
 
183
    
196
184
    def __init__(self):
197
185
        super(InstrumentedConfig, self).__init__()
198
186
        self._calls = []
214
202
active = True
215
203
nonactive = False
216
204
"""
217
 
 
218
 
 
219
205
class TestConfigObj(tests.TestCase):
220
 
 
221
206
    def test_get_bool(self):
222
 
        co = config.ConfigObj(StringIO(bool_config))
 
207
        from bzrlib.config import ConfigObj
 
208
        co = ConfigObj(StringIO(bool_config))
223
209
        self.assertIs(co.get_bool('DEFAULT', 'active'), True)
224
210
        self.assertIs(co.get_bool('DEFAULT', 'inactive'), False)
225
211
        self.assertIs(co.get_bool('UPPERCASE', 'active'), True)
226
212
        self.assertIs(co.get_bool('UPPERCASE', 'nonactive'), False)
227
213
 
228
 
    def test_hash_sign_in_value(self):
229
 
        """
230
 
        Before 4.5.0, ConfigObj did not quote # signs in values, so they'd be
231
 
        treated as comments when read in again. (#86838)
232
 
        """
233
 
        co = config.ConfigObj()
234
 
        co['test'] = 'foo#bar'
235
 
        lines = co.write()
236
 
        self.assertEqual(lines, ['test = "foo#bar"'])
237
 
        co2 = config.ConfigObj(lines)
238
 
        self.assertEqual(co2['test'], 'foo#bar')
239
 
 
240
214
 
241
215
erroneous_config = """[section] # line 1
242
216
good=good # line 2
243
217
[section] # line 3
244
218
whocares=notme # line 4
245
219
"""
246
 
 
247
 
 
248
220
class TestConfigObjErrors(tests.TestCase):
249
221
 
250
222
    def test_duplicate_section_name_error_line(self):
251
223
        try:
252
 
            co = configobj.ConfigObj(StringIO(erroneous_config),
253
 
                                     raise_errors=True)
 
224
            co = ConfigObj(StringIO(erroneous_config), raise_errors=True)
254
225
        except config.configobj.DuplicateError, e:
255
226
            self.assertEqual(3, e.line_number)
256
227
        else:
257
228
            self.fail('Error in config file not detected')
258
229
 
259
 
 
260
230
class TestConfig(tests.TestCase):
261
231
 
262
232
    def test_constructs(self):
263
233
        config.Config()
264
 
 
 
234
 
265
235
    def test_no_default_editor(self):
266
236
        self.assertRaises(NotImplementedError, config.Config().get_editor)
267
237
 
321
291
        if sys.platform == 'win32':
322
292
            os.environ['BZR_HOME'] = \
323
293
                r'C:\Documents and Settings\bogus\Application Data'
324
 
            self.bzr_home = \
325
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0'
326
 
        else:
327
 
            self.bzr_home = '/home/bogus/.bazaar'
328
294
 
329
295
    def test_config_dir(self):
330
 
        self.assertEqual(config.config_dir(), self.bzr_home)
 
296
        if sys.platform == 'win32':
 
297
            self.assertEqual(config.config_dir(), 
 
298
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0')
 
299
        else:
 
300
            self.assertEqual(config.config_dir(), '/home/bogus/.bazaar')
331
301
 
332
302
    def test_config_filename(self):
333
 
        self.assertEqual(config.config_filename(),
334
 
                         self.bzr_home + '/bazaar.conf')
 
303
        if sys.platform == 'win32':
 
304
            self.assertEqual(config.config_filename(), 
 
305
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/bazaar.conf')
 
306
        else:
 
307
            self.assertEqual(config.config_filename(),
 
308
                             '/home/bogus/.bazaar/bazaar.conf')
335
309
 
336
310
    def test_branches_config_filename(self):
337
 
        self.assertEqual(config.branches_config_filename(),
338
 
                         self.bzr_home + '/branches.conf')
 
311
        if sys.platform == 'win32':
 
312
            self.assertEqual(config.branches_config_filename(), 
 
313
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/branches.conf')
 
314
        else:
 
315
            self.assertEqual(config.branches_config_filename(),
 
316
                             '/home/bogus/.bazaar/branches.conf')
339
317
 
340
318
    def test_locations_config_filename(self):
341
 
        self.assertEqual(config.locations_config_filename(),
342
 
                         self.bzr_home + '/locations.conf')
 
319
        if sys.platform == 'win32':
 
320
            self.assertEqual(config.locations_config_filename(), 
 
321
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/locations.conf')
 
322
        else:
 
323
            self.assertEqual(config.locations_config_filename(),
 
324
                             '/home/bogus/.bazaar/locations.conf')
343
325
 
344
326
    def test_authentication_config_filename(self):
345
 
        self.assertEqual(config.authentication_config_filename(),
346
 
                         self.bzr_home + '/authentication.conf')
347
 
 
 
327
        if sys.platform == 'win32':
 
328
            self.assertEqual(config.authentication_config_filename(), 
 
329
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/authentication.conf')
 
330
        else:
 
331
            self.assertEqual(config.authentication_config_filename(),
 
332
                             '/home/bogus/.bazaar/authentication.conf')
348
333
 
349
334
class TestIniConfig(tests.TestCase):
350
335
 
356
341
        my_config = config.IniBasedConfig(None)
357
342
        self.failUnless(
358
343
            isinstance(my_config._get_parser(file=config_file),
359
 
                        configobj.ConfigObj))
 
344
                        ConfigObj))
360
345
 
361
346
    def test_cached(self):
362
347
        config_file = StringIO(sample_config_text.encode('utf-8'))
371
356
        my_config = config.GlobalConfig()
372
357
 
373
358
    def test_calls_read_filenames(self):
374
 
        # replace the class that is constructed, to check its parameters
 
359
        # replace the class that is constructured, to check its parameters
375
360
        oldparserclass = config.ConfigObj
376
361
        config.ConfigObj = InstrumentedConfigObj
377
362
        my_config = config.GlobalConfig()
448
433
        local_path = osutils.getcwd().encode('utf8')
449
434
        # Surprisingly ConfigObj doesn't create a trailing newline
450
435
        self.check_file_contents(locations,
451
 
                                 '[%s/branch]\n'
452
 
                                 'push_location = http://foobar\n'
453
 
                                 'push_location:policy = norecurse\n'
454
 
                                 % (local_path,))
 
436
            '[%s/branch]\npush_location = http://foobar\npush_location:policy = norecurse' % (local_path,))
455
437
 
456
438
    def test_autonick_urlencoded(self):
457
439
        b = self.make_branch('!repo')
575
557
        my_config = self._get_sample_config()
576
558
        self.assertEqual("something",
577
559
                         my_config.get_user_option('user_global_option'))
578
 
 
 
560
        
579
561
    def test_post_commit_default(self):
580
562
        my_config = self._get_sample_config()
581
563
        self.assertEqual(None, my_config.post_commit())
588
570
        my_config = self._get_sample_config()
589
571
        self.assertEqual('help', my_config.get_alias('h'))
590
572
 
591
 
    def test_get_aliases(self):
592
 
        my_config = self._get_sample_config()
593
 
        aliases = my_config.get_aliases()
594
 
        self.assertEqual(2, len(aliases))
595
 
        sorted_keys = sorted(aliases)
596
 
        self.assertEqual('help', aliases[sorted_keys[0]])
597
 
        self.assertEqual(sample_long_alias, aliases[sorted_keys[1]])
598
 
 
599
573
    def test_get_no_alias(self):
600
574
        my_config = self._get_sample_config()
601
575
        self.assertEqual(None, my_config.get_alias('foo'))
605
579
        self.assertEqual(sample_long_alias, my_config.get_alias('ll'))
606
580
 
607
581
 
608
 
class TestGlobalConfigSavingOptions(tests.TestCaseInTempDir):
609
 
 
610
 
    def test_empty(self):
611
 
        my_config = config.GlobalConfig()
612
 
        self.assertEqual(0, len(my_config.get_aliases()))
613
 
 
614
 
    def test_set_alias(self):
615
 
        my_config = config.GlobalConfig()
616
 
        alias_value = 'commit --strict'
617
 
        my_config.set_alias('commit', alias_value)
618
 
        new_config = config.GlobalConfig()
619
 
        self.assertEqual(alias_value, new_config.get_alias('commit'))
620
 
 
621
 
    def test_remove_alias(self):
622
 
        my_config = config.GlobalConfig()
623
 
        my_config.set_alias('commit', 'commit --strict')
624
 
        # Now remove the alias again.
625
 
        my_config.unset_alias('commit')
626
 
        new_config = config.GlobalConfig()
627
 
        self.assertIs(None, new_config.get_alias('commit'))
628
 
 
629
 
 
630
582
class TestLocationConfig(tests.TestCaseInTempDir):
631
583
 
632
584
    def test_constructs(self):
637
589
        # This is testing the correct file names are provided.
638
590
        # TODO: consolidate with the test for GlobalConfigs filename checks.
639
591
        #
640
 
        # replace the class that is constructed, to check its parameters
 
592
        # replace the class that is constructured, to check its parameters
641
593
        oldparserclass = config.ConfigObj
642
594
        config.ConfigObj = InstrumentedConfigObj
643
595
        try:
671
623
    def test__get_matching_sections_no_match(self):
672
624
        self.get_branch_config('/')
673
625
        self.assertEqual([], self.my_location_config._get_matching_sections())
674
 
 
 
626
        
675
627
    def test__get_matching_sections_exact(self):
676
628
        self.get_branch_config('http://www.example.com')
677
629
        self.assertEqual([('http://www.example.com', '')],
678
630
                         self.my_location_config._get_matching_sections())
679
 
 
 
631
   
680
632
    def test__get_matching_sections_suffix_does_not(self):
681
633
        self.get_branch_config('http://www.example.com-com')
682
634
        self.assertEqual([], self.my_location_config._get_matching_sections())
694
646
    def test__get_matching_sections_ignoreparent_subdir(self):
695
647
        self.get_branch_config(
696
648
            'http://www.example.com/ignoreparent/childbranch')
697
 
        self.assertEqual([('http://www.example.com/ignoreparent',
698
 
                           'childbranch')],
 
649
        self.assertEqual([('http://www.example.com/ignoreparent', 'childbranch')],
699
650
                         self.my_location_config._get_matching_sections())
700
651
 
701
652
    def test__get_matching_sections_subdir_trailing_slash(self):
781
732
        self.get_branch_config('/a/c')
782
733
        self.assertEqual(config.CHECK_NEVER,
783
734
                         self.my_config.signature_checking())
784
 
 
 
735
        
785
736
    def test_signatures_when_available(self):
786
737
        self.get_branch_config('/a/', global_config=sample_ignore_signatures)
787
738
        self.assertEqual(config.CHECK_IF_POSSIBLE,
788
739
                         self.my_config.signature_checking())
789
 
 
 
740
        
790
741
    def test_signatures_always(self):
791
742
        self.get_branch_config('/b')
792
743
        self.assertEqual(config.CHECK_ALWAYS,
793
744
                         self.my_config.signature_checking())
794
 
 
 
745
        
795
746
    def test_gpg_signing_command(self):
796
747
        self.get_branch_config('/b')
797
748
        self.assertEqual("gnome-gpg", self.my_config.gpg_signing_command())
951
902
        self.assertIs(self.my_config.get_user_option('foo'), None)
952
903
        self.my_config.set_user_option('foo', 'bar')
953
904
        self.assertEqual(
954
 
            self.my_config.branch.control_files.files['branch.conf'].strip(),
 
905
            self.my_config.branch.control_files.files['branch.conf'], 
955
906
            'foo = bar')
956
907
        self.assertEqual(self.my_config.get_user_option('foo'), 'bar')
957
908
        self.my_config.set_user_option('foo', 'baz',
959
910
        self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
960
911
        self.my_config.set_user_option('foo', 'qux')
961
912
        self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
962
 
 
 
913
        
963
914
    def test_get_bzr_remote_path(self):
964
915
        my_config = config.LocationConfig('/a/c')
965
916
        self.assertEqual('bzr', my_config.get_bzr_remote_path())
982
933
 
983
934
class TestBranchConfigItems(tests.TestCaseInTempDir):
984
935
 
985
 
    def get_branch_config(self, global_config=None, location=None,
 
936
    def get_branch_config(self, global_config=None, location=None, 
986
937
                          location_config=None, branch_data_config=None):
987
938
        my_config = config.BranchConfig(FakeBranch(location))
988
939
        if global_config is not None:
1002
953
        my_config = config.BranchConfig(branch)
1003
954
        self.assertEqual("Robert Collins <robertc@example.net>",
1004
955
                         my_config.username())
1005
 
        my_config.branch.control_files.files['email'] = "John"
1006
 
        my_config.set_user_option('email',
 
956
        branch.control_files.email = "John"
 
957
        my_config.set_user_option('email', 
1007
958
                                  "Robert Collins <robertc@example.org>")
1008
959
        self.assertEqual("John", my_config.username())
1009
 
        del my_config.branch.control_files.files['email']
 
960
        branch.control_files.email = None
1010
961
        self.assertEqual("Robert Collins <robertc@example.org>",
1011
962
                         my_config.username())
1012
963
 
1013
964
    def test_not_set_in_branch(self):
1014
965
        my_config = self.get_branch_config(sample_config_text)
 
966
        my_config.branch.control_files.email = None
1015
967
        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
1016
968
                         my_config._get_user_id())
1017
 
        my_config.branch.control_files.files['email'] = "John"
 
969
        my_config.branch.control_files.email = "John"
1018
970
        self.assertEqual("John", my_config._get_user_id())
1019
971
 
1020
972
    def test_BZR_EMAIL_OVERRIDES(self):
1023
975
        my_config = config.BranchConfig(branch)
1024
976
        self.assertEqual("Robert Collins <robertc@example.org>",
1025
977
                         my_config.username())
1026
 
 
 
978
    
1027
979
    def test_signatures_forced(self):
1028
980
        my_config = self.get_branch_config(
1029
981
            global_config=sample_always_signatures)
1073
1025
    def test_config_precedence(self):
1074
1026
        my_config = self.get_branch_config(global_config=precedence_global)
1075
1027
        self.assertEqual(my_config.get_user_option('option'), 'global')
1076
 
        my_config = self.get_branch_config(global_config=precedence_global,
 
1028
        my_config = self.get_branch_config(global_config=precedence_global, 
1077
1029
                                      branch_data_config=precedence_branch)
1078
1030
        self.assertEqual(my_config.get_user_option('option'), 'branch')
1079
 
        my_config = self.get_branch_config(global_config=precedence_global,
 
1031
        my_config = self.get_branch_config(global_config=precedence_global, 
1080
1032
                                      branch_data_config=precedence_branch,
1081
1033
                                      location_config=precedence_location)
1082
1034
        self.assertEqual(my_config.get_user_option('option'), 'recurse')
1083
 
        my_config = self.get_branch_config(global_config=precedence_global,
 
1035
        my_config = self.get_branch_config(global_config=precedence_global, 
1084
1036
                                      branch_data_config=precedence_branch,
1085
1037
                                      location_config=precedence_location,
1086
1038
                                      location='http://example.com/specific')
1137
1089
        self.assertRaises(errors.NoEmailInUsername,
1138
1090
                          config.extract_email_address, 'Jane Tester')
1139
1091
 
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'))
1151
1092
 
1152
1093
class TestTreeConfig(tests.TestCaseWithTransport):
1153
1094
 
1177
1118
        self.assertEqual(value, 'value3-section')
1178
1119
 
1179
1120
 
1180
 
class TestTransportConfig(tests.TestCaseWithTransport):
1181
 
 
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('.'),
1185
 
                                               'control.conf')
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',
1201
 
                                         default='default')
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')
1207
 
 
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())
1218
 
 
1219
 
 
1220
1121
class TestAuthenticationConfigFile(tests.TestCase):
1221
1122
    """Test the authentication.conf file matching"""
1222
1123
 
1232
1133
        self.assertEquals(expected_user, user)
1233
1134
        self.assertEquals(expected_password, password)
1234
1135
 
1235
 
    def test_empty_config(self):
 
1136
    def  test_empty_config(self):
1236
1137
        conf = config.AuthenticationConfig(_file=StringIO())
1237
1138
        self.assertEquals({}, conf._get_config())
1238
1139
        self._got_user_passwd(None, None, conf, 'http', 'foo.net')
1239
1140
 
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')
1243
 
 
1244
 
    def test_auth_section_header_not_closed(self):
 
1141
    def test_broken_config(self):
1245
1142
        conf = config.AuthenticationConfig(_file=StringIO('[DEF'))
1246
1143
        self.assertRaises(errors.ParseConfigError, conf._get_config)
1247
1144
 
1248
 
    def test_auth_value_not_boolean(self):
1249
1145
        conf = config.AuthenticationConfig(_file=StringIO(
1250
1146
                """[broken]
1251
1147
scheme=ftp
1253
1149
verify_certificates=askme # Error: Not a boolean
1254
1150
"""))
1255
1151
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1256
 
 
1257
 
    def test_auth_value_not_int(self):
1258
1152
        conf = config.AuthenticationConfig(_file=StringIO(
1259
1153
                """[broken]
1260
1154
scheme=ftp
1379
1273
        self._got_user_passwd(None, None,
1380
1274
                              conf, 'http', 'bar.org', user='georges')
1381
1275
 
1382
 
    def test_credentials_for_user_without_password(self):
1383
 
        conf = config.AuthenticationConfig(_file=StringIO(
1384
 
                """
1385
 
[without password]
1386
 
scheme=http
1387
 
host=bar.org
1388
 
user=jim
1389
 
"""))
1390
 
        # Get user but no password
1391
 
        self._got_user_passwd('jim', None,
1392
 
                              conf, 'http', 'bar.org')
1393
 
 
1394
1276
    def test_verify_certificates(self):
1395
1277
        conf = config.AuthenticationConfig(_file=StringIO(
1396
1278
                """
1454
1336
            'SMTP %(user)s@%(host)s:%(port)d password: ',
1455
1337
            'smtp', port=10025)
1456
1338
 
1457
 
    def test_ssh_password_emits_warning(self):
1458
 
        conf = config.AuthenticationConfig(_file=StringIO(
1459
 
                """
1460
 
[ssh with password]
1461
 
scheme=ssh
1462
 
host=bar.org
1463
 
user=jim
1464
 
password=jimpass
1465
 
"""))
1466
 
        entered_password = 'typed-by-hand'
1467
 
        stdout = tests.StringIOWrapper()
1468
 
        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1469
 
                                            stdout=stdout)
1470
 
 
1471
 
        # Since the password defined in the authentication config is ignored,
1472
 
        # the user is prompted
1473
 
        self.assertEquals(entered_password,
1474
 
                          conf.get_password('ssh', 'bar.org', user='jim'))
1475
 
        self.assertContainsRe(
1476
 
            self._get_log(keep_log_file=True),
1477
 
            'password ignored in section \[ssh with password\]')
1478
 
 
1479
 
    def test_ssh_without_password_doesnt_emit_warning(self):
1480
 
        conf = config.AuthenticationConfig(_file=StringIO(
1481
 
                """
1482
 
[ssh with password]
1483
 
scheme=ssh
1484
 
host=bar.org
1485
 
user=jim
1486
 
"""))
1487
 
        entered_password = 'typed-by-hand'
1488
 
        stdout = tests.StringIOWrapper()
1489
 
        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1490
 
                                            stdout=stdout)
1491
 
 
1492
 
        # Since the password defined in the authentication config is ignored,
1493
 
        # the user is prompted
1494
 
        self.assertEquals(entered_password,
1495
 
                          conf.get_password('ssh', 'bar.org', user='jim'))
1496
 
        # No warning shoud be emitted since there is no password. We are only
1497
 
        # providing "user".
1498
 
        self.assertNotContainsRe(
1499
 
            self._get_log(keep_log_file=True),
1500
 
            'password ignored in section \[ssh with password\]')
1501
 
 
1502
1339
 
1503
1340
# FIXME: Once we have a way to declare authentication to all test servers, we
1504
1341
# can implement generic tests.