← 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-10-29 05:04:00 UTC
  • mfrom: (2947.1.3 pack)
  • Revision ID: pqm@pqm.ubuntu.com-20071029050400-j2jmz8smj2yecfrr
(robertc) Fix pack-repository to support get_parents calls as the first call on a repository, and fix full-branch push/pull performance to not suck terribly. (Robert Collins)

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
23
24
 
24
25
#import bzrlib specific imports here
25
26
from bzrlib import (
26
 
    branch,
27
 
    bzrdir,
28
27
    config,
29
28
    errors,
30
29
    osutils,
31
30
    mail_client,
32
 
    ui,
33
31
    urlutils,
34
 
    tests,
35
32
    trace,
36
 
    transport,
37
33
    )
38
 
from bzrlib.util.configobj import configobj
 
34
from bzrlib.branch import Branch
 
35
from bzrlib.bzrdir import BzrDir
 
36
from bzrlib.tests import TestCase, TestCaseInTempDir, TestCaseWithTransport
39
37
 
40
38
 
41
39
sample_long_alias="log -r-15..-1 --line"
147
145
            self.base = "http://example.com/branches/demo"
148
146
        else:
149
147
            self.base = base
150
 
        self._transport = self.control_files = \
151
 
            FakeControlFilesAndTransport(user_id=user_id)
 
148
        self.control_files = FakeControlFiles(user_id=user_id)
152
149
 
153
150
    def lock_write(self):
154
151
        pass
157
154
        pass
158
155
 
159
156
 
160
 
class FakeControlFilesAndTransport(object):
 
157
class FakeControlFiles(object):
161
158
 
162
159
    def __init__(self, user_id=None):
 
160
        self.email = user_id
163
161
        self.files = {}
164
 
        if user_id:
165
 
            self.files['email'] = user_id
166
 
        self._transport = self
167
162
 
168
163
    def get_utf8(self, filename):
169
 
        # from LockableFiles
170
 
        raise AssertionError("get_utf8 should no longer be used")
 
164
        if filename != 'email':
 
165
            raise NotImplementedError
 
166
        if self.email is not None:
 
167
            return StringIO(self.email)
 
168
        raise errors.NoSuchFile(filename)
171
169
 
172
170
    def get(self, filename):
173
 
        # from Transport
174
171
        try:
175
172
            return StringIO(self.files[filename])
176
173
        except KeyError:
177
174
            raise errors.NoSuchFile(filename)
178
175
 
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
176
    def put(self, filename, fileobj):
187
177
        self.files[filename] = fileobj.read()
188
178
 
189
 
    def put_file(self, filename, fileobj):
190
 
        return self.put(filename, fileobj)
191
 
 
192
179
 
193
180
class InstrumentedConfig(config.Config):
194
181
    """An instrumented config that supplies stubs for template methods."""
195
 
 
 
182
    
196
183
    def __init__(self):
197
184
        super(InstrumentedConfig, self).__init__()
198
185
        self._calls = []
214
201
active = True
215
202
nonactive = False
216
203
"""
217
 
 
218
 
 
219
 
class TestConfigObj(tests.TestCase):
220
 
 
 
204
class TestConfigObj(TestCase):
221
205
    def test_get_bool(self):
222
 
        co = config.ConfigObj(StringIO(bool_config))
 
206
        from bzrlib.config import ConfigObj
 
207
        co = ConfigObj(StringIO(bool_config))
223
208
        self.assertIs(co.get_bool('DEFAULT', 'active'), True)
224
209
        self.assertIs(co.get_bool('DEFAULT', 'inactive'), False)
225
210
        self.assertIs(co.get_bool('UPPERCASE', 'active'), True)
226
211
        self.assertIs(co.get_bool('UPPERCASE', 'nonactive'), False)
227
212
 
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
213
 
241
214
erroneous_config = """[section] # line 1
242
215
good=good # line 2
243
216
[section] # line 3
244
217
whocares=notme # line 4
245
218
"""
246
 
 
247
 
 
248
 
class TestConfigObjErrors(tests.TestCase):
 
219
class TestConfigObjErrors(TestCase):
249
220
 
250
221
    def test_duplicate_section_name_error_line(self):
251
222
        try:
252
 
            co = configobj.ConfigObj(StringIO(erroneous_config),
253
 
                                     raise_errors=True)
 
223
            co = ConfigObj(StringIO(erroneous_config), raise_errors=True)
254
224
        except config.configobj.DuplicateError, e:
255
225
            self.assertEqual(3, e.line_number)
256
226
        else:
257
227
            self.fail('Error in config file not detected')
258
228
 
259
 
 
260
 
class TestConfig(tests.TestCase):
 
229
class TestConfig(TestCase):
261
230
 
262
231
    def test_constructs(self):
263
232
        config.Config()
264
 
 
 
233
 
265
234
    def test_no_default_editor(self):
266
235
        self.assertRaises(NotImplementedError, config.Config().get_editor)
267
236
 
313
282
        self.assertEqual('long', my_config.log_format())
314
283
 
315
284
 
316
 
class TestConfigPath(tests.TestCase):
 
285
class TestConfigPath(TestCase):
317
286
 
318
287
    def setUp(self):
319
288
        super(TestConfigPath, self).setUp()
321
290
        if sys.platform == 'win32':
322
291
            os.environ['BZR_HOME'] = \
323
292
                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
293
 
329
294
    def test_config_dir(self):
330
 
        self.assertEqual(config.config_dir(), self.bzr_home)
 
295
        if sys.platform == 'win32':
 
296
            self.assertEqual(config.config_dir(), 
 
297
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0')
 
298
        else:
 
299
            self.assertEqual(config.config_dir(), '/home/bogus/.bazaar')
331
300
 
332
301
    def test_config_filename(self):
333
 
        self.assertEqual(config.config_filename(),
334
 
                         self.bzr_home + '/bazaar.conf')
 
302
        if sys.platform == 'win32':
 
303
            self.assertEqual(config.config_filename(), 
 
304
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/bazaar.conf')
 
305
        else:
 
306
            self.assertEqual(config.config_filename(),
 
307
                             '/home/bogus/.bazaar/bazaar.conf')
335
308
 
336
309
    def test_branches_config_filename(self):
337
 
        self.assertEqual(config.branches_config_filename(),
338
 
                         self.bzr_home + '/branches.conf')
 
310
        if sys.platform == 'win32':
 
311
            self.assertEqual(config.branches_config_filename(), 
 
312
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/branches.conf')
 
313
        else:
 
314
            self.assertEqual(config.branches_config_filename(),
 
315
                             '/home/bogus/.bazaar/branches.conf')
339
316
 
340
317
    def test_locations_config_filename(self):
341
 
        self.assertEqual(config.locations_config_filename(),
342
 
                         self.bzr_home + '/locations.conf')
343
 
 
344
 
    def test_authentication_config_filename(self):
345
 
        self.assertEqual(config.authentication_config_filename(),
346
 
                         self.bzr_home + '/authentication.conf')
347
 
 
348
 
 
349
 
class TestIniConfig(tests.TestCase):
 
318
        if sys.platform == 'win32':
 
319
            self.assertEqual(config.locations_config_filename(), 
 
320
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/locations.conf')
 
321
        else:
 
322
            self.assertEqual(config.locations_config_filename(),
 
323
                             '/home/bogus/.bazaar/locations.conf')
 
324
 
 
325
class TestIniConfig(TestCase):
350
326
 
351
327
    def test_contructs(self):
352
328
        my_config = config.IniBasedConfig("nothing")
356
332
        my_config = config.IniBasedConfig(None)
357
333
        self.failUnless(
358
334
            isinstance(my_config._get_parser(file=config_file),
359
 
                        configobj.ConfigObj))
 
335
                        ConfigObj))
360
336
 
361
337
    def test_cached(self):
362
338
        config_file = StringIO(sample_config_text.encode('utf-8'))
365
341
        self.failUnless(my_config._get_parser() is parser)
366
342
 
367
343
 
368
 
class TestGetConfig(tests.TestCase):
 
344
class TestGetConfig(TestCase):
369
345
 
370
346
    def test_constructs(self):
371
347
        my_config = config.GlobalConfig()
372
348
 
373
349
    def test_calls_read_filenames(self):
374
 
        # replace the class that is constructed, to check its parameters
 
350
        # replace the class that is constructured, to check its parameters
375
351
        oldparserclass = config.ConfigObj
376
352
        config.ConfigObj = InstrumentedConfigObj
377
353
        my_config = config.GlobalConfig()
384
360
                                          'utf-8')])
385
361
 
386
362
 
387
 
class TestBranchConfig(tests.TestCaseWithTransport):
 
363
class TestBranchConfig(TestCaseWithTransport):
388
364
 
389
365
    def test_constructs(self):
390
366
        branch = FakeBranch()
400
376
 
401
377
    def test_get_config(self):
402
378
        """The Branch.get_config method works properly"""
403
 
        b = bzrdir.BzrDir.create_standalone_workingtree('.').branch
 
379
        b = BzrDir.create_standalone_workingtree('.').branch
404
380
        my_config = b.get_config()
405
381
        self.assertIs(my_config.get_user_option('wacky'), None)
406
382
        my_config.set_user_option('wacky', 'unlikely')
407
383
        self.assertEqual(my_config.get_user_option('wacky'), 'unlikely')
408
384
 
409
385
        # Ensure we get the same thing if we start again
410
 
        b2 = branch.Branch.open('.')
 
386
        b2 = Branch.open('.')
411
387
        my_config2 = b2.get_config()
412
388
        self.assertEqual(my_config2.get_user_option('wacky'), 'unlikely')
413
389
 
448
424
        local_path = osutils.getcwd().encode('utf8')
449
425
        # Surprisingly ConfigObj doesn't create a trailing newline
450
426
        self.check_file_contents(locations,
451
 
                                 '[%s/branch]\n'
452
 
                                 'push_location = http://foobar\n'
453
 
                                 'push_location:policy = norecurse\n'
454
 
                                 % (local_path,))
 
427
            '[%s/branch]\npush_location = http://foobar\npush_location:policy = norecurse' % (local_path,))
455
428
 
456
429
    def test_autonick_urlencoded(self):
457
430
        b = self.make_branch('!repo')
495
468
            trace.warning = _warning
496
469
 
497
470
 
498
 
class TestGlobalConfigItems(tests.TestCase):
 
471
class TestGlobalConfigItems(TestCase):
499
472
 
500
473
    def test_user_id(self):
501
474
        config_file = StringIO(sample_config_text.encode('utf-8'))
575
548
        my_config = self._get_sample_config()
576
549
        self.assertEqual("something",
577
550
                         my_config.get_user_option('user_global_option'))
578
 
 
 
551
        
579
552
    def test_post_commit_default(self):
580
553
        my_config = self._get_sample_config()
581
554
        self.assertEqual(None, my_config.post_commit())
588
561
        my_config = self._get_sample_config()
589
562
        self.assertEqual('help', my_config.get_alias('h'))
590
563
 
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
564
    def test_get_no_alias(self):
600
565
        my_config = self._get_sample_config()
601
566
        self.assertEqual(None, my_config.get_alias('foo'))
605
570
        self.assertEqual(sample_long_alias, my_config.get_alias('ll'))
606
571
 
607
572
 
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
 
class TestLocationConfig(tests.TestCaseInTempDir):
 
573
class TestLocationConfig(TestCaseInTempDir):
631
574
 
632
575
    def test_constructs(self):
633
576
        my_config = config.LocationConfig('http://example.com')
637
580
        # This is testing the correct file names are provided.
638
581
        # TODO: consolidate with the test for GlobalConfigs filename checks.
639
582
        #
640
 
        # replace the class that is constructed, to check its parameters
 
583
        # replace the class that is constructured, to check its parameters
641
584
        oldparserclass = config.ConfigObj
642
585
        config.ConfigObj = InstrumentedConfigObj
643
586
        try:
671
614
    def test__get_matching_sections_no_match(self):
672
615
        self.get_branch_config('/')
673
616
        self.assertEqual([], self.my_location_config._get_matching_sections())
674
 
 
 
617
        
675
618
    def test__get_matching_sections_exact(self):
676
619
        self.get_branch_config('http://www.example.com')
677
620
        self.assertEqual([('http://www.example.com', '')],
678
621
                         self.my_location_config._get_matching_sections())
679
 
 
 
622
   
680
623
    def test__get_matching_sections_suffix_does_not(self):
681
624
        self.get_branch_config('http://www.example.com-com')
682
625
        self.assertEqual([], self.my_location_config._get_matching_sections())
694
637
    def test__get_matching_sections_ignoreparent_subdir(self):
695
638
        self.get_branch_config(
696
639
            'http://www.example.com/ignoreparent/childbranch')
697
 
        self.assertEqual([('http://www.example.com/ignoreparent',
698
 
                           'childbranch')],
 
640
        self.assertEqual([('http://www.example.com/ignoreparent', 'childbranch')],
699
641
                         self.my_location_config._get_matching_sections())
700
642
 
701
643
    def test__get_matching_sections_subdir_trailing_slash(self):
781
723
        self.get_branch_config('/a/c')
782
724
        self.assertEqual(config.CHECK_NEVER,
783
725
                         self.my_config.signature_checking())
784
 
 
 
726
        
785
727
    def test_signatures_when_available(self):
786
728
        self.get_branch_config('/a/', global_config=sample_ignore_signatures)
787
729
        self.assertEqual(config.CHECK_IF_POSSIBLE,
788
730
                         self.my_config.signature_checking())
789
 
 
 
731
        
790
732
    def test_signatures_always(self):
791
733
        self.get_branch_config('/b')
792
734
        self.assertEqual(config.CHECK_ALWAYS,
793
735
                         self.my_config.signature_checking())
794
 
 
 
736
        
795
737
    def test_gpg_signing_command(self):
796
738
        self.get_branch_config('/b')
797
739
        self.assertEqual("gnome-gpg", self.my_config.gpg_signing_command())
951
893
        self.assertIs(self.my_config.get_user_option('foo'), None)
952
894
        self.my_config.set_user_option('foo', 'bar')
953
895
        self.assertEqual(
954
 
            self.my_config.branch.control_files.files['branch.conf'].strip(),
 
896
            self.my_config.branch.control_files.files['branch.conf'], 
955
897
            'foo = bar')
956
898
        self.assertEqual(self.my_config.get_user_option('foo'), 'bar')
957
899
        self.my_config.set_user_option('foo', 'baz',
959
901
        self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
960
902
        self.my_config.set_user_option('foo', 'qux')
961
903
        self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
962
 
 
 
904
        
963
905
    def test_get_bzr_remote_path(self):
964
906
        my_config = config.LocationConfig('/a/c')
965
907
        self.assertEqual('bzr', my_config.get_bzr_remote_path())
980
922
"""
981
923
 
982
924
 
983
 
class TestBranchConfigItems(tests.TestCaseInTempDir):
 
925
class TestBranchConfigItems(TestCaseInTempDir):
984
926
 
985
 
    def get_branch_config(self, global_config=None, location=None,
 
927
    def get_branch_config(self, global_config=None, location=None, 
986
928
                          location_config=None, branch_data_config=None):
987
929
        my_config = config.BranchConfig(FakeBranch(location))
988
930
        if global_config is not None:
1002
944
        my_config = config.BranchConfig(branch)
1003
945
        self.assertEqual("Robert Collins <robertc@example.net>",
1004
946
                         my_config.username())
1005
 
        my_config.branch.control_files.files['email'] = "John"
1006
 
        my_config.set_user_option('email',
 
947
        branch.control_files.email = "John"
 
948
        my_config.set_user_option('email', 
1007
949
                                  "Robert Collins <robertc@example.org>")
1008
950
        self.assertEqual("John", my_config.username())
1009
 
        del my_config.branch.control_files.files['email']
 
951
        branch.control_files.email = None
1010
952
        self.assertEqual("Robert Collins <robertc@example.org>",
1011
953
                         my_config.username())
1012
954
 
1013
955
    def test_not_set_in_branch(self):
1014
956
        my_config = self.get_branch_config(sample_config_text)
 
957
        my_config.branch.control_files.email = None
1015
958
        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
1016
959
                         my_config._get_user_id())
1017
 
        my_config.branch.control_files.files['email'] = "John"
 
960
        my_config.branch.control_files.email = "John"
1018
961
        self.assertEqual("John", my_config._get_user_id())
1019
962
 
1020
963
    def test_BZR_EMAIL_OVERRIDES(self):
1023
966
        my_config = config.BranchConfig(branch)
1024
967
        self.assertEqual("Robert Collins <robertc@example.org>",
1025
968
                         my_config.username())
1026
 
 
 
969
    
1027
970
    def test_signatures_forced(self):
1028
971
        my_config = self.get_branch_config(
1029
972
            global_config=sample_always_signatures)
1073
1016
    def test_config_precedence(self):
1074
1017
        my_config = self.get_branch_config(global_config=precedence_global)
1075
1018
        self.assertEqual(my_config.get_user_option('option'), 'global')
1076
 
        my_config = self.get_branch_config(global_config=precedence_global,
 
1019
        my_config = self.get_branch_config(global_config=precedence_global, 
1077
1020
                                      branch_data_config=precedence_branch)
1078
1021
        self.assertEqual(my_config.get_user_option('option'), 'branch')
1079
 
        my_config = self.get_branch_config(global_config=precedence_global,
 
1022
        my_config = self.get_branch_config(global_config=precedence_global, 
1080
1023
                                      branch_data_config=precedence_branch,
1081
1024
                                      location_config=precedence_location)
1082
1025
        self.assertEqual(my_config.get_user_option('option'), 'recurse')
1083
 
        my_config = self.get_branch_config(global_config=precedence_global,
 
1026
        my_config = self.get_branch_config(global_config=precedence_global, 
1084
1027
                                      branch_data_config=precedence_branch,
1085
1028
                                      location_config=precedence_location,
1086
1029
                                      location='http://example.com/specific')
1129
1072
        self.assertRaises(errors.UnknownMailClient, config.get_mail_client)
1130
1073
 
1131
1074
 
1132
 
class TestMailAddressExtraction(tests.TestCase):
 
1075
class TestMailAddressExtraction(TestCase):
1133
1076
 
1134
1077
    def test_extract_email_address(self):
1135
1078
        self.assertEqual('jane@test.com',
1137
1080
        self.assertRaises(errors.NoEmailInUsername,
1138
1081
                          config.extract_email_address, 'Jane Tester')
1139
1082
 
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
1083
 
1152
 
class TestTreeConfig(tests.TestCaseWithTransport):
 
1084
class TestTreeConfig(TestCaseWithTransport):
1153
1085
 
1154
1086
    def test_get_value(self):
1155
1087
        """Test that retreiving a value from a section is possible"""
1175
1107
        self.assertEqual(value, 'value3-top')
1176
1108
        value = tree_config.get_option('key3', 'SECTION')
1177
1109
        self.assertEqual(value, 'value3-section')
1178
 
 
1179
 
 
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
 
class TestAuthenticationConfigFile(tests.TestCase):
1221
 
    """Test the authentication.conf file matching"""
1222
 
 
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:
1227
 
            user = None
1228
 
            password = None
1229
 
        else:
1230
 
            user = credentials['user']
1231
 
            password = credentials['password']
1232
 
        self.assertEquals(expected_user, user)
1233
 
        self.assertEquals(expected_password, password)
1234
 
 
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')
1239
 
 
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):
1245
 
        conf = config.AuthenticationConfig(_file=StringIO('[DEF'))
1246
 
        self.assertRaises(errors.ParseConfigError, conf._get_config)
1247
 
 
1248
 
    def test_auth_value_not_boolean(self):
1249
 
        conf = config.AuthenticationConfig(_file=StringIO(
1250
 
                """[broken]
1251
 
scheme=ftp
1252
 
user=joe
1253
 
verify_certificates=askme # Error: Not a boolean
1254
 
"""))
1255
 
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1256
 
 
1257
 
    def test_auth_value_not_int(self):
1258
 
        conf = config.AuthenticationConfig(_file=StringIO(
1259
 
                """[broken]
1260
 
scheme=ftp
1261
 
user=joe
1262
 
port=port # Error: Not an int
1263
 
"""))
1264
 
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1265
 
 
1266
 
    def test_credentials_for_scheme_host(self):
1267
 
        conf = config.AuthenticationConfig(_file=StringIO(
1268
 
                """# Identity on foo.net
1269
 
[ftp definition]
1270
 
scheme=ftp
1271
 
host=foo.net
1272
 
user=joe
1273
 
password=secret-pass
1274
 
"""))
1275
 
        # Basic matching
1276
 
        self._got_user_passwd('joe', 'secret-pass', conf, 'ftp', 'foo.net')
1277
 
        # different scheme
1278
 
        self._got_user_passwd(None, None, conf, 'http', 'foo.net')
1279
 
        # different host
1280
 
        self._got_user_passwd(None, None, conf, 'ftp', 'bar.net')
1281
 
 
1282
 
    def test_credentials_for_host_port(self):
1283
 
        conf = config.AuthenticationConfig(_file=StringIO(
1284
 
                """# Identity on foo.net
1285
 
[ftp definition]
1286
 
scheme=ftp
1287
 
port=10021
1288
 
host=foo.net
1289
 
user=joe
1290
 
password=secret-pass
1291
 
"""))
1292
 
        # No port
1293
 
        self._got_user_passwd('joe', 'secret-pass',
1294
 
                              conf, 'ftp', 'foo.net', port=10021)
1295
 
        # different port
1296
 
        self._got_user_passwd(None, None, conf, 'ftp', 'foo.net')
1297
 
 
1298
 
    def test_for_matching_host(self):
1299
 
        conf = config.AuthenticationConfig(_file=StringIO(
1300
 
                """# Identity on foo.net
1301
 
[sourceforge]
1302
 
scheme=bzr
1303
 
host=bzr.sf.net
1304
 
user=joe
1305
 
password=joepass
1306
 
[sourceforge domain]
1307
 
scheme=bzr
1308
 
host=.bzr.sf.net
1309
 
user=georges
1310
 
password=bendover
1311
 
"""))
1312
 
        # matching domain
1313
 
        self._got_user_passwd('georges', 'bendover',
1314
 
                              conf, 'bzr', 'foo.bzr.sf.net')
1315
 
        # phishing attempt
1316
 
        self._got_user_passwd(None, None,
1317
 
                              conf, 'bzr', 'bbzr.sf.net')
1318
 
 
1319
 
    def test_for_matching_host_None(self):
1320
 
        conf = config.AuthenticationConfig(_file=StringIO(
1321
 
                """# Identity on foo.net
1322
 
[catchup bzr]
1323
 
scheme=bzr
1324
 
user=joe
1325
 
password=joepass
1326
 
[DEFAULT]
1327
 
user=georges
1328
 
password=bendover
1329
 
"""))
1330
 
        # match no host
1331
 
        self._got_user_passwd('joe', 'joepass',
1332
 
                              conf, 'bzr', 'quux.net')
1333
 
        # no host but different scheme
1334
 
        self._got_user_passwd('georges', 'bendover',
1335
 
                              conf, 'ftp', 'quux.net')
1336
 
 
1337
 
    def test_credentials_for_path(self):
1338
 
        conf = config.AuthenticationConfig(_file=StringIO(
1339
 
                """
1340
 
[http dir1]
1341
 
scheme=http
1342
 
host=bar.org
1343
 
path=/dir1
1344
 
user=jim
1345
 
password=jimpass
1346
 
[http dir2]
1347
 
scheme=http
1348
 
host=bar.org
1349
 
path=/dir2
1350
 
user=georges
1351
 
password=bendover
1352
 
"""))
1353
 
        # no path no dice
1354
 
        self._got_user_passwd(None, None,
1355
 
                              conf, 'http', host='bar.org', path='/dir3')
1356
 
        # matching path
1357
 
        self._got_user_passwd('georges', 'bendover',
1358
 
                              conf, 'http', host='bar.org', path='/dir2')
1359
 
        # matching subdir
1360
 
        self._got_user_passwd('jim', 'jimpass',
1361
 
                              conf, 'http', host='bar.org',path='/dir1/subdir')
1362
 
 
1363
 
    def test_credentials_for_user(self):
1364
 
        conf = config.AuthenticationConfig(_file=StringIO(
1365
 
                """
1366
 
[with user]
1367
 
scheme=http
1368
 
host=bar.org
1369
 
user=jim
1370
 
password=jimpass
1371
 
"""))
1372
 
        # Get user
1373
 
        self._got_user_passwd('jim', 'jimpass',
1374
 
                              conf, 'http', 'bar.org')
1375
 
        # Get same user
1376
 
        self._got_user_passwd('jim', 'jimpass',
1377
 
                              conf, 'http', 'bar.org', user='jim')
1378
 
        # Don't get a different user if one is specified
1379
 
        self._got_user_passwd(None, None,
1380
 
                              conf, 'http', 'bar.org', user='georges')
1381
 
 
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
 
    def test_verify_certificates(self):
1395
 
        conf = config.AuthenticationConfig(_file=StringIO(
1396
 
                """
1397
 
[self-signed]
1398
 
scheme=https
1399
 
host=bar.org
1400
 
user=jim
1401
 
password=jimpass
1402
 
verify_certificates=False
1403
 
[normal]
1404
 
scheme=https
1405
 
host=foo.net
1406
 
user=georges
1407
 
password=bendover
1408
 
"""))
1409
 
        credentials = conf.get_credentials('https', 'bar.org')
1410
 
        self.assertEquals(False, credentials.get('verify_certificates'))
1411
 
        credentials = conf.get_credentials('https', 'foo.net')
1412
 
        self.assertEquals(True, credentials.get('verify_certificates'))
1413
 
 
1414
 
 
1415
 
class TestAuthenticationConfig(tests.TestCase):
1416
 
    """Test AuthenticationConfig behaviour"""
1417
 
 
1418
 
    def _check_default_prompt(self, expected_prompt_format, scheme,
1419
 
                              host=None, port=None, realm=None, path=None):
1420
 
        if host is None:
1421
 
            host = 'bar.org'
1422
 
        user, password = 'jim', 'precious'
1423
 
        expected_prompt = expected_prompt_format % {
1424
 
            'scheme': scheme, 'host': host, 'port': port,
1425
 
            'user': user, 'realm': realm}
1426
 
 
1427
 
        stdout = tests.StringIOWrapper()
1428
 
        ui.ui_factory = tests.TestUIFactory(stdin=password + '\n',
1429
 
                                            stdout=stdout)
1430
 
        # We use an empty conf so that the user is always prompted
1431
 
        conf = config.AuthenticationConfig()
1432
 
        self.assertEquals(password,
1433
 
                          conf.get_password(scheme, host, user, port=port,
1434
 
                                            realm=realm, path=path))
1435
 
        self.assertEquals(stdout.getvalue(), expected_prompt)
1436
 
 
1437
 
    def test_default_prompts(self):
1438
 
        # HTTP prompts can't be tested here, see test_http.py
1439
 
        self._check_default_prompt('FTP %(user)s@%(host)s password: ', 'ftp')
1440
 
        self._check_default_prompt('FTP %(user)s@%(host)s:%(port)d password: ',
1441
 
                                   'ftp', port=10020)
1442
 
 
1443
 
        self._check_default_prompt('SSH %(user)s@%(host)s:%(port)d password: ',
1444
 
                                   'ssh', port=12345)
1445
 
        # SMTP port handling is a bit special (it's handled if embedded in the
1446
 
        # host too)
1447
 
        # FIXME: should we: forbid that, extend it to other schemes, leave
1448
 
        # things as they are that's fine thank you ?
1449
 
        self._check_default_prompt('SMTP %(user)s@%(host)s password: ',
1450
 
                                   'smtp')
1451
 
        self._check_default_prompt('SMTP %(user)s@%(host)s password: ',
1452
 
                                   'smtp', host='bar.org:10025')
1453
 
        self._check_default_prompt(
1454
 
            'SMTP %(user)s@%(host)s:%(port)d password: ',
1455
 
            'smtp', port=10025)
1456
 
 
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
 
 
1503
 
# FIXME: Once we have a way to declare authentication to all test servers, we
1504
 
# can implement generic tests.
1505
 
# test_user_password_in_url
1506
 
# test_user_in_url_password_from_config
1507
 
# test_user_in_url_password_prompted
1508
 
# test_user_in_config
1509
 
# test_user_getpass.getuser
1510
 
# test_user_prompted ?
1511
 
class TestAuthenticationRing(tests.TestCaseWithTransport):
1512
 
    pass