← 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: John Arbash Meinel
  • Date: 2006-10-16 04:50:19 UTC
  • mfrom: (2079 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2080.
  • Revision ID: john@arbash-meinel.com-20061016045019-58fb4e339f93b1d7
[merge] bzr.dev 2079

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_config.py
1
 
# Copyright (C) 2005, 2006, 2008 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 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
13
13
#
14
14
# You should have received a copy of the GNU General Public License
15
15
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
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
 
    mail_client,
32
 
    ui,
33
30
    urlutils,
34
 
    tests,
35
 
    trace,
36
 
    transport,
37
31
    )
38
 
from bzrlib.util.configobj import configobj
 
32
from bzrlib.branch import Branch
 
33
from bzrlib.bzrdir import BzrDir
 
34
from bzrlib.tests import TestCase, TestCaseInTempDir, TestCaseWithTransport
39
35
 
40
36
 
41
37
sample_long_alias="log -r-15..-1 --line"
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
 
"""
 
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
 
105
88
 
106
89
 
107
90
class InstrumentedConfigObj(object):
121
104
    def __setitem__(self, key, value):
122
105
        self._calls.append(('__setitem__', key, value))
123
106
 
124
 
    def __delitem__(self, key):
125
 
        self._calls.append(('__delitem__', key))
126
 
 
127
 
    def keys(self):
128
 
        self._calls.append(('keys',))
129
 
        return []
130
 
 
131
107
    def write(self, arg):
132
108
        self._calls.append(('write',))
133
109
 
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
 
 
142
110
 
143
111
class FakeBranch(object):
144
112
 
147
115
            self.base = "http://example.com/branches/demo"
148
116
        else:
149
117
            self.base = base
150
 
        self._transport = self.control_files = \
151
 
            FakeControlFilesAndTransport(user_id=user_id)
152
 
 
153
 
    def _get_config(self):
154
 
        return config.TransportConfig(self._transport, 'branch.conf')
 
118
        self.control_files = FakeControlFiles(user_id=user_id)
155
119
 
156
120
    def lock_write(self):
157
121
        pass
160
124
        pass
161
125
 
162
126
 
163
 
class FakeControlFilesAndTransport(object):
 
127
class FakeControlFiles(object):
164
128
 
165
129
    def __init__(self, user_id=None):
 
130
        self.email = user_id
166
131
        self.files = {}
167
 
        if user_id:
168
 
            self.files['email'] = user_id
169
 
        self._transport = self
170
132
 
171
133
    def get_utf8(self, filename):
172
 
        # from LockableFiles
173
 
        raise AssertionError("get_utf8 should no longer be used")
 
134
        if filename != 'email':
 
135
            raise NotImplementedError
 
136
        if self.email is not None:
 
137
            return StringIO(self.email)
 
138
        raise errors.NoSuchFile(filename)
174
139
 
175
140
    def get(self, filename):
176
 
        # from Transport
177
141
        try:
178
142
            return StringIO(self.files[filename])
179
143
        except KeyError:
180
144
            raise errors.NoSuchFile(filename)
181
145
 
182
 
    def get_bytes(self, filename):
183
 
        # from Transport
184
 
        try:
185
 
            return self.files[filename]
186
 
        except KeyError:
187
 
            raise errors.NoSuchFile(filename)
188
 
 
189
146
    def put(self, filename, fileobj):
190
147
        self.files[filename] = fileobj.read()
191
148
 
192
 
    def put_file(self, filename, fileobj):
193
 
        return self.put(filename, fileobj)
194
 
 
195
149
 
196
150
class InstrumentedConfig(config.Config):
197
151
    """An instrumented config that supplies stubs for template methods."""
198
 
 
 
152
    
199
153
    def __init__(self):
200
154
        super(InstrumentedConfig, self).__init__()
201
155
        self._calls = []
217
171
active = True
218
172
nonactive = False
219
173
"""
220
 
 
221
 
 
222
 
class TestConfigObj(tests.TestCase):
223
 
 
 
174
class TestConfigObj(TestCase):
224
175
    def test_get_bool(self):
225
 
        co = config.ConfigObj(StringIO(bool_config))
 
176
        from bzrlib.config import ConfigObj
 
177
        co = ConfigObj(StringIO(bool_config))
226
178
        self.assertIs(co.get_bool('DEFAULT', 'active'), True)
227
179
        self.assertIs(co.get_bool('DEFAULT', 'inactive'), False)
228
180
        self.assertIs(co.get_bool('UPPERCASE', 'active'), True)
229
181
        self.assertIs(co.get_bool('UPPERCASE', 'nonactive'), False)
230
182
 
231
 
    def test_hash_sign_in_value(self):
232
 
        """
233
 
        Before 4.5.0, ConfigObj did not quote # signs in values, so they'd be
234
 
        treated as comments when read in again. (#86838)
235
 
        """
236
 
        co = config.ConfigObj()
237
 
        co['test'] = 'foo#bar'
238
 
        lines = co.write()
239
 
        self.assertEqual(lines, ['test = "foo#bar"'])
240
 
        co2 = config.ConfigObj(lines)
241
 
        self.assertEqual(co2['test'], 'foo#bar')
242
 
 
243
 
 
244
 
erroneous_config = """[section] # line 1
245
 
good=good # line 2
246
 
[section] # line 3
247
 
whocares=notme # line 4
248
 
"""
249
 
 
250
 
 
251
 
class TestConfigObjErrors(tests.TestCase):
252
 
 
253
 
    def test_duplicate_section_name_error_line(self):
254
 
        try:
255
 
            co = configobj.ConfigObj(StringIO(erroneous_config),
256
 
                                     raise_errors=True)
257
 
        except config.configobj.DuplicateError, e:
258
 
            self.assertEqual(3, e.line_number)
259
 
        else:
260
 
            self.fail('Error in config file not detected')
261
 
 
262
 
 
263
 
class TestConfig(tests.TestCase):
 
183
 
 
184
class TestConfig(TestCase):
264
185
 
265
186
    def test_constructs(self):
266
187
        config.Config()
267
 
 
 
188
 
268
189
    def test_no_default_editor(self):
269
190
        self.assertRaises(NotImplementedError, config.Config().get_editor)
270
191
 
316
237
        self.assertEqual('long', my_config.log_format())
317
238
 
318
239
 
319
 
class TestConfigPath(tests.TestCase):
 
240
class TestConfigPath(TestCase):
320
241
 
321
242
    def setUp(self):
322
243
        super(TestConfigPath, self).setUp()
 
244
        self.old_home = os.environ.get('HOME', None)
 
245
        self.old_appdata = os.environ.get('APPDATA', None)
323
246
        os.environ['HOME'] = '/home/bogus'
324
 
        if sys.platform == 'win32':
325
 
            os.environ['BZR_HOME'] = \
326
 
                r'C:\Documents and Settings\bogus\Application Data'
327
 
            self.bzr_home = \
328
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0'
329
 
        else:
330
 
            self.bzr_home = '/home/bogus/.bazaar'
 
247
        os.environ['APPDATA'] = \
 
248
            r'C:\Documents and Settings\bogus\Application Data'
331
249
 
 
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
    
332
261
    def test_config_dir(self):
333
 
        self.assertEqual(config.config_dir(), self.bzr_home)
 
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')
334
267
 
335
268
    def test_config_filename(self):
336
 
        self.assertEqual(config.config_filename(),
337
 
                         self.bzr_home + '/bazaar.conf')
 
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')
338
275
 
339
276
    def test_branches_config_filename(self):
340
 
        self.assertEqual(config.branches_config_filename(),
341
 
                         self.bzr_home + '/branches.conf')
 
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')
342
283
 
343
284
    def test_locations_config_filename(self):
344
 
        self.assertEqual(config.locations_config_filename(),
345
 
                         self.bzr_home + '/locations.conf')
346
 
 
347
 
    def test_authentication_config_filename(self):
348
 
        self.assertEqual(config.authentication_config_filename(),
349
 
                         self.bzr_home + '/authentication.conf')
350
 
 
351
 
 
352
 
class TestIniConfig(tests.TestCase):
 
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):
353
293
 
354
294
    def test_contructs(self):
355
295
        my_config = config.IniBasedConfig("nothing")
359
299
        my_config = config.IniBasedConfig(None)
360
300
        self.failUnless(
361
301
            isinstance(my_config._get_parser(file=config_file),
362
 
                        configobj.ConfigObj))
 
302
                        ConfigObj))
363
303
 
364
304
    def test_cached(self):
365
305
        config_file = StringIO(sample_config_text.encode('utf-8'))
368
308
        self.failUnless(my_config._get_parser() is parser)
369
309
 
370
310
 
371
 
class TestGetConfig(tests.TestCase):
 
311
class TestGetConfig(TestCase):
372
312
 
373
313
    def test_constructs(self):
374
314
        my_config = config.GlobalConfig()
375
315
 
376
316
    def test_calls_read_filenames(self):
377
 
        # replace the class that is constructed, to check its parameters
 
317
        # replace the class that is constructured, to check its parameters
378
318
        oldparserclass = config.ConfigObj
379
319
        config.ConfigObj = InstrumentedConfigObj
380
320
        my_config = config.GlobalConfig()
387
327
                                          'utf-8')])
388
328
 
389
329
 
390
 
class TestBranchConfig(tests.TestCaseWithTransport):
 
330
class TestBranchConfig(TestCaseWithTransport):
391
331
 
392
332
    def test_constructs(self):
393
333
        branch = FakeBranch()
403
343
 
404
344
    def test_get_config(self):
405
345
        """The Branch.get_config method works properly"""
406
 
        b = bzrdir.BzrDir.create_standalone_workingtree('.').branch
 
346
        b = BzrDir.create_standalone_workingtree('.').branch
407
347
        my_config = b.get_config()
408
348
        self.assertIs(my_config.get_user_option('wacky'), None)
409
349
        my_config.set_user_option('wacky', 'unlikely')
410
350
        self.assertEqual(my_config.get_user_option('wacky'), 'unlikely')
411
351
 
412
352
        # Ensure we get the same thing if we start again
413
 
        b2 = branch.Branch.open('.')
 
353
        b2 = Branch.open('.')
414
354
        my_config2 = b2.get_config()
415
355
        self.assertEqual(my_config2.get_user_option('wacky'), 'unlikely')
416
356
 
428
368
        locations = config.locations_config_filename()
429
369
        config.ensure_config_dir_exists()
430
370
        local_url = urlutils.local_path_to_url('branch')
431
 
        open(locations, 'wb').write('[%s]\nnickname = foobar'
 
371
        open(locations, 'wb').write('[%s]\nnickname = foobar' 
432
372
                                    % (local_url,))
433
373
        self.assertEqual('foobar', branch.nick)
434
374
 
439
379
 
440
380
        locations = config.locations_config_filename()
441
381
        config.ensure_config_dir_exists()
442
 
        open(locations, 'wb').write('[%s/branch]\nnickname = barry'
 
382
        open(locations, 'wb').write('[%s/branch]\nnickname = barry' 
443
383
                                    % (osutils.getcwd().encode('utf8'),))
444
384
        self.assertEqual('barry', branch.nick)
445
385
 
446
386
    def test_config_creates_local(self):
447
387
        """Creating a new entry in config uses a local path."""
448
 
        branch = self.make_branch('branch', format='knit')
 
388
        branch = self.make_branch('branch')
449
389
        branch.set_push_location('http://foobar')
450
390
        locations = config.locations_config_filename()
451
391
        local_path = osutils.getcwd().encode('utf8')
452
392
        # Surprisingly ConfigObj doesn't create a trailing newline
453
393
        self.check_file_contents(locations,
454
 
                                 '[%s/branch]\n'
455
 
                                 'push_location = http://foobar\n'
456
 
                                 'push_location:policy = norecurse\n'
457
 
                                 % (local_path,))
458
 
 
459
 
    def test_autonick_urlencoded(self):
460
 
        b = self.make_branch('!repo')
461
 
        self.assertEqual('!repo', b.get_config().get_nickname())
462
 
 
463
 
    def test_warn_if_masked(self):
464
 
        _warning = trace.warning
465
 
        warnings = []
466
 
        def warning(*args):
467
 
            warnings.append(args[0] % args[1:])
468
 
 
469
 
        def set_option(store, warn_masked=True):
470
 
            warnings[:] = []
471
 
            conf.set_user_option('example_option', repr(store), store=store,
472
 
                                 warn_masked=warn_masked)
473
 
        def assertWarning(warning):
474
 
            if warning is None:
475
 
                self.assertEqual(0, len(warnings))
476
 
            else:
477
 
                self.assertEqual(1, len(warnings))
478
 
                self.assertEqual(warning, warnings[0])
479
 
        trace.warning = warning
480
 
        try:
481
 
            branch = self.make_branch('.')
482
 
            conf = branch.get_config()
483
 
            set_option(config.STORE_GLOBAL)
484
 
            assertWarning(None)
485
 
            set_option(config.STORE_BRANCH)
486
 
            assertWarning(None)
487
 
            set_option(config.STORE_GLOBAL)
488
 
            assertWarning('Value "4" is masked by "3" from branch.conf')
489
 
            set_option(config.STORE_GLOBAL, warn_masked=False)
490
 
            assertWarning(None)
491
 
            set_option(config.STORE_LOCATION)
492
 
            assertWarning(None)
493
 
            set_option(config.STORE_BRANCH)
494
 
            assertWarning('Value "3" is masked by "0" from locations.conf')
495
 
            set_option(config.STORE_BRANCH, warn_masked=False)
496
 
            assertWarning(None)
497
 
        finally:
498
 
            trace.warning = _warning
499
 
 
500
 
 
501
 
class TestGlobalConfigItems(tests.TestCase):
 
394
            '[%s/branch]\npush_location = http://foobar' % (local_path,))
 
395
 
 
396
 
 
397
class TestGlobalConfigItems(TestCase):
502
398
 
503
399
    def test_user_id(self):
504
400
        config_file = StringIO(sample_config_text.encode('utf-8'))
578
474
        my_config = self._get_sample_config()
579
475
        self.assertEqual("something",
580
476
                         my_config.get_user_option('user_global_option'))
581
 
 
 
477
        
582
478
    def test_post_commit_default(self):
583
479
        my_config = self._get_sample_config()
584
480
        self.assertEqual(None, my_config.post_commit())
591
487
        my_config = self._get_sample_config()
592
488
        self.assertEqual('help', my_config.get_alias('h'))
593
489
 
594
 
    def test_get_aliases(self):
595
 
        my_config = self._get_sample_config()
596
 
        aliases = my_config.get_aliases()
597
 
        self.assertEqual(2, len(aliases))
598
 
        sorted_keys = sorted(aliases)
599
 
        self.assertEqual('help', aliases[sorted_keys[0]])
600
 
        self.assertEqual(sample_long_alias, aliases[sorted_keys[1]])
601
 
 
602
490
    def test_get_no_alias(self):
603
491
        my_config = self._get_sample_config()
604
492
        self.assertEqual(None, my_config.get_alias('foo'))
608
496
        self.assertEqual(sample_long_alias, my_config.get_alias('ll'))
609
497
 
610
498
 
611
 
class TestGlobalConfigSavingOptions(tests.TestCaseInTempDir):
612
 
 
613
 
    def test_empty(self):
614
 
        my_config = config.GlobalConfig()
615
 
        self.assertEqual(0, len(my_config.get_aliases()))
616
 
 
617
 
    def test_set_alias(self):
618
 
        my_config = config.GlobalConfig()
619
 
        alias_value = 'commit --strict'
620
 
        my_config.set_alias('commit', alias_value)
621
 
        new_config = config.GlobalConfig()
622
 
        self.assertEqual(alias_value, new_config.get_alias('commit'))
623
 
 
624
 
    def test_remove_alias(self):
625
 
        my_config = config.GlobalConfig()
626
 
        my_config.set_alias('commit', 'commit --strict')
627
 
        # Now remove the alias again.
628
 
        my_config.unset_alias('commit')
629
 
        new_config = config.GlobalConfig()
630
 
        self.assertIs(None, new_config.get_alias('commit'))
631
 
 
632
 
 
633
 
class TestLocationConfig(tests.TestCaseInTempDir):
 
499
class TestLocationConfig(TestCaseInTempDir):
634
500
 
635
501
    def test_constructs(self):
636
502
        my_config = config.LocationConfig('http://example.com')
640
506
        # This is testing the correct file names are provided.
641
507
        # TODO: consolidate with the test for GlobalConfigs filename checks.
642
508
        #
643
 
        # replace the class that is constructed, to check its parameters
 
509
        # replace the class that is constructured, to check its parameters
644
510
        oldparserclass = config.ConfigObj
645
511
        config.ConfigObj = InstrumentedConfigObj
646
512
        try:
674
540
    def test__get_matching_sections_no_match(self):
675
541
        self.get_branch_config('/')
676
542
        self.assertEqual([], self.my_location_config._get_matching_sections())
677
 
 
 
543
        
678
544
    def test__get_matching_sections_exact(self):
679
545
        self.get_branch_config('http://www.example.com')
680
546
        self.assertEqual([('http://www.example.com', '')],
681
547
                         self.my_location_config._get_matching_sections())
682
 
 
 
548
   
683
549
    def test__get_matching_sections_suffix_does_not(self):
684
550
        self.get_branch_config('http://www.example.com-com')
685
551
        self.assertEqual([], self.my_location_config._get_matching_sections())
697
563
    def test__get_matching_sections_ignoreparent_subdir(self):
698
564
        self.get_branch_config(
699
565
            'http://www.example.com/ignoreparent/childbranch')
700
 
        self.assertEqual([('http://www.example.com/ignoreparent',
701
 
                           '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')],
702
579
                         self.my_location_config._get_matching_sections())
703
580
 
704
581
    def test__get_matching_sections_subdir_trailing_slash(self):
730
607
        self.assertEqual([('/a/c', ''), ('/a/*', ''), ('/a/', 'c')],
731
608
                         self.my_location_config._get_matching_sections())
732
609
 
733
 
    def test__get_option_policy_normal(self):
734
 
        self.get_branch_config('http://www.example.com')
735
 
        self.assertEqual(
736
 
            self.my_location_config._get_config_policy(
737
 
            'http://www.example.com', 'normal_option'),
738
 
            config.POLICY_NONE)
739
 
 
740
 
    def test__get_option_policy_norecurse(self):
741
 
        self.get_branch_config('http://www.example.com')
742
 
        self.assertEqual(
743
 
            self.my_location_config._get_option_policy(
744
 
            'http://www.example.com', 'norecurse_option'),
745
 
            config.POLICY_NORECURSE)
746
 
        # Test old recurse=False setting:
747
 
        self.assertEqual(
748
 
            self.my_location_config._get_option_policy(
749
 
            'http://www.example.com/norecurse', 'normal_option'),
750
 
            config.POLICY_NORECURSE)
751
 
 
752
 
    def test__get_option_policy_normal(self):
753
 
        self.get_branch_config('http://www.example.com')
754
 
        self.assertEqual(
755
 
            self.my_location_config._get_option_policy(
756
 
            'http://www.example.com', 'appendpath_option'),
757
 
            config.POLICY_APPENDPATH)
758
 
 
759
610
    def test_location_without_username(self):
760
611
        self.get_branch_config('http://www.example.com/ignoreparent')
761
612
        self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
784
635
        self.get_branch_config('/a/c')
785
636
        self.assertEqual(config.CHECK_NEVER,
786
637
                         self.my_config.signature_checking())
787
 
 
 
638
        
788
639
    def test_signatures_when_available(self):
789
640
        self.get_branch_config('/a/', global_config=sample_ignore_signatures)
790
641
        self.assertEqual(config.CHECK_IF_POSSIBLE,
791
642
                         self.my_config.signature_checking())
792
 
 
 
643
        
793
644
    def test_signatures_always(self):
794
645
        self.get_branch_config('/b')
795
646
        self.assertEqual(config.CHECK_ALWAYS,
796
647
                         self.my_config.signature_checking())
797
 
 
 
648
        
798
649
    def test_gpg_signing_command(self):
799
650
        self.get_branch_config('/b')
800
651
        self.assertEqual("gnome-gpg", self.my_config.gpg_signing_command())
813
664
        self.assertEqual('local',
814
665
                         self.my_config.get_user_option('user_local_option'))
815
666
 
816
 
    def test_get_user_option_appendpath(self):
817
 
        # returned as is for the base path:
818
 
        self.get_branch_config('http://www.example.com')
819
 
        self.assertEqual('append',
820
 
                         self.my_config.get_user_option('appendpath_option'))
821
 
        # Extra path components get appended:
822
 
        self.get_branch_config('http://www.example.com/a/b/c')
823
 
        self.assertEqual('append/a/b/c',
824
 
                         self.my_config.get_user_option('appendpath_option'))
825
 
        # Overriden for http://www.example.com/dir, where it is a
826
 
        # normal option:
827
 
        self.get_branch_config('http://www.example.com/dir/a/b/c')
828
 
        self.assertEqual('normal',
829
 
                         self.my_config.get_user_option('appendpath_option'))
830
 
 
831
 
    def test_get_user_option_norecurse(self):
832
 
        self.get_branch_config('http://www.example.com')
833
 
        self.assertEqual('norecurse',
834
 
                         self.my_config.get_user_option('norecurse_option'))
835
 
        self.get_branch_config('http://www.example.com/dir')
836
 
        self.assertEqual(None,
837
 
                         self.my_config.get_user_option('norecurse_option'))
838
 
        # http://www.example.com/norecurse is a recurse=False section
839
 
        # that redefines normal_option.  Subdirectories do not pick up
840
 
        # this redefinition.
841
 
        self.get_branch_config('http://www.example.com/norecurse')
842
 
        self.assertEqual('norecurse',
843
 
                         self.my_config.get_user_option('normal_option'))
844
 
        self.get_branch_config('http://www.example.com/norecurse/subdir')
845
 
        self.assertEqual('normal',
846
 
                         self.my_config.get_user_option('normal_option'))
847
 
 
848
 
    def test_set_user_option_norecurse(self):
849
 
        self.get_branch_config('http://www.example.com')
850
 
        self.my_config.set_user_option('foo', 'bar',
851
 
                                       store=config.STORE_LOCATION_NORECURSE)
852
 
        self.assertEqual(
853
 
            self.my_location_config._get_option_policy(
854
 
            'http://www.example.com', 'foo'),
855
 
            config.POLICY_NORECURSE)
856
 
 
857
 
    def test_set_user_option_appendpath(self):
858
 
        self.get_branch_config('http://www.example.com')
859
 
        self.my_config.set_user_option('foo', 'bar',
860
 
                                       store=config.STORE_LOCATION_APPENDPATH)
861
 
        self.assertEqual(
862
 
            self.my_location_config._get_option_policy(
863
 
            'http://www.example.com', 'foo'),
864
 
            config.POLICY_APPENDPATH)
865
 
 
866
 
    def test_set_user_option_change_policy(self):
867
 
        self.get_branch_config('http://www.example.com')
868
 
        self.my_config.set_user_option('norecurse_option', 'normal',
869
 
                                       store=config.STORE_LOCATION)
870
 
        self.assertEqual(
871
 
            self.my_location_config._get_option_policy(
872
 
            'http://www.example.com', 'norecurse_option'),
873
 
            config.POLICY_NONE)
874
 
 
875
 
    def test_set_user_option_recurse_false_section(self):
876
 
        # The following section has recurse=False set.  The test is to
877
 
        # make sure that a normal option can be added to the section,
878
 
        # converting recurse=False to the norecurse policy.
879
 
        self.get_branch_config('http://www.example.com/norecurse')
880
 
        self.callDeprecated(['The recurse option is deprecated as of 0.14.  '
881
 
                             'The section "http://www.example.com/norecurse" '
882
 
                             'has been converted to use policies.'],
883
 
                            self.my_config.set_user_option,
884
 
                            'foo', 'bar', store=config.STORE_LOCATION)
885
 
        self.assertEqual(
886
 
            self.my_location_config._get_option_policy(
887
 
            'http://www.example.com/norecurse', 'foo'),
888
 
            config.POLICY_NONE)
889
 
        # The previously existing option is still norecurse:
890
 
        self.assertEqual(
891
 
            self.my_location_config._get_option_policy(
892
 
            'http://www.example.com/norecurse', 'normal_option'),
893
 
            config.POLICY_NORECURSE)
894
 
 
895
667
    def test_post_commit_default(self):
896
668
        self.get_branch_config('/a/c')
897
669
        self.assertEqual('bzrlib.tests.test_config.post_commit',
924
696
 
925
697
        os.mkdir = checked_mkdir
926
698
        try:
927
 
            self.callDeprecated(['The recurse option is deprecated as of '
928
 
                                 '0.14.  The section "/a/c" has been '
929
 
                                 'converted to use policies.'],
930
 
                                self.my_config.set_user_option,
931
 
                                'foo', 'bar', store=config.STORE_LOCATION)
 
699
            self.my_config.set_user_option('foo', 'bar', local=True)
932
700
        finally:
933
701
            os.mkdir = real_mkdir
934
702
 
938
706
                          ('__setitem__', '/a/c', {}),
939
707
                          ('__getitem__', '/a/c'),
940
708
                          ('__setitem__', 'foo', 'bar'),
941
 
                          ('__getitem__', '/a/c'),
942
 
                          ('as_bool', 'recurse'),
943
 
                          ('__getitem__', '/a/c'),
944
 
                          ('__delitem__', 'recurse'),
945
 
                          ('__getitem__', '/a/c'),
946
 
                          ('keys',),
947
 
                          ('__getitem__', '/a/c'),
948
 
                          ('__contains__', 'foo:policy'),
949
709
                          ('write',)],
950
710
                         record._calls[1:])
951
711
 
954
714
        self.assertIs(self.my_config.get_user_option('foo'), None)
955
715
        self.my_config.set_user_option('foo', 'bar')
956
716
        self.assertEqual(
957
 
            self.my_config.branch.control_files.files['branch.conf'].strip(),
 
717
            self.my_config.branch.control_files.files['branch.conf'], 
958
718
            'foo = bar')
959
719
        self.assertEqual(self.my_config.get_user_option('foo'), 'bar')
960
 
        self.my_config.set_user_option('foo', 'baz',
961
 
                                       store=config.STORE_LOCATION)
 
720
        self.my_config.set_user_option('foo', 'baz', local=True)
962
721
        self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
963
722
        self.my_config.set_user_option('foo', 'qux')
964
723
        self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
965
 
 
966
 
    def test_get_bzr_remote_path(self):
967
 
        my_config = config.LocationConfig('/a/c')
968
 
        self.assertEqual('bzr', my_config.get_bzr_remote_path())
969
 
        my_config.set_user_option('bzr_remote_path', '/path-bzr')
970
 
        self.assertEqual('/path-bzr', my_config.get_bzr_remote_path())
971
 
        os.environ['BZR_REMOTE_PATH'] = '/environ-bzr'
972
 
        self.assertEqual('/environ-bzr', my_config.get_bzr_remote_path())
973
 
 
 
724
        
974
725
 
975
726
precedence_global = 'option = global'
976
727
precedence_branch = 'option = branch'
983
734
"""
984
735
 
985
736
 
986
 
class TestBranchConfigItems(tests.TestCaseInTempDir):
 
737
class TestBranchConfigItems(TestCaseInTempDir):
987
738
 
988
 
    def get_branch_config(self, global_config=None, location=None,
 
739
    def get_branch_config(self, global_config=None, location=None, 
989
740
                          location_config=None, branch_data_config=None):
990
741
        my_config = config.BranchConfig(FakeBranch(location))
991
742
        if global_config is not None:
1005
756
        my_config = config.BranchConfig(branch)
1006
757
        self.assertEqual("Robert Collins <robertc@example.net>",
1007
758
                         my_config.username())
1008
 
        my_config.branch.control_files.files['email'] = "John"
1009
 
        my_config.set_user_option('email',
 
759
        branch.control_files.email = "John"
 
760
        my_config.set_user_option('email', 
1010
761
                                  "Robert Collins <robertc@example.org>")
1011
762
        self.assertEqual("John", my_config.username())
1012
 
        del my_config.branch.control_files.files['email']
 
763
        branch.control_files.email = None
1013
764
        self.assertEqual("Robert Collins <robertc@example.org>",
1014
765
                         my_config.username())
1015
766
 
1016
767
    def test_not_set_in_branch(self):
1017
768
        my_config = self.get_branch_config(sample_config_text)
 
769
        my_config.branch.control_files.email = None
1018
770
        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
1019
771
                         my_config._get_user_id())
1020
 
        my_config.branch.control_files.files['email'] = "John"
 
772
        my_config.branch.control_files.email = "John"
1021
773
        self.assertEqual("John", my_config._get_user_id())
1022
774
 
1023
775
    def test_BZR_EMAIL_OVERRIDES(self):
1026
778
        my_config = config.BranchConfig(branch)
1027
779
        self.assertEqual("Robert Collins <robertc@example.org>",
1028
780
                         my_config.username())
1029
 
 
 
781
    
1030
782
    def test_signatures_forced(self):
1031
783
        my_config = self.get_branch_config(
1032
784
            global_config=sample_always_signatures)
1069
821
        # post-commit is ignored when bresent in branch data
1070
822
        self.assertEqual('bzrlib.tests.test_config.post_commit',
1071
823
                         my_config.post_commit())
1072
 
        my_config.set_user_option('post_commit', 'rmtree_root',
1073
 
                                  store=config.STORE_LOCATION)
 
824
        my_config.set_user_option('post_commit', 'rmtree_root', local=True)
1074
825
        self.assertEqual('rmtree_root', my_config.post_commit())
1075
826
 
1076
827
    def test_config_precedence(self):
1077
828
        my_config = self.get_branch_config(global_config=precedence_global)
1078
829
        self.assertEqual(my_config.get_user_option('option'), 'global')
1079
 
        my_config = self.get_branch_config(global_config=precedence_global,
 
830
        my_config = self.get_branch_config(global_config=precedence_global, 
1080
831
                                      branch_data_config=precedence_branch)
1081
832
        self.assertEqual(my_config.get_user_option('option'), 'branch')
1082
 
        my_config = self.get_branch_config(global_config=precedence_global,
 
833
        my_config = self.get_branch_config(global_config=precedence_global, 
1083
834
                                      branch_data_config=precedence_branch,
1084
835
                                      location_config=precedence_location)
1085
836
        self.assertEqual(my_config.get_user_option('option'), 'recurse')
1086
 
        my_config = self.get_branch_config(global_config=precedence_global,
 
837
        my_config = self.get_branch_config(global_config=precedence_global, 
1087
838
                                      branch_data_config=precedence_branch,
1088
839
                                      location_config=precedence_location,
1089
840
                                      location='http://example.com/specific')
1090
841
        self.assertEqual(my_config.get_user_option('option'), 'exact')
1091
842
 
1092
 
    def test_get_mail_client(self):
1093
 
        config = self.get_branch_config()
1094
 
        client = config.get_mail_client()
1095
 
        self.assertIsInstance(client, mail_client.DefaultMail)
1096
 
 
1097
 
        # Specific clients
1098
 
        config.set_user_option('mail_client', 'evolution')
1099
 
        client = config.get_mail_client()
1100
 
        self.assertIsInstance(client, mail_client.Evolution)
1101
 
 
1102
 
        config.set_user_option('mail_client', 'kmail')
1103
 
        client = config.get_mail_client()
1104
 
        self.assertIsInstance(client, mail_client.KMail)
1105
 
 
1106
 
        config.set_user_option('mail_client', 'mutt')
1107
 
        client = config.get_mail_client()
1108
 
        self.assertIsInstance(client, mail_client.Mutt)
1109
 
 
1110
 
        config.set_user_option('mail_client', 'thunderbird')
1111
 
        client = config.get_mail_client()
1112
 
        self.assertIsInstance(client, mail_client.Thunderbird)
1113
 
 
1114
 
        # Generic options
1115
 
        config.set_user_option('mail_client', 'default')
1116
 
        client = config.get_mail_client()
1117
 
        self.assertIsInstance(client, mail_client.DefaultMail)
1118
 
 
1119
 
        config.set_user_option('mail_client', 'editor')
1120
 
        client = config.get_mail_client()
1121
 
        self.assertIsInstance(client, mail_client.Editor)
1122
 
 
1123
 
        config.set_user_option('mail_client', 'mapi')
1124
 
        client = config.get_mail_client()
1125
 
        self.assertIsInstance(client, mail_client.MAPIClient)
1126
 
 
1127
 
        config.set_user_option('mail_client', 'xdg-email')
1128
 
        client = config.get_mail_client()
1129
 
        self.assertIsInstance(client, mail_client.XDGEmail)
1130
 
 
1131
 
        config.set_user_option('mail_client', 'firebird')
1132
 
        self.assertRaises(errors.UnknownMailClient, config.get_mail_client)
1133
 
 
1134
 
 
1135
 
class TestMailAddressExtraction(tests.TestCase):
 
843
 
 
844
class TestMailAddressExtraction(TestCase):
1136
845
 
1137
846
    def test_extract_email_address(self):
1138
847
        self.assertEqual('jane@test.com',
1139
848
                         config.extract_email_address('Jane <jane@test.com>'))
1140
849
        self.assertRaises(errors.NoEmailInUsername,
1141
850
                          config.extract_email_address, 'Jane Tester')
1142
 
 
1143
 
    def test_parse_username(self):
1144
 
        self.assertEqual(('', 'jdoe@example.com'),
1145
 
                         config.parse_username('jdoe@example.com'))
1146
 
        self.assertEqual(('', 'jdoe@example.com'),
1147
 
                         config.parse_username('<jdoe@example.com>'))
1148
 
        self.assertEqual(('John Doe', 'jdoe@example.com'),
1149
 
                         config.parse_username('John Doe <jdoe@example.com>'))
1150
 
        self.assertEqual(('John Doe', ''),
1151
 
                         config.parse_username('John Doe'))
1152
 
        self.assertEqual(('John Doe', 'jdoe@example.com'),
1153
 
                         config.parse_username('John Doe jdoe@example.com'))
1154
 
 
1155
 
class TestTreeConfig(tests.TestCaseWithTransport):
1156
 
 
1157
 
    def test_get_value(self):
1158
 
        """Test that retreiving a value from a section is possible"""
1159
 
        branch = self.make_branch('.')
1160
 
        tree_config = config.TreeConfig(branch)
1161
 
        tree_config.set_option('value', 'key', 'SECTION')
1162
 
        tree_config.set_option('value2', 'key2')
1163
 
        tree_config.set_option('value3-top', 'key3')
1164
 
        tree_config.set_option('value3-section', 'key3', 'SECTION')
1165
 
        value = tree_config.get_option('key', 'SECTION')
1166
 
        self.assertEqual(value, 'value')
1167
 
        value = tree_config.get_option('key2')
1168
 
        self.assertEqual(value, 'value2')
1169
 
        self.assertEqual(tree_config.get_option('non-existant'), None)
1170
 
        value = tree_config.get_option('non-existant', 'SECTION')
1171
 
        self.assertEqual(value, None)
1172
 
        value = tree_config.get_option('non-existant', default='default')
1173
 
        self.assertEqual(value, 'default')
1174
 
        self.assertEqual(tree_config.get_option('key2', 'NOSECTION'), None)
1175
 
        value = tree_config.get_option('key2', 'NOSECTION', default='default')
1176
 
        self.assertEqual(value, 'default')
1177
 
        value = tree_config.get_option('key3')
1178
 
        self.assertEqual(value, 'value3-top')
1179
 
        value = tree_config.get_option('key3', 'SECTION')
1180
 
        self.assertEqual(value, 'value3-section')
1181
 
 
1182
 
 
1183
 
class TestTransportConfig(tests.TestCaseWithTransport):
1184
 
 
1185
 
    def test_get_value(self):
1186
 
        """Test that retreiving a value from a section is possible"""
1187
 
        bzrdir_config = config.TransportConfig(transport.get_transport('.'),
1188
 
                                               'control.conf')
1189
 
        bzrdir_config.set_option('value', 'key', 'SECTION')
1190
 
        bzrdir_config.set_option('value2', 'key2')
1191
 
        bzrdir_config.set_option('value3-top', 'key3')
1192
 
        bzrdir_config.set_option('value3-section', 'key3', 'SECTION')
1193
 
        value = bzrdir_config.get_option('key', 'SECTION')
1194
 
        self.assertEqual(value, 'value')
1195
 
        value = bzrdir_config.get_option('key2')
1196
 
        self.assertEqual(value, 'value2')
1197
 
        self.assertEqual(bzrdir_config.get_option('non-existant'), None)
1198
 
        value = bzrdir_config.get_option('non-existant', 'SECTION')
1199
 
        self.assertEqual(value, None)
1200
 
        value = bzrdir_config.get_option('non-existant', default='default')
1201
 
        self.assertEqual(value, 'default')
1202
 
        self.assertEqual(bzrdir_config.get_option('key2', 'NOSECTION'), None)
1203
 
        value = bzrdir_config.get_option('key2', 'NOSECTION',
1204
 
                                         default='default')
1205
 
        self.assertEqual(value, 'default')
1206
 
        value = bzrdir_config.get_option('key3')
1207
 
        self.assertEqual(value, 'value3-top')
1208
 
        value = bzrdir_config.get_option('key3', 'SECTION')
1209
 
        self.assertEqual(value, 'value3-section')
1210
 
 
1211
 
    def test_set_unset_default_stack_on(self):
1212
 
        my_dir = self.make_bzrdir('.')
1213
 
        bzrdir_config = config.BzrDirConfig(my_dir.transport)
1214
 
        self.assertIs(None, bzrdir_config.get_default_stack_on())
1215
 
        bzrdir_config.set_default_stack_on('Foo')
1216
 
        self.assertEqual('Foo', bzrdir_config._config.get_option(
1217
 
                         'default_stack_on'))
1218
 
        self.assertEqual('Foo', bzrdir_config.get_default_stack_on())
1219
 
        bzrdir_config.set_default_stack_on(None)
1220
 
        self.assertIs(None, bzrdir_config.get_default_stack_on())
1221
 
 
1222
 
 
1223
 
class TestAuthenticationConfigFile(tests.TestCase):
1224
 
    """Test the authentication.conf file matching"""
1225
 
 
1226
 
    def _got_user_passwd(self, expected_user, expected_password,
1227
 
                         config, *args, **kwargs):
1228
 
        credentials = config.get_credentials(*args, **kwargs)
1229
 
        if credentials is None:
1230
 
            user = None
1231
 
            password = None
1232
 
        else:
1233
 
            user = credentials['user']
1234
 
            password = credentials['password']
1235
 
        self.assertEquals(expected_user, user)
1236
 
        self.assertEquals(expected_password, password)
1237
 
 
1238
 
    def test_empty_config(self):
1239
 
        conf = config.AuthenticationConfig(_file=StringIO())
1240
 
        self.assertEquals({}, conf._get_config())
1241
 
        self._got_user_passwd(None, None, conf, 'http', 'foo.net')
1242
 
 
1243
 
    def test_missing_auth_section_header(self):
1244
 
        conf = config.AuthenticationConfig(_file=StringIO('foo = bar'))
1245
 
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1246
 
 
1247
 
    def test_auth_section_header_not_closed(self):
1248
 
        conf = config.AuthenticationConfig(_file=StringIO('[DEF'))
1249
 
        self.assertRaises(errors.ParseConfigError, conf._get_config)
1250
 
 
1251
 
    def test_auth_value_not_boolean(self):
1252
 
        conf = config.AuthenticationConfig(_file=StringIO(
1253
 
                """[broken]
1254
 
scheme=ftp
1255
 
user=joe
1256
 
verify_certificates=askme # Error: Not a boolean
1257
 
"""))
1258
 
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1259
 
 
1260
 
    def test_auth_value_not_int(self):
1261
 
        conf = config.AuthenticationConfig(_file=StringIO(
1262
 
                """[broken]
1263
 
scheme=ftp
1264
 
user=joe
1265
 
port=port # Error: Not an int
1266
 
"""))
1267
 
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1268
 
 
1269
 
    def test_unknown_password_encoding(self):
1270
 
        conf = config.AuthenticationConfig(_file=StringIO(
1271
 
                """[broken]
1272
 
scheme=ftp
1273
 
user=joe
1274
 
password_encoding=unknown
1275
 
"""))
1276
 
        self.assertRaises(ValueError, conf.get_password,
1277
 
                          'ftp', 'foo.net', 'joe')
1278
 
 
1279
 
    def test_credentials_for_scheme_host(self):
1280
 
        conf = config.AuthenticationConfig(_file=StringIO(
1281
 
                """# Identity on foo.net
1282
 
[ftp definition]
1283
 
scheme=ftp
1284
 
host=foo.net
1285
 
user=joe
1286
 
password=secret-pass
1287
 
"""))
1288
 
        # Basic matching
1289
 
        self._got_user_passwd('joe', 'secret-pass', conf, 'ftp', 'foo.net')
1290
 
        # different scheme
1291
 
        self._got_user_passwd(None, None, conf, 'http', 'foo.net')
1292
 
        # different host
1293
 
        self._got_user_passwd(None, None, conf, 'ftp', 'bar.net')
1294
 
 
1295
 
    def test_credentials_for_host_port(self):
1296
 
        conf = config.AuthenticationConfig(_file=StringIO(
1297
 
                """# Identity on foo.net
1298
 
[ftp definition]
1299
 
scheme=ftp
1300
 
port=10021
1301
 
host=foo.net
1302
 
user=joe
1303
 
password=secret-pass
1304
 
"""))
1305
 
        # No port
1306
 
        self._got_user_passwd('joe', 'secret-pass',
1307
 
                              conf, 'ftp', 'foo.net', port=10021)
1308
 
        # different port
1309
 
        self._got_user_passwd(None, None, conf, 'ftp', 'foo.net')
1310
 
 
1311
 
    def test_for_matching_host(self):
1312
 
        conf = config.AuthenticationConfig(_file=StringIO(
1313
 
                """# Identity on foo.net
1314
 
[sourceforge]
1315
 
scheme=bzr
1316
 
host=bzr.sf.net
1317
 
user=joe
1318
 
password=joepass
1319
 
[sourceforge domain]
1320
 
scheme=bzr
1321
 
host=.bzr.sf.net
1322
 
user=georges
1323
 
password=bendover
1324
 
"""))
1325
 
        # matching domain
1326
 
        self._got_user_passwd('georges', 'bendover',
1327
 
                              conf, 'bzr', 'foo.bzr.sf.net')
1328
 
        # phishing attempt
1329
 
        self._got_user_passwd(None, None,
1330
 
                              conf, 'bzr', 'bbzr.sf.net')
1331
 
 
1332
 
    def test_for_matching_host_None(self):
1333
 
        conf = config.AuthenticationConfig(_file=StringIO(
1334
 
                """# Identity on foo.net
1335
 
[catchup bzr]
1336
 
scheme=bzr
1337
 
user=joe
1338
 
password=joepass
1339
 
[DEFAULT]
1340
 
user=georges
1341
 
password=bendover
1342
 
"""))
1343
 
        # match no host
1344
 
        self._got_user_passwd('joe', 'joepass',
1345
 
                              conf, 'bzr', 'quux.net')
1346
 
        # no host but different scheme
1347
 
        self._got_user_passwd('georges', 'bendover',
1348
 
                              conf, 'ftp', 'quux.net')
1349
 
 
1350
 
    def test_credentials_for_path(self):
1351
 
        conf = config.AuthenticationConfig(_file=StringIO(
1352
 
                """
1353
 
[http dir1]
1354
 
scheme=http
1355
 
host=bar.org
1356
 
path=/dir1
1357
 
user=jim
1358
 
password=jimpass
1359
 
[http dir2]
1360
 
scheme=http
1361
 
host=bar.org
1362
 
path=/dir2
1363
 
user=georges
1364
 
password=bendover
1365
 
"""))
1366
 
        # no path no dice
1367
 
        self._got_user_passwd(None, None,
1368
 
                              conf, 'http', host='bar.org', path='/dir3')
1369
 
        # matching path
1370
 
        self._got_user_passwd('georges', 'bendover',
1371
 
                              conf, 'http', host='bar.org', path='/dir2')
1372
 
        # matching subdir
1373
 
        self._got_user_passwd('jim', 'jimpass',
1374
 
                              conf, 'http', host='bar.org',path='/dir1/subdir')
1375
 
 
1376
 
    def test_credentials_for_user(self):
1377
 
        conf = config.AuthenticationConfig(_file=StringIO(
1378
 
                """
1379
 
[with user]
1380
 
scheme=http
1381
 
host=bar.org
1382
 
user=jim
1383
 
password=jimpass
1384
 
"""))
1385
 
        # Get user
1386
 
        self._got_user_passwd('jim', 'jimpass',
1387
 
                              conf, 'http', 'bar.org')
1388
 
        # Get same user
1389
 
        self._got_user_passwd('jim', 'jimpass',
1390
 
                              conf, 'http', 'bar.org', user='jim')
1391
 
        # Don't get a different user if one is specified
1392
 
        self._got_user_passwd(None, None,
1393
 
                              conf, 'http', 'bar.org', user='georges')
1394
 
 
1395
 
    def test_credentials_for_user_without_password(self):
1396
 
        conf = config.AuthenticationConfig(_file=StringIO(
1397
 
                """
1398
 
[without password]
1399
 
scheme=http
1400
 
host=bar.org
1401
 
user=jim
1402
 
"""))
1403
 
        # Get user but no password
1404
 
        self._got_user_passwd('jim', None,
1405
 
                              conf, 'http', 'bar.org')
1406
 
 
1407
 
    def test_verify_certificates(self):
1408
 
        conf = config.AuthenticationConfig(_file=StringIO(
1409
 
                """
1410
 
[self-signed]
1411
 
scheme=https
1412
 
host=bar.org
1413
 
user=jim
1414
 
password=jimpass
1415
 
verify_certificates=False
1416
 
[normal]
1417
 
scheme=https
1418
 
host=foo.net
1419
 
user=georges
1420
 
password=bendover
1421
 
"""))
1422
 
        credentials = conf.get_credentials('https', 'bar.org')
1423
 
        self.assertEquals(False, credentials.get('verify_certificates'))
1424
 
        credentials = conf.get_credentials('https', 'foo.net')
1425
 
        self.assertEquals(True, credentials.get('verify_certificates'))
1426
 
 
1427
 
 
1428
 
class TestAuthenticationStorage(tests.TestCaseInTempDir):
1429
 
 
1430
 
    def test_set_credentials(self):
1431
 
        conf = config.AuthenticationConfig()
1432
 
        conf.set_credentials('name', 'host', 'user', 'scheme', 'password',
1433
 
        99, path='/foo', verify_certificates=False, realm='realm')
1434
 
        credentials = conf.get_credentials(host='host', scheme='scheme',
1435
 
                                           port=99, path='/foo',
1436
 
                                           realm='realm')
1437
 
        CREDENTIALS = {'name': 'name', 'user': 'user', 'password': 'password',
1438
 
                       'verify_certificates': False, 'scheme': 'scheme', 
1439
 
                       'host': 'host', 'port': 99, 'path': '/foo', 
1440
 
                       'realm': 'realm'}
1441
 
        self.assertEqual(CREDENTIALS, credentials)
1442
 
        credentials_from_disk = config.AuthenticationConfig().get_credentials(
1443
 
            host='host', scheme='scheme', port=99, path='/foo', realm='realm')
1444
 
        self.assertEqual(CREDENTIALS, credentials_from_disk)
1445
 
 
1446
 
    def test_reset_credentials_different_name(self):
1447
 
        conf = config.AuthenticationConfig()
1448
 
        conf.set_credentials('name', 'host', 'user', 'scheme', 'password'),
1449
 
        conf.set_credentials('name2', 'host', 'user2', 'scheme', 'password'),
1450
 
        self.assertIs(None, conf._get_config().get('name'))
1451
 
        credentials = conf.get_credentials(host='host', scheme='scheme')
1452
 
        CREDENTIALS = {'name': 'name2', 'user': 'user2', 'password':
1453
 
                       'password', 'verify_certificates': True, 
1454
 
                       'scheme': 'scheme', 'host': 'host', 'port': None, 
1455
 
                       'path': None, 'realm': None}
1456
 
        self.assertEqual(CREDENTIALS, credentials)
1457
 
 
1458
 
 
1459
 
class TestAuthenticationConfig(tests.TestCase):
1460
 
    """Test AuthenticationConfig behaviour"""
1461
 
 
1462
 
    def _check_default_prompt(self, expected_prompt_format, scheme,
1463
 
                              host=None, port=None, realm=None, path=None):
1464
 
        if host is None:
1465
 
            host = 'bar.org'
1466
 
        user, password = 'jim', 'precious'
1467
 
        expected_prompt = expected_prompt_format % {
1468
 
            'scheme': scheme, 'host': host, 'port': port,
1469
 
            'user': user, 'realm': realm}
1470
 
 
1471
 
        stdout = tests.StringIOWrapper()
1472
 
        ui.ui_factory = tests.TestUIFactory(stdin=password + '\n',
1473
 
                                            stdout=stdout)
1474
 
        # We use an empty conf so that the user is always prompted
1475
 
        conf = config.AuthenticationConfig()
1476
 
        self.assertEquals(password,
1477
 
                          conf.get_password(scheme, host, user, port=port,
1478
 
                                            realm=realm, path=path))
1479
 
        self.assertEquals(stdout.getvalue(), expected_prompt)
1480
 
 
1481
 
    def test_default_prompts(self):
1482
 
        # HTTP prompts can't be tested here, see test_http.py
1483
 
        self._check_default_prompt('FTP %(user)s@%(host)s password: ', 'ftp')
1484
 
        self._check_default_prompt('FTP %(user)s@%(host)s:%(port)d password: ',
1485
 
                                   'ftp', port=10020)
1486
 
 
1487
 
        self._check_default_prompt('SSH %(user)s@%(host)s:%(port)d password: ',
1488
 
                                   'ssh', port=12345)
1489
 
        # SMTP port handling is a bit special (it's handled if embedded in the
1490
 
        # host too)
1491
 
        # FIXME: should we: forbid that, extend it to other schemes, leave
1492
 
        # things as they are that's fine thank you ?
1493
 
        self._check_default_prompt('SMTP %(user)s@%(host)s password: ',
1494
 
                                   'smtp')
1495
 
        self._check_default_prompt('SMTP %(user)s@%(host)s password: ',
1496
 
                                   'smtp', host='bar.org:10025')
1497
 
        self._check_default_prompt(
1498
 
            'SMTP %(user)s@%(host)s:%(port)d password: ',
1499
 
            'smtp', port=10025)
1500
 
 
1501
 
    def test_ssh_password_emits_warning(self):
1502
 
        conf = config.AuthenticationConfig(_file=StringIO(
1503
 
                """
1504
 
[ssh with password]
1505
 
scheme=ssh
1506
 
host=bar.org
1507
 
user=jim
1508
 
password=jimpass
1509
 
"""))
1510
 
        entered_password = 'typed-by-hand'
1511
 
        stdout = tests.StringIOWrapper()
1512
 
        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1513
 
                                            stdout=stdout)
1514
 
 
1515
 
        # Since the password defined in the authentication config is ignored,
1516
 
        # the user is prompted
1517
 
        self.assertEquals(entered_password,
1518
 
                          conf.get_password('ssh', 'bar.org', user='jim'))
1519
 
        self.assertContainsRe(
1520
 
            self._get_log(keep_log_file=True),
1521
 
            'password ignored in section \[ssh with password\]')
1522
 
 
1523
 
    def test_ssh_without_password_doesnt_emit_warning(self):
1524
 
        conf = config.AuthenticationConfig(_file=StringIO(
1525
 
                """
1526
 
[ssh with password]
1527
 
scheme=ssh
1528
 
host=bar.org
1529
 
user=jim
1530
 
"""))
1531
 
        entered_password = 'typed-by-hand'
1532
 
        stdout = tests.StringIOWrapper()
1533
 
        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1534
 
                                            stdout=stdout)
1535
 
 
1536
 
        # Since the password defined in the authentication config is ignored,
1537
 
        # the user is prompted
1538
 
        self.assertEquals(entered_password,
1539
 
                          conf.get_password('ssh', 'bar.org', user='jim'))
1540
 
        # No warning shoud be emitted since there is no password. We are only
1541
 
        # providing "user".
1542
 
        self.assertNotContainsRe(
1543
 
            self._get_log(keep_log_file=True),
1544
 
            'password ignored in section \[ssh with password\]')
1545
 
 
1546
 
 
1547
 
class TestCredentialStoreRegistry(tests.TestCase):
1548
 
 
1549
 
    def _get_cs_registry(self):
1550
 
        return config.credential_store_registry
1551
 
 
1552
 
    def test_default_credential_store(self):
1553
 
        r = self._get_cs_registry()
1554
 
        default = r.get_credential_store(None)
1555
 
        self.assertIsInstance(default, config.PlainTextCredentialStore)
1556
 
 
1557
 
    def test_unknown_credential_store(self):
1558
 
        r = self._get_cs_registry()
1559
 
        # It's hard to imagine someone creating a credential store named
1560
 
        # 'unknown' so we use that as an never registered key.
1561
 
        self.assertRaises(KeyError, r.get_credential_store, 'unknown')
1562
 
 
1563
 
 
1564
 
class TestPlainTextCredentialStore(tests.TestCase):
1565
 
 
1566
 
    def test_decode_password(self):
1567
 
        r = config.credential_store_registry
1568
 
        plain_text = r.get_credential_store()
1569
 
        decoded = plain_text.decode_password(dict(password='secret'))
1570
 
        self.assertEquals('secret', decoded)
1571
 
 
1572
 
 
1573
 
# FIXME: Once we have a way to declare authentication to all test servers, we
1574
 
# can implement generic tests.
1575
 
# test_user_password_in_url
1576
 
# test_user_in_url_password_from_config
1577
 
# test_user_in_url_password_prompted
1578
 
# test_user_in_config
1579
 
# test_user_getpass.getuser
1580
 
# test_user_prompted ?
1581
 
class TestAuthenticationRing(tests.TestCaseWithTransport):
1582
 
    pass