~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_config.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-05-19 06:14:38 UTC
  • mfrom: (1704.2.23 bzr.mbp.integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060519061438-6300caf3926c3cff
(mbp) small fixes

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 by Canonical Ltd
 
2
#   Authors: Robert Collins <robert.collins@canonical.com>
2
3
#
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
12
13
#
13
14
# You should have received a copy of the GNU General Public License
14
15
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
17
 
17
18
"""Tests for finding and reading the bzr config file[s]."""
18
19
# import system imports here
 
20
from bzrlib.util.configobj.configobj import ConfigObj, ConfigObjError
19
21
from cStringIO import StringIO
20
22
import os
21
23
import sys
22
24
 
23
25
#import bzrlib specific imports here
24
 
from bzrlib import (
25
 
    branch,
26
 
    bzrdir,
27
 
    config,
28
 
    diff,
29
 
    errors,
30
 
    osutils,
31
 
    mail_client,
32
 
    ui,
33
 
    urlutils,
34
 
    tests,
35
 
    trace,
36
 
    transport,
37
 
    )
38
 
from bzrlib.util.configobj import configobj
 
26
import bzrlib.config as config
 
27
import bzrlib.errors as errors
 
28
from bzrlib.tests import TestCase, TestCaseInTempDir
39
29
 
40
30
 
41
31
sample_long_alias="log -r-15..-1 --line"
42
 
sample_config_text = u"""
43
 
[DEFAULT]
44
 
email=Erik B\u00e5gfors <erik@bagfors.nu>
45
 
editor=vim
46
 
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
 
"""
 
32
sample_config_text = ("[DEFAULT]\n"
 
33
                      u"email=Erik B\u00e5gfors <erik@bagfors.nu>\n"
 
34
                      "editor=vim\n"
 
35
                      "gpg_signing_command=gnome-gpg\n"
 
36
                      "log_format=short\n"
 
37
                      "user_global_option=something\n"
 
38
                      "[ALIASES]\n"
 
39
                      "h=help\n"
 
40
                      "ll=" + sample_long_alias + "\n")
 
41
 
 
42
 
 
43
sample_always_signatures = ("[DEFAULT]\n"
 
44
                            "check_signatures=require\n")
 
45
 
 
46
 
 
47
sample_ignore_signatures = ("[DEFAULT]\n"
 
48
                            "check_signatures=ignore\n")
 
49
 
 
50
 
 
51
sample_maybe_signatures = ("[DEFAULT]\n"
 
52
                            "check_signatures=check-available\n")
 
53
 
 
54
 
 
55
sample_branches_text = ("[http://www.example.com]\n"
 
56
                        "# Top level policy\n"
 
57
                        "email=Robert Collins <robertc@example.org>\n"
 
58
                        "[http://www.example.com/useglobal]\n"
 
59
                        "# different project, forces global lookup\n"
 
60
                        "recurse=false\n"
 
61
                        "[/b/]\n"
 
62
                        "check_signatures=require\n"
 
63
                        "# test trailing / matching with no children\n"
 
64
                        "[/a/]\n"
 
65
                        "check_signatures=check-available\n"
 
66
                        "gpg_signing_command=false\n"
 
67
                        "user_local_option=local\n"
 
68
                        "# test trailing / matching\n"
 
69
                        "[/a/*]\n"
 
70
                        "#subdirs will match but not the parent\n"
 
71
                        "recurse=False\n"
 
72
                        "[/a/c]\n"
 
73
                        "check_signatures=ignore\n"
 
74
                        "post_commit=bzrlib.tests.test_config.post_commit\n"
 
75
                        "#testing explicit beats globs\n")
 
76
 
106
77
 
107
78
 
108
79
class InstrumentedConfigObj(object):
122
93
    def __setitem__(self, key, value):
123
94
        self._calls.append(('__setitem__', key, value))
124
95
 
125
 
    def __delitem__(self, key):
126
 
        self._calls.append(('__delitem__', key))
127
 
 
128
 
    def keys(self):
129
 
        self._calls.append(('keys',))
130
 
        return []
131
 
 
132
96
    def write(self, arg):
133
97
        self._calls.append(('write',))
134
98
 
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
 
 
143
99
 
144
100
class FakeBranch(object):
145
101
 
146
 
    def __init__(self, base=None, user_id=None):
147
 
        if base is None:
148
 
            self.base = "http://example.com/branches/demo"
149
 
        else:
150
 
            self.base = base
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')
156
 
 
157
 
    def lock_write(self):
158
 
        pass
159
 
 
160
 
    def unlock(self):
161
 
        pass
162
 
 
163
 
 
164
 
class FakeControlFilesAndTransport(object):
165
 
 
166
 
    def __init__(self, user_id=None):
167
 
        self.files = {}
168
 
        if user_id:
169
 
            self.files['email'] = user_id
170
 
        self._transport = self
 
102
    def __init__(self):
 
103
        self.base = "http://example.com/branches/demo"
 
104
        self.control_files = FakeControlFiles()
 
105
 
 
106
 
 
107
class FakeControlFiles(object):
 
108
 
 
109
    def __init__(self):
 
110
        self.email = 'Robert Collins <robertc@example.net>\n'
171
111
 
172
112
    def get_utf8(self, filename):
173
 
        # from LockableFiles
174
 
        raise AssertionError("get_utf8 should no longer be used")
175
 
 
176
 
    def get(self, filename):
177
 
        # from Transport
178
 
        try:
179
 
            return StringIO(self.files[filename])
180
 
        except KeyError:
181
 
            raise errors.NoSuchFile(filename)
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
 
 
190
 
    def put(self, filename, fileobj):
191
 
        self.files[filename] = fileobj.read()
192
 
 
193
 
    def put_file(self, filename, fileobj):
194
 
        return self.put(filename, fileobj)
 
113
        if filename != 'email':
 
114
            raise NotImplementedError
 
115
        if self.email is not None:
 
116
            return StringIO(self.email)
 
117
        raise errors.NoSuchFile(filename)
195
118
 
196
119
 
197
120
class InstrumentedConfig(config.Config):
198
121
    """An instrumented config that supplies stubs for template methods."""
199
 
 
 
122
    
200
123
    def __init__(self):
201
124
        super(InstrumentedConfig, self).__init__()
202
125
        self._calls = []
210
133
        self._calls.append('_get_signature_checking')
211
134
        return self._signatures
212
135
 
213
 
    def _get_change_editor(self):
214
 
        self._calls.append('_get_change_editor')
215
 
        return 'vimdiff -fo @new_path @old_path'
216
 
 
217
136
 
218
137
bool_config = """[DEFAULT]
219
138
active = true
222
141
active = True
223
142
nonactive = False
224
143
"""
225
 
 
226
 
 
227
 
class TestConfigObj(tests.TestCase):
228
 
 
 
144
class TestConfigObj(TestCase):
229
145
    def test_get_bool(self):
230
 
        co = config.ConfigObj(StringIO(bool_config))
 
146
        from bzrlib.config import ConfigObj
 
147
        co = ConfigObj(StringIO(bool_config))
231
148
        self.assertIs(co.get_bool('DEFAULT', 'active'), True)
232
149
        self.assertIs(co.get_bool('DEFAULT', 'inactive'), False)
233
150
        self.assertIs(co.get_bool('UPPERCASE', 'active'), True)
234
151
        self.assertIs(co.get_bool('UPPERCASE', 'nonactive'), False)
235
152
 
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):
 
153
 
 
154
class TestConfig(TestCase):
269
155
 
270
156
    def test_constructs(self):
271
157
        config.Config()
272
 
 
 
158
 
273
159
    def test_no_default_editor(self):
274
160
        self.assertRaises(NotImplementedError, config.Config().get_editor)
275
161
 
286
172
 
287
173
    def test_signatures_default(self):
288
174
        my_config = config.Config()
289
 
        self.assertFalse(my_config.signature_needed())
290
175
        self.assertEqual(config.CHECK_IF_POSSIBLE,
291
176
                         my_config.signature_checking())
292
 
        self.assertEqual(config.SIGN_WHEN_REQUIRED,
293
 
                         my_config.signing_policy())
294
177
 
295
178
    def test_signatures_template_method(self):
296
179
        my_config = InstrumentedConfig()
320
203
        my_config = config.Config()
321
204
        self.assertEqual('long', my_config.log_format())
322
205
 
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):
 
206
 
 
207
class TestConfigPath(TestCase):
333
208
 
334
209
    def setUp(self):
335
210
        super(TestConfigPath, self).setUp()
 
211
        self.old_home = os.environ.get('HOME', None)
 
212
        self.old_appdata = os.environ.get('APPDATA', None)
336
213
        os.environ['HOME'] = '/home/bogus'
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'
 
214
        os.environ['APPDATA'] = \
 
215
            r'C:\Documents and Settings\bogus\Application Data'
345
216
 
 
217
    def tearDown(self):
 
218
        if self.old_home is None:
 
219
            del os.environ['HOME']
 
220
        else:
 
221
            os.environ['HOME'] = self.old_home
 
222
        if self.old_appdata is None:
 
223
            del os.environ['APPDATA']
 
224
        else:
 
225
            os.environ['APPDATA'] = self.old_appdata
 
226
        super(TestConfigPath, self).tearDown()
 
227
    
346
228
    def test_config_dir(self):
347
 
        self.assertEqual(config.config_dir(), self.bzr_home)
 
229
        if sys.platform == 'win32':
 
230
            self.assertEqual(config.config_dir(), 
 
231
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0')
 
232
        else:
 
233
            self.assertEqual(config.config_dir(), '/home/bogus/.bazaar')
348
234
 
349
235
    def test_config_filename(self):
350
 
        self.assertEqual(config.config_filename(),
351
 
                         self.bzr_home + '/bazaar.conf')
 
236
        if sys.platform == 'win32':
 
237
            self.assertEqual(config.config_filename(), 
 
238
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/bazaar.conf')
 
239
        else:
 
240
            self.assertEqual(config.config_filename(),
 
241
                             '/home/bogus/.bazaar/bazaar.conf')
352
242
 
353
243
    def test_branches_config_filename(self):
354
 
        self.assertEqual(config.branches_config_filename(),
355
 
                         self.bzr_home + '/branches.conf')
356
 
 
357
 
    def test_locations_config_filename(self):
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):
 
244
        if sys.platform == 'win32':
 
245
            self.assertEqual(config.branches_config_filename(), 
 
246
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/branches.conf')
 
247
        else:
 
248
            self.assertEqual(config.branches_config_filename(),
 
249
                             '/home/bogus/.bazaar/branches.conf')
 
250
 
 
251
class TestIniConfig(TestCase):
379
252
 
380
253
    def test_contructs(self):
381
254
        my_config = config.IniBasedConfig("nothing")
385
258
        my_config = config.IniBasedConfig(None)
386
259
        self.failUnless(
387
260
            isinstance(my_config._get_parser(file=config_file),
388
 
                        configobj.ConfigObj))
 
261
                        ConfigObj))
389
262
 
390
263
    def test_cached(self):
391
264
        config_file = StringIO(sample_config_text.encode('utf-8'))
394
267
        self.failUnless(my_config._get_parser() is parser)
395
268
 
396
269
 
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):
 
270
class TestGetConfig(TestCase):
445
271
 
446
272
    def test_constructs(self):
447
273
        my_config = config.GlobalConfig()
448
274
 
449
275
    def test_calls_read_filenames(self):
450
 
        # replace the class that is constructed, to check its parameters
 
276
        # replace the class that is constructured, to check its parameters
451
277
        oldparserclass = config.ConfigObj
452
278
        config.ConfigObj = InstrumentedConfigObj
453
279
        my_config = config.GlobalConfig()
460
286
                                          'utf-8')])
461
287
 
462
288
 
463
 
class TestBranchConfig(tests.TestCaseWithTransport):
 
289
class TestBranchConfig(TestCaseInTempDir):
464
290
 
465
291
    def test_constructs(self):
466
292
        branch = FakeBranch()
474
300
        self.assertEqual(branch.base, location_config.location)
475
301
        self.failUnless(location_config is my_config._get_location_config())
476
302
 
477
 
    def test_get_config(self):
478
 
        """The Branch.get_config method works properly"""
479
 
        b = bzrdir.BzrDir.create_standalone_workingtree('.').branch
480
 
        my_config = b.get_config()
481
 
        self.assertIs(my_config.get_user_option('wacky'), None)
482
 
        my_config.set_user_option('wacky', 'unlikely')
483
 
        self.assertEqual(my_config.get_user_option('wacky'), 'unlikely')
484
 
 
485
 
        # Ensure we get the same thing if we start again
486
 
        b2 = branch.Branch.open('.')
487
 
        my_config2 = b2.get_config()
488
 
        self.assertEqual(my_config2.get_user_option('wacky'), 'unlikely')
489
 
 
490
 
    def test_has_explicit_nickname(self):
491
 
        b = self.make_branch('.')
492
 
        self.assertFalse(b.get_config().has_explicit_nickname())
493
 
        b.nick = 'foo'
494
 
        self.assertTrue(b.get_config().has_explicit_nickname())
495
 
 
496
 
    def test_config_url(self):
497
 
        """The Branch.get_config will use section that uses a local url"""
498
 
        branch = self.make_branch('branch')
499
 
        self.assertEqual('branch', branch.nick)
500
 
 
501
 
        locations = config.locations_config_filename()
502
 
        config.ensure_config_dir_exists()
503
 
        local_url = urlutils.local_path_to_url('branch')
504
 
        open(locations, 'wb').write('[%s]\nnickname = foobar'
505
 
                                    % (local_url,))
506
 
        self.assertEqual('foobar', branch.nick)
507
 
 
508
 
    def test_config_local_path(self):
509
 
        """The Branch.get_config will use a local system path"""
510
 
        branch = self.make_branch('branch')
511
 
        self.assertEqual('branch', branch.nick)
512
 
 
513
 
        locations = config.locations_config_filename()
514
 
        config.ensure_config_dir_exists()
515
 
        open(locations, 'wb').write('[%s/branch]\nnickname = barry'
516
 
                                    % (osutils.getcwd().encode('utf8'),))
517
 
        self.assertEqual('barry', branch.nick)
518
 
 
519
 
    def test_config_creates_local(self):
520
 
        """Creating a new entry in config uses a local path."""
521
 
        branch = self.make_branch('branch', format='knit')
522
 
        branch.set_push_location('http://foobar')
523
 
        locations = config.locations_config_filename()
524
 
        local_path = osutils.getcwd().encode('utf8')
525
 
        # Surprisingly ConfigObj doesn't create a trailing newline
526
 
        self.check_file_contents(locations,
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):
 
303
 
 
304
class TestGlobalConfigItems(TestCase):
575
305
 
576
306
    def test_user_id(self):
577
307
        config_file = StringIO(sample_config_text.encode('utf-8'))
596
326
        config_file = StringIO(sample_always_signatures)
597
327
        my_config = config.GlobalConfig()
598
328
        my_config._parser = my_config._get_parser(file=config_file)
599
 
        self.assertEqual(config.CHECK_NEVER,
 
329
        self.assertEqual(config.CHECK_ALWAYS,
600
330
                         my_config.signature_checking())
601
 
        self.assertEqual(config.SIGN_ALWAYS,
602
 
                         my_config.signing_policy())
603
331
        self.assertEqual(True, my_config.signature_needed())
604
332
 
605
333
    def test_signatures_if_possible(self):
606
334
        config_file = StringIO(sample_maybe_signatures)
607
335
        my_config = config.GlobalConfig()
608
336
        my_config._parser = my_config._get_parser(file=config_file)
609
 
        self.assertEqual(config.CHECK_NEVER,
 
337
        self.assertEqual(config.CHECK_IF_POSSIBLE,
610
338
                         my_config.signature_checking())
611
 
        self.assertEqual(config.SIGN_WHEN_REQUIRED,
612
 
                         my_config.signing_policy())
613
339
        self.assertEqual(False, my_config.signature_needed())
614
340
 
615
341
    def test_signatures_ignore(self):
616
342
        config_file = StringIO(sample_ignore_signatures)
617
343
        my_config = config.GlobalConfig()
618
344
        my_config._parser = my_config._get_parser(file=config_file)
619
 
        self.assertEqual(config.CHECK_ALWAYS,
 
345
        self.assertEqual(config.CHECK_NEVER,
620
346
                         my_config.signature_checking())
621
 
        self.assertEqual(config.SIGN_NEVER,
622
 
                         my_config.signing_policy())
623
347
        self.assertEqual(False, my_config.signature_needed())
624
348
 
625
349
    def _get_sample_config(self):
651
375
        my_config = self._get_sample_config()
652
376
        self.assertEqual("something",
653
377
                         my_config.get_user_option('user_global_option'))
654
 
 
 
378
        
655
379
    def test_post_commit_default(self):
656
380
        my_config = self._get_sample_config()
657
381
        self.assertEqual(None, my_config.post_commit())
664
388
        my_config = self._get_sample_config()
665
389
        self.assertEqual('help', my_config.get_alias('h'))
666
390
 
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
 
 
675
391
    def test_get_no_alias(self):
676
392
        my_config = self._get_sample_config()
677
393
        self.assertEqual(None, my_config.get_alias('foo'))
680
396
        my_config = self._get_sample_config()
681
397
        self.assertEqual(sample_long_alias, my_config.get_alias('ll'))
682
398
 
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):
 
399
 
 
400
class TestLocationConfig(TestCaseInTempDir):
719
401
 
720
402
    def test_constructs(self):
721
403
        my_config = config.LocationConfig('http://example.com')
725
407
        # This is testing the correct file names are provided.
726
408
        # TODO: consolidate with the test for GlobalConfigs filename checks.
727
409
        #
728
 
        # replace the class that is constructed, to check its parameters
 
410
        # replace the class that is constructured, to check its parameters
729
411
        oldparserclass = config.ConfigObj
730
412
        config.ConfigObj = InstrumentedConfigObj
 
413
        my_config = config.LocationConfig('http://www.example.com')
731
414
        try:
732
 
            my_config = config.LocationConfig('http://www.example.com')
733
415
            parser = my_config._get_parser()
734
416
        finally:
735
417
            config.ConfigObj = oldparserclass
736
418
        self.failUnless(isinstance(parser, InstrumentedConfigObj))
737
419
        self.assertEqual(parser._calls,
738
 
                         [('__init__', config.locations_config_filename(),
 
420
                         [('__init__', config.branches_config_filename(),
739
421
                           'utf-8')])
740
 
        config.ensure_config_dir_exists()
741
 
        #os.mkdir(config.config_dir())
742
 
        f = file(config.branches_config_filename(), 'wb')
743
 
        f.write('')
744
 
        f.close()
745
 
        oldparserclass = config.ConfigObj
746
 
        config.ConfigObj = InstrumentedConfigObj
747
 
        try:
748
 
            my_config = config.LocationConfig('http://www.example.com')
749
 
            parser = my_config._get_parser()
750
 
        finally:
751
 
            config.ConfigObj = oldparserclass
752
422
 
753
423
    def test_get_global_config(self):
754
 
        my_config = config.BranchConfig(FakeBranch('http://example.com'))
 
424
        my_config = config.LocationConfig('http://example.com')
755
425
        global_config = my_config._get_global_config()
756
426
        self.failUnless(isinstance(global_config, config.GlobalConfig))
757
427
        self.failUnless(global_config is my_config._get_global_config())
758
428
 
759
 
    def test__get_matching_sections_no_match(self):
760
 
        self.get_branch_config('/')
761
 
        self.assertEqual([], self.my_location_config._get_matching_sections())
762
 
 
763
 
    def test__get_matching_sections_exact(self):
764
 
        self.get_branch_config('http://www.example.com')
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):
769
 
        self.get_branch_config('http://www.example.com-com')
770
 
        self.assertEqual([], self.my_location_config._get_matching_sections())
771
 
 
772
 
    def test__get_matching_sections_subdir_recursive(self):
773
 
        self.get_branch_config('http://www.example.com/com')
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):
783
 
        self.get_branch_config(
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())
788
 
 
789
 
    def test__get_matching_sections_subdir_trailing_slash(self):
790
 
        self.get_branch_config('/b')
791
 
        self.assertEqual([('/b/', '')],
792
 
                         self.my_location_config._get_matching_sections())
793
 
 
794
 
    def test__get_matching_sections_subdir_child(self):
795
 
        self.get_branch_config('/a/foo')
796
 
        self.assertEqual([('/a/*', ''), ('/a/', 'foo')],
797
 
                         self.my_location_config._get_matching_sections())
798
 
 
799
 
    def test__get_matching_sections_subdir_child_child(self):
800
 
        self.get_branch_config('/a/foo/bar')
801
 
        self.assertEqual([('/a/*', 'bar'), ('/a/', 'foo/bar')],
802
 
                         self.my_location_config._get_matching_sections())
803
 
 
804
 
    def test__get_matching_sections_trailing_slash_with_children(self):
805
 
        self.get_branch_config('/a/')
806
 
        self.assertEqual([('/a/', '')],
807
 
                         self.my_location_config._get_matching_sections())
808
 
 
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'.
814
 
        self.get_branch_config('/a/c')
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)
 
429
    def test__get_section_no_match(self):
 
430
        self.get_location_config('/')
 
431
        self.assertEqual(None, self.my_config._get_section())
 
432
        
 
433
    def test__get_section_exact(self):
 
434
        self.get_location_config('http://www.example.com')
 
435
        self.assertEqual('http://www.example.com',
 
436
                         self.my_config._get_section())
 
437
   
 
438
    def test__get_section_suffix_does_not(self):
 
439
        self.get_location_config('http://www.example.com-com')
 
440
        self.assertEqual(None, self.my_config._get_section())
 
441
 
 
442
    def test__get_section_subdir_recursive(self):
 
443
        self.get_location_config('http://www.example.com/com')
 
444
        self.assertEqual('http://www.example.com',
 
445
                         self.my_config._get_section())
 
446
 
 
447
    def test__get_section_subdir_matches(self):
 
448
        self.get_location_config('http://www.example.com/useglobal')
 
449
        self.assertEqual('http://www.example.com/useglobal',
 
450
                         self.my_config._get_section())
 
451
 
 
452
    def test__get_section_subdir_nonrecursive(self):
 
453
        self.get_location_config(
 
454
            'http://www.example.com/useglobal/childbranch')
 
455
        self.assertEqual('http://www.example.com',
 
456
                         self.my_config._get_section())
 
457
 
 
458
    def test__get_section_subdir_trailing_slash(self):
 
459
        self.get_location_config('/b')
 
460
        self.assertEqual('/b/', self.my_config._get_section())
 
461
 
 
462
    def test__get_section_subdir_child(self):
 
463
        self.get_location_config('/a/foo')
 
464
        self.assertEqual('/a/*', self.my_config._get_section())
 
465
 
 
466
    def test__get_section_subdir_child_child(self):
 
467
        self.get_location_config('/a/foo/bar')
 
468
        self.assertEqual('/a/', self.my_config._get_section())
 
469
 
 
470
    def test__get_section_trailing_slash_with_children(self):
 
471
        self.get_location_config('/a/')
 
472
        self.assertEqual('/a/', self.my_config._get_section())
 
473
 
 
474
    def test__get_section_explicit_over_glob(self):
 
475
        self.get_location_config('/a/c')
 
476
        self.assertEqual('/a/c', self.my_config._get_section())
 
477
 
843
478
 
844
479
    def test_location_without_username(self):
845
 
        self.get_branch_config('http://www.example.com/ignoreparent')
 
480
        self.get_location_config('http://www.example.com/useglobal')
846
481
        self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
847
482
                         self.my_config.username())
848
483
 
849
484
    def test_location_not_listed(self):
850
485
        """Test that the global username is used when no location matches"""
851
 
        self.get_branch_config('/home/robertc/sources')
 
486
        self.get_location_config('/home/robertc/sources')
852
487
        self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
853
488
                         self.my_config.username())
854
489
 
855
490
    def test_overriding_location(self):
856
 
        self.get_branch_config('http://www.example.com/foo')
 
491
        self.get_location_config('http://www.example.com/foo')
857
492
        self.assertEqual('Robert Collins <robertc@example.org>',
858
493
                         self.my_config.username())
859
494
 
860
495
    def test_signatures_not_set(self):
861
 
        self.get_branch_config('http://www.example.com',
 
496
        self.get_location_config('http://www.example.com',
862
497
                                 global_config=sample_ignore_signatures)
863
 
        self.assertEqual(config.CHECK_ALWAYS,
 
498
        self.assertEqual(config.CHECK_NEVER,
864
499
                         self.my_config.signature_checking())
865
 
        self.assertEqual(config.SIGN_NEVER,
866
 
                         self.my_config.signing_policy())
867
500
 
868
501
    def test_signatures_never(self):
869
 
        self.get_branch_config('/a/c')
 
502
        self.get_location_config('/a/c')
870
503
        self.assertEqual(config.CHECK_NEVER,
871
504
                         self.my_config.signature_checking())
872
 
 
 
505
        
873
506
    def test_signatures_when_available(self):
874
 
        self.get_branch_config('/a/', global_config=sample_ignore_signatures)
 
507
        self.get_location_config('/a/', global_config=sample_ignore_signatures)
875
508
        self.assertEqual(config.CHECK_IF_POSSIBLE,
876
509
                         self.my_config.signature_checking())
877
 
 
 
510
        
878
511
    def test_signatures_always(self):
879
 
        self.get_branch_config('/b')
 
512
        self.get_location_config('/b')
880
513
        self.assertEqual(config.CHECK_ALWAYS,
881
514
                         self.my_config.signature_checking())
882
 
 
 
515
        
883
516
    def test_gpg_signing_command(self):
884
 
        self.get_branch_config('/b')
 
517
        self.get_location_config('/b')
885
518
        self.assertEqual("gnome-gpg", self.my_config.gpg_signing_command())
886
519
 
887
520
    def test_gpg_signing_command_missing(self):
888
 
        self.get_branch_config('/a')
 
521
        self.get_location_config('/a')
889
522
        self.assertEqual("false", self.my_config.gpg_signing_command())
890
523
 
891
524
    def test_get_user_option_global(self):
892
 
        self.get_branch_config('/a')
 
525
        self.get_location_config('/a')
893
526
        self.assertEqual('something',
894
527
                         self.my_config.get_user_option('user_global_option'))
895
528
 
896
529
    def test_get_user_option_local(self):
897
 
        self.get_branch_config('/a')
 
530
        self.get_location_config('/a')
898
531
        self.assertEqual('local',
899
532
                         self.my_config.get_user_option('user_local_option'))
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
 
 
 
533
        
980
534
    def test_post_commit_default(self):
981
 
        self.get_branch_config('/a/c')
 
535
        self.get_location_config('/a/c')
982
536
        self.assertEqual('bzrlib.tests.test_config.post_commit',
983
537
                         self.my_config.post_commit())
984
538
 
985
 
    def get_branch_config(self, location, global_config=None):
 
539
    def get_location_config(self, location, global_config=None):
986
540
        if global_config is None:
987
541
            global_file = StringIO(sample_config_text.encode('utf-8'))
988
542
        else:
989
543
            global_file = StringIO(global_config.encode('utf-8'))
990
544
        branches_file = StringIO(sample_branches_text.encode('utf-8'))
991
 
        self.my_config = config.BranchConfig(FakeBranch(location))
992
 
        # Force location config to use specified file
993
 
        self.my_location_config = self.my_config._get_location_config()
994
 
        self.my_location_config._get_parser(branches_file)
995
 
        # Force global config to use specified file
 
545
        self.my_config = config.LocationConfig(location)
 
546
        self.my_config._get_parser(branches_file)
996
547
        self.my_config._get_global_config()._get_parser(global_file)
997
548
 
998
549
    def test_set_user_setting_sets_and_saves(self):
999
 
        self.get_branch_config('/a/c')
 
550
        self.get_location_config('/a/c')
1000
551
        record = InstrumentedConfigObj("foo")
1001
 
        self.my_location_config._parser = record
 
552
        self.my_config._parser = record
1002
553
 
1003
554
        real_mkdir = os.mkdir
1004
555
        self.created = False
1009
560
 
1010
561
        os.mkdir = checked_mkdir
1011
562
        try:
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)
 
563
            self.my_config.set_user_option('foo', 'bar')
1017
564
        finally:
1018
565
            os.mkdir = real_mkdir
1019
566
 
1023
570
                          ('__setitem__', '/a/c', {}),
1024
571
                          ('__getitem__', '/a/c'),
1025
572
                          ('__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'),
1034
573
                          ('write',)],
1035
574
                         record._calls[1:])
1036
575
 
1037
 
    def test_set_user_setting_sets_and_saves2(self):
1038
 
        self.get_branch_config('/a/c')
1039
 
        self.assertIs(self.my_config.get_user_option('foo'), None)
1040
 
        self.my_config.set_user_option('foo', 'bar')
1041
 
        self.assertEqual(
1042
 
            self.my_config.branch.control_files.files['branch.conf'].strip(),
1043
 
            'foo = bar')
1044
 
        self.assertEqual(self.my_config.get_user_option('foo'), 'bar')
1045
 
        self.my_config.set_user_option('foo', 'baz',
1046
 
                                       store=config.STORE_LOCATION)
1047
 
        self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
1048
 
        self.my_config.set_user_option('foo', 'qux')
1049
 
        self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
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
 
 
1059
 
 
1060
 
precedence_global = 'option = global'
1061
 
precedence_branch = 'option = branch'
1062
 
precedence_location = """
1063
 
[http://]
1064
 
recurse = true
1065
 
option = recurse
1066
 
[http://example.com/specific]
1067
 
option = exact
1068
 
"""
1069
 
 
1070
 
 
1071
 
class TestBranchConfigItems(tests.TestCaseInTempDir):
1072
 
 
1073
 
    def get_branch_config(self, global_config=None, location=None,
1074
 
                          location_config=None, branch_data_config=None):
1075
 
        my_config = config.BranchConfig(FakeBranch(location))
1076
 
        if global_config is not None:
1077
 
            global_file = StringIO(global_config.encode('utf-8'))
1078
 
            my_config._get_global_config()._get_parser(global_file)
1079
 
        self.my_location_config = my_config._get_location_config()
1080
 
        if location_config is not None:
1081
 
            location_file = StringIO(location_config.encode('utf-8'))
1082
 
            self.my_location_config._get_parser(location_file)
1083
 
        if branch_data_config is not None:
1084
 
            my_config.branch.control_files.files['branch.conf'] = \
1085
 
                branch_data_config
1086
 
        return my_config
 
576
 
 
577
class TestBranchConfigItems(TestCase):
1087
578
 
1088
579
    def test_user_id(self):
1089
 
        branch = FakeBranch(user_id='Robert Collins <robertc@example.net>')
 
580
        branch = FakeBranch()
1090
581
        my_config = config.BranchConfig(branch)
1091
582
        self.assertEqual("Robert Collins <robertc@example.net>",
1092
 
                         my_config.username())
1093
 
        my_config.branch.control_files.files['email'] = "John"
1094
 
        my_config.set_user_option('email',
1095
 
                                  "Robert Collins <robertc@example.org>")
1096
 
        self.assertEqual("John", my_config.username())
1097
 
        del my_config.branch.control_files.files['email']
1098
 
        self.assertEqual("Robert Collins <robertc@example.org>",
1099
 
                         my_config.username())
 
583
                         my_config._get_user_id())
 
584
        branch.control_files.email = "John"
 
585
        self.assertEqual("John", my_config._get_user_id())
1100
586
 
1101
587
    def test_not_set_in_branch(self):
1102
 
        my_config = self.get_branch_config(sample_config_text)
 
588
        branch = FakeBranch()
 
589
        my_config = config.BranchConfig(branch)
 
590
        branch.control_files.email = None
 
591
        config_file = StringIO(sample_config_text.encode('utf-8'))
 
592
        (my_config._get_location_config().
 
593
            _get_global_config()._get_parser(config_file))
1103
594
        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
1104
595
                         my_config._get_user_id())
1105
 
        my_config.branch.control_files.files['email'] = "John"
 
596
        branch.control_files.email = "John"
1106
597
        self.assertEqual("John", my_config._get_user_id())
1107
598
 
1108
 
    def test_BZR_EMAIL_OVERRIDES(self):
1109
 
        os.environ['BZR_EMAIL'] = "Robert Collins <robertc@example.org>"
 
599
    def test_BZREMAIL_OVERRIDES(self):
 
600
        os.environ['BZREMAIL'] = "Robert Collins <robertc@example.org>"
1110
601
        branch = FakeBranch()
1111
602
        my_config = config.BranchConfig(branch)
1112
603
        self.assertEqual("Robert Collins <robertc@example.org>",
1113
604
                         my_config.username())
1114
 
 
 
605
    
1115
606
    def test_signatures_forced(self):
1116
 
        my_config = self.get_branch_config(
1117
 
            global_config=sample_always_signatures)
1118
 
        self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
1119
 
        self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
1120
 
        self.assertTrue(my_config.signature_needed())
1121
 
 
1122
 
    def test_signatures_forced_branch(self):
1123
 
        my_config = self.get_branch_config(
1124
 
            global_config=sample_ignore_signatures,
1125
 
            branch_data_config=sample_always_signatures)
1126
 
        self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
1127
 
        self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
1128
 
        self.assertTrue(my_config.signature_needed())
 
607
        branch = FakeBranch()
 
608
        my_config = config.BranchConfig(branch)
 
609
        config_file = StringIO(sample_always_signatures)
 
610
        (my_config._get_location_config().
 
611
            _get_global_config()._get_parser(config_file))
 
612
        self.assertEqual(config.CHECK_ALWAYS, my_config.signature_checking())
1129
613
 
1130
614
    def test_gpg_signing_command(self):
1131
 
        my_config = self.get_branch_config(
1132
 
            # branch data cannot set gpg_signing_command
1133
 
            branch_data_config="gpg_signing_command=pgp")
 
615
        branch = FakeBranch()
 
616
        my_config = config.BranchConfig(branch)
1134
617
        config_file = StringIO(sample_config_text.encode('utf-8'))
1135
 
        my_config._get_global_config()._get_parser(config_file)
 
618
        (my_config._get_location_config().
 
619
            _get_global_config()._get_parser(config_file))
1136
620
        self.assertEqual('gnome-gpg', my_config.gpg_signing_command())
1137
621
 
1138
622
    def test_get_user_option_global(self):
1139
623
        branch = FakeBranch()
1140
624
        my_config = config.BranchConfig(branch)
1141
625
        config_file = StringIO(sample_config_text.encode('utf-8'))
1142
 
        (my_config._get_global_config()._get_parser(config_file))
 
626
        (my_config._get_location_config().
 
627
            _get_global_config()._get_parser(config_file))
1143
628
        self.assertEqual('something',
1144
629
                         my_config.get_user_option('user_global_option'))
1145
630
 
1146
631
    def test_post_commit_default(self):
1147
632
        branch = FakeBranch()
1148
 
        my_config = self.get_branch_config(sample_config_text, '/a/c',
1149
 
                                           sample_branches_text)
1150
 
        self.assertEqual(my_config.branch.base, '/a/c')
1151
 
        self.assertEqual('bzrlib.tests.test_config.post_commit',
1152
 
                         my_config.post_commit())
1153
 
        my_config.set_user_option('post_commit', 'rmtree_root')
1154
 
        # post-commit is ignored when bresent in branch data
1155
 
        self.assertEqual('bzrlib.tests.test_config.post_commit',
1156
 
                         my_config.post_commit())
1157
 
        my_config.set_user_option('post_commit', 'rmtree_root',
1158
 
                                  store=config.STORE_LOCATION)
1159
 
        self.assertEqual('rmtree_root', my_config.post_commit())
1160
 
 
1161
 
    def test_config_precedence(self):
1162
 
        my_config = self.get_branch_config(global_config=precedence_global)
1163
 
        self.assertEqual(my_config.get_user_option('option'), 'global')
1164
 
        my_config = self.get_branch_config(global_config=precedence_global,
1165
 
                                      branch_data_config=precedence_branch)
1166
 
        self.assertEqual(my_config.get_user_option('option'), 'branch')
1167
 
        my_config = self.get_branch_config(global_config=precedence_global,
1168
 
                                      branch_data_config=precedence_branch,
1169
 
                                      location_config=precedence_location)
1170
 
        self.assertEqual(my_config.get_user_option('option'), 'recurse')
1171
 
        my_config = self.get_branch_config(global_config=precedence_global,
1172
 
                                      branch_data_config=precedence_branch,
1173
 
                                      location_config=precedence_location,
1174
 
                                      location='http://example.com/specific')
1175
 
        self.assertEqual(my_config.get_user_option('option'), 'exact')
1176
 
 
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):
 
633
        branch.base='/a/c'
 
634
        my_config = config.BranchConfig(branch)
 
635
        config_file = StringIO(sample_config_text.encode('utf-8'))
 
636
        (my_config._get_location_config().
 
637
            _get_global_config()._get_parser(config_file))
 
638
        branch_file = StringIO(sample_branches_text)
 
639
        my_config._get_location_config()._get_parser(branch_file)
 
640
        self.assertEqual('bzrlib.tests.test_config.post_commit',
 
641
                         my_config.post_commit())
 
642
 
 
643
 
 
644
class TestMailAddressExtraction(TestCase):
1221
645
 
1222
646
    def test_extract_email_address(self):
1223
647
        self.assertEqual('jane@test.com',
1224
648
                         config.extract_email_address('Jane <jane@test.com>'))
1225
 
        self.assertRaises(errors.NoEmailInUsername,
 
649
        self.assertRaises(errors.BzrError,
1226
650
                          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