← 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: Jelmer Vernooij
  • Date: 2009-02-03 15:48:02 UTC
  • mto: (3978.3.6 branch-bzrdir-inter)
  • mto: This revision was merged to the branch mainline in revision 4250.
  • Revision ID: jelmer@samba.org-20090203154802-niup4xrso35yba65
Move most of push to IterGenericBranchBzrDir.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_config.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2008 Canonical Ltd
2
2
#   Authors: Robert Collins <robert.collins@canonical.com>
3
3
#
4
4
# This program is free software; you can redistribute it and/or modify
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
21
20
from cStringIO import StringIO
22
21
import os
23
22
import sys
24
23
 
25
24
#import bzrlib specific imports here
26
25
from bzrlib import (
 
26
    branch,
 
27
    bzrdir,
27
28
    config,
28
29
    errors,
29
30
    osutils,
 
31
    mail_client,
 
32
    ui,
30
33
    urlutils,
 
34
    tests,
 
35
    trace,
 
36
    transport,
31
37
    )
32
 
from bzrlib.branch import Branch
33
 
from bzrlib.bzrdir import BzrDir
34
 
from bzrlib.tests import TestCase, TestCaseInTempDir, TestCaseWithTransport
 
38
from bzrlib.util.configobj import configobj
35
39
 
36
40
 
37
41
sample_long_alias="log -r-15..-1 --line"
38
 
sample_config_text = ("[DEFAULT]\n"
39
 
                      u"email=Erik B\u00e5gfors <erik@bagfors.nu>\n"
40
 
                      "editor=vim\n"
41
 
                      "gpg_signing_command=gnome-gpg\n"
42
 
                      "log_format=short\n"
43
 
                      "user_global_option=something\n"
44
 
                      "[ALIASES]\n"
45
 
                      "h=help\n"
46
 
                      "ll=" + sample_long_alias + "\n")
47
 
 
48
 
 
49
 
sample_always_signatures = ("[DEFAULT]\n"
50
 
                            "check_signatures=ignore\n"
51
 
                            "create_signatures=always")
52
 
 
53
 
 
54
 
sample_ignore_signatures = ("[DEFAULT]\n"
55
 
                            "check_signatures=require\n"
56
 
                            "create_signatures=never")
57
 
 
58
 
 
59
 
sample_maybe_signatures = ("[DEFAULT]\n"
60
 
                            "check_signatures=ignore\n"
61
 
                            "create_signatures=when-required")
62
 
 
63
 
 
64
 
sample_branches_text = ("[http://www.example.com]\n"
65
 
                        "# Top level policy\n"
66
 
                        "email=Robert Collins <robertc@example.org>\n"
67
 
                        "[http://www.example.com/ignoreparent]\n"
68
 
                        "# different project: ignore parent dir config\n"
69
 
                        "ignore_parents=true\n"
70
 
                        "[http://www.example.com/norecurse]\n"
71
 
                        "# configuration items that only apply to this dir\n"
72
 
                        "recurse=false\n"
73
 
                        "[/b/]\n"
74
 
                        "check_signatures=require\n"
75
 
                        "# test trailing / matching with no children\n"
76
 
                        "[/a/]\n"
77
 
                        "check_signatures=check-available\n"
78
 
                        "gpg_signing_command=false\n"
79
 
                        "user_local_option=local\n"
80
 
                        "# test trailing / matching\n"
81
 
                        "[/a/*]\n"
82
 
                        "#subdirs will match but not the parent\n"
83
 
                        "[/a/c]\n"
84
 
                        "check_signatures=ignore\n"
85
 
                        "post_commit=bzrlib.tests.test_config.post_commit\n"
86
 
                        "#testing explicit beats globs\n")
87
 
 
 
42
sample_config_text = u"""
 
43
[DEFAULT]
 
44
email=Erik B\u00e5gfors <erik@bagfors.nu>
 
45
editor=vim
 
46
gpg_signing_command=gnome-gpg
 
47
log_format=short
 
48
user_global_option=something
 
49
[ALIASES]
 
50
h=help
 
51
ll=""" + sample_long_alias + "\n"
 
52
 
 
53
 
 
54
sample_always_signatures = """
 
55
[DEFAULT]
 
56
check_signatures=ignore
 
57
create_signatures=always
 
58
"""
 
59
 
 
60
sample_ignore_signatures = """
 
61
[DEFAULT]
 
62
check_signatures=require
 
63
create_signatures=never
 
64
"""
 
65
 
 
66
sample_maybe_signatures = """
 
67
[DEFAULT]
 
68
check_signatures=ignore
 
69
create_signatures=when-required
 
70
"""
 
71
 
 
72
sample_branches_text = """
 
73
[http://www.example.com]
 
74
# Top level policy
 
75
email=Robert Collins <robertc@example.org>
 
76
normal_option = normal
 
77
appendpath_option = append
 
78
appendpath_option:policy = appendpath
 
79
norecurse_option = norecurse
 
80
norecurse_option:policy = norecurse
 
81
[http://www.example.com/ignoreparent]
 
82
# different project: ignore parent dir config
 
83
ignore_parents=true
 
84
[http://www.example.com/norecurse]
 
85
# configuration items that only apply to this dir
 
86
recurse=false
 
87
normal_option = norecurse
 
88
[http://www.example.com/dir]
 
89
appendpath_option = normal
 
90
[/b/]
 
91
check_signatures=require
 
92
# test trailing / matching with no children
 
93
[/a/]
 
94
check_signatures=check-available
 
95
gpg_signing_command=false
 
96
user_local_option=local
 
97
# test trailing / matching
 
98
[/a/*]
 
99
#subdirs will match but not the parent
 
100
[/a/c]
 
101
check_signatures=ignore
 
102
post_commit=bzrlib.tests.test_config.post_commit
 
103
#testing explicit beats globs
 
104
"""
88
105
 
89
106
 
90
107
class InstrumentedConfigObj(object):
104
121
    def __setitem__(self, key, value):
105
122
        self._calls.append(('__setitem__', key, value))
106
123
 
 
124
    def __delitem__(self, key):
 
125
        self._calls.append(('__delitem__', key))
 
126
 
 
127
    def keys(self):
 
128
        self._calls.append(('keys',))
 
129
        return []
 
130
 
107
131
    def write(self, arg):
108
132
        self._calls.append(('write',))
109
133
 
 
134
    def as_bool(self, value):
 
135
        self._calls.append(('as_bool', value))
 
136
        return False
 
137
 
 
138
    def get_value(self, section, name):
 
139
        self._calls.append(('get_value', section, name))
 
140
        return None
 
141
 
110
142
 
111
143
class FakeBranch(object):
112
144
 
115
147
            self.base = "http://example.com/branches/demo"
116
148
        else:
117
149
            self.base = base
118
 
        self.control_files = FakeControlFiles(user_id=user_id)
 
150
        self._transport = self.control_files = \
 
151
            FakeControlFilesAndTransport(user_id=user_id)
119
152
 
120
153
    def lock_write(self):
121
154
        pass
124
157
        pass
125
158
 
126
159
 
127
 
class FakeControlFiles(object):
 
160
class FakeControlFilesAndTransport(object):
128
161
 
129
162
    def __init__(self, user_id=None):
130
 
        self.email = user_id
131
163
        self.files = {}
 
164
        if user_id:
 
165
            self.files['email'] = user_id
 
166
        self._transport = self
132
167
 
133
168
    def get_utf8(self, filename):
134
 
        if filename != 'email':
135
 
            raise NotImplementedError
136
 
        if self.email is not None:
137
 
            return StringIO(self.email)
138
 
        raise errors.NoSuchFile(filename)
 
169
        # from LockableFiles
 
170
        raise AssertionError("get_utf8 should no longer be used")
139
171
 
140
172
    def get(self, filename):
 
173
        # from Transport
141
174
        try:
142
175
            return StringIO(self.files[filename])
143
176
        except KeyError:
144
177
            raise errors.NoSuchFile(filename)
145
178
 
 
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
 
146
186
    def put(self, filename, fileobj):
147
187
        self.files[filename] = fileobj.read()
148
188
 
 
189
    def put_file(self, filename, fileobj):
 
190
        return self.put(filename, fileobj)
 
191
 
149
192
 
150
193
class InstrumentedConfig(config.Config):
151
194
    """An instrumented config that supplies stubs for template methods."""
152
 
    
 
195
 
153
196
    def __init__(self):
154
197
        super(InstrumentedConfig, self).__init__()
155
198
        self._calls = []
171
214
active = True
172
215
nonactive = False
173
216
"""
174
 
class TestConfigObj(TestCase):
 
217
 
 
218
 
 
219
class TestConfigObj(tests.TestCase):
 
220
 
175
221
    def test_get_bool(self):
176
 
        from bzrlib.config import ConfigObj
177
 
        co = ConfigObj(StringIO(bool_config))
 
222
        co = config.ConfigObj(StringIO(bool_config))
178
223
        self.assertIs(co.get_bool('DEFAULT', 'active'), True)
179
224
        self.assertIs(co.get_bool('DEFAULT', 'inactive'), False)
180
225
        self.assertIs(co.get_bool('UPPERCASE', 'active'), True)
181
226
        self.assertIs(co.get_bool('UPPERCASE', 'nonactive'), False)
182
227
 
183
 
 
184
 
class TestConfig(TestCase):
 
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
 
 
241
erroneous_config = """[section] # line 1
 
242
good=good # line 2
 
243
[section] # line 3
 
244
whocares=notme # line 4
 
245
"""
 
246
 
 
247
 
 
248
class TestConfigObjErrors(tests.TestCase):
 
249
 
 
250
    def test_duplicate_section_name_error_line(self):
 
251
        try:
 
252
            co = configobj.ConfigObj(StringIO(erroneous_config),
 
253
                                     raise_errors=True)
 
254
        except config.configobj.DuplicateError, e:
 
255
            self.assertEqual(3, e.line_number)
 
256
        else:
 
257
            self.fail('Error in config file not detected')
 
258
 
 
259
 
 
260
class TestConfig(tests.TestCase):
185
261
 
186
262
    def test_constructs(self):
187
263
        config.Config()
188
 
 
 
264
 
189
265
    def test_no_default_editor(self):
190
266
        self.assertRaises(NotImplementedError, config.Config().get_editor)
191
267
 
237
313
        self.assertEqual('long', my_config.log_format())
238
314
 
239
315
 
240
 
class TestConfigPath(TestCase):
 
316
class TestConfigPath(tests.TestCase):
241
317
 
242
318
    def setUp(self):
243
319
        super(TestConfigPath, self).setUp()
244
 
        self.old_home = os.environ.get('HOME', None)
245
 
        self.old_appdata = os.environ.get('APPDATA', None)
246
320
        os.environ['HOME'] = '/home/bogus'
247
 
        os.environ['APPDATA'] = \
248
 
            r'C:\Documents and Settings\bogus\Application Data'
 
321
        if sys.platform == 'win32':
 
322
            os.environ['BZR_HOME'] = \
 
323
                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'
249
328
 
250
 
    def tearDown(self):
251
 
        if self.old_home is None:
252
 
            del os.environ['HOME']
253
 
        else:
254
 
            os.environ['HOME'] = self.old_home
255
 
        if self.old_appdata is None:
256
 
            del os.environ['APPDATA']
257
 
        else:
258
 
            os.environ['APPDATA'] = self.old_appdata
259
 
        super(TestConfigPath, self).tearDown()
260
 
    
261
329
    def test_config_dir(self):
262
 
        if sys.platform == 'win32':
263
 
            self.assertEqual(config.config_dir(), 
264
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0')
265
 
        else:
266
 
            self.assertEqual(config.config_dir(), '/home/bogus/.bazaar')
 
330
        self.assertEqual(config.config_dir(), self.bzr_home)
267
331
 
268
332
    def test_config_filename(self):
269
 
        if sys.platform == 'win32':
270
 
            self.assertEqual(config.config_filename(), 
271
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/bazaar.conf')
272
 
        else:
273
 
            self.assertEqual(config.config_filename(),
274
 
                             '/home/bogus/.bazaar/bazaar.conf')
 
333
        self.assertEqual(config.config_filename(),
 
334
                         self.bzr_home + '/bazaar.conf')
275
335
 
276
336
    def test_branches_config_filename(self):
277
 
        if sys.platform == 'win32':
278
 
            self.assertEqual(config.branches_config_filename(), 
279
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/branches.conf')
280
 
        else:
281
 
            self.assertEqual(config.branches_config_filename(),
282
 
                             '/home/bogus/.bazaar/branches.conf')
 
337
        self.assertEqual(config.branches_config_filename(),
 
338
                         self.bzr_home + '/branches.conf')
283
339
 
284
340
    def test_locations_config_filename(self):
285
 
        if sys.platform == 'win32':
286
 
            self.assertEqual(config.locations_config_filename(), 
287
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/locations.conf')
288
 
        else:
289
 
            self.assertEqual(config.locations_config_filename(),
290
 
                             '/home/bogus/.bazaar/locations.conf')
291
 
 
292
 
class TestIniConfig(TestCase):
 
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):
293
350
 
294
351
    def test_contructs(self):
295
352
        my_config = config.IniBasedConfig("nothing")
299
356
        my_config = config.IniBasedConfig(None)
300
357
        self.failUnless(
301
358
            isinstance(my_config._get_parser(file=config_file),
302
 
                        ConfigObj))
 
359
                        configobj.ConfigObj))
303
360
 
304
361
    def test_cached(self):
305
362
        config_file = StringIO(sample_config_text.encode('utf-8'))
308
365
        self.failUnless(my_config._get_parser() is parser)
309
366
 
310
367
 
311
 
class TestGetConfig(TestCase):
 
368
class TestGetConfig(tests.TestCase):
312
369
 
313
370
    def test_constructs(self):
314
371
        my_config = config.GlobalConfig()
315
372
 
316
373
    def test_calls_read_filenames(self):
317
 
        # replace the class that is constructured, to check its parameters
 
374
        # replace the class that is constructed, to check its parameters
318
375
        oldparserclass = config.ConfigObj
319
376
        config.ConfigObj = InstrumentedConfigObj
320
377
        my_config = config.GlobalConfig()
327
384
                                          'utf-8')])
328
385
 
329
386
 
330
 
class TestBranchConfig(TestCaseWithTransport):
 
387
class TestBranchConfig(tests.TestCaseWithTransport):
331
388
 
332
389
    def test_constructs(self):
333
390
        branch = FakeBranch()
343
400
 
344
401
    def test_get_config(self):
345
402
        """The Branch.get_config method works properly"""
346
 
        b = BzrDir.create_standalone_workingtree('.').branch
 
403
        b = bzrdir.BzrDir.create_standalone_workingtree('.').branch
347
404
        my_config = b.get_config()
348
405
        self.assertIs(my_config.get_user_option('wacky'), None)
349
406
        my_config.set_user_option('wacky', 'unlikely')
350
407
        self.assertEqual(my_config.get_user_option('wacky'), 'unlikely')
351
408
 
352
409
        # Ensure we get the same thing if we start again
353
 
        b2 = Branch.open('.')
 
410
        b2 = branch.Branch.open('.')
354
411
        my_config2 = b2.get_config()
355
412
        self.assertEqual(my_config2.get_user_option('wacky'), 'unlikely')
356
413
 
385
442
 
386
443
    def test_config_creates_local(self):
387
444
        """Creating a new entry in config uses a local path."""
388
 
        branch = self.make_branch('branch')
 
445
        branch = self.make_branch('branch', format='knit')
389
446
        branch.set_push_location('http://foobar')
390
447
        locations = config.locations_config_filename()
391
448
        local_path = osutils.getcwd().encode('utf8')
392
449
        # Surprisingly ConfigObj doesn't create a trailing newline
393
450
        self.check_file_contents(locations,
394
 
            '[%s/branch]\npush_location = http://foobar' % (local_path,))
395
 
 
396
 
 
397
 
class TestGlobalConfigItems(TestCase):
 
451
                                 '[%s/branch]\n'
 
452
                                 'push_location = http://foobar\n'
 
453
                                 'push_location:policy = norecurse\n'
 
454
                                 % (local_path,))
 
455
 
 
456
    def test_autonick_urlencoded(self):
 
457
        b = self.make_branch('!repo')
 
458
        self.assertEqual('!repo', b.get_config().get_nickname())
 
459
 
 
460
    def test_warn_if_masked(self):
 
461
        _warning = trace.warning
 
462
        warnings = []
 
463
        def warning(*args):
 
464
            warnings.append(args[0] % args[1:])
 
465
 
 
466
        def set_option(store, warn_masked=True):
 
467
            warnings[:] = []
 
468
            conf.set_user_option('example_option', repr(store), store=store,
 
469
                                 warn_masked=warn_masked)
 
470
        def assertWarning(warning):
 
471
            if warning is None:
 
472
                self.assertEqual(0, len(warnings))
 
473
            else:
 
474
                self.assertEqual(1, len(warnings))
 
475
                self.assertEqual(warning, warnings[0])
 
476
        trace.warning = warning
 
477
        try:
 
478
            branch = self.make_branch('.')
 
479
            conf = branch.get_config()
 
480
            set_option(config.STORE_GLOBAL)
 
481
            assertWarning(None)
 
482
            set_option(config.STORE_BRANCH)
 
483
            assertWarning(None)
 
484
            set_option(config.STORE_GLOBAL)
 
485
            assertWarning('Value "4" is masked by "3" from branch.conf')
 
486
            set_option(config.STORE_GLOBAL, warn_masked=False)
 
487
            assertWarning(None)
 
488
            set_option(config.STORE_LOCATION)
 
489
            assertWarning(None)
 
490
            set_option(config.STORE_BRANCH)
 
491
            assertWarning('Value "3" is masked by "0" from locations.conf')
 
492
            set_option(config.STORE_BRANCH, warn_masked=False)
 
493
            assertWarning(None)
 
494
        finally:
 
495
            trace.warning = _warning
 
496
 
 
497
 
 
498
class TestGlobalConfigItems(tests.TestCase):
398
499
 
399
500
    def test_user_id(self):
400
501
        config_file = StringIO(sample_config_text.encode('utf-8'))
474
575
        my_config = self._get_sample_config()
475
576
        self.assertEqual("something",
476
577
                         my_config.get_user_option('user_global_option'))
477
 
        
 
578
 
478
579
    def test_post_commit_default(self):
479
580
        my_config = self._get_sample_config()
480
581
        self.assertEqual(None, my_config.post_commit())
487
588
        my_config = self._get_sample_config()
488
589
        self.assertEqual('help', my_config.get_alias('h'))
489
590
 
 
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
 
490
599
    def test_get_no_alias(self):
491
600
        my_config = self._get_sample_config()
492
601
        self.assertEqual(None, my_config.get_alias('foo'))
496
605
        self.assertEqual(sample_long_alias, my_config.get_alias('ll'))
497
606
 
498
607
 
499
 
class TestLocationConfig(TestCaseInTempDir):
 
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):
500
631
 
501
632
    def test_constructs(self):
502
633
        my_config = config.LocationConfig('http://example.com')
506
637
        # This is testing the correct file names are provided.
507
638
        # TODO: consolidate with the test for GlobalConfigs filename checks.
508
639
        #
509
 
        # replace the class that is constructured, to check its parameters
 
640
        # replace the class that is constructed, to check its parameters
510
641
        oldparserclass = config.ConfigObj
511
642
        config.ConfigObj = InstrumentedConfigObj
512
643
        try:
540
671
    def test__get_matching_sections_no_match(self):
541
672
        self.get_branch_config('/')
542
673
        self.assertEqual([], self.my_location_config._get_matching_sections())
543
 
        
 
674
 
544
675
    def test__get_matching_sections_exact(self):
545
676
        self.get_branch_config('http://www.example.com')
546
677
        self.assertEqual([('http://www.example.com', '')],
547
678
                         self.my_location_config._get_matching_sections())
548
 
   
 
679
 
549
680
    def test__get_matching_sections_suffix_does_not(self):
550
681
        self.get_branch_config('http://www.example.com-com')
551
682
        self.assertEqual([], self.my_location_config._get_matching_sections())
563
694
    def test__get_matching_sections_ignoreparent_subdir(self):
564
695
        self.get_branch_config(
565
696
            'http://www.example.com/ignoreparent/childbranch')
566
 
        self.assertEqual([('http://www.example.com/ignoreparent', 'childbranch')],
567
 
                         self.my_location_config._get_matching_sections())
568
 
 
569
 
    def test__get_matching_sections_norecurse(self):
570
 
        self.get_branch_config('http://www.example.com/norecurse')
571
 
        self.assertEqual([('http://www.example.com/norecurse', ''),
572
 
                          ('http://www.example.com', 'norecurse')],
573
 
                         self.my_location_config._get_matching_sections())
574
 
 
575
 
    def test__get_matching_sections_norecurse_subdir(self):
576
 
        self.get_branch_config(
577
 
            'http://www.example.com/norecurse/childbranch')
578
 
        self.assertEqual([('http://www.example.com', 'norecurse/childbranch')],
 
697
        self.assertEqual([('http://www.example.com/ignoreparent',
 
698
                           'childbranch')],
579
699
                         self.my_location_config._get_matching_sections())
580
700
 
581
701
    def test__get_matching_sections_subdir_trailing_slash(self):
607
727
        self.assertEqual([('/a/c', ''), ('/a/*', ''), ('/a/', 'c')],
608
728
                         self.my_location_config._get_matching_sections())
609
729
 
 
730
    def test__get_option_policy_normal(self):
 
731
        self.get_branch_config('http://www.example.com')
 
732
        self.assertEqual(
 
733
            self.my_location_config._get_config_policy(
 
734
            'http://www.example.com', 'normal_option'),
 
735
            config.POLICY_NONE)
 
736
 
 
737
    def test__get_option_policy_norecurse(self):
 
738
        self.get_branch_config('http://www.example.com')
 
739
        self.assertEqual(
 
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:
 
744
        self.assertEqual(
 
745
            self.my_location_config._get_option_policy(
 
746
            'http://www.example.com/norecurse', 'normal_option'),
 
747
            config.POLICY_NORECURSE)
 
748
 
 
749
    def test__get_option_policy_normal(self):
 
750
        self.get_branch_config('http://www.example.com')
 
751
        self.assertEqual(
 
752
            self.my_location_config._get_option_policy(
 
753
            'http://www.example.com', 'appendpath_option'),
 
754
            config.POLICY_APPENDPATH)
 
755
 
610
756
    def test_location_without_username(self):
611
757
        self.get_branch_config('http://www.example.com/ignoreparent')
612
758
        self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
635
781
        self.get_branch_config('/a/c')
636
782
        self.assertEqual(config.CHECK_NEVER,
637
783
                         self.my_config.signature_checking())
638
 
        
 
784
 
639
785
    def test_signatures_when_available(self):
640
786
        self.get_branch_config('/a/', global_config=sample_ignore_signatures)
641
787
        self.assertEqual(config.CHECK_IF_POSSIBLE,
642
788
                         self.my_config.signature_checking())
643
 
        
 
789
 
644
790
    def test_signatures_always(self):
645
791
        self.get_branch_config('/b')
646
792
        self.assertEqual(config.CHECK_ALWAYS,
647
793
                         self.my_config.signature_checking())
648
 
        
 
794
 
649
795
    def test_gpg_signing_command(self):
650
796
        self.get_branch_config('/b')
651
797
        self.assertEqual("gnome-gpg", self.my_config.gpg_signing_command())
664
810
        self.assertEqual('local',
665
811
                         self.my_config.get_user_option('user_local_option'))
666
812
 
 
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
 
823
        # normal option:
 
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'))
 
827
 
 
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
 
837
        # this redefinition.
 
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'))
 
844
 
 
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)
 
849
        self.assertEqual(
 
850
            self.my_location_config._get_option_policy(
 
851
            'http://www.example.com', 'foo'),
 
852
            config.POLICY_NORECURSE)
 
853
 
 
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)
 
858
        self.assertEqual(
 
859
            self.my_location_config._get_option_policy(
 
860
            'http://www.example.com', 'foo'),
 
861
            config.POLICY_APPENDPATH)
 
862
 
 
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)
 
867
        self.assertEqual(
 
868
            self.my_location_config._get_option_policy(
 
869
            'http://www.example.com', 'norecurse_option'),
 
870
            config.POLICY_NONE)
 
871
 
 
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)
 
882
        self.assertEqual(
 
883
            self.my_location_config._get_option_policy(
 
884
            'http://www.example.com/norecurse', 'foo'),
 
885
            config.POLICY_NONE)
 
886
        # The previously existing option is still norecurse:
 
887
        self.assertEqual(
 
888
            self.my_location_config._get_option_policy(
 
889
            'http://www.example.com/norecurse', 'normal_option'),
 
890
            config.POLICY_NORECURSE)
 
891
 
667
892
    def test_post_commit_default(self):
668
893
        self.get_branch_config('/a/c')
669
894
        self.assertEqual('bzrlib.tests.test_config.post_commit',
696
921
 
697
922
        os.mkdir = checked_mkdir
698
923
        try:
699
 
            self.my_config.set_user_option('foo', 'bar', local=True)
 
924
            self.callDeprecated(['The recurse option is deprecated as of '
 
925
                                 '0.14.  The section "/a/c" has been '
 
926
                                 'converted to use policies.'],
 
927
                                self.my_config.set_user_option,
 
928
                                'foo', 'bar', store=config.STORE_LOCATION)
700
929
        finally:
701
930
            os.mkdir = real_mkdir
702
931
 
706
935
                          ('__setitem__', '/a/c', {}),
707
936
                          ('__getitem__', '/a/c'),
708
937
                          ('__setitem__', 'foo', 'bar'),
 
938
                          ('__getitem__', '/a/c'),
 
939
                          ('as_bool', 'recurse'),
 
940
                          ('__getitem__', '/a/c'),
 
941
                          ('__delitem__', 'recurse'),
 
942
                          ('__getitem__', '/a/c'),
 
943
                          ('keys',),
 
944
                          ('__getitem__', '/a/c'),
 
945
                          ('__contains__', 'foo:policy'),
709
946
                          ('write',)],
710
947
                         record._calls[1:])
711
948
 
714
951
        self.assertIs(self.my_config.get_user_option('foo'), None)
715
952
        self.my_config.set_user_option('foo', 'bar')
716
953
        self.assertEqual(
717
 
            self.my_config.branch.control_files.files['branch.conf'], 
 
954
            self.my_config.branch.control_files.files['branch.conf'].strip(),
718
955
            'foo = bar')
719
956
        self.assertEqual(self.my_config.get_user_option('foo'), 'bar')
720
 
        self.my_config.set_user_option('foo', 'baz', local=True)
 
957
        self.my_config.set_user_option('foo', 'baz',
 
958
                                       store=config.STORE_LOCATION)
721
959
        self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
722
960
        self.my_config.set_user_option('foo', 'qux')
723
961
        self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
724
 
        
 
962
 
 
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())
 
970
 
725
971
 
726
972
precedence_global = 'option = global'
727
973
precedence_branch = 'option = branch'
734
980
"""
735
981
 
736
982
 
737
 
class TestBranchConfigItems(TestCaseInTempDir):
 
983
class TestBranchConfigItems(tests.TestCaseInTempDir):
738
984
 
739
 
    def get_branch_config(self, global_config=None, location=None, 
 
985
    def get_branch_config(self, global_config=None, location=None,
740
986
                          location_config=None, branch_data_config=None):
741
987
        my_config = config.BranchConfig(FakeBranch(location))
742
988
        if global_config is not None:
756
1002
        my_config = config.BranchConfig(branch)
757
1003
        self.assertEqual("Robert Collins <robertc@example.net>",
758
1004
                         my_config.username())
759
 
        branch.control_files.email = "John"
760
 
        my_config.set_user_option('email', 
 
1005
        my_config.branch.control_files.files['email'] = "John"
 
1006
        my_config.set_user_option('email',
761
1007
                                  "Robert Collins <robertc@example.org>")
762
1008
        self.assertEqual("John", my_config.username())
763
 
        branch.control_files.email = None
 
1009
        del my_config.branch.control_files.files['email']
764
1010
        self.assertEqual("Robert Collins <robertc@example.org>",
765
1011
                         my_config.username())
766
1012
 
767
1013
    def test_not_set_in_branch(self):
768
1014
        my_config = self.get_branch_config(sample_config_text)
769
 
        my_config.branch.control_files.email = None
770
1015
        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
771
1016
                         my_config._get_user_id())
772
 
        my_config.branch.control_files.email = "John"
 
1017
        my_config.branch.control_files.files['email'] = "John"
773
1018
        self.assertEqual("John", my_config._get_user_id())
774
1019
 
775
1020
    def test_BZR_EMAIL_OVERRIDES(self):
778
1023
        my_config = config.BranchConfig(branch)
779
1024
        self.assertEqual("Robert Collins <robertc@example.org>",
780
1025
                         my_config.username())
781
 
    
 
1026
 
782
1027
    def test_signatures_forced(self):
783
1028
        my_config = self.get_branch_config(
784
1029
            global_config=sample_always_signatures)
821
1066
        # post-commit is ignored when bresent in branch data
822
1067
        self.assertEqual('bzrlib.tests.test_config.post_commit',
823
1068
                         my_config.post_commit())
824
 
        my_config.set_user_option('post_commit', 'rmtree_root', local=True)
 
1069
        my_config.set_user_option('post_commit', 'rmtree_root',
 
1070
                                  store=config.STORE_LOCATION)
825
1071
        self.assertEqual('rmtree_root', my_config.post_commit())
826
1072
 
827
1073
    def test_config_precedence(self):
828
1074
        my_config = self.get_branch_config(global_config=precedence_global)
829
1075
        self.assertEqual(my_config.get_user_option('option'), 'global')
830
 
        my_config = self.get_branch_config(global_config=precedence_global, 
 
1076
        my_config = self.get_branch_config(global_config=precedence_global,
831
1077
                                      branch_data_config=precedence_branch)
832
1078
        self.assertEqual(my_config.get_user_option('option'), 'branch')
833
 
        my_config = self.get_branch_config(global_config=precedence_global, 
 
1079
        my_config = self.get_branch_config(global_config=precedence_global,
834
1080
                                      branch_data_config=precedence_branch,
835
1081
                                      location_config=precedence_location)
836
1082
        self.assertEqual(my_config.get_user_option('option'), 'recurse')
837
 
        my_config = self.get_branch_config(global_config=precedence_global, 
 
1083
        my_config = self.get_branch_config(global_config=precedence_global,
838
1084
                                      branch_data_config=precedence_branch,
839
1085
                                      location_config=precedence_location,
840
1086
                                      location='http://example.com/specific')
841
1087
        self.assertEqual(my_config.get_user_option('option'), 'exact')
842
1088
 
843
 
 
844
 
class TestMailAddressExtraction(TestCase):
 
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)
 
1093
 
 
1094
        # Specific clients
 
1095
        config.set_user_option('mail_client', 'evolution')
 
1096
        client = config.get_mail_client()
 
1097
        self.assertIsInstance(client, mail_client.Evolution)
 
1098
 
 
1099
        config.set_user_option('mail_client', 'kmail')
 
1100
        client = config.get_mail_client()
 
1101
        self.assertIsInstance(client, mail_client.KMail)
 
1102
 
 
1103
        config.set_user_option('mail_client', 'mutt')
 
1104
        client = config.get_mail_client()
 
1105
        self.assertIsInstance(client, mail_client.Mutt)
 
1106
 
 
1107
        config.set_user_option('mail_client', 'thunderbird')
 
1108
        client = config.get_mail_client()
 
1109
        self.assertIsInstance(client, mail_client.Thunderbird)
 
1110
 
 
1111
        # Generic options
 
1112
        config.set_user_option('mail_client', 'default')
 
1113
        client = config.get_mail_client()
 
1114
        self.assertIsInstance(client, mail_client.DefaultMail)
 
1115
 
 
1116
        config.set_user_option('mail_client', 'editor')
 
1117
        client = config.get_mail_client()
 
1118
        self.assertIsInstance(client, mail_client.Editor)
 
1119
 
 
1120
        config.set_user_option('mail_client', 'mapi')
 
1121
        client = config.get_mail_client()
 
1122
        self.assertIsInstance(client, mail_client.MAPIClient)
 
1123
 
 
1124
        config.set_user_option('mail_client', 'xdg-email')
 
1125
        client = config.get_mail_client()
 
1126
        self.assertIsInstance(client, mail_client.XDGEmail)
 
1127
 
 
1128
        config.set_user_option('mail_client', 'firebird')
 
1129
        self.assertRaises(errors.UnknownMailClient, config.get_mail_client)
 
1130
 
 
1131
 
 
1132
class TestMailAddressExtraction(tests.TestCase):
845
1133
 
846
1134
    def test_extract_email_address(self):
847
1135
        self.assertEqual('jane@test.com',
848
1136
                         config.extract_email_address('Jane <jane@test.com>'))
849
1137
        self.assertRaises(errors.NoEmailInUsername,
850
1138
                          config.extract_email_address, 'Jane Tester')
 
1139
 
 
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
 
 
1152
class TestTreeConfig(tests.TestCaseWithTransport):
 
1153
 
 
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')
 
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_unknown_password_encoding(self):
 
1267
        conf = config.AuthenticationConfig(_file=StringIO(
 
1268
                """[broken]
 
1269
scheme=ftp
 
1270
user=joe
 
1271
password_encoding=unknown
 
1272
"""))
 
1273
        self.assertRaises(ValueError, conf.get_password,
 
1274
                          'ftp', 'foo.net', 'joe')
 
1275
 
 
1276
    def test_credentials_for_scheme_host(self):
 
1277
        conf = config.AuthenticationConfig(_file=StringIO(
 
1278
                """# Identity on foo.net
 
1279
[ftp definition]
 
1280
scheme=ftp
 
1281
host=foo.net
 
1282
user=joe
 
1283
password=secret-pass
 
1284
"""))
 
1285
        # Basic matching
 
1286
        self._got_user_passwd('joe', 'secret-pass', conf, 'ftp', 'foo.net')
 
1287
        # different scheme
 
1288
        self._got_user_passwd(None, None, conf, 'http', 'foo.net')
 
1289
        # different host
 
1290
        self._got_user_passwd(None, None, conf, 'ftp', 'bar.net')
 
1291
 
 
1292
    def test_credentials_for_host_port(self):
 
1293
        conf = config.AuthenticationConfig(_file=StringIO(
 
1294
                """# Identity on foo.net
 
1295
[ftp definition]
 
1296
scheme=ftp
 
1297
port=10021
 
1298
host=foo.net
 
1299
user=joe
 
1300
password=secret-pass
 
1301
"""))
 
1302
        # No port
 
1303
        self._got_user_passwd('joe', 'secret-pass',
 
1304
                              conf, 'ftp', 'foo.net', port=10021)
 
1305
        # different port
 
1306
        self._got_user_passwd(None, None, conf, 'ftp', 'foo.net')
 
1307
 
 
1308
    def test_for_matching_host(self):
 
1309
        conf = config.AuthenticationConfig(_file=StringIO(
 
1310
                """# Identity on foo.net
 
1311
[sourceforge]
 
1312
scheme=bzr
 
1313
host=bzr.sf.net
 
1314
user=joe
 
1315
password=joepass
 
1316
[sourceforge domain]
 
1317
scheme=bzr
 
1318
host=.bzr.sf.net
 
1319
user=georges
 
1320
password=bendover
 
1321
"""))
 
1322
        # matching domain
 
1323
        self._got_user_passwd('georges', 'bendover',
 
1324
                              conf, 'bzr', 'foo.bzr.sf.net')
 
1325
        # phishing attempt
 
1326
        self._got_user_passwd(None, None,
 
1327
                              conf, 'bzr', 'bbzr.sf.net')
 
1328
 
 
1329
    def test_for_matching_host_None(self):
 
1330
        conf = config.AuthenticationConfig(_file=StringIO(
 
1331
                """# Identity on foo.net
 
1332
[catchup bzr]
 
1333
scheme=bzr
 
1334
user=joe
 
1335
password=joepass
 
1336
[DEFAULT]
 
1337
user=georges
 
1338
password=bendover
 
1339
"""))
 
1340
        # match no host
 
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')
 
1346
 
 
1347
    def test_credentials_for_path(self):
 
1348
        conf = config.AuthenticationConfig(_file=StringIO(
 
1349
                """
 
1350
[http dir1]
 
1351
scheme=http
 
1352
host=bar.org
 
1353
path=/dir1
 
1354
user=jim
 
1355
password=jimpass
 
1356
[http dir2]
 
1357
scheme=http
 
1358
host=bar.org
 
1359
path=/dir2
 
1360
user=georges
 
1361
password=bendover
 
1362
"""))
 
1363
        # no path no dice
 
1364
        self._got_user_passwd(None, None,
 
1365
                              conf, 'http', host='bar.org', path='/dir3')
 
1366
        # matching path
 
1367
        self._got_user_passwd('georges', 'bendover',
 
1368
                              conf, 'http', host='bar.org', path='/dir2')
 
1369
        # matching subdir
 
1370
        self._got_user_passwd('jim', 'jimpass',
 
1371
                              conf, 'http', host='bar.org',path='/dir1/subdir')
 
1372
 
 
1373
    def test_credentials_for_user(self):
 
1374
        conf = config.AuthenticationConfig(_file=StringIO(
 
1375
                """
 
1376
[with user]
 
1377
scheme=http
 
1378
host=bar.org
 
1379
user=jim
 
1380
password=jimpass
 
1381
"""))
 
1382
        # Get user
 
1383
        self._got_user_passwd('jim', 'jimpass',
 
1384
                              conf, 'http', 'bar.org')
 
1385
        # Get same user
 
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')
 
1391
 
 
1392
    def test_credentials_for_user_without_password(self):
 
1393
        conf = config.AuthenticationConfig(_file=StringIO(
 
1394
                """
 
1395
[without password]
 
1396
scheme=http
 
1397
host=bar.org
 
1398
user=jim
 
1399
"""))
 
1400
        # Get user but no password
 
1401
        self._got_user_passwd('jim', None,
 
1402
                              conf, 'http', 'bar.org')
 
1403
 
 
1404
    def test_verify_certificates(self):
 
1405
        conf = config.AuthenticationConfig(_file=StringIO(
 
1406
                """
 
1407
[self-signed]
 
1408
scheme=https
 
1409
host=bar.org
 
1410
user=jim
 
1411
password=jimpass
 
1412
verify_certificates=False
 
1413
[normal]
 
1414
scheme=https
 
1415
host=foo.net
 
1416
user=georges
 
1417
password=bendover
 
1418
"""))
 
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'))
 
1423
 
 
1424
 
 
1425
class TestAuthenticationStorage(tests.TestCaseInTempDir):
 
1426
 
 
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)
 
1439
 
 
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)
 
1449
 
 
1450
 
 
1451
class TestAuthenticationConfig(tests.TestCase):
 
1452
    """Test AuthenticationConfig behaviour"""
 
1453
 
 
1454
    def _check_default_prompt(self, expected_prompt_format, scheme,
 
1455
                              host=None, port=None, realm=None, path=None):
 
1456
        if host is None:
 
1457
            host = 'bar.org'
 
1458
        user, password = 'jim', 'precious'
 
1459
        expected_prompt = expected_prompt_format % {
 
1460
            'scheme': scheme, 'host': host, 'port': port,
 
1461
            'user': user, 'realm': realm}
 
1462
 
 
1463
        stdout = tests.StringIOWrapper()
 
1464
        ui.ui_factory = tests.TestUIFactory(stdin=password + '\n',
 
1465
                                            stdout=stdout)
 
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)
 
1472
 
 
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: ',
 
1477
                                   'ftp', port=10020)
 
1478
 
 
1479
        self._check_default_prompt('SSH %(user)s@%(host)s:%(port)d password: ',
 
1480
                                   'ssh', port=12345)
 
1481
        # SMTP port handling is a bit special (it's handled if embedded in the
 
1482
        # host too)
 
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: ',
 
1486
                                   'smtp')
 
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: ',
 
1491
            'smtp', port=10025)
 
1492
 
 
1493
    def test_ssh_password_emits_warning(self):
 
1494
        conf = config.AuthenticationConfig(_file=StringIO(
 
1495
                """
 
1496
[ssh with password]
 
1497
scheme=ssh
 
1498
host=bar.org
 
1499
user=jim
 
1500
password=jimpass
 
1501
"""))
 
1502
        entered_password = 'typed-by-hand'
 
1503
        stdout = tests.StringIOWrapper()
 
1504
        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
 
1505
                                            stdout=stdout)
 
1506
 
 
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\]')
 
1514
 
 
1515
    def test_ssh_without_password_doesnt_emit_warning(self):
 
1516
        conf = config.AuthenticationConfig(_file=StringIO(
 
1517
                """
 
1518
[ssh with password]
 
1519
scheme=ssh
 
1520
host=bar.org
 
1521
user=jim
 
1522
"""))
 
1523
        entered_password = 'typed-by-hand'
 
1524
        stdout = tests.StringIOWrapper()
 
1525
        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
 
1526
                                            stdout=stdout)
 
1527
 
 
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
 
1533
        # providing "user".
 
1534
        self.assertNotContainsRe(
 
1535
            self._get_log(keep_log_file=True),
 
1536
            'password ignored in section \[ssh with password\]')
 
1537
 
 
1538
 
 
1539
class TestCredentialStoreRegistry(tests.TestCase):
 
1540
 
 
1541
    def _get_cs_registry(self):
 
1542
        return config.credential_store_registry
 
1543
 
 
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)
 
1548
 
 
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')
 
1554
 
 
1555
 
 
1556
class TestPlainTextCredentialStore(tests.TestCase):
 
1557
 
 
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)
 
1563
 
 
1564
 
 
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):
 
1574
    pass