← 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: 2009-10-02 20:32:50 UTC
  • mto: (4679.6.1 2.1-export-c-api)
  • mto: This revision was merged to the branch mainline in revision 4735.
  • Revision ID: john@arbash-meinel.com-20091002203250-q6iv6o2mwjqp4g53
Add __iter__ support.

Show diffs side-by-side

added added

removed removed

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