~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_config.py

  • Committer: Vincent Ladeuil
  • Date: 2010-02-03 07:18:36 UTC
  • mto: (5008.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5009.
  • Revision ID: v.ladeuil+lp@free.fr-20100203071836-u9b86q68fr9ri5s6
Fix NEWS.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006 by Canonical Ltd
2
 
#   Authors: Robert Collins <robert.collins@canonical.com>
 
1
# Copyright (C) 2005, 2006, 2008, 2009 Canonical Ltd
3
2
#
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
13
12
#
14
13
# You should have received a copy of the GNU General Public License
15
14
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
16
 
18
17
"""Tests for finding and reading the bzr config file[s]."""
19
18
# import system imports here
20
 
from bzrlib.util.configobj.configobj import ConfigObj, ConfigObjError
21
19
from cStringIO import StringIO
22
20
import os
23
21
import sys
24
22
 
25
23
#import bzrlib specific imports here
26
24
from bzrlib import (
 
25
    branch,
 
26
    bzrdir,
27
27
    config,
 
28
    diff,
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/useglobal]\n"
68
 
                        "# different project, forces global lookup\n"
69
 
                        "recurse=false\n"
70
 
                        "[/b/]\n"
71
 
                        "check_signatures=require\n"
72
 
                        "# test trailing / matching with no children\n"
73
 
                        "[/a/]\n"
74
 
                        "check_signatures=check-available\n"
75
 
                        "gpg_signing_command=false\n"
76
 
                        "user_local_option=local\n"
77
 
                        "# test trailing / matching\n"
78
 
                        "[/a/*]\n"
79
 
                        "#subdirs will match but not the parent\n"
80
 
                        "recurse=False\n"
81
 
                        "[/a/c]\n"
82
 
                        "check_signatures=ignore\n"
83
 
                        "post_commit=bzrlib.tests.test_config.post_commit\n"
84
 
                        "#testing explicit beats globs\n")
85
 
 
 
42
sample_config_text = u"""
 
43
[DEFAULT]
 
44
email=Erik B\u00e5gfors <erik@bagfors.nu>
 
45
editor=vim
 
46
change_editor=vimdiff -of @new_path @old_path
 
47
gpg_signing_command=gnome-gpg
 
48
log_format=short
 
49
user_global_option=something
 
50
[ALIASES]
 
51
h=help
 
52
ll=""" + sample_long_alias + "\n"
 
53
 
 
54
 
 
55
sample_always_signatures = """
 
56
[DEFAULT]
 
57
check_signatures=ignore
 
58
create_signatures=always
 
59
"""
 
60
 
 
61
sample_ignore_signatures = """
 
62
[DEFAULT]
 
63
check_signatures=require
 
64
create_signatures=never
 
65
"""
 
66
 
 
67
sample_maybe_signatures = """
 
68
[DEFAULT]
 
69
check_signatures=ignore
 
70
create_signatures=when-required
 
71
"""
 
72
 
 
73
sample_branches_text = """
 
74
[http://www.example.com]
 
75
# Top level policy
 
76
email=Robert Collins <robertc@example.org>
 
77
normal_option = normal
 
78
appendpath_option = append
 
79
appendpath_option:policy = appendpath
 
80
norecurse_option = norecurse
 
81
norecurse_option:policy = norecurse
 
82
[http://www.example.com/ignoreparent]
 
83
# different project: ignore parent dir config
 
84
ignore_parents=true
 
85
[http://www.example.com/norecurse]
 
86
# configuration items that only apply to this dir
 
87
recurse=false
 
88
normal_option = norecurse
 
89
[http://www.example.com/dir]
 
90
appendpath_option = normal
 
91
[/b/]
 
92
check_signatures=require
 
93
# test trailing / matching with no children
 
94
[/a/]
 
95
check_signatures=check-available
 
96
gpg_signing_command=false
 
97
user_local_option=local
 
98
# test trailing / matching
 
99
[/a/*]
 
100
#subdirs will match but not the parent
 
101
[/a/c]
 
102
check_signatures=ignore
 
103
post_commit=bzrlib.tests.test_config.post_commit
 
104
#testing explicit beats globs
 
105
"""
86
106
 
87
107
 
88
108
class InstrumentedConfigObj(object):
102
122
    def __setitem__(self, key, value):
103
123
        self._calls.append(('__setitem__', key, value))
104
124
 
 
125
    def __delitem__(self, key):
 
126
        self._calls.append(('__delitem__', key))
 
127
 
 
128
    def keys(self):
 
129
        self._calls.append(('keys',))
 
130
        return []
 
131
 
105
132
    def write(self, arg):
106
133
        self._calls.append(('write',))
107
134
 
 
135
    def as_bool(self, value):
 
136
        self._calls.append(('as_bool', value))
 
137
        return False
 
138
 
 
139
    def get_value(self, section, name):
 
140
        self._calls.append(('get_value', section, name))
 
141
        return None
 
142
 
108
143
 
109
144
class FakeBranch(object):
110
145
 
113
148
            self.base = "http://example.com/branches/demo"
114
149
        else:
115
150
            self.base = base
116
 
        self.control_files = FakeControlFiles(user_id=user_id)
 
151
        self._transport = self.control_files = \
 
152
            FakeControlFilesAndTransport(user_id=user_id)
 
153
 
 
154
    def _get_config(self):
 
155
        return config.TransportConfig(self._transport, 'branch.conf')
117
156
 
118
157
    def lock_write(self):
119
158
        pass
122
161
        pass
123
162
 
124
163
 
125
 
class FakeControlFiles(object):
 
164
class FakeControlFilesAndTransport(object):
126
165
 
127
166
    def __init__(self, user_id=None):
128
 
        self.email = user_id
129
167
        self.files = {}
 
168
        if user_id:
 
169
            self.files['email'] = user_id
 
170
        self._transport = self
130
171
 
131
172
    def get_utf8(self, filename):
132
 
        if filename != 'email':
133
 
            raise NotImplementedError
134
 
        if self.email is not None:
135
 
            return StringIO(self.email)
136
 
        raise errors.NoSuchFile(filename)
 
173
        # from LockableFiles
 
174
        raise AssertionError("get_utf8 should no longer be used")
137
175
 
138
176
    def get(self, filename):
 
177
        # from Transport
139
178
        try:
140
179
            return StringIO(self.files[filename])
141
180
        except KeyError:
142
181
            raise errors.NoSuchFile(filename)
143
182
 
 
183
    def get_bytes(self, filename):
 
184
        # from Transport
 
185
        try:
 
186
            return self.files[filename]
 
187
        except KeyError:
 
188
            raise errors.NoSuchFile(filename)
 
189
 
144
190
    def put(self, filename, fileobj):
145
191
        self.files[filename] = fileobj.read()
146
192
 
 
193
    def put_file(self, filename, fileobj):
 
194
        return self.put(filename, fileobj)
 
195
 
147
196
 
148
197
class InstrumentedConfig(config.Config):
149
198
    """An instrumented config that supplies stubs for template methods."""
150
 
    
 
199
 
151
200
    def __init__(self):
152
201
        super(InstrumentedConfig, self).__init__()
153
202
        self._calls = []
161
210
        self._calls.append('_get_signature_checking')
162
211
        return self._signatures
163
212
 
 
213
    def _get_change_editor(self):
 
214
        self._calls.append('_get_change_editor')
 
215
        return 'vimdiff -fo @new_path @old_path'
 
216
 
164
217
 
165
218
bool_config = """[DEFAULT]
166
219
active = true
169
222
active = True
170
223
nonactive = False
171
224
"""
172
 
class TestConfigObj(TestCase):
 
225
 
 
226
 
 
227
class TestConfigObj(tests.TestCase):
 
228
 
173
229
    def test_get_bool(self):
174
 
        from bzrlib.config import ConfigObj
175
 
        co = ConfigObj(StringIO(bool_config))
 
230
        co = config.ConfigObj(StringIO(bool_config))
176
231
        self.assertIs(co.get_bool('DEFAULT', 'active'), True)
177
232
        self.assertIs(co.get_bool('DEFAULT', 'inactive'), False)
178
233
        self.assertIs(co.get_bool('UPPERCASE', 'active'), True)
179
234
        self.assertIs(co.get_bool('UPPERCASE', 'nonactive'), False)
180
235
 
181
 
 
182
 
class TestConfig(TestCase):
 
236
    def test_hash_sign_in_value(self):
 
237
        """
 
238
        Before 4.5.0, ConfigObj did not quote # signs in values, so they'd be
 
239
        treated as comments when read in again. (#86838)
 
240
        """
 
241
        co = config.ConfigObj()
 
242
        co['test'] = 'foo#bar'
 
243
        lines = co.write()
 
244
        self.assertEqual(lines, ['test = "foo#bar"'])
 
245
        co2 = config.ConfigObj(lines)
 
246
        self.assertEqual(co2['test'], 'foo#bar')
 
247
 
 
248
 
 
249
erroneous_config = """[section] # line 1
 
250
good=good # line 2
 
251
[section] # line 3
 
252
whocares=notme # line 4
 
253
"""
 
254
 
 
255
 
 
256
class TestConfigObjErrors(tests.TestCase):
 
257
 
 
258
    def test_duplicate_section_name_error_line(self):
 
259
        try:
 
260
            co = configobj.ConfigObj(StringIO(erroneous_config),
 
261
                                     raise_errors=True)
 
262
        except config.configobj.DuplicateError, e:
 
263
            self.assertEqual(3, e.line_number)
 
264
        else:
 
265
            self.fail('Error in config file not detected')
 
266
 
 
267
 
 
268
class TestConfig(tests.TestCase):
183
269
 
184
270
    def test_constructs(self):
185
271
        config.Config()
186
 
 
 
272
 
187
273
    def test_no_default_editor(self):
188
274
        self.assertRaises(NotImplementedError, config.Config().get_editor)
189
275
 
234
320
        my_config = config.Config()
235
321
        self.assertEqual('long', my_config.log_format())
236
322
 
237
 
 
238
 
class TestConfigPath(TestCase):
 
323
    def test_get_change_editor(self):
 
324
        my_config = InstrumentedConfig()
 
325
        change_editor = my_config.get_change_editor('old_tree', 'new_tree')
 
326
        self.assertEqual(['_get_change_editor'], my_config._calls)
 
327
        self.assertIs(diff.DiffFromTool, change_editor.__class__)
 
328
        self.assertEqual(['vimdiff', '-fo', '@new_path', '@old_path'],
 
329
                         change_editor.command_template)
 
330
 
 
331
 
 
332
class TestConfigPath(tests.TestCase):
239
333
 
240
334
    def setUp(self):
241
335
        super(TestConfigPath, self).setUp()
242
 
        self.old_home = os.environ.get('HOME', None)
243
 
        self.old_appdata = os.environ.get('APPDATA', None)
244
336
        os.environ['HOME'] = '/home/bogus'
245
 
        os.environ['APPDATA'] = \
246
 
            r'C:\Documents and Settings\bogus\Application Data'
 
337
        os.environ['XDG_CACHE_DIR'] = ''
 
338
        if sys.platform == 'win32':
 
339
            os.environ['BZR_HOME'] = \
 
340
                r'C:\Documents and Settings\bogus\Application Data'
 
341
            self.bzr_home = \
 
342
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0'
 
343
        else:
 
344
            self.bzr_home = '/home/bogus/.bazaar'
247
345
 
248
 
    def tearDown(self):
249
 
        if self.old_home is None:
250
 
            del os.environ['HOME']
251
 
        else:
252
 
            os.environ['HOME'] = self.old_home
253
 
        if self.old_appdata is None:
254
 
            del os.environ['APPDATA']
255
 
        else:
256
 
            os.environ['APPDATA'] = self.old_appdata
257
 
        super(TestConfigPath, self).tearDown()
258
 
    
259
346
    def test_config_dir(self):
260
 
        if sys.platform == 'win32':
261
 
            self.assertEqual(config.config_dir(), 
262
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0')
263
 
        else:
264
 
            self.assertEqual(config.config_dir(), '/home/bogus/.bazaar')
 
347
        self.assertEqual(config.config_dir(), self.bzr_home)
265
348
 
266
349
    def test_config_filename(self):
267
 
        if sys.platform == 'win32':
268
 
            self.assertEqual(config.config_filename(), 
269
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/bazaar.conf')
270
 
        else:
271
 
            self.assertEqual(config.config_filename(),
272
 
                             '/home/bogus/.bazaar/bazaar.conf')
 
350
        self.assertEqual(config.config_filename(),
 
351
                         self.bzr_home + '/bazaar.conf')
273
352
 
274
353
    def test_branches_config_filename(self):
275
 
        if sys.platform == 'win32':
276
 
            self.assertEqual(config.branches_config_filename(), 
277
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/branches.conf')
278
 
        else:
279
 
            self.assertEqual(config.branches_config_filename(),
280
 
                             '/home/bogus/.bazaar/branches.conf')
 
354
        self.assertEqual(config.branches_config_filename(),
 
355
                         self.bzr_home + '/branches.conf')
281
356
 
282
357
    def test_locations_config_filename(self):
283
 
        if sys.platform == 'win32':
284
 
            self.assertEqual(config.locations_config_filename(), 
285
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/locations.conf')
286
 
        else:
287
 
            self.assertEqual(config.locations_config_filename(),
288
 
                             '/home/bogus/.bazaar/locations.conf')
289
 
 
290
 
class TestIniConfig(TestCase):
 
358
        self.assertEqual(config.locations_config_filename(),
 
359
                         self.bzr_home + '/locations.conf')
 
360
 
 
361
    def test_authentication_config_filename(self):
 
362
        self.assertEqual(config.authentication_config_filename(),
 
363
                         self.bzr_home + '/authentication.conf')
 
364
 
 
365
    def test_xdg_cache_dir(self):
 
366
        self.assertEqual(config.xdg_cache_dir(),
 
367
            '/home/bogus/.cache')
 
368
 
 
369
 
 
370
class TestIniConfig(tests.TestCase):
 
371
 
 
372
    def make_config_parser(self, s):
 
373
        conf = config.IniBasedConfig(None)
 
374
        parser = conf._get_parser(file=StringIO(s.encode('utf-8')))
 
375
        return conf, parser
 
376
 
 
377
 
 
378
class TestIniConfigBuilding(TestIniConfig):
291
379
 
292
380
    def test_contructs(self):
293
381
        my_config = config.IniBasedConfig("nothing")
297
385
        my_config = config.IniBasedConfig(None)
298
386
        self.failUnless(
299
387
            isinstance(my_config._get_parser(file=config_file),
300
 
                        ConfigObj))
 
388
                        configobj.ConfigObj))
301
389
 
302
390
    def test_cached(self):
303
391
        config_file = StringIO(sample_config_text.encode('utf-8'))
306
394
        self.failUnless(my_config._get_parser() is parser)
307
395
 
308
396
 
309
 
class TestGetConfig(TestCase):
 
397
class TestGetUserOptionAs(TestIniConfig):
 
398
 
 
399
    def test_get_user_option_as_bool(self):
 
400
        conf, parser = self.make_config_parser("""
 
401
a_true_bool = true
 
402
a_false_bool = 0
 
403
an_invalid_bool = maybe
 
404
a_list = hmm, who knows ? # This is interpreted as a list !
 
405
""")
 
406
        get_bool = conf.get_user_option_as_bool
 
407
        self.assertEqual(True, get_bool('a_true_bool'))
 
408
        self.assertEqual(False, get_bool('a_false_bool'))
 
409
        self.assertIs(None, get_bool('an_invalid_bool'))
 
410
        self.assertIs(None, get_bool('not_defined_in_this_config'))
 
411
 
 
412
 
 
413
    def test_get_user_option_as_list(self):
 
414
        conf, parser = self.make_config_parser("""
 
415
a_list = a,b,c
 
416
length_1 = 1,
 
417
one_item = x
 
418
""")
 
419
        get_list = conf.get_user_option_as_list
 
420
        self.assertEqual(['a', 'b', 'c'], get_list('a_list'))
 
421
        self.assertEqual(['1'], get_list('length_1'))
 
422
        self.assertEqual('x', conf.get_user_option('one_item'))
 
423
        # automatically cast to list
 
424
        self.assertEqual(['x'], get_list('one_item'))
 
425
 
 
426
 
 
427
class TestSupressWarning(TestIniConfig):
 
428
 
 
429
    def make_warnings_config(self, s):
 
430
        conf, parser = self.make_config_parser(s)
 
431
        return conf.suppress_warning
 
432
 
 
433
    def test_suppress_warning_unknown(self):
 
434
        suppress_warning = self.make_warnings_config('')
 
435
        self.assertEqual(False, suppress_warning('unknown_warning'))
 
436
 
 
437
    def test_suppress_warning_known(self):
 
438
        suppress_warning = self.make_warnings_config('suppress_warnings=a,b')
 
439
        self.assertEqual(False, suppress_warning('c'))
 
440
        self.assertEqual(True, suppress_warning('a'))
 
441
        self.assertEqual(True, suppress_warning('b'))
 
442
 
 
443
 
 
444
class TestGetConfig(tests.TestCase):
310
445
 
311
446
    def test_constructs(self):
312
447
        my_config = config.GlobalConfig()
313
448
 
314
449
    def test_calls_read_filenames(self):
315
 
        # replace the class that is constructured, to check its parameters
 
450
        # replace the class that is constructed, to check its parameters
316
451
        oldparserclass = config.ConfigObj
317
452
        config.ConfigObj = InstrumentedConfigObj
318
453
        my_config = config.GlobalConfig()
325
460
                                          'utf-8')])
326
461
 
327
462
 
328
 
class TestBranchConfig(TestCaseWithTransport):
 
463
class TestBranchConfig(tests.TestCaseWithTransport):
329
464
 
330
465
    def test_constructs(self):
331
466
        branch = FakeBranch()
341
476
 
342
477
    def test_get_config(self):
343
478
        """The Branch.get_config method works properly"""
344
 
        b = BzrDir.create_standalone_workingtree('.').branch
 
479
        b = bzrdir.BzrDir.create_standalone_workingtree('.').branch
345
480
        my_config = b.get_config()
346
481
        self.assertIs(my_config.get_user_option('wacky'), None)
347
482
        my_config.set_user_option('wacky', 'unlikely')
348
483
        self.assertEqual(my_config.get_user_option('wacky'), 'unlikely')
349
484
 
350
485
        # Ensure we get the same thing if we start again
351
 
        b2 = Branch.open('.')
 
486
        b2 = branch.Branch.open('.')
352
487
        my_config2 = b2.get_config()
353
488
        self.assertEqual(my_config2.get_user_option('wacky'), 'unlikely')
354
489
 
366
501
        locations = config.locations_config_filename()
367
502
        config.ensure_config_dir_exists()
368
503
        local_url = urlutils.local_path_to_url('branch')
369
 
        open(locations, 'wb').write('[%s]\nnickname = foobar' 
 
504
        open(locations, 'wb').write('[%s]\nnickname = foobar'
370
505
                                    % (local_url,))
371
506
        self.assertEqual('foobar', branch.nick)
372
507
 
377
512
 
378
513
        locations = config.locations_config_filename()
379
514
        config.ensure_config_dir_exists()
380
 
        open(locations, 'wb').write('[%s/branch]\nnickname = barry' 
 
515
        open(locations, 'wb').write('[%s/branch]\nnickname = barry'
381
516
                                    % (osutils.getcwd().encode('utf8'),))
382
517
        self.assertEqual('barry', branch.nick)
383
518
 
384
519
    def test_config_creates_local(self):
385
520
        """Creating a new entry in config uses a local path."""
386
 
        branch = self.make_branch('branch')
 
521
        branch = self.make_branch('branch', format='knit')
387
522
        branch.set_push_location('http://foobar')
388
523
        locations = config.locations_config_filename()
389
524
        local_path = osutils.getcwd().encode('utf8')
390
525
        # Surprisingly ConfigObj doesn't create a trailing newline
391
526
        self.check_file_contents(locations,
392
 
            '[%s/branch]\npush_location = http://foobar' % (local_path,))
393
 
 
394
 
 
395
 
class TestGlobalConfigItems(TestCase):
 
527
                                 '[%s/branch]\n'
 
528
                                 'push_location = http://foobar\n'
 
529
                                 'push_location:policy = norecurse\n'
 
530
                                 % (local_path,))
 
531
 
 
532
    def test_autonick_urlencoded(self):
 
533
        b = self.make_branch('!repo')
 
534
        self.assertEqual('!repo', b.get_config().get_nickname())
 
535
 
 
536
    def test_warn_if_masked(self):
 
537
        _warning = trace.warning
 
538
        warnings = []
 
539
        def warning(*args):
 
540
            warnings.append(args[0] % args[1:])
 
541
 
 
542
        def set_option(store, warn_masked=True):
 
543
            warnings[:] = []
 
544
            conf.set_user_option('example_option', repr(store), store=store,
 
545
                                 warn_masked=warn_masked)
 
546
        def assertWarning(warning):
 
547
            if warning is None:
 
548
                self.assertEqual(0, len(warnings))
 
549
            else:
 
550
                self.assertEqual(1, len(warnings))
 
551
                self.assertEqual(warning, warnings[0])
 
552
        trace.warning = warning
 
553
        try:
 
554
            branch = self.make_branch('.')
 
555
            conf = branch.get_config()
 
556
            set_option(config.STORE_GLOBAL)
 
557
            assertWarning(None)
 
558
            set_option(config.STORE_BRANCH)
 
559
            assertWarning(None)
 
560
            set_option(config.STORE_GLOBAL)
 
561
            assertWarning('Value "4" is masked by "3" from branch.conf')
 
562
            set_option(config.STORE_GLOBAL, warn_masked=False)
 
563
            assertWarning(None)
 
564
            set_option(config.STORE_LOCATION)
 
565
            assertWarning(None)
 
566
            set_option(config.STORE_BRANCH)
 
567
            assertWarning('Value "3" is masked by "0" from locations.conf')
 
568
            set_option(config.STORE_BRANCH, warn_masked=False)
 
569
            assertWarning(None)
 
570
        finally:
 
571
            trace.warning = _warning
 
572
 
 
573
 
 
574
class TestGlobalConfigItems(tests.TestCase):
396
575
 
397
576
    def test_user_id(self):
398
577
        config_file = StringIO(sample_config_text.encode('utf-8'))
472
651
        my_config = self._get_sample_config()
473
652
        self.assertEqual("something",
474
653
                         my_config.get_user_option('user_global_option'))
475
 
        
 
654
 
476
655
    def test_post_commit_default(self):
477
656
        my_config = self._get_sample_config()
478
657
        self.assertEqual(None, my_config.post_commit())
485
664
        my_config = self._get_sample_config()
486
665
        self.assertEqual('help', my_config.get_alias('h'))
487
666
 
 
667
    def test_get_aliases(self):
 
668
        my_config = self._get_sample_config()
 
669
        aliases = my_config.get_aliases()
 
670
        self.assertEqual(2, len(aliases))
 
671
        sorted_keys = sorted(aliases)
 
672
        self.assertEqual('help', aliases[sorted_keys[0]])
 
673
        self.assertEqual(sample_long_alias, aliases[sorted_keys[1]])
 
674
 
488
675
    def test_get_no_alias(self):
489
676
        my_config = self._get_sample_config()
490
677
        self.assertEqual(None, my_config.get_alias('foo'))
493
680
        my_config = self._get_sample_config()
494
681
        self.assertEqual(sample_long_alias, my_config.get_alias('ll'))
495
682
 
496
 
 
497
 
class TestLocationConfig(TestCaseInTempDir):
 
683
    def test_get_change_editor(self):
 
684
        my_config = self._get_sample_config()
 
685
        change_editor = my_config.get_change_editor('old', 'new')
 
686
        self.assertIs(diff.DiffFromTool, change_editor.__class__)
 
687
        self.assertEqual('vimdiff -of @new_path @old_path',
 
688
                         ' '.join(change_editor.command_template))
 
689
 
 
690
    def test_get_no_change_editor(self):
 
691
        my_config = self._get_empty_config()
 
692
        change_editor = my_config.get_change_editor('old', 'new')
 
693
        self.assertIs(None, change_editor)
 
694
 
 
695
 
 
696
class TestGlobalConfigSavingOptions(tests.TestCaseInTempDir):
 
697
 
 
698
    def test_empty(self):
 
699
        my_config = config.GlobalConfig()
 
700
        self.assertEqual(0, len(my_config.get_aliases()))
 
701
 
 
702
    def test_set_alias(self):
 
703
        my_config = config.GlobalConfig()
 
704
        alias_value = 'commit --strict'
 
705
        my_config.set_alias('commit', alias_value)
 
706
        new_config = config.GlobalConfig()
 
707
        self.assertEqual(alias_value, new_config.get_alias('commit'))
 
708
 
 
709
    def test_remove_alias(self):
 
710
        my_config = config.GlobalConfig()
 
711
        my_config.set_alias('commit', 'commit --strict')
 
712
        # Now remove the alias again.
 
713
        my_config.unset_alias('commit')
 
714
        new_config = config.GlobalConfig()
 
715
        self.assertIs(None, new_config.get_alias('commit'))
 
716
 
 
717
 
 
718
class TestLocationConfig(tests.TestCaseInTempDir):
498
719
 
499
720
    def test_constructs(self):
500
721
        my_config = config.LocationConfig('http://example.com')
504
725
        # This is testing the correct file names are provided.
505
726
        # TODO: consolidate with the test for GlobalConfigs filename checks.
506
727
        #
507
 
        # replace the class that is constructured, to check its parameters
 
728
        # replace the class that is constructed, to check its parameters
508
729
        oldparserclass = config.ConfigObj
509
730
        config.ConfigObj = InstrumentedConfigObj
510
731
        try:
535
756
        self.failUnless(isinstance(global_config, config.GlobalConfig))
536
757
        self.failUnless(global_config is my_config._get_global_config())
537
758
 
538
 
    def test__get_section_no_match(self):
 
759
    def test__get_matching_sections_no_match(self):
539
760
        self.get_branch_config('/')
540
 
        self.assertEqual(None, self.my_location_config._get_section())
541
 
        
542
 
    def test__get_section_exact(self):
 
761
        self.assertEqual([], self.my_location_config._get_matching_sections())
 
762
 
 
763
    def test__get_matching_sections_exact(self):
543
764
        self.get_branch_config('http://www.example.com')
544
 
        self.assertEqual('http://www.example.com',
545
 
                         self.my_location_config._get_section())
546
 
   
547
 
    def test__get_section_suffix_does_not(self):
 
765
        self.assertEqual([('http://www.example.com', '')],
 
766
                         self.my_location_config._get_matching_sections())
 
767
 
 
768
    def test__get_matching_sections_suffix_does_not(self):
548
769
        self.get_branch_config('http://www.example.com-com')
549
 
        self.assertEqual(None, self.my_location_config._get_section())
 
770
        self.assertEqual([], self.my_location_config._get_matching_sections())
550
771
 
551
 
    def test__get_section_subdir_recursive(self):
 
772
    def test__get_matching_sections_subdir_recursive(self):
552
773
        self.get_branch_config('http://www.example.com/com')
553
 
        self.assertEqual('http://www.example.com',
554
 
                         self.my_location_config._get_section())
555
 
 
556
 
    def test__get_section_subdir_matches(self):
557
 
        self.get_branch_config('http://www.example.com/useglobal')
558
 
        self.assertEqual('http://www.example.com/useglobal',
559
 
                         self.my_location_config._get_section())
560
 
 
561
 
    def test__get_section_subdir_nonrecursive(self):
 
774
        self.assertEqual([('http://www.example.com', 'com')],
 
775
                         self.my_location_config._get_matching_sections())
 
776
 
 
777
    def test__get_matching_sections_ignoreparent(self):
 
778
        self.get_branch_config('http://www.example.com/ignoreparent')
 
779
        self.assertEqual([('http://www.example.com/ignoreparent', '')],
 
780
                         self.my_location_config._get_matching_sections())
 
781
 
 
782
    def test__get_matching_sections_ignoreparent_subdir(self):
562
783
        self.get_branch_config(
563
 
            'http://www.example.com/useglobal/childbranch')
564
 
        self.assertEqual('http://www.example.com',
565
 
                         self.my_location_config._get_section())
 
784
            'http://www.example.com/ignoreparent/childbranch')
 
785
        self.assertEqual([('http://www.example.com/ignoreparent',
 
786
                           'childbranch')],
 
787
                         self.my_location_config._get_matching_sections())
566
788
 
567
 
    def test__get_section_subdir_trailing_slash(self):
 
789
    def test__get_matching_sections_subdir_trailing_slash(self):
568
790
        self.get_branch_config('/b')
569
 
        self.assertEqual('/b/', self.my_location_config._get_section())
 
791
        self.assertEqual([('/b/', '')],
 
792
                         self.my_location_config._get_matching_sections())
570
793
 
571
 
    def test__get_section_subdir_child(self):
 
794
    def test__get_matching_sections_subdir_child(self):
572
795
        self.get_branch_config('/a/foo')
573
 
        self.assertEqual('/a/*', self.my_location_config._get_section())
 
796
        self.assertEqual([('/a/*', ''), ('/a/', 'foo')],
 
797
                         self.my_location_config._get_matching_sections())
574
798
 
575
 
    def test__get_section_subdir_child_child(self):
 
799
    def test__get_matching_sections_subdir_child_child(self):
576
800
        self.get_branch_config('/a/foo/bar')
577
 
        self.assertEqual('/a/', self.my_location_config._get_section())
 
801
        self.assertEqual([('/a/*', 'bar'), ('/a/', 'foo/bar')],
 
802
                         self.my_location_config._get_matching_sections())
578
803
 
579
 
    def test__get_section_trailing_slash_with_children(self):
 
804
    def test__get_matching_sections_trailing_slash_with_children(self):
580
805
        self.get_branch_config('/a/')
581
 
        self.assertEqual('/a/', self.my_location_config._get_section())
 
806
        self.assertEqual([('/a/', '')],
 
807
                         self.my_location_config._get_matching_sections())
582
808
 
583
 
    def test__get_section_explicit_over_glob(self):
 
809
    def test__get_matching_sections_explicit_over_glob(self):
 
810
        # XXX: 2006-09-08 jamesh
 
811
        # This test only passes because ord('c') > ord('*').  If there
 
812
        # was a config section for '/a/?', it would get precedence
 
813
        # over '/a/c'.
584
814
        self.get_branch_config('/a/c')
585
 
        self.assertEqual('/a/c', self.my_location_config._get_section())
586
 
 
 
815
        self.assertEqual([('/a/c', ''), ('/a/*', ''), ('/a/', 'c')],
 
816
                         self.my_location_config._get_matching_sections())
 
817
 
 
818
    def test__get_option_policy_normal(self):
 
819
        self.get_branch_config('http://www.example.com')
 
820
        self.assertEqual(
 
821
            self.my_location_config._get_config_policy(
 
822
            'http://www.example.com', 'normal_option'),
 
823
            config.POLICY_NONE)
 
824
 
 
825
    def test__get_option_policy_norecurse(self):
 
826
        self.get_branch_config('http://www.example.com')
 
827
        self.assertEqual(
 
828
            self.my_location_config._get_option_policy(
 
829
            'http://www.example.com', 'norecurse_option'),
 
830
            config.POLICY_NORECURSE)
 
831
        # Test old recurse=False setting:
 
832
        self.assertEqual(
 
833
            self.my_location_config._get_option_policy(
 
834
            'http://www.example.com/norecurse', 'normal_option'),
 
835
            config.POLICY_NORECURSE)
 
836
 
 
837
    def test__get_option_policy_normal(self):
 
838
        self.get_branch_config('http://www.example.com')
 
839
        self.assertEqual(
 
840
            self.my_location_config._get_option_policy(
 
841
            'http://www.example.com', 'appendpath_option'),
 
842
            config.POLICY_APPENDPATH)
587
843
 
588
844
    def test_location_without_username(self):
589
 
        self.get_branch_config('http://www.example.com/useglobal')
 
845
        self.get_branch_config('http://www.example.com/ignoreparent')
590
846
        self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
591
847
                         self.my_config.username())
592
848
 
613
869
        self.get_branch_config('/a/c')
614
870
        self.assertEqual(config.CHECK_NEVER,
615
871
                         self.my_config.signature_checking())
616
 
        
 
872
 
617
873
    def test_signatures_when_available(self):
618
874
        self.get_branch_config('/a/', global_config=sample_ignore_signatures)
619
875
        self.assertEqual(config.CHECK_IF_POSSIBLE,
620
876
                         self.my_config.signature_checking())
621
 
        
 
877
 
622
878
    def test_signatures_always(self):
623
879
        self.get_branch_config('/b')
624
880
        self.assertEqual(config.CHECK_ALWAYS,
625
881
                         self.my_config.signature_checking())
626
 
        
 
882
 
627
883
    def test_gpg_signing_command(self):
628
884
        self.get_branch_config('/b')
629
885
        self.assertEqual("gnome-gpg", self.my_config.gpg_signing_command())
641
897
        self.get_branch_config('/a')
642
898
        self.assertEqual('local',
643
899
                         self.my_config.get_user_option('user_local_option'))
644
 
        
 
900
 
 
901
    def test_get_user_option_appendpath(self):
 
902
        # returned as is for the base path:
 
903
        self.get_branch_config('http://www.example.com')
 
904
        self.assertEqual('append',
 
905
                         self.my_config.get_user_option('appendpath_option'))
 
906
        # Extra path components get appended:
 
907
        self.get_branch_config('http://www.example.com/a/b/c')
 
908
        self.assertEqual('append/a/b/c',
 
909
                         self.my_config.get_user_option('appendpath_option'))
 
910
        # Overriden for http://www.example.com/dir, where it is a
 
911
        # normal option:
 
912
        self.get_branch_config('http://www.example.com/dir/a/b/c')
 
913
        self.assertEqual('normal',
 
914
                         self.my_config.get_user_option('appendpath_option'))
 
915
 
 
916
    def test_get_user_option_norecurse(self):
 
917
        self.get_branch_config('http://www.example.com')
 
918
        self.assertEqual('norecurse',
 
919
                         self.my_config.get_user_option('norecurse_option'))
 
920
        self.get_branch_config('http://www.example.com/dir')
 
921
        self.assertEqual(None,
 
922
                         self.my_config.get_user_option('norecurse_option'))
 
923
        # http://www.example.com/norecurse is a recurse=False section
 
924
        # that redefines normal_option.  Subdirectories do not pick up
 
925
        # this redefinition.
 
926
        self.get_branch_config('http://www.example.com/norecurse')
 
927
        self.assertEqual('norecurse',
 
928
                         self.my_config.get_user_option('normal_option'))
 
929
        self.get_branch_config('http://www.example.com/norecurse/subdir')
 
930
        self.assertEqual('normal',
 
931
                         self.my_config.get_user_option('normal_option'))
 
932
 
 
933
    def test_set_user_option_norecurse(self):
 
934
        self.get_branch_config('http://www.example.com')
 
935
        self.my_config.set_user_option('foo', 'bar',
 
936
                                       store=config.STORE_LOCATION_NORECURSE)
 
937
        self.assertEqual(
 
938
            self.my_location_config._get_option_policy(
 
939
            'http://www.example.com', 'foo'),
 
940
            config.POLICY_NORECURSE)
 
941
 
 
942
    def test_set_user_option_appendpath(self):
 
943
        self.get_branch_config('http://www.example.com')
 
944
        self.my_config.set_user_option('foo', 'bar',
 
945
                                       store=config.STORE_LOCATION_APPENDPATH)
 
946
        self.assertEqual(
 
947
            self.my_location_config._get_option_policy(
 
948
            'http://www.example.com', 'foo'),
 
949
            config.POLICY_APPENDPATH)
 
950
 
 
951
    def test_set_user_option_change_policy(self):
 
952
        self.get_branch_config('http://www.example.com')
 
953
        self.my_config.set_user_option('norecurse_option', 'normal',
 
954
                                       store=config.STORE_LOCATION)
 
955
        self.assertEqual(
 
956
            self.my_location_config._get_option_policy(
 
957
            'http://www.example.com', 'norecurse_option'),
 
958
            config.POLICY_NONE)
 
959
 
 
960
    def test_set_user_option_recurse_false_section(self):
 
961
        # The following section has recurse=False set.  The test is to
 
962
        # make sure that a normal option can be added to the section,
 
963
        # converting recurse=False to the norecurse policy.
 
964
        self.get_branch_config('http://www.example.com/norecurse')
 
965
        self.callDeprecated(['The recurse option is deprecated as of 0.14.  '
 
966
                             'The section "http://www.example.com/norecurse" '
 
967
                             'has been converted to use policies.'],
 
968
                            self.my_config.set_user_option,
 
969
                            'foo', 'bar', store=config.STORE_LOCATION)
 
970
        self.assertEqual(
 
971
            self.my_location_config._get_option_policy(
 
972
            'http://www.example.com/norecurse', 'foo'),
 
973
            config.POLICY_NONE)
 
974
        # The previously existing option is still norecurse:
 
975
        self.assertEqual(
 
976
            self.my_location_config._get_option_policy(
 
977
            'http://www.example.com/norecurse', 'normal_option'),
 
978
            config.POLICY_NORECURSE)
 
979
 
645
980
    def test_post_commit_default(self):
646
981
        self.get_branch_config('/a/c')
647
982
        self.assertEqual('bzrlib.tests.test_config.post_commit',
674
1009
 
675
1010
        os.mkdir = checked_mkdir
676
1011
        try:
677
 
            self.my_config.set_user_option('foo', 'bar', local=True)
 
1012
            self.callDeprecated(['The recurse option is deprecated as of '
 
1013
                                 '0.14.  The section "/a/c" has been '
 
1014
                                 'converted to use policies.'],
 
1015
                                self.my_config.set_user_option,
 
1016
                                'foo', 'bar', store=config.STORE_LOCATION)
678
1017
        finally:
679
1018
            os.mkdir = real_mkdir
680
1019
 
684
1023
                          ('__setitem__', '/a/c', {}),
685
1024
                          ('__getitem__', '/a/c'),
686
1025
                          ('__setitem__', 'foo', 'bar'),
 
1026
                          ('__getitem__', '/a/c'),
 
1027
                          ('as_bool', 'recurse'),
 
1028
                          ('__getitem__', '/a/c'),
 
1029
                          ('__delitem__', 'recurse'),
 
1030
                          ('__getitem__', '/a/c'),
 
1031
                          ('keys',),
 
1032
                          ('__getitem__', '/a/c'),
 
1033
                          ('__contains__', 'foo:policy'),
687
1034
                          ('write',)],
688
1035
                         record._calls[1:])
689
1036
 
692
1039
        self.assertIs(self.my_config.get_user_option('foo'), None)
693
1040
        self.my_config.set_user_option('foo', 'bar')
694
1041
        self.assertEqual(
695
 
            self.my_config.branch.control_files.files['branch.conf'], 
 
1042
            self.my_config.branch.control_files.files['branch.conf'].strip(),
696
1043
            'foo = bar')
697
1044
        self.assertEqual(self.my_config.get_user_option('foo'), 'bar')
698
 
        self.my_config.set_user_option('foo', 'baz', local=True)
 
1045
        self.my_config.set_user_option('foo', 'baz',
 
1046
                                       store=config.STORE_LOCATION)
699
1047
        self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
700
1048
        self.my_config.set_user_option('foo', 'qux')
701
1049
        self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
702
 
        
 
1050
 
 
1051
    def test_get_bzr_remote_path(self):
 
1052
        my_config = config.LocationConfig('/a/c')
 
1053
        self.assertEqual('bzr', my_config.get_bzr_remote_path())
 
1054
        my_config.set_user_option('bzr_remote_path', '/path-bzr')
 
1055
        self.assertEqual('/path-bzr', my_config.get_bzr_remote_path())
 
1056
        os.environ['BZR_REMOTE_PATH'] = '/environ-bzr'
 
1057
        self.assertEqual('/environ-bzr', my_config.get_bzr_remote_path())
 
1058
 
703
1059
 
704
1060
precedence_global = 'option = global'
705
1061
precedence_branch = 'option = branch'
712
1068
"""
713
1069
 
714
1070
 
715
 
class TestBranchConfigItems(TestCaseInTempDir):
 
1071
class TestBranchConfigItems(tests.TestCaseInTempDir):
716
1072
 
717
 
    def get_branch_config(self, global_config=None, location=None, 
 
1073
    def get_branch_config(self, global_config=None, location=None,
718
1074
                          location_config=None, branch_data_config=None):
719
1075
        my_config = config.BranchConfig(FakeBranch(location))
720
1076
        if global_config is not None:
734
1090
        my_config = config.BranchConfig(branch)
735
1091
        self.assertEqual("Robert Collins <robertc@example.net>",
736
1092
                         my_config.username())
737
 
        branch.control_files.email = "John"
738
 
        my_config.set_user_option('email', 
 
1093
        my_config.branch.control_files.files['email'] = "John"
 
1094
        my_config.set_user_option('email',
739
1095
                                  "Robert Collins <robertc@example.org>")
740
1096
        self.assertEqual("John", my_config.username())
741
 
        branch.control_files.email = None
 
1097
        del my_config.branch.control_files.files['email']
742
1098
        self.assertEqual("Robert Collins <robertc@example.org>",
743
1099
                         my_config.username())
744
1100
 
745
1101
    def test_not_set_in_branch(self):
746
1102
        my_config = self.get_branch_config(sample_config_text)
747
 
        my_config.branch.control_files.email = None
748
1103
        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
749
1104
                         my_config._get_user_id())
750
 
        my_config.branch.control_files.email = "John"
 
1105
        my_config.branch.control_files.files['email'] = "John"
751
1106
        self.assertEqual("John", my_config._get_user_id())
752
1107
 
753
 
    def test_BZREMAIL_OVERRIDES(self):
754
 
        os.environ['BZREMAIL'] = "Robert Collins <robertc@example.org>"
 
1108
    def test_BZR_EMAIL_OVERRIDES(self):
 
1109
        os.environ['BZR_EMAIL'] = "Robert Collins <robertc@example.org>"
755
1110
        branch = FakeBranch()
756
1111
        my_config = config.BranchConfig(branch)
757
1112
        self.assertEqual("Robert Collins <robertc@example.org>",
758
1113
                         my_config.username())
759
 
    
 
1114
 
760
1115
    def test_signatures_forced(self):
761
1116
        my_config = self.get_branch_config(
762
1117
            global_config=sample_always_signatures)
799
1154
        # post-commit is ignored when bresent in branch data
800
1155
        self.assertEqual('bzrlib.tests.test_config.post_commit',
801
1156
                         my_config.post_commit())
802
 
        my_config.set_user_option('post_commit', 'rmtree_root', local=True)
 
1157
        my_config.set_user_option('post_commit', 'rmtree_root',
 
1158
                                  store=config.STORE_LOCATION)
803
1159
        self.assertEqual('rmtree_root', my_config.post_commit())
804
1160
 
805
1161
    def test_config_precedence(self):
806
1162
        my_config = self.get_branch_config(global_config=precedence_global)
807
1163
        self.assertEqual(my_config.get_user_option('option'), 'global')
808
 
        my_config = self.get_branch_config(global_config=precedence_global, 
 
1164
        my_config = self.get_branch_config(global_config=precedence_global,
809
1165
                                      branch_data_config=precedence_branch)
810
1166
        self.assertEqual(my_config.get_user_option('option'), 'branch')
811
 
        my_config = self.get_branch_config(global_config=precedence_global, 
 
1167
        my_config = self.get_branch_config(global_config=precedence_global,
812
1168
                                      branch_data_config=precedence_branch,
813
1169
                                      location_config=precedence_location)
814
1170
        self.assertEqual(my_config.get_user_option('option'), 'recurse')
815
 
        my_config = self.get_branch_config(global_config=precedence_global, 
 
1171
        my_config = self.get_branch_config(global_config=precedence_global,
816
1172
                                      branch_data_config=precedence_branch,
817
1173
                                      location_config=precedence_location,
818
1174
                                      location='http://example.com/specific')
819
1175
        self.assertEqual(my_config.get_user_option('option'), 'exact')
820
1176
 
821
 
 
822
 
class TestMailAddressExtraction(TestCase):
 
1177
    def test_get_mail_client(self):
 
1178
        config = self.get_branch_config()
 
1179
        client = config.get_mail_client()
 
1180
        self.assertIsInstance(client, mail_client.DefaultMail)
 
1181
 
 
1182
        # Specific clients
 
1183
        config.set_user_option('mail_client', 'evolution')
 
1184
        client = config.get_mail_client()
 
1185
        self.assertIsInstance(client, mail_client.Evolution)
 
1186
 
 
1187
        config.set_user_option('mail_client', 'kmail')
 
1188
        client = config.get_mail_client()
 
1189
        self.assertIsInstance(client, mail_client.KMail)
 
1190
 
 
1191
        config.set_user_option('mail_client', 'mutt')
 
1192
        client = config.get_mail_client()
 
1193
        self.assertIsInstance(client, mail_client.Mutt)
 
1194
 
 
1195
        config.set_user_option('mail_client', 'thunderbird')
 
1196
        client = config.get_mail_client()
 
1197
        self.assertIsInstance(client, mail_client.Thunderbird)
 
1198
 
 
1199
        # Generic options
 
1200
        config.set_user_option('mail_client', 'default')
 
1201
        client = config.get_mail_client()
 
1202
        self.assertIsInstance(client, mail_client.DefaultMail)
 
1203
 
 
1204
        config.set_user_option('mail_client', 'editor')
 
1205
        client = config.get_mail_client()
 
1206
        self.assertIsInstance(client, mail_client.Editor)
 
1207
 
 
1208
        config.set_user_option('mail_client', 'mapi')
 
1209
        client = config.get_mail_client()
 
1210
        self.assertIsInstance(client, mail_client.MAPIClient)
 
1211
 
 
1212
        config.set_user_option('mail_client', 'xdg-email')
 
1213
        client = config.get_mail_client()
 
1214
        self.assertIsInstance(client, mail_client.XDGEmail)
 
1215
 
 
1216
        config.set_user_option('mail_client', 'firebird')
 
1217
        self.assertRaises(errors.UnknownMailClient, config.get_mail_client)
 
1218
 
 
1219
 
 
1220
class TestMailAddressExtraction(tests.TestCase):
823
1221
 
824
1222
    def test_extract_email_address(self):
825
1223
        self.assertEqual('jane@test.com',
826
1224
                         config.extract_email_address('Jane <jane@test.com>'))
827
 
        self.assertRaises(errors.BzrError,
 
1225
        self.assertRaises(errors.NoEmailInUsername,
828
1226
                          config.extract_email_address, 'Jane Tester')
 
1227
 
 
1228
    def test_parse_username(self):
 
1229
        self.assertEqual(('', 'jdoe@example.com'),
 
1230
                         config.parse_username('jdoe@example.com'))
 
1231
        self.assertEqual(('', 'jdoe@example.com'),
 
1232
                         config.parse_username('<jdoe@example.com>'))
 
1233
        self.assertEqual(('John Doe', 'jdoe@example.com'),
 
1234
                         config.parse_username('John Doe <jdoe@example.com>'))
 
1235
        self.assertEqual(('John Doe', ''),
 
1236
                         config.parse_username('John Doe'))
 
1237
        self.assertEqual(('John Doe', 'jdoe@example.com'),
 
1238
                         config.parse_username('John Doe jdoe@example.com'))
 
1239
 
 
1240
class TestTreeConfig(tests.TestCaseWithTransport):
 
1241
 
 
1242
    def test_get_value(self):
 
1243
        """Test that retreiving a value from a section is possible"""
 
1244
        branch = self.make_branch('.')
 
1245
        tree_config = config.TreeConfig(branch)
 
1246
        tree_config.set_option('value', 'key', 'SECTION')
 
1247
        tree_config.set_option('value2', 'key2')
 
1248
        tree_config.set_option('value3-top', 'key3')
 
1249
        tree_config.set_option('value3-section', 'key3', 'SECTION')
 
1250
        value = tree_config.get_option('key', 'SECTION')
 
1251
        self.assertEqual(value, 'value')
 
1252
        value = tree_config.get_option('key2')
 
1253
        self.assertEqual(value, 'value2')
 
1254
        self.assertEqual(tree_config.get_option('non-existant'), None)
 
1255
        value = tree_config.get_option('non-existant', 'SECTION')
 
1256
        self.assertEqual(value, None)
 
1257
        value = tree_config.get_option('non-existant', default='default')
 
1258
        self.assertEqual(value, 'default')
 
1259
        self.assertEqual(tree_config.get_option('key2', 'NOSECTION'), None)
 
1260
        value = tree_config.get_option('key2', 'NOSECTION', default='default')
 
1261
        self.assertEqual(value, 'default')
 
1262
        value = tree_config.get_option('key3')
 
1263
        self.assertEqual(value, 'value3-top')
 
1264
        value = tree_config.get_option('key3', 'SECTION')
 
1265
        self.assertEqual(value, 'value3-section')
 
1266
 
 
1267
 
 
1268
class TestTransportConfig(tests.TestCaseWithTransport):
 
1269
 
 
1270
    def test_get_value(self):
 
1271
        """Test that retreiving a value from a section is possible"""
 
1272
        bzrdir_config = config.TransportConfig(transport.get_transport('.'),
 
1273
                                               'control.conf')
 
1274
        bzrdir_config.set_option('value', 'key', 'SECTION')
 
1275
        bzrdir_config.set_option('value2', 'key2')
 
1276
        bzrdir_config.set_option('value3-top', 'key3')
 
1277
        bzrdir_config.set_option('value3-section', 'key3', 'SECTION')
 
1278
        value = bzrdir_config.get_option('key', 'SECTION')
 
1279
        self.assertEqual(value, 'value')
 
1280
        value = bzrdir_config.get_option('key2')
 
1281
        self.assertEqual(value, 'value2')
 
1282
        self.assertEqual(bzrdir_config.get_option('non-existant'), None)
 
1283
        value = bzrdir_config.get_option('non-existant', 'SECTION')
 
1284
        self.assertEqual(value, None)
 
1285
        value = bzrdir_config.get_option('non-existant', default='default')
 
1286
        self.assertEqual(value, 'default')
 
1287
        self.assertEqual(bzrdir_config.get_option('key2', 'NOSECTION'), None)
 
1288
        value = bzrdir_config.get_option('key2', 'NOSECTION',
 
1289
                                         default='default')
 
1290
        self.assertEqual(value, 'default')
 
1291
        value = bzrdir_config.get_option('key3')
 
1292
        self.assertEqual(value, 'value3-top')
 
1293
        value = bzrdir_config.get_option('key3', 'SECTION')
 
1294
        self.assertEqual(value, 'value3-section')
 
1295
 
 
1296
    def test_set_unset_default_stack_on(self):
 
1297
        my_dir = self.make_bzrdir('.')
 
1298
        bzrdir_config = config.BzrDirConfig(my_dir)
 
1299
        self.assertIs(None, bzrdir_config.get_default_stack_on())
 
1300
        bzrdir_config.set_default_stack_on('Foo')
 
1301
        self.assertEqual('Foo', bzrdir_config._config.get_option(
 
1302
                         'default_stack_on'))
 
1303
        self.assertEqual('Foo', bzrdir_config.get_default_stack_on())
 
1304
        bzrdir_config.set_default_stack_on(None)
 
1305
        self.assertIs(None, bzrdir_config.get_default_stack_on())
 
1306
 
 
1307
 
 
1308
class TestAuthenticationConfigFile(tests.TestCase):
 
1309
    """Test the authentication.conf file matching"""
 
1310
 
 
1311
    def _got_user_passwd(self, expected_user, expected_password,
 
1312
                         config, *args, **kwargs):
 
1313
        credentials = config.get_credentials(*args, **kwargs)
 
1314
        if credentials is None:
 
1315
            user = None
 
1316
            password = None
 
1317
        else:
 
1318
            user = credentials['user']
 
1319
            password = credentials['password']
 
1320
        self.assertEquals(expected_user, user)
 
1321
        self.assertEquals(expected_password, password)
 
1322
 
 
1323
    def test_empty_config(self):
 
1324
        conf = config.AuthenticationConfig(_file=StringIO())
 
1325
        self.assertEquals({}, conf._get_config())
 
1326
        self._got_user_passwd(None, None, conf, 'http', 'foo.net')
 
1327
 
 
1328
    def test_missing_auth_section_header(self):
 
1329
        conf = config.AuthenticationConfig(_file=StringIO('foo = bar'))
 
1330
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
 
1331
 
 
1332
    def test_auth_section_header_not_closed(self):
 
1333
        conf = config.AuthenticationConfig(_file=StringIO('[DEF'))
 
1334
        self.assertRaises(errors.ParseConfigError, conf._get_config)
 
1335
 
 
1336
    def test_auth_value_not_boolean(self):
 
1337
        conf = config.AuthenticationConfig(_file=StringIO(
 
1338
                """[broken]
 
1339
scheme=ftp
 
1340
user=joe
 
1341
verify_certificates=askme # Error: Not a boolean
 
1342
"""))
 
1343
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
 
1344
 
 
1345
    def test_auth_value_not_int(self):
 
1346
        conf = config.AuthenticationConfig(_file=StringIO(
 
1347
                """[broken]
 
1348
scheme=ftp
 
1349
user=joe
 
1350
port=port # Error: Not an int
 
1351
"""))
 
1352
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
 
1353
 
 
1354
    def test_unknown_password_encoding(self):
 
1355
        conf = config.AuthenticationConfig(_file=StringIO(
 
1356
                """[broken]
 
1357
scheme=ftp
 
1358
user=joe
 
1359
password_encoding=unknown
 
1360
"""))
 
1361
        self.assertRaises(ValueError, conf.get_password,
 
1362
                          'ftp', 'foo.net', 'joe')
 
1363
 
 
1364
    def test_credentials_for_scheme_host(self):
 
1365
        conf = config.AuthenticationConfig(_file=StringIO(
 
1366
                """# Identity on foo.net
 
1367
[ftp definition]
 
1368
scheme=ftp
 
1369
host=foo.net
 
1370
user=joe
 
1371
password=secret-pass
 
1372
"""))
 
1373
        # Basic matching
 
1374
        self._got_user_passwd('joe', 'secret-pass', conf, 'ftp', 'foo.net')
 
1375
        # different scheme
 
1376
        self._got_user_passwd(None, None, conf, 'http', 'foo.net')
 
1377
        # different host
 
1378
        self._got_user_passwd(None, None, conf, 'ftp', 'bar.net')
 
1379
 
 
1380
    def test_credentials_for_host_port(self):
 
1381
        conf = config.AuthenticationConfig(_file=StringIO(
 
1382
                """# Identity on foo.net
 
1383
[ftp definition]
 
1384
scheme=ftp
 
1385
port=10021
 
1386
host=foo.net
 
1387
user=joe
 
1388
password=secret-pass
 
1389
"""))
 
1390
        # No port
 
1391
        self._got_user_passwd('joe', 'secret-pass',
 
1392
                              conf, 'ftp', 'foo.net', port=10021)
 
1393
        # different port
 
1394
        self._got_user_passwd(None, None, conf, 'ftp', 'foo.net')
 
1395
 
 
1396
    def test_for_matching_host(self):
 
1397
        conf = config.AuthenticationConfig(_file=StringIO(
 
1398
                """# Identity on foo.net
 
1399
[sourceforge]
 
1400
scheme=bzr
 
1401
host=bzr.sf.net
 
1402
user=joe
 
1403
password=joepass
 
1404
[sourceforge domain]
 
1405
scheme=bzr
 
1406
host=.bzr.sf.net
 
1407
user=georges
 
1408
password=bendover
 
1409
"""))
 
1410
        # matching domain
 
1411
        self._got_user_passwd('georges', 'bendover',
 
1412
                              conf, 'bzr', 'foo.bzr.sf.net')
 
1413
        # phishing attempt
 
1414
        self._got_user_passwd(None, None,
 
1415
                              conf, 'bzr', 'bbzr.sf.net')
 
1416
 
 
1417
    def test_for_matching_host_None(self):
 
1418
        conf = config.AuthenticationConfig(_file=StringIO(
 
1419
                """# Identity on foo.net
 
1420
[catchup bzr]
 
1421
scheme=bzr
 
1422
user=joe
 
1423
password=joepass
 
1424
[DEFAULT]
 
1425
user=georges
 
1426
password=bendover
 
1427
"""))
 
1428
        # match no host
 
1429
        self._got_user_passwd('joe', 'joepass',
 
1430
                              conf, 'bzr', 'quux.net')
 
1431
        # no host but different scheme
 
1432
        self._got_user_passwd('georges', 'bendover',
 
1433
                              conf, 'ftp', 'quux.net')
 
1434
 
 
1435
    def test_credentials_for_path(self):
 
1436
        conf = config.AuthenticationConfig(_file=StringIO(
 
1437
                """
 
1438
[http dir1]
 
1439
scheme=http
 
1440
host=bar.org
 
1441
path=/dir1
 
1442
user=jim
 
1443
password=jimpass
 
1444
[http dir2]
 
1445
scheme=http
 
1446
host=bar.org
 
1447
path=/dir2
 
1448
user=georges
 
1449
password=bendover
 
1450
"""))
 
1451
        # no path no dice
 
1452
        self._got_user_passwd(None, None,
 
1453
                              conf, 'http', host='bar.org', path='/dir3')
 
1454
        # matching path
 
1455
        self._got_user_passwd('georges', 'bendover',
 
1456
                              conf, 'http', host='bar.org', path='/dir2')
 
1457
        # matching subdir
 
1458
        self._got_user_passwd('jim', 'jimpass',
 
1459
                              conf, 'http', host='bar.org',path='/dir1/subdir')
 
1460
 
 
1461
    def test_credentials_for_user(self):
 
1462
        conf = config.AuthenticationConfig(_file=StringIO(
 
1463
                """
 
1464
[with user]
 
1465
scheme=http
 
1466
host=bar.org
 
1467
user=jim
 
1468
password=jimpass
 
1469
"""))
 
1470
        # Get user
 
1471
        self._got_user_passwd('jim', 'jimpass',
 
1472
                              conf, 'http', 'bar.org')
 
1473
        # Get same user
 
1474
        self._got_user_passwd('jim', 'jimpass',
 
1475
                              conf, 'http', 'bar.org', user='jim')
 
1476
        # Don't get a different user if one is specified
 
1477
        self._got_user_passwd(None, None,
 
1478
                              conf, 'http', 'bar.org', user='georges')
 
1479
 
 
1480
    def test_credentials_for_user_without_password(self):
 
1481
        conf = config.AuthenticationConfig(_file=StringIO(
 
1482
                """
 
1483
[without password]
 
1484
scheme=http
 
1485
host=bar.org
 
1486
user=jim
 
1487
"""))
 
1488
        # Get user but no password
 
1489
        self._got_user_passwd('jim', None,
 
1490
                              conf, 'http', 'bar.org')
 
1491
 
 
1492
    def test_verify_certificates(self):
 
1493
        conf = config.AuthenticationConfig(_file=StringIO(
 
1494
                """
 
1495
[self-signed]
 
1496
scheme=https
 
1497
host=bar.org
 
1498
user=jim
 
1499
password=jimpass
 
1500
verify_certificates=False
 
1501
[normal]
 
1502
scheme=https
 
1503
host=foo.net
 
1504
user=georges
 
1505
password=bendover
 
1506
"""))
 
1507
        credentials = conf.get_credentials('https', 'bar.org')
 
1508
        self.assertEquals(False, credentials.get('verify_certificates'))
 
1509
        credentials = conf.get_credentials('https', 'foo.net')
 
1510
        self.assertEquals(True, credentials.get('verify_certificates'))
 
1511
 
 
1512
 
 
1513
class TestAuthenticationStorage(tests.TestCaseInTempDir):
 
1514
 
 
1515
    def test_set_credentials(self):
 
1516
        conf = config.AuthenticationConfig()
 
1517
        conf.set_credentials('name', 'host', 'user', 'scheme', 'password',
 
1518
        99, path='/foo', verify_certificates=False, realm='realm')
 
1519
        credentials = conf.get_credentials(host='host', scheme='scheme',
 
1520
                                           port=99, path='/foo',
 
1521
                                           realm='realm')
 
1522
        CREDENTIALS = {'name': 'name', 'user': 'user', 'password': 'password',
 
1523
                       'verify_certificates': False, 'scheme': 'scheme', 
 
1524
                       'host': 'host', 'port': 99, 'path': '/foo', 
 
1525
                       'realm': 'realm'}
 
1526
        self.assertEqual(CREDENTIALS, credentials)
 
1527
        credentials_from_disk = config.AuthenticationConfig().get_credentials(
 
1528
            host='host', scheme='scheme', port=99, path='/foo', realm='realm')
 
1529
        self.assertEqual(CREDENTIALS, credentials_from_disk)
 
1530
 
 
1531
    def test_reset_credentials_different_name(self):
 
1532
        conf = config.AuthenticationConfig()
 
1533
        conf.set_credentials('name', 'host', 'user', 'scheme', 'password'),
 
1534
        conf.set_credentials('name2', 'host', 'user2', 'scheme', 'password'),
 
1535
        self.assertIs(None, conf._get_config().get('name'))
 
1536
        credentials = conf.get_credentials(host='host', scheme='scheme')
 
1537
        CREDENTIALS = {'name': 'name2', 'user': 'user2', 'password':
 
1538
                       'password', 'verify_certificates': True, 
 
1539
                       'scheme': 'scheme', 'host': 'host', 'port': None, 
 
1540
                       'path': None, 'realm': None}
 
1541
        self.assertEqual(CREDENTIALS, credentials)
 
1542
 
 
1543
 
 
1544
class TestAuthenticationConfig(tests.TestCase):
 
1545
    """Test AuthenticationConfig behaviour"""
 
1546
 
 
1547
    def _check_default_password_prompt(self, expected_prompt_format, scheme,
 
1548
                                       host=None, port=None, realm=None,
 
1549
                                       path=None):
 
1550
        if host is None:
 
1551
            host = 'bar.org'
 
1552
        user, password = 'jim', 'precious'
 
1553
        expected_prompt = expected_prompt_format % {
 
1554
            'scheme': scheme, 'host': host, 'port': port,
 
1555
            'user': user, 'realm': realm}
 
1556
 
 
1557
        stdout = tests.StringIOWrapper()
 
1558
        stderr = tests.StringIOWrapper()
 
1559
        ui.ui_factory = tests.TestUIFactory(stdin=password + '\n',
 
1560
                                            stdout=stdout, stderr=stderr)
 
1561
        # We use an empty conf so that the user is always prompted
 
1562
        conf = config.AuthenticationConfig()
 
1563
        self.assertEquals(password,
 
1564
                          conf.get_password(scheme, host, user, port=port,
 
1565
                                            realm=realm, path=path))
 
1566
        self.assertEquals(expected_prompt, stderr.getvalue())
 
1567
        self.assertEquals('', stdout.getvalue())
 
1568
 
 
1569
    def _check_default_username_prompt(self, expected_prompt_format, scheme,
 
1570
                                       host=None, port=None, realm=None,
 
1571
                                       path=None):
 
1572
        if host is None:
 
1573
            host = 'bar.org'
 
1574
        username = 'jim'
 
1575
        expected_prompt = expected_prompt_format % {
 
1576
            'scheme': scheme, 'host': host, 'port': port,
 
1577
            'realm': realm}
 
1578
        stdout = tests.StringIOWrapper()
 
1579
        stderr = tests.StringIOWrapper()
 
1580
        ui.ui_factory = tests.TestUIFactory(stdin=username+ '\n',
 
1581
                                            stdout=stdout, stderr=stderr)
 
1582
        # We use an empty conf so that the user is always prompted
 
1583
        conf = config.AuthenticationConfig()
 
1584
        self.assertEquals(username, conf.get_user(scheme, host, port=port,
 
1585
                          realm=realm, path=path, ask=True))
 
1586
        self.assertEquals(expected_prompt, stderr.getvalue())
 
1587
        self.assertEquals('', stdout.getvalue())
 
1588
 
 
1589
    def test_username_defaults_prompts(self):
 
1590
        # HTTP prompts can't be tested here, see test_http.py
 
1591
        self._check_default_username_prompt('FTP %(host)s username: ', 'ftp')
 
1592
        self._check_default_username_prompt(
 
1593
            'FTP %(host)s:%(port)d username: ', 'ftp', port=10020)
 
1594
        self._check_default_username_prompt(
 
1595
            'SSH %(host)s:%(port)d username: ', 'ssh', port=12345)
 
1596
 
 
1597
    def test_username_default_no_prompt(self):
 
1598
        conf = config.AuthenticationConfig()
 
1599
        self.assertEquals(None,
 
1600
            conf.get_user('ftp', 'example.com'))
 
1601
        self.assertEquals("explicitdefault",
 
1602
            conf.get_user('ftp', 'example.com', default="explicitdefault"))
 
1603
 
 
1604
    def test_password_default_prompts(self):
 
1605
        # HTTP prompts can't be tested here, see test_http.py
 
1606
        self._check_default_password_prompt(
 
1607
            'FTP %(user)s@%(host)s password: ', 'ftp')
 
1608
        self._check_default_password_prompt(
 
1609
            'FTP %(user)s@%(host)s:%(port)d password: ', 'ftp', port=10020)
 
1610
        self._check_default_password_prompt(
 
1611
            'SSH %(user)s@%(host)s:%(port)d password: ', 'ssh', port=12345)
 
1612
        # SMTP port handling is a bit special (it's handled if embedded in the
 
1613
        # host too)
 
1614
        # FIXME: should we: forbid that, extend it to other schemes, leave
 
1615
        # things as they are that's fine thank you ?
 
1616
        self._check_default_password_prompt('SMTP %(user)s@%(host)s password: ',
 
1617
                                            'smtp')
 
1618
        self._check_default_password_prompt('SMTP %(user)s@%(host)s password: ',
 
1619
                                            'smtp', host='bar.org:10025')
 
1620
        self._check_default_password_prompt(
 
1621
            'SMTP %(user)s@%(host)s:%(port)d password: ',
 
1622
            'smtp', port=10025)
 
1623
 
 
1624
    def test_ssh_password_emits_warning(self):
 
1625
        conf = config.AuthenticationConfig(_file=StringIO(
 
1626
                """
 
1627
[ssh with password]
 
1628
scheme=ssh
 
1629
host=bar.org
 
1630
user=jim
 
1631
password=jimpass
 
1632
"""))
 
1633
        entered_password = 'typed-by-hand'
 
1634
        stdout = tests.StringIOWrapper()
 
1635
        stderr = tests.StringIOWrapper()
 
1636
        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
 
1637
                                            stdout=stdout, stderr=stderr)
 
1638
 
 
1639
        # Since the password defined in the authentication config is ignored,
 
1640
        # the user is prompted
 
1641
        self.assertEquals(entered_password,
 
1642
                          conf.get_password('ssh', 'bar.org', user='jim'))
 
1643
        self.assertContainsRe(
 
1644
            self.get_log(),
 
1645
            'password ignored in section \[ssh with password\]')
 
1646
 
 
1647
    def test_ssh_without_password_doesnt_emit_warning(self):
 
1648
        conf = config.AuthenticationConfig(_file=StringIO(
 
1649
                """
 
1650
[ssh with password]
 
1651
scheme=ssh
 
1652
host=bar.org
 
1653
user=jim
 
1654
"""))
 
1655
        entered_password = 'typed-by-hand'
 
1656
        stdout = tests.StringIOWrapper()
 
1657
        stderr = tests.StringIOWrapper()
 
1658
        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
 
1659
                                            stdout=stdout,
 
1660
                                            stderr=stderr)
 
1661
 
 
1662
        # Since the password defined in the authentication config is ignored,
 
1663
        # the user is prompted
 
1664
        self.assertEquals(entered_password,
 
1665
                          conf.get_password('ssh', 'bar.org', user='jim'))
 
1666
        # No warning shoud be emitted since there is no password. We are only
 
1667
        # providing "user".
 
1668
        self.assertNotContainsRe(
 
1669
            self.get_log(),
 
1670
            'password ignored in section \[ssh with password\]')
 
1671
 
 
1672
    def test_uses_fallback_stores(self):
 
1673
        self.overrideAttr(config, 'credential_store_registry',
 
1674
                          config.CredentialStoreRegistry())
 
1675
        store = StubCredentialStore()
 
1676
        store.add_credentials("http", "example.com", "joe", "secret")
 
1677
        config.credential_store_registry.register("stub", store, fallback=True)
 
1678
        conf = config.AuthenticationConfig(_file=StringIO())
 
1679
        creds = conf.get_credentials("http", "example.com")
 
1680
        self.assertEquals("joe", creds["user"])
 
1681
        self.assertEquals("secret", creds["password"])
 
1682
 
 
1683
 
 
1684
class StubCredentialStore(config.CredentialStore):
 
1685
 
 
1686
    def __init__(self):
 
1687
        self._username = {}
 
1688
        self._password = {}
 
1689
 
 
1690
    def add_credentials(self, scheme, host, user, password=None):
 
1691
        self._username[(scheme, host)] = user
 
1692
        self._password[(scheme, host)] = password
 
1693
 
 
1694
    def get_credentials(self, scheme, host, port=None, user=None,
 
1695
        path=None, realm=None):
 
1696
        key = (scheme, host)
 
1697
        if not key in self._username:
 
1698
            return None
 
1699
        return { "scheme": scheme, "host": host, "port": port,
 
1700
                "user": self._username[key], "password": self._password[key]}
 
1701
 
 
1702
 
 
1703
class CountingCredentialStore(config.CredentialStore):
 
1704
 
 
1705
    def __init__(self):
 
1706
        self._calls = 0
 
1707
 
 
1708
    def get_credentials(self, scheme, host, port=None, user=None,
 
1709
        path=None, realm=None):
 
1710
        self._calls += 1
 
1711
        return None
 
1712
 
 
1713
 
 
1714
class TestCredentialStoreRegistry(tests.TestCase):
 
1715
 
 
1716
    def _get_cs_registry(self):
 
1717
        return config.credential_store_registry
 
1718
 
 
1719
    def test_default_credential_store(self):
 
1720
        r = self._get_cs_registry()
 
1721
        default = r.get_credential_store(None)
 
1722
        self.assertIsInstance(default, config.PlainTextCredentialStore)
 
1723
 
 
1724
    def test_unknown_credential_store(self):
 
1725
        r = self._get_cs_registry()
 
1726
        # It's hard to imagine someone creating a credential store named
 
1727
        # 'unknown' so we use that as an never registered key.
 
1728
        self.assertRaises(KeyError, r.get_credential_store, 'unknown')
 
1729
 
 
1730
    def test_fallback_none_registered(self):
 
1731
        r = config.CredentialStoreRegistry()
 
1732
        self.assertEquals(None,
 
1733
                          r.get_fallback_credentials("http", "example.com"))
 
1734
 
 
1735
    def test_register(self):
 
1736
        r = config.CredentialStoreRegistry()
 
1737
        r.register("stub", StubCredentialStore(), fallback=False)
 
1738
        r.register("another", StubCredentialStore(), fallback=True)
 
1739
        self.assertEquals(["another", "stub"], r.keys())
 
1740
 
 
1741
    def test_register_lazy(self):
 
1742
        r = config.CredentialStoreRegistry()
 
1743
        r.register_lazy("stub", "bzrlib.tests.test_config",
 
1744
                        "StubCredentialStore", fallback=False)
 
1745
        self.assertEquals(["stub"], r.keys())
 
1746
        self.assertIsInstance(r.get_credential_store("stub"),
 
1747
                              StubCredentialStore)
 
1748
 
 
1749
    def test_is_fallback(self):
 
1750
        r = config.CredentialStoreRegistry()
 
1751
        r.register("stub1", None, fallback=False)
 
1752
        r.register("stub2", None, fallback=True)
 
1753
        self.assertEquals(False, r.is_fallback("stub1"))
 
1754
        self.assertEquals(True, r.is_fallback("stub2"))
 
1755
 
 
1756
    def test_no_fallback(self):
 
1757
        r = config.CredentialStoreRegistry()
 
1758
        store = CountingCredentialStore()
 
1759
        r.register("count", store, fallback=False)
 
1760
        self.assertEquals(None,
 
1761
                          r.get_fallback_credentials("http", "example.com"))
 
1762
        self.assertEquals(0, store._calls)
 
1763
 
 
1764
    def test_fallback_credentials(self):
 
1765
        r = config.CredentialStoreRegistry()
 
1766
        store = StubCredentialStore()
 
1767
        store.add_credentials("http", "example.com",
 
1768
                              "somebody", "geheim")
 
1769
        r.register("stub", store, fallback=True)
 
1770
        creds = r.get_fallback_credentials("http", "example.com")
 
1771
        self.assertEquals("somebody", creds["user"])
 
1772
        self.assertEquals("geheim", creds["password"])
 
1773
 
 
1774
    def test_fallback_first_wins(self):
 
1775
        r = config.CredentialStoreRegistry()
 
1776
        stub1 = StubCredentialStore()
 
1777
        stub1.add_credentials("http", "example.com",
 
1778
                              "somebody", "stub1")
 
1779
        r.register("stub1", stub1, fallback=True)
 
1780
        stub2 = StubCredentialStore()
 
1781
        stub2.add_credentials("http", "example.com",
 
1782
                              "somebody", "stub2")
 
1783
        r.register("stub2", stub1, fallback=True)
 
1784
        creds = r.get_fallback_credentials("http", "example.com")
 
1785
        self.assertEquals("somebody", creds["user"])
 
1786
        self.assertEquals("stub1", creds["password"])
 
1787
 
 
1788
 
 
1789
class TestPlainTextCredentialStore(tests.TestCase):
 
1790
 
 
1791
    def test_decode_password(self):
 
1792
        r = config.credential_store_registry
 
1793
        plain_text = r.get_credential_store()
 
1794
        decoded = plain_text.decode_password(dict(password='secret'))
 
1795
        self.assertEquals('secret', decoded)
 
1796
 
 
1797
 
 
1798
# FIXME: Once we have a way to declare authentication to all test servers, we
 
1799
# can implement generic tests.
 
1800
# test_user_password_in_url
 
1801
# test_user_in_url_password_from_config
 
1802
# test_user_in_url_password_prompted
 
1803
# test_user_in_config
 
1804
# test_user_getpass.getuser
 
1805
# test_user_prompted ?
 
1806
class TestAuthenticationRing(tests.TestCaseWithTransport):
 
1807
    pass