← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/testconfig.py

  • Committer: Robert Collins
  • Date: 2005-10-17 11:56:54 UTC
  • mfrom: (1185.16.59)
  • Revision ID: robertc@robertcollins.net-20051017115654-662239e1587524a8
merge from martin.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/testconfig.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005 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 ConfigParser import ConfigParser
19
21
from cStringIO import StringIO
20
22
import os
21
23
import sys
22
 
import threading
23
 
 
24
 
 
25
 
from testtools import matchers
26
24
 
27
25
#import bzrlib specific imports here
28
 
from bzrlib import (
29
 
    branch,
30
 
    bzrdir,
31
 
    config,
32
 
    diff,
33
 
    errors,
34
 
    osutils,
35
 
    mail_client,
36
 
    mergetools,
37
 
    ui,
38
 
    urlutils,
39
 
    registry,
40
 
    remote,
41
 
    tests,
42
 
    trace,
43
 
    transport,
44
 
    )
45
 
from bzrlib.symbol_versioning import (
46
 
    deprecated_in,
47
 
    deprecated_method,
48
 
    )
49
 
from bzrlib.transport import remote as transport_remote
50
 
from bzrlib.tests import (
51
 
    features,
52
 
    scenarios,
53
 
    test_server,
54
 
    )
55
 
from bzrlib.util.configobj import configobj
56
 
 
57
 
 
58
 
def lockable_config_scenarios():
59
 
    return [
60
 
        ('global',
61
 
         {'config_class': config.GlobalConfig,
62
 
          'config_args': [],
63
 
          'config_section': 'DEFAULT'}),
64
 
        ('locations',
65
 
         {'config_class': config.LocationConfig,
66
 
          'config_args': ['.'],
67
 
          'config_section': '.'}),]
68
 
 
69
 
 
70
 
load_tests = scenarios.load_tests_apply_scenarios
71
 
 
72
 
# Register helpers to build stores
73
 
config.test_store_builder_registry.register(
74
 
    'configobj', lambda test: config.IniFileStore(test.get_transport(),
75
 
                                                  'configobj.conf'))
76
 
config.test_store_builder_registry.register(
77
 
    'bazaar', lambda test: config.GlobalStore())
78
 
config.test_store_builder_registry.register(
79
 
    'location', lambda test: config.LocationStore())
80
 
 
81
 
 
82
 
def build_backing_branch(test, relpath,
83
 
                         transport_class=None, server_class=None):
84
 
    """Test helper to create a backing branch only once.
85
 
 
86
 
    Some tests needs multiple stores/stacks to check concurrent update
87
 
    behaviours. As such, they need to build different branch *objects* even if
88
 
    they share the branch on disk.
89
 
 
90
 
    :param relpath: The relative path to the branch. (Note that the helper
91
 
        should always specify the same relpath).
92
 
 
93
 
    :param transport_class: The Transport class the test needs to use.
94
 
 
95
 
    :param server_class: The server associated with the ``transport_class``
96
 
        above.
97
 
 
98
 
    Either both or neither of ``transport_class`` and ``server_class`` should
99
 
    be specified.
100
 
    """
101
 
    if transport_class is not None and server_class is not None:
102
 
        test.transport_class = transport_class
103
 
        test.transport_server = server_class
104
 
    elif not (transport_class is None and server_class is None):
105
 
        raise AssertionError('Specify both ``transport_class`` and '
106
 
                             '``server_class`` or neither of them')
107
 
    if getattr(test, 'backing_branch', None) is None:
108
 
        # First call, let's build the branch on disk
109
 
        test.backing_branch = test.make_branch(relpath)
110
 
 
111
 
 
112
 
def build_branch_store(test):
113
 
    build_backing_branch(test, 'branch')
114
 
    b = branch.Branch.open('branch')
115
 
    return config.BranchStore(b)
116
 
config.test_store_builder_registry.register('branch', build_branch_store)
117
 
 
118
 
 
119
 
def build_remote_branch_store(test):
120
 
    # There is only one permutation (but we won't be able to handle more with
121
 
    # this design anyway)
122
 
    (transport_class,
123
 
     server_class) = transport_remote.get_test_permutations()[0]
124
 
    build_backing_branch(test, 'branch', transport_class, server_class)
125
 
    b = branch.Branch.open(test.get_url('branch'))
126
 
    return config.BranchStore(b)
127
 
config.test_store_builder_registry.register('remote_branch',
128
 
                                            build_remote_branch_store)
129
 
 
130
 
 
131
 
config.test_stack_builder_registry.register(
132
 
    'bazaar', lambda test: config.GlobalStack())
133
 
config.test_stack_builder_registry.register(
134
 
    'location', lambda test: config.LocationStack('.'))
135
 
 
136
 
 
137
 
def build_branch_stack(test):
138
 
    build_backing_branch(test, 'branch')
139
 
    b = branch.Branch.open('branch')
140
 
    return config.BranchStack(b)
141
 
config.test_stack_builder_registry.register('branch', build_branch_stack)
142
 
 
143
 
 
144
 
def build_remote_branch_stack(test):
145
 
    # There is only one permutation (but we won't be able to handle more with
146
 
    # this design anyway)
147
 
    (transport_class,
148
 
     server_class) = transport_remote.get_test_permutations()[0]
149
 
    build_backing_branch(test, 'branch', transport_class, server_class)
150
 
    b = branch.Branch.open(test.get_url('branch'))
151
 
    return config.BranchStack(b)
152
 
config.test_stack_builder_registry.register('remote_branch',
153
 
                                            build_remote_branch_stack)
154
 
 
155
 
 
156
 
sample_long_alias="log -r-15..-1 --line"
157
 
sample_config_text = u"""
158
 
[DEFAULT]
159
 
email=Erik B\u00e5gfors <erik@bagfors.nu>
160
 
editor=vim
161
 
change_editor=vimdiff -of @new_path @old_path
162
 
gpg_signing_command=gnome-gpg
163
 
gpg_signing_key=DD4D5088
164
 
log_format=short
165
 
validate_signatures_in_log=true
166
 
acceptable_keys=amy
167
 
user_global_option=something
168
 
bzr.mergetool.sometool=sometool {base} {this} {other} -o {result}
169
 
bzr.mergetool.funkytool=funkytool "arg with spaces" {this_temp}
170
 
bzr.default_mergetool=sometool
171
 
[ALIASES]
172
 
h=help
173
 
ll=""" + sample_long_alias + "\n"
174
 
 
175
 
 
176
 
sample_always_signatures = """
177
 
[DEFAULT]
178
 
check_signatures=ignore
179
 
create_signatures=always
180
 
"""
181
 
 
182
 
sample_ignore_signatures = """
183
 
[DEFAULT]
184
 
check_signatures=require
185
 
create_signatures=never
186
 
"""
187
 
 
188
 
sample_maybe_signatures = """
189
 
[DEFAULT]
190
 
check_signatures=ignore
191
 
create_signatures=when-required
192
 
"""
193
 
 
194
 
sample_branches_text = """
195
 
[http://www.example.com]
196
 
# Top level policy
197
 
email=Robert Collins <robertc@example.org>
198
 
normal_option = normal
199
 
appendpath_option = append
200
 
appendpath_option:policy = appendpath
201
 
norecurse_option = norecurse
202
 
norecurse_option:policy = norecurse
203
 
[http://www.example.com/ignoreparent]
204
 
# different project: ignore parent dir config
205
 
ignore_parents=true
206
 
[http://www.example.com/norecurse]
207
 
# configuration items that only apply to this dir
208
 
recurse=false
209
 
normal_option = norecurse
210
 
[http://www.example.com/dir]
211
 
appendpath_option = normal
212
 
[/b/]
213
 
check_signatures=require
214
 
# test trailing / matching with no children
215
 
[/a/]
216
 
check_signatures=check-available
217
 
gpg_signing_command=false
218
 
gpg_signing_key=default
219
 
user_local_option=local
220
 
# test trailing / matching
221
 
[/a/*]
222
 
#subdirs will match but not the parent
223
 
[/a/c]
224
 
check_signatures=ignore
225
 
post_commit=bzrlib.tests.test_config.post_commit
226
 
#testing explicit beats globs
227
 
"""
228
 
 
229
 
 
230
 
def create_configs(test):
231
 
    """Create configuration files for a given test.
232
 
 
233
 
    This requires creating a tree (and populate the ``test.tree`` attribute)
234
 
    and its associated branch and will populate the following attributes:
235
 
 
236
 
    - branch_config: A BranchConfig for the associated branch.
237
 
 
238
 
    - locations_config : A LocationConfig for the associated branch
239
 
 
240
 
    - bazaar_config: A GlobalConfig.
241
 
 
242
 
    The tree and branch are created in a 'tree' subdirectory so the tests can
243
 
    still use the test directory to stay outside of the branch.
244
 
    """
245
 
    tree = test.make_branch_and_tree('tree')
246
 
    test.tree = tree
247
 
    test.branch_config = config.BranchConfig(tree.branch)
248
 
    test.locations_config = config.LocationConfig(tree.basedir)
249
 
    test.bazaar_config = config.GlobalConfig()
250
 
 
251
 
 
252
 
def create_configs_with_file_option(test):
253
 
    """Create configuration files with a ``file`` option set in each.
254
 
 
255
 
    This builds on ``create_configs`` and add one ``file`` option in each
256
 
    configuration with a value which allows identifying the configuration file.
257
 
    """
258
 
    create_configs(test)
259
 
    test.bazaar_config.set_user_option('file', 'bazaar')
260
 
    test.locations_config.set_user_option('file', 'locations')
261
 
    test.branch_config.set_user_option('file', 'branch')
262
 
 
263
 
 
264
 
class TestOptionsMixin:
265
 
 
266
 
    def assertOptions(self, expected, conf):
267
 
        # We don't care about the parser (as it will make tests hard to write
268
 
        # and error-prone anyway)
269
 
        self.assertThat([opt[:4] for opt in conf._get_options()],
270
 
                        matchers.Equals(expected))
271
 
 
272
 
 
273
 
class InstrumentedConfigObj(object):
274
 
    """A config obj look-enough-alike to record calls made to it."""
275
 
 
276
 
    def __contains__(self, thing):
277
 
        self._calls.append(('__contains__', thing))
278
 
        return False
279
 
 
280
 
    def __getitem__(self, key):
281
 
        self._calls.append(('__getitem__', key))
282
 
        return self
283
 
 
284
 
    def __init__(self, input, encoding=None):
285
 
        self._calls = [('__init__', input, encoding)]
286
 
 
287
 
    def __setitem__(self, key, value):
288
 
        self._calls.append(('__setitem__', key, value))
289
 
 
290
 
    def __delitem__(self, key):
291
 
        self._calls.append(('__delitem__', key))
292
 
 
293
 
    def keys(self):
294
 
        self._calls.append(('keys',))
295
 
        return []
296
 
 
297
 
    def reload(self):
298
 
        self._calls.append(('reload',))
299
 
 
300
 
    def write(self, arg):
301
 
        self._calls.append(('write',))
302
 
 
303
 
    def as_bool(self, value):
304
 
        self._calls.append(('as_bool', value))
305
 
        return False
306
 
 
307
 
    def get_value(self, section, name):
308
 
        self._calls.append(('get_value', section, name))
309
 
        return None
 
26
import bzrlib.config as config
 
27
import bzrlib.errors as errors
 
28
from bzrlib.selftest import TestCase, TestCaseInTempDir
 
29
 
 
30
 
 
31
sample_config_text = ("[DEFAULT]\n"
 
32
                      "email=Robert Collins <robertc@example.com>\n"
 
33
                      "editor=vim\n"
 
34
                      "gpg_signing_command=gnome-gpg\n")
 
35
 
 
36
 
 
37
sample_always_signatures = ("[DEFAULT]\n"
 
38
                            "check_signatures=require\n")
 
39
 
 
40
 
 
41
sample_ignore_signatures = ("[DEFAULT]\n"
 
42
                            "check_signatures=ignore\n")
 
43
 
 
44
 
 
45
sample_maybe_signatures = ("[DEFAULT]\n"
 
46
                            "check_signatures=check-available\n")
 
47
 
 
48
 
 
49
sample_branches_text = ("[http://www.example.com]\n"
 
50
                        "# Top level policy\n"
 
51
                        "email=Robert Collins <robertc@example.org>\n"
 
52
                        "[http://www.example.com/useglobal]\n"
 
53
                        "# different project, forces global lookup\n"
 
54
                        "recurse=false\n"
 
55
                        "[/b/]\n"
 
56
                        "check_signatures=require\n"
 
57
                        "# test trailing / matching with no children\n"
 
58
                        "[/a/]\n"
 
59
                        "check_signatures=check-available\n"
 
60
                        "gpg_signing_command=false\n"
 
61
                        "# test trailing / matching\n"
 
62
                        "[/a/*]\n"
 
63
                        "#subdirs will match but not the parent\n"
 
64
                        "recurse=False\n"
 
65
                        "[/a/c]\n"
 
66
                        "check_signatures=ignore\n"
 
67
                        "#testing explicit beats globs\n")
 
68
 
 
69
 
 
70
class InstrumentedConfigParser(object):
 
71
    """A config parser look-enough-alike to record calls made to it."""
 
72
 
 
73
    def __init__(self):
 
74
        self._calls = []
 
75
 
 
76
    def read(self, filenames):
 
77
        self._calls.append(('read', filenames))
310
78
 
311
79
 
312
80
class FakeBranch(object):
313
81
 
314
 
    def __init__(self, base=None, user_id=None):
315
 
        if base is None:
316
 
            self.base = "http://example.com/branches/demo"
317
 
        else:
318
 
            self.base = base
319
 
        self._transport = self.control_files = \
320
 
            FakeControlFilesAndTransport(user_id=user_id)
321
 
 
322
 
    def _get_config(self):
323
 
        return config.TransportConfig(self._transport, 'branch.conf')
324
 
 
325
 
    def lock_write(self):
326
 
        pass
327
 
 
328
 
    def unlock(self):
329
 
        pass
330
 
 
331
 
 
332
 
class FakeControlFilesAndTransport(object):
333
 
 
334
 
    def __init__(self, user_id=None):
335
 
        self.files = {}
336
 
        if user_id:
337
 
            self.files['email'] = user_id
338
 
        self._transport = self
339
 
 
340
 
    def get_utf8(self, filename):
341
 
        # from LockableFiles
342
 
        raise AssertionError("get_utf8 should no longer be used")
343
 
 
344
 
    def get(self, filename):
345
 
        # from Transport
346
 
        try:
347
 
            return StringIO(self.files[filename])
348
 
        except KeyError:
349
 
            raise errors.NoSuchFile(filename)
350
 
 
351
 
    def get_bytes(self, filename):
352
 
        # from Transport
353
 
        try:
354
 
            return self.files[filename]
355
 
        except KeyError:
356
 
            raise errors.NoSuchFile(filename)
357
 
 
358
 
    def put(self, filename, fileobj):
359
 
        self.files[filename] = fileobj.read()
360
 
 
361
 
    def put_file(self, filename, fileobj):
362
 
        return self.put(filename, fileobj)
 
82
    def __init__(self):
 
83
        self.base = "http://example.com/branches/demo"
 
84
        self.email = 'Robert Collins <robertc@example.net>\n'
 
85
 
 
86
    def controlfile(self, filename, mode):
 
87
        if filename != 'email':
 
88
            raise NotImplementedError
 
89
        if self.email is not None:
 
90
            return StringIO(self.email)
 
91
        raise errors.NoSuchFile
363
92
 
364
93
 
365
94
class InstrumentedConfig(config.Config):
366
95
    """An instrumented config that supplies stubs for template methods."""
367
 
 
 
96
    
368
97
    def __init__(self):
369
98
        super(InstrumentedConfig, self).__init__()
370
99
        self._calls = []
378
107
        self._calls.append('_get_signature_checking')
379
108
        return self._signatures
380
109
 
381
 
    def _get_change_editor(self):
382
 
        self._calls.append('_get_change_editor')
383
 
        return 'vimdiff -fo @new_path @old_path'
384
 
 
385
 
 
386
 
bool_config = """[DEFAULT]
387
 
active = true
388
 
inactive = false
389
 
[UPPERCASE]
390
 
active = True
391
 
nonactive = False
392
 
"""
393
 
 
394
 
 
395
 
class TestConfigObj(tests.TestCase):
396
 
 
397
 
    def test_get_bool(self):
398
 
        co = config.ConfigObj(StringIO(bool_config))
399
 
        self.assertIs(co.get_bool('DEFAULT', 'active'), True)
400
 
        self.assertIs(co.get_bool('DEFAULT', 'inactive'), False)
401
 
        self.assertIs(co.get_bool('UPPERCASE', 'active'), True)
402
 
        self.assertIs(co.get_bool('UPPERCASE', 'nonactive'), False)
403
 
 
404
 
    def test_hash_sign_in_value(self):
405
 
        """
406
 
        Before 4.5.0, ConfigObj did not quote # signs in values, so they'd be
407
 
        treated as comments when read in again. (#86838)
408
 
        """
409
 
        co = config.ConfigObj()
410
 
        co['test'] = 'foo#bar'
411
 
        outfile = StringIO()
412
 
        co.write(outfile=outfile)
413
 
        lines = outfile.getvalue().splitlines()
414
 
        self.assertEqual(lines, ['test = "foo#bar"'])
415
 
        co2 = config.ConfigObj(lines)
416
 
        self.assertEqual(co2['test'], 'foo#bar')
417
 
 
418
 
    def test_triple_quotes(self):
419
 
        # Bug #710410: if the value string has triple quotes
420
 
        # then ConfigObj versions up to 4.7.2 will quote them wrong
421
 
        # and won't able to read them back
422
 
        triple_quotes_value = '''spam
423
 
""" that's my spam """
424
 
eggs'''
425
 
        co = config.ConfigObj()
426
 
        co['test'] = triple_quotes_value
427
 
        # While writing this test another bug in ConfigObj has been found:
428
 
        # method co.write() without arguments produces list of lines
429
 
        # one option per line, and multiline values are not split
430
 
        # across multiple lines,
431
 
        # and that breaks the parsing these lines back by ConfigObj.
432
 
        # This issue only affects test, but it's better to avoid
433
 
        # `co.write()` construct at all.
434
 
        # [bialix 20110222] bug report sent to ConfigObj's author
435
 
        outfile = StringIO()
436
 
        co.write(outfile=outfile)
437
 
        output = outfile.getvalue()
438
 
        # now we're trying to read it back
439
 
        co2 = config.ConfigObj(StringIO(output))
440
 
        self.assertEquals(triple_quotes_value, co2['test'])
441
 
 
442
 
 
443
 
erroneous_config = """[section] # line 1
444
 
good=good # line 2
445
 
[section] # line 3
446
 
whocares=notme # line 4
447
 
"""
448
 
 
449
 
 
450
 
class TestConfigObjErrors(tests.TestCase):
451
 
 
452
 
    def test_duplicate_section_name_error_line(self):
453
 
        try:
454
 
            co = configobj.ConfigObj(StringIO(erroneous_config),
455
 
                                     raise_errors=True)
456
 
        except config.configobj.DuplicateError, e:
457
 
            self.assertEqual(3, e.line_number)
458
 
        else:
459
 
            self.fail('Error in config file not detected')
460
 
 
461
 
 
462
 
class TestConfig(tests.TestCase):
 
110
 
 
111
class TestConfig(TestCase):
463
112
 
464
113
    def test_constructs(self):
465
114
        config.Config()
466
 
 
 
115
 
467
116
    def test_no_default_editor(self):
468
 
        self.assertRaises(
469
 
            NotImplementedError,
470
 
            self.applyDeprecated, deprecated_in((2, 4, 0)),
471
 
            config.Config().get_editor)
 
117
        self.assertRaises(NotImplementedError, config.Config().get_editor)
472
118
 
473
119
    def test_user_email(self):
474
120
        my_config = InstrumentedConfig()
483
129
 
484
130
    def test_signatures_default(self):
485
131
        my_config = config.Config()
486
 
        self.assertFalse(my_config.signature_needed())
487
132
        self.assertEqual(config.CHECK_IF_POSSIBLE,
488
133
                         my_config.signature_checking())
489
 
        self.assertEqual(config.SIGN_WHEN_REQUIRED,
490
 
                         my_config.signing_policy())
491
134
 
492
135
    def test_signatures_template_method(self):
493
136
        my_config = InstrumentedConfig()
505
148
        my_config = config.Config()
506
149
        self.assertEqual('gpg', my_config.gpg_signing_command())
507
150
 
508
 
    def test_get_user_option_default(self):
509
 
        my_config = config.Config()
510
 
        self.assertEqual(None, my_config.get_user_option('no_option'))
511
 
 
512
 
    def test_post_commit_default(self):
513
 
        my_config = config.Config()
514
 
        self.assertEqual(None, my_config.post_commit())
515
 
 
516
 
    def test_log_format_default(self):
517
 
        my_config = config.Config()
518
 
        self.assertEqual('long', my_config.log_format())
519
 
 
520
 
    def test_acceptable_keys_default(self):
521
 
        my_config = config.Config()
522
 
        self.assertEqual(None, my_config.acceptable_keys())
523
 
 
524
 
    def test_validate_signatures_in_log_default(self):
525
 
        my_config = config.Config()
526
 
        self.assertEqual(False, my_config.validate_signatures_in_log())
527
 
 
528
 
    def test_get_change_editor(self):
529
 
        my_config = InstrumentedConfig()
530
 
        change_editor = my_config.get_change_editor('old_tree', 'new_tree')
531
 
        self.assertEqual(['_get_change_editor'], my_config._calls)
532
 
        self.assertIs(diff.DiffFromTool, change_editor.__class__)
533
 
        self.assertEqual(['vimdiff', '-fo', '@new_path', '@old_path'],
534
 
                         change_editor.command_template)
535
 
 
536
 
 
537
 
class TestConfigPath(tests.TestCase):
 
151
 
 
152
class TestConfigPath(TestCase):
538
153
 
539
154
    def setUp(self):
540
155
        super(TestConfigPath, self).setUp()
541
 
        self.overrideEnv('HOME', '/home/bogus')
542
 
        self.overrideEnv('XDG_CACHE_DIR', '')
543
 
        if sys.platform == 'win32':
544
 
            self.overrideEnv(
545
 
                'BZR_HOME', r'C:\Documents and Settings\bogus\Application Data')
546
 
            self.bzr_home = \
547
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0'
548
 
        else:
549
 
            self.bzr_home = '/home/bogus/.bazaar'
 
156
        self.oldenv = os.environ.get('HOME', None)
 
157
        os.environ['HOME'] = '/home/bogus'
550
158
 
 
159
    def tearDown(self):
 
160
        os.environ['HOME'] = self.oldenv
 
161
        super(TestConfigPath, self).tearDown()
 
162
    
551
163
    def test_config_dir(self):
552
 
        self.assertEqual(config.config_dir(), self.bzr_home)
 
164
        self.assertEqual(config.config_dir(), '/home/bogus/.bazaar')
553
165
 
554
166
    def test_config_filename(self):
555
167
        self.assertEqual(config.config_filename(),
556
 
                         self.bzr_home + '/bazaar.conf')
557
 
 
558
 
    def test_locations_config_filename(self):
559
 
        self.assertEqual(config.locations_config_filename(),
560
 
                         self.bzr_home + '/locations.conf')
561
 
 
562
 
    def test_authentication_config_filename(self):
563
 
        self.assertEqual(config.authentication_config_filename(),
564
 
                         self.bzr_home + '/authentication.conf')
565
 
 
566
 
    def test_xdg_cache_dir(self):
567
 
        self.assertEqual(config.xdg_cache_dir(),
568
 
            '/home/bogus/.cache')
569
 
 
570
 
 
571
 
class TestXDGConfigDir(tests.TestCaseInTempDir):
572
 
    # must be in temp dir because config tests for the existence of the bazaar
573
 
    # subdirectory of $XDG_CONFIG_HOME
574
 
 
575
 
    def setUp(self):
576
 
        if sys.platform in ('darwin', 'win32'):
577
 
            raise tests.TestNotApplicable(
578
 
                'XDG config dir not used on this platform')
579
 
        super(TestXDGConfigDir, self).setUp()
580
 
        self.overrideEnv('HOME', self.test_home_dir)
581
 
        # BZR_HOME overrides everything we want to test so unset it.
582
 
        self.overrideEnv('BZR_HOME', None)
583
 
 
584
 
    def test_xdg_config_dir_exists(self):
585
 
        """When ~/.config/bazaar exists, use it as the config dir."""
586
 
        newdir = osutils.pathjoin(self.test_home_dir, '.config', 'bazaar')
587
 
        os.makedirs(newdir)
588
 
        self.assertEqual(config.config_dir(), newdir)
589
 
 
590
 
    def test_xdg_config_home(self):
591
 
        """When XDG_CONFIG_HOME is set, use it."""
592
 
        xdgconfigdir = osutils.pathjoin(self.test_home_dir, 'xdgconfig')
593
 
        self.overrideEnv('XDG_CONFIG_HOME', xdgconfigdir)
594
 
        newdir = osutils.pathjoin(xdgconfigdir, 'bazaar')
595
 
        os.makedirs(newdir)
596
 
        self.assertEqual(config.config_dir(), newdir)
597
 
 
598
 
 
599
 
class TestIniConfig(tests.TestCaseInTempDir):
600
 
 
601
 
    def make_config_parser(self, s):
602
 
        conf = config.IniBasedConfig.from_string(s)
603
 
        return conf, conf._get_parser()
604
 
 
605
 
 
606
 
class TestIniConfigBuilding(TestIniConfig):
 
168
                         '/home/bogus/.bazaar/bazaar.conf')
 
169
 
 
170
    def test_branches_config_filename(self):
 
171
        self.assertEqual(config.branches_config_filename(),
 
172
                         '/home/bogus/.bazaar/branches.conf')
 
173
 
 
174
class TestIniConfig(TestCase):
607
175
 
608
176
    def test_contructs(self):
609
 
        my_config = config.IniBasedConfig()
 
177
        my_config = config.IniBasedConfig("nothing")
610
178
 
611
179
    def test_from_fp(self):
612
 
        my_config = config.IniBasedConfig.from_string(sample_config_text)
613
 
        self.assertIsInstance(my_config._get_parser(), configobj.ConfigObj)
 
180
        config_file = StringIO(sample_config_text)
 
181
        my_config = config.IniBasedConfig(None)
 
182
        self.failUnless(
 
183
            isinstance(my_config._get_parser(file=config_file),
 
184
                        ConfigParser))
614
185
 
615
186
    def test_cached(self):
616
 
        my_config = config.IniBasedConfig.from_string(sample_config_text)
617
 
        parser = my_config._get_parser()
618
 
        self.assertTrue(my_config._get_parser() is parser)
619
 
 
620
 
    def _dummy_chown(self, path, uid, gid):
621
 
        self.path, self.uid, self.gid = path, uid, gid
622
 
 
623
 
    def test_ini_config_ownership(self):
624
 
        """Ensure that chown is happening during _write_config_file"""
625
 
        self.requireFeature(features.chown_feature)
626
 
        self.overrideAttr(os, 'chown', self._dummy_chown)
627
 
        self.path = self.uid = self.gid = None
628
 
        conf = config.IniBasedConfig(file_name='./foo.conf')
629
 
        conf._write_config_file()
630
 
        self.assertEquals(self.path, './foo.conf')
631
 
        self.assertTrue(isinstance(self.uid, int))
632
 
        self.assertTrue(isinstance(self.gid, int))
633
 
 
634
 
    def test_get_filename_parameter_is_deprecated_(self):
635
 
        conf = self.callDeprecated([
636
 
            'IniBasedConfig.__init__(get_filename) was deprecated in 2.3.'
637
 
            ' Use file_name instead.'],
638
 
            config.IniBasedConfig, lambda: 'ini.conf')
639
 
        self.assertEqual('ini.conf', conf.file_name)
640
 
 
641
 
    def test_get_parser_file_parameter_is_deprecated_(self):
642
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
643
 
        conf = config.IniBasedConfig.from_string(sample_config_text)
644
 
        conf = self.callDeprecated([
645
 
            'IniBasedConfig._get_parser(file=xxx) was deprecated in 2.3.'
646
 
            ' Use IniBasedConfig(_content=xxx) instead.'],
647
 
            conf._get_parser, file=config_file)
648
 
 
649
 
 
650
 
class TestIniConfigSaving(tests.TestCaseInTempDir):
651
 
 
652
 
    def test_cant_save_without_a_file_name(self):
653
 
        conf = config.IniBasedConfig()
654
 
        self.assertRaises(AssertionError, conf._write_config_file)
655
 
 
656
 
    def test_saved_with_content(self):
657
 
        content = 'foo = bar\n'
658
 
        conf = config.IniBasedConfig.from_string(
659
 
            content, file_name='./test.conf', save=True)
660
 
        self.assertFileEqual(content, 'test.conf')
661
 
 
662
 
 
663
 
class TestIniConfigOptionExpansionDefaultValue(tests.TestCaseInTempDir):
664
 
    """What is the default value of expand for config options.
665
 
 
666
 
    This is an opt-in beta feature used to evaluate whether or not option
667
 
    references can appear in dangerous place raising exceptions, disapearing
668
 
    (and as such corrupting data) or if it's safe to activate the option by
669
 
    default.
670
 
 
671
 
    Note that these tests relies on config._expand_default_value being already
672
 
    overwritten in the parent class setUp.
673
 
    """
674
 
 
675
 
    def setUp(self):
676
 
        super(TestIniConfigOptionExpansionDefaultValue, self).setUp()
677
 
        self.config = None
678
 
        self.warnings = []
679
 
        def warning(*args):
680
 
            self.warnings.append(args[0] % args[1:])
681
 
        self.overrideAttr(trace, 'warning', warning)
682
 
 
683
 
    def get_config(self, expand):
684
 
        c = config.GlobalConfig.from_string('bzr.config.expand=%s' % (expand,),
685
 
                                            save=True)
686
 
        return c
687
 
 
688
 
    def assertExpandIs(self, expected):
689
 
        actual = config._get_expand_default_value()
690
 
        #self.config.get_user_option_as_bool('bzr.config.expand')
691
 
        self.assertEquals(expected, actual)
692
 
 
693
 
    def test_default_is_None(self):
694
 
        self.assertEquals(None, config._expand_default_value)
695
 
 
696
 
    def test_default_is_False_even_if_None(self):
697
 
        self.config = self.get_config(None)
698
 
        self.assertExpandIs(False)
699
 
 
700
 
    def test_default_is_False_even_if_invalid(self):
701
 
        self.config = self.get_config('<your choice>')
702
 
        self.assertExpandIs(False)
703
 
        # ...
704
 
        # Huh ? My choice is False ? Thanks, always happy to hear that :D
705
 
        # Wait, you've been warned !
706
 
        self.assertLength(1, self.warnings)
707
 
        self.assertEquals(
708
 
            'Value "<your choice>" is not a boolean for "bzr.config.expand"',
709
 
            self.warnings[0])
710
 
 
711
 
    def test_default_is_True(self):
712
 
        self.config = self.get_config(True)
713
 
        self.assertExpandIs(True)
714
 
 
715
 
    def test_default_is_False(self):
716
 
        self.config = self.get_config(False)
717
 
        self.assertExpandIs(False)
718
 
 
719
 
 
720
 
class TestIniConfigOptionExpansion(tests.TestCase):
721
 
    """Test option expansion from the IniConfig level.
722
 
 
723
 
    What we really want here is to test the Config level, but the class being
724
 
    abstract as far as storing values is concerned, this can't be done
725
 
    properly (yet).
726
 
    """
727
 
    # FIXME: This should be rewritten when all configs share a storage
728
 
    # implementation -- vila 2011-02-18
729
 
 
730
 
    def get_config(self, string=None):
731
 
        if string is None:
732
 
            string = ''
733
 
        c = config.IniBasedConfig.from_string(string)
734
 
        return c
735
 
 
736
 
    def assertExpansion(self, expected, conf, string, env=None):
737
 
        self.assertEquals(expected, conf.expand_options(string, env))
738
 
 
739
 
    def test_no_expansion(self):
740
 
        c = self.get_config('')
741
 
        self.assertExpansion('foo', c, 'foo')
742
 
 
743
 
    def test_env_adding_options(self):
744
 
        c = self.get_config('')
745
 
        self.assertExpansion('bar', c, '{foo}', {'foo': 'bar'})
746
 
 
747
 
    def test_env_overriding_options(self):
748
 
        c = self.get_config('foo=baz')
749
 
        self.assertExpansion('bar', c, '{foo}', {'foo': 'bar'})
750
 
 
751
 
    def test_simple_ref(self):
752
 
        c = self.get_config('foo=xxx')
753
 
        self.assertExpansion('xxx', c, '{foo}')
754
 
 
755
 
    def test_unknown_ref(self):
756
 
        c = self.get_config('')
757
 
        self.assertRaises(errors.ExpandingUnknownOption,
758
 
                          c.expand_options, '{foo}')
759
 
 
760
 
    def test_indirect_ref(self):
761
 
        c = self.get_config('''
762
 
foo=xxx
763
 
bar={foo}
764
 
''')
765
 
        self.assertExpansion('xxx', c, '{bar}')
766
 
 
767
 
    def test_embedded_ref(self):
768
 
        c = self.get_config('''
769
 
foo=xxx
770
 
bar=foo
771
 
''')
772
 
        self.assertExpansion('xxx', c, '{{bar}}')
773
 
 
774
 
    def test_simple_loop(self):
775
 
        c = self.get_config('foo={foo}')
776
 
        self.assertRaises(errors.OptionExpansionLoop, c.expand_options, '{foo}')
777
 
 
778
 
    def test_indirect_loop(self):
779
 
        c = self.get_config('''
780
 
foo={bar}
781
 
bar={baz}
782
 
baz={foo}''')
783
 
        e = self.assertRaises(errors.OptionExpansionLoop,
784
 
                              c.expand_options, '{foo}')
785
 
        self.assertEquals('foo->bar->baz', e.refs)
786
 
        self.assertEquals('{foo}', e.string)
787
 
 
788
 
    def test_list(self):
789
 
        conf = self.get_config('''
790
 
foo=start
791
 
bar=middle
792
 
baz=end
793
 
list={foo},{bar},{baz}
794
 
''')
795
 
        self.assertEquals(['start', 'middle', 'end'],
796
 
                           conf.get_user_option('list', expand=True))
797
 
 
798
 
    def test_cascading_list(self):
799
 
        conf = self.get_config('''
800
 
foo=start,{bar}
801
 
bar=middle,{baz}
802
 
baz=end
803
 
list={foo}
804
 
''')
805
 
        self.assertEquals(['start', 'middle', 'end'],
806
 
                           conf.get_user_option('list', expand=True))
807
 
 
808
 
    def test_pathological_hidden_list(self):
809
 
        conf = self.get_config('''
810
 
foo=bin
811
 
bar=go
812
 
start={foo
813
 
middle=},{
814
 
end=bar}
815
 
hidden={start}{middle}{end}
816
 
''')
817
 
        # Nope, it's either a string or a list, and the list wins as soon as a
818
 
        # ',' appears, so the string concatenation never occur.
819
 
        self.assertEquals(['{foo', '}', '{', 'bar}'],
820
 
                          conf.get_user_option('hidden', expand=True))
821
 
 
822
 
class TestLocationConfigOptionExpansion(tests.TestCaseInTempDir):
823
 
 
824
 
    def get_config(self, location, string=None):
825
 
        if string is None:
826
 
            string = ''
827
 
        # Since we don't save the config we won't strictly require to inherit
828
 
        # from TestCaseInTempDir, but an error occurs so quickly...
829
 
        c = config.LocationConfig.from_string(string, location)
830
 
        return c
831
 
 
832
 
    def test_dont_cross_unrelated_section(self):
833
 
        c = self.get_config('/another/branch/path','''
834
 
[/one/branch/path]
835
 
foo = hello
836
 
bar = {foo}/2
837
 
 
838
 
[/another/branch/path]
839
 
bar = {foo}/2
840
 
''')
841
 
        self.assertRaises(errors.ExpandingUnknownOption,
842
 
                          c.get_user_option, 'bar', expand=True)
843
 
 
844
 
    def test_cross_related_sections(self):
845
 
        c = self.get_config('/project/branch/path','''
846
 
[/project]
847
 
foo = qu
848
 
 
849
 
[/project/branch/path]
850
 
bar = {foo}ux
851
 
''')
852
 
        self.assertEquals('quux', c.get_user_option('bar', expand=True))
853
 
 
854
 
 
855
 
class TestIniBaseConfigOnDisk(tests.TestCaseInTempDir):
856
 
 
857
 
    def test_cannot_reload_without_name(self):
858
 
        conf = config.IniBasedConfig.from_string(sample_config_text)
859
 
        self.assertRaises(AssertionError, conf.reload)
860
 
 
861
 
    def test_reload_see_new_value(self):
862
 
        c1 = config.IniBasedConfig.from_string('editor=vim\n',
863
 
                                               file_name='./test/conf')
864
 
        c1._write_config_file()
865
 
        c2 = config.IniBasedConfig.from_string('editor=emacs\n',
866
 
                                               file_name='./test/conf')
867
 
        c2._write_config_file()
868
 
        self.assertEqual('vim', c1.get_user_option('editor'))
869
 
        self.assertEqual('emacs', c2.get_user_option('editor'))
870
 
        # Make sure we get the Right value
871
 
        c1.reload()
872
 
        self.assertEqual('emacs', c1.get_user_option('editor'))
873
 
 
874
 
 
875
 
class TestLockableConfig(tests.TestCaseInTempDir):
876
 
 
877
 
    scenarios = lockable_config_scenarios()
878
 
 
879
 
    # Set by load_tests
880
 
    config_class = None
881
 
    config_args = None
882
 
    config_section = None
883
 
 
884
 
    def setUp(self):
885
 
        super(TestLockableConfig, self).setUp()
886
 
        self._content = '[%s]\none=1\ntwo=2\n' % (self.config_section,)
887
 
        self.config = self.create_config(self._content)
888
 
 
889
 
    def get_existing_config(self):
890
 
        return self.config_class(*self.config_args)
891
 
 
892
 
    def create_config(self, content):
893
 
        kwargs = dict(save=True)
894
 
        c = self.config_class.from_string(content, *self.config_args, **kwargs)
895
 
        return c
896
 
 
897
 
    def test_simple_read_access(self):
898
 
        self.assertEquals('1', self.config.get_user_option('one'))
899
 
 
900
 
    def test_simple_write_access(self):
901
 
        self.config.set_user_option('one', 'one')
902
 
        self.assertEquals('one', self.config.get_user_option('one'))
903
 
 
904
 
    def test_listen_to_the_last_speaker(self):
905
 
        c1 = self.config
906
 
        c2 = self.get_existing_config()
907
 
        c1.set_user_option('one', 'ONE')
908
 
        c2.set_user_option('two', 'TWO')
909
 
        self.assertEquals('ONE', c1.get_user_option('one'))
910
 
        self.assertEquals('TWO', c2.get_user_option('two'))
911
 
        # The second update respect the first one
912
 
        self.assertEquals('ONE', c2.get_user_option('one'))
913
 
 
914
 
    def test_last_speaker_wins(self):
915
 
        # If the same config is not shared, the same variable modified twice
916
 
        # can only see a single result.
917
 
        c1 = self.config
918
 
        c2 = self.get_existing_config()
919
 
        c1.set_user_option('one', 'c1')
920
 
        c2.set_user_option('one', 'c2')
921
 
        self.assertEquals('c2', c2._get_user_option('one'))
922
 
        # The first modification is still available until another refresh
923
 
        # occur
924
 
        self.assertEquals('c1', c1._get_user_option('one'))
925
 
        c1.set_user_option('two', 'done')
926
 
        self.assertEquals('c2', c1._get_user_option('one'))
927
 
 
928
 
    def test_writes_are_serialized(self):
929
 
        c1 = self.config
930
 
        c2 = self.get_existing_config()
931
 
 
932
 
        # We spawn a thread that will pause *during* the write
933
 
        before_writing = threading.Event()
934
 
        after_writing = threading.Event()
935
 
        writing_done = threading.Event()
936
 
        c1_orig = c1._write_config_file
937
 
        def c1_write_config_file():
938
 
            before_writing.set()
939
 
            c1_orig()
940
 
            # The lock is held. We wait for the main thread to decide when to
941
 
            # continue
942
 
            after_writing.wait()
943
 
        c1._write_config_file = c1_write_config_file
944
 
        def c1_set_option():
945
 
            c1.set_user_option('one', 'c1')
946
 
            writing_done.set()
947
 
        t1 = threading.Thread(target=c1_set_option)
948
 
        # Collect the thread after the test
949
 
        self.addCleanup(t1.join)
950
 
        # Be ready to unblock the thread if the test goes wrong
951
 
        self.addCleanup(after_writing.set)
952
 
        t1.start()
953
 
        before_writing.wait()
954
 
        self.assertTrue(c1._lock.is_held)
955
 
        self.assertRaises(errors.LockContention,
956
 
                          c2.set_user_option, 'one', 'c2')
957
 
        self.assertEquals('c1', c1.get_user_option('one'))
958
 
        # Let the lock be released
959
 
        after_writing.set()
960
 
        writing_done.wait()
961
 
        c2.set_user_option('one', 'c2')
962
 
        self.assertEquals('c2', c2.get_user_option('one'))
963
 
 
964
 
    def test_read_while_writing(self):
965
 
       c1 = self.config
966
 
       # We spawn a thread that will pause *during* the write
967
 
       ready_to_write = threading.Event()
968
 
       do_writing = threading.Event()
969
 
       writing_done = threading.Event()
970
 
       c1_orig = c1._write_config_file
971
 
       def c1_write_config_file():
972
 
           ready_to_write.set()
973
 
           # The lock is held. We wait for the main thread to decide when to
974
 
           # continue
975
 
           do_writing.wait()
976
 
           c1_orig()
977
 
           writing_done.set()
978
 
       c1._write_config_file = c1_write_config_file
979
 
       def c1_set_option():
980
 
           c1.set_user_option('one', 'c1')
981
 
       t1 = threading.Thread(target=c1_set_option)
982
 
       # Collect the thread after the test
983
 
       self.addCleanup(t1.join)
984
 
       # Be ready to unblock the thread if the test goes wrong
985
 
       self.addCleanup(do_writing.set)
986
 
       t1.start()
987
 
       # Ensure the thread is ready to write
988
 
       ready_to_write.wait()
989
 
       self.assertTrue(c1._lock.is_held)
990
 
       self.assertEquals('c1', c1.get_user_option('one'))
991
 
       # If we read during the write, we get the old value
992
 
       c2 = self.get_existing_config()
993
 
       self.assertEquals('1', c2.get_user_option('one'))
994
 
       # Let the writing occur and ensure it occurred
995
 
       do_writing.set()
996
 
       writing_done.wait()
997
 
       # Now we get the updated value
998
 
       c3 = self.get_existing_config()
999
 
       self.assertEquals('c1', c3.get_user_option('one'))
1000
 
 
1001
 
 
1002
 
class TestGetUserOptionAs(TestIniConfig):
1003
 
 
1004
 
    def test_get_user_option_as_bool(self):
1005
 
        conf, parser = self.make_config_parser("""
1006
 
a_true_bool = true
1007
 
a_false_bool = 0
1008
 
an_invalid_bool = maybe
1009
 
a_list = hmm, who knows ? # This is interpreted as a list !
1010
 
""")
1011
 
        get_bool = conf.get_user_option_as_bool
1012
 
        self.assertEqual(True, get_bool('a_true_bool'))
1013
 
        self.assertEqual(False, get_bool('a_false_bool'))
1014
 
        warnings = []
1015
 
        def warning(*args):
1016
 
            warnings.append(args[0] % args[1:])
1017
 
        self.overrideAttr(trace, 'warning', warning)
1018
 
        msg = 'Value "%s" is not a boolean for "%s"'
1019
 
        self.assertIs(None, get_bool('an_invalid_bool'))
1020
 
        self.assertEquals(msg % ('maybe', 'an_invalid_bool'), warnings[0])
1021
 
        warnings = []
1022
 
        self.assertIs(None, get_bool('not_defined_in_this_config'))
1023
 
        self.assertEquals([], warnings)
1024
 
 
1025
 
    def test_get_user_option_as_list(self):
1026
 
        conf, parser = self.make_config_parser("""
1027
 
a_list = a,b,c
1028
 
length_1 = 1,
1029
 
one_item = x
1030
 
""")
1031
 
        get_list = conf.get_user_option_as_list
1032
 
        self.assertEqual(['a', 'b', 'c'], get_list('a_list'))
1033
 
        self.assertEqual(['1'], get_list('length_1'))
1034
 
        self.assertEqual('x', conf.get_user_option('one_item'))
1035
 
        # automatically cast to list
1036
 
        self.assertEqual(['x'], get_list('one_item'))
1037
 
 
1038
 
 
1039
 
class TestSupressWarning(TestIniConfig):
1040
 
 
1041
 
    def make_warnings_config(self, s):
1042
 
        conf, parser = self.make_config_parser(s)
1043
 
        return conf.suppress_warning
1044
 
 
1045
 
    def test_suppress_warning_unknown(self):
1046
 
        suppress_warning = self.make_warnings_config('')
1047
 
        self.assertEqual(False, suppress_warning('unknown_warning'))
1048
 
 
1049
 
    def test_suppress_warning_known(self):
1050
 
        suppress_warning = self.make_warnings_config('suppress_warnings=a,b')
1051
 
        self.assertEqual(False, suppress_warning('c'))
1052
 
        self.assertEqual(True, suppress_warning('a'))
1053
 
        self.assertEqual(True, suppress_warning('b'))
1054
 
 
1055
 
 
1056
 
class TestGetConfig(tests.TestCase):
 
187
        config_file = StringIO(sample_config_text)
 
188
        my_config = config.IniBasedConfig(None)
 
189
        parser = my_config._get_parser(file=config_file)
 
190
        self.failUnless(my_config._get_parser() is parser)
 
191
 
 
192
 
 
193
class TestGetConfig(TestCase):
1057
194
 
1058
195
    def test_constructs(self):
1059
196
        my_config = config.GlobalConfig()
1060
197
 
1061
198
    def test_calls_read_filenames(self):
1062
 
        # replace the class that is constructed, to check its parameters
1063
 
        oldparserclass = config.ConfigObj
1064
 
        config.ConfigObj = InstrumentedConfigObj
 
199
        # replace the class that is constructured, to check its parameters
 
200
        oldparserclass = config.ConfigParser
 
201
        config.ConfigParser = InstrumentedConfigParser
1065
202
        my_config = config.GlobalConfig()
1066
203
        try:
1067
204
            parser = my_config._get_parser()
1068
205
        finally:
1069
 
            config.ConfigObj = oldparserclass
1070
 
        self.assertIsInstance(parser, InstrumentedConfigObj)
1071
 
        self.assertEqual(parser._calls, [('__init__', config.config_filename(),
1072
 
                                          'utf-8')])
1073
 
 
1074
 
 
1075
 
class TestBranchConfig(tests.TestCaseWithTransport):
 
206
            config.ConfigParser = oldparserclass
 
207
        self.failUnless(isinstance(parser, InstrumentedConfigParser))
 
208
        self.assertEqual(parser._calls, [('read', [config.config_filename()])])
 
209
 
 
210
 
 
211
class TestBranchConfig(TestCaseInTempDir):
1076
212
 
1077
213
    def test_constructs(self):
1078
214
        branch = FakeBranch()
1084
220
        my_config = config.BranchConfig(branch)
1085
221
        location_config = my_config._get_location_config()
1086
222
        self.assertEqual(branch.base, location_config.location)
1087
 
        self.assertIs(location_config, my_config._get_location_config())
1088
 
 
1089
 
    def test_get_config(self):
1090
 
        """The Branch.get_config method works properly"""
1091
 
        b = bzrdir.BzrDir.create_standalone_workingtree('.').branch
1092
 
        my_config = b.get_config()
1093
 
        self.assertIs(my_config.get_user_option('wacky'), None)
1094
 
        my_config.set_user_option('wacky', 'unlikely')
1095
 
        self.assertEqual(my_config.get_user_option('wacky'), 'unlikely')
1096
 
 
1097
 
        # Ensure we get the same thing if we start again
1098
 
        b2 = branch.Branch.open('.')
1099
 
        my_config2 = b2.get_config()
1100
 
        self.assertEqual(my_config2.get_user_option('wacky'), 'unlikely')
1101
 
 
1102
 
    def test_has_explicit_nickname(self):
1103
 
        b = self.make_branch('.')
1104
 
        self.assertFalse(b.get_config().has_explicit_nickname())
1105
 
        b.nick = 'foo'
1106
 
        self.assertTrue(b.get_config().has_explicit_nickname())
1107
 
 
1108
 
    def test_config_url(self):
1109
 
        """The Branch.get_config will use section that uses a local url"""
1110
 
        branch = self.make_branch('branch')
1111
 
        self.assertEqual('branch', branch.nick)
1112
 
 
1113
 
        local_url = urlutils.local_path_to_url('branch')
1114
 
        conf = config.LocationConfig.from_string(
1115
 
            '[%s]\nnickname = foobar' % (local_url,),
1116
 
            local_url, save=True)
1117
 
        self.assertEqual('foobar', branch.nick)
1118
 
 
1119
 
    def test_config_local_path(self):
1120
 
        """The Branch.get_config will use a local system path"""
1121
 
        branch = self.make_branch('branch')
1122
 
        self.assertEqual('branch', branch.nick)
1123
 
 
1124
 
        local_path = osutils.getcwd().encode('utf8')
1125
 
        conf = config.LocationConfig.from_string(
1126
 
            '[%s/branch]\nnickname = barry' % (local_path,),
1127
 
            'branch',  save=True)
1128
 
        self.assertEqual('barry', branch.nick)
1129
 
 
1130
 
    def test_config_creates_local(self):
1131
 
        """Creating a new entry in config uses a local path."""
1132
 
        branch = self.make_branch('branch', format='knit')
1133
 
        branch.set_push_location('http://foobar')
1134
 
        local_path = osutils.getcwd().encode('utf8')
1135
 
        # Surprisingly ConfigObj doesn't create a trailing newline
1136
 
        self.check_file_contents(config.locations_config_filename(),
1137
 
                                 '[%s/branch]\n'
1138
 
                                 'push_location = http://foobar\n'
1139
 
                                 'push_location:policy = norecurse\n'
1140
 
                                 % (local_path,))
1141
 
 
1142
 
    def test_autonick_urlencoded(self):
1143
 
        b = self.make_branch('!repo')
1144
 
        self.assertEqual('!repo', b.get_config().get_nickname())
1145
 
 
1146
 
    def test_warn_if_masked(self):
1147
 
        warnings = []
1148
 
        def warning(*args):
1149
 
            warnings.append(args[0] % args[1:])
1150
 
        self.overrideAttr(trace, 'warning', warning)
1151
 
 
1152
 
        def set_option(store, warn_masked=True):
1153
 
            warnings[:] = []
1154
 
            conf.set_user_option('example_option', repr(store), store=store,
1155
 
                                 warn_masked=warn_masked)
1156
 
        def assertWarning(warning):
1157
 
            if warning is None:
1158
 
                self.assertEqual(0, len(warnings))
1159
 
            else:
1160
 
                self.assertEqual(1, len(warnings))
1161
 
                self.assertEqual(warning, warnings[0])
1162
 
        branch = self.make_branch('.')
1163
 
        conf = branch.get_config()
1164
 
        set_option(config.STORE_GLOBAL)
1165
 
        assertWarning(None)
1166
 
        set_option(config.STORE_BRANCH)
1167
 
        assertWarning(None)
1168
 
        set_option(config.STORE_GLOBAL)
1169
 
        assertWarning('Value "4" is masked by "3" from branch.conf')
1170
 
        set_option(config.STORE_GLOBAL, warn_masked=False)
1171
 
        assertWarning(None)
1172
 
        set_option(config.STORE_LOCATION)
1173
 
        assertWarning(None)
1174
 
        set_option(config.STORE_BRANCH)
1175
 
        assertWarning('Value "3" is masked by "0" from locations.conf')
1176
 
        set_option(config.STORE_BRANCH, warn_masked=False)
1177
 
        assertWarning(None)
1178
 
 
1179
 
 
1180
 
class TestGlobalConfigItems(tests.TestCaseInTempDir):
 
223
        self.failUnless(location_config is my_config._get_location_config())
 
224
 
 
225
 
 
226
class TestGlobalConfigItems(TestCase):
1181
227
 
1182
228
    def test_user_id(self):
1183
 
        my_config = config.GlobalConfig.from_string(sample_config_text)
1184
 
        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
 
229
        config_file = StringIO(sample_config_text)
 
230
        my_config = config.GlobalConfig()
 
231
        my_config._parser = my_config._get_parser(file=config_file)
 
232
        self.assertEqual("Robert Collins <robertc@example.com>",
1185
233
                         my_config._get_user_id())
1186
234
 
1187
235
    def test_absent_user_id(self):
 
236
        config_file = StringIO("")
1188
237
        my_config = config.GlobalConfig()
 
238
        my_config._parser = my_config._get_parser(file=config_file)
1189
239
        self.assertEqual(None, my_config._get_user_id())
1190
240
 
1191
241
    def test_configured_editor(self):
1192
 
        my_config = config.GlobalConfig.from_string(sample_config_text)
1193
 
        editor = self.applyDeprecated(
1194
 
            deprecated_in((2, 4, 0)), my_config.get_editor)
1195
 
        self.assertEqual('vim', editor)
 
242
        config_file = StringIO(sample_config_text)
 
243
        my_config = config.GlobalConfig()
 
244
        my_config._parser = my_config._get_parser(file=config_file)
 
245
        self.assertEqual("vim", my_config.get_editor())
1196
246
 
1197
247
    def test_signatures_always(self):
1198
 
        my_config = config.GlobalConfig.from_string(sample_always_signatures)
1199
 
        self.assertEqual(config.CHECK_NEVER,
 
248
        config_file = StringIO(sample_always_signatures)
 
249
        my_config = config.GlobalConfig()
 
250
        my_config._parser = my_config._get_parser(file=config_file)
 
251
        self.assertEqual(config.CHECK_ALWAYS,
1200
252
                         my_config.signature_checking())
1201
 
        self.assertEqual(config.SIGN_ALWAYS,
1202
 
                         my_config.signing_policy())
1203
253
        self.assertEqual(True, my_config.signature_needed())
1204
254
 
1205
255
    def test_signatures_if_possible(self):
1206
 
        my_config = config.GlobalConfig.from_string(sample_maybe_signatures)
1207
 
        self.assertEqual(config.CHECK_NEVER,
 
256
        config_file = StringIO(sample_maybe_signatures)
 
257
        my_config = config.GlobalConfig()
 
258
        my_config._parser = my_config._get_parser(file=config_file)
 
259
        self.assertEqual(config.CHECK_IF_POSSIBLE,
1208
260
                         my_config.signature_checking())
1209
 
        self.assertEqual(config.SIGN_WHEN_REQUIRED,
1210
 
                         my_config.signing_policy())
1211
261
        self.assertEqual(False, my_config.signature_needed())
1212
262
 
1213
263
    def test_signatures_ignore(self):
1214
 
        my_config = config.GlobalConfig.from_string(sample_ignore_signatures)
1215
 
        self.assertEqual(config.CHECK_ALWAYS,
 
264
        config_file = StringIO(sample_ignore_signatures)
 
265
        my_config = config.GlobalConfig()
 
266
        my_config._parser = my_config._get_parser(file=config_file)
 
267
        self.assertEqual(config.CHECK_NEVER,
1216
268
                         my_config.signature_checking())
1217
 
        self.assertEqual(config.SIGN_NEVER,
1218
 
                         my_config.signing_policy())
1219
269
        self.assertEqual(False, my_config.signature_needed())
1220
270
 
1221
 
    def _get_sample_config(self):
1222
 
        my_config = config.GlobalConfig.from_string(sample_config_text)
1223
 
        return my_config
1224
 
 
1225
271
    def test_gpg_signing_command(self):
1226
 
        my_config = self._get_sample_config()
 
272
        config_file = StringIO(sample_config_text)
 
273
        my_config = config.GlobalConfig()
 
274
        my_config._parser = my_config._get_parser(file=config_file)
1227
275
        self.assertEqual("gnome-gpg", my_config.gpg_signing_command())
1228
276
        self.assertEqual(False, my_config.signature_needed())
1229
277
 
1230
 
    def test_gpg_signing_key(self):
1231
 
        my_config = self._get_sample_config()
1232
 
        self.assertEqual("DD4D5088", my_config.gpg_signing_key())
1233
 
 
1234
 
    def _get_empty_config(self):
1235
 
        my_config = config.GlobalConfig()
1236
 
        return my_config
1237
 
 
1238
278
    def test_gpg_signing_command_unset(self):
1239
 
        my_config = self._get_empty_config()
 
279
        config_file = StringIO("")
 
280
        my_config = config.GlobalConfig()
 
281
        my_config._parser = my_config._get_parser(file=config_file)
1240
282
        self.assertEqual("gpg", my_config.gpg_signing_command())
1241
283
 
1242
 
    def test_get_user_option_default(self):
1243
 
        my_config = self._get_empty_config()
1244
 
        self.assertEqual(None, my_config.get_user_option('no_option'))
1245
 
 
1246
 
    def test_get_user_option_global(self):
1247
 
        my_config = self._get_sample_config()
1248
 
        self.assertEqual("something",
1249
 
                         my_config.get_user_option('user_global_option'))
1250
 
 
1251
 
    def test_post_commit_default(self):
1252
 
        my_config = self._get_sample_config()
1253
 
        self.assertEqual(None, my_config.post_commit())
1254
 
 
1255
 
    def test_configured_logformat(self):
1256
 
        my_config = self._get_sample_config()
1257
 
        self.assertEqual("short", my_config.log_format())
1258
 
 
1259
 
    def test_configured_acceptable_keys(self):
1260
 
        my_config = self._get_sample_config()
1261
 
        self.assertEqual("amy", my_config.acceptable_keys())
1262
 
 
1263
 
    def test_configured_validate_signatures_in_log(self):
1264
 
        my_config = self._get_sample_config()
1265
 
        self.assertEqual(True, my_config.validate_signatures_in_log())
1266
 
 
1267
 
    def test_get_alias(self):
1268
 
        my_config = self._get_sample_config()
1269
 
        self.assertEqual('help', my_config.get_alias('h'))
1270
 
 
1271
 
    def test_get_aliases(self):
1272
 
        my_config = self._get_sample_config()
1273
 
        aliases = my_config.get_aliases()
1274
 
        self.assertEqual(2, len(aliases))
1275
 
        sorted_keys = sorted(aliases)
1276
 
        self.assertEqual('help', aliases[sorted_keys[0]])
1277
 
        self.assertEqual(sample_long_alias, aliases[sorted_keys[1]])
1278
 
 
1279
 
    def test_get_no_alias(self):
1280
 
        my_config = self._get_sample_config()
1281
 
        self.assertEqual(None, my_config.get_alias('foo'))
1282
 
 
1283
 
    def test_get_long_alias(self):
1284
 
        my_config = self._get_sample_config()
1285
 
        self.assertEqual(sample_long_alias, my_config.get_alias('ll'))
1286
 
 
1287
 
    def test_get_change_editor(self):
1288
 
        my_config = self._get_sample_config()
1289
 
        change_editor = my_config.get_change_editor('old', 'new')
1290
 
        self.assertIs(diff.DiffFromTool, change_editor.__class__)
1291
 
        self.assertEqual('vimdiff -of @new_path @old_path',
1292
 
                         ' '.join(change_editor.command_template))
1293
 
 
1294
 
    def test_get_no_change_editor(self):
1295
 
        my_config = self._get_empty_config()
1296
 
        change_editor = my_config.get_change_editor('old', 'new')
1297
 
        self.assertIs(None, change_editor)
1298
 
 
1299
 
    def test_get_merge_tools(self):
1300
 
        conf = self._get_sample_config()
1301
 
        tools = conf.get_merge_tools()
1302
 
        self.log(repr(tools))
1303
 
        self.assertEqual(
1304
 
            {u'funkytool' : u'funkytool "arg with spaces" {this_temp}',
1305
 
            u'sometool' : u'sometool {base} {this} {other} -o {result}'},
1306
 
            tools)
1307
 
 
1308
 
    def test_get_merge_tools_empty(self):
1309
 
        conf = self._get_empty_config()
1310
 
        tools = conf.get_merge_tools()
1311
 
        self.assertEqual({}, tools)
1312
 
 
1313
 
    def test_find_merge_tool(self):
1314
 
        conf = self._get_sample_config()
1315
 
        cmdline = conf.find_merge_tool('sometool')
1316
 
        self.assertEqual('sometool {base} {this} {other} -o {result}', cmdline)
1317
 
 
1318
 
    def test_find_merge_tool_not_found(self):
1319
 
        conf = self._get_sample_config()
1320
 
        cmdline = conf.find_merge_tool('DOES NOT EXIST')
1321
 
        self.assertIs(cmdline, None)
1322
 
 
1323
 
    def test_find_merge_tool_known(self):
1324
 
        conf = self._get_empty_config()
1325
 
        cmdline = conf.find_merge_tool('kdiff3')
1326
 
        self.assertEquals('kdiff3 {base} {this} {other} -o {result}', cmdline)
1327
 
 
1328
 
    def test_find_merge_tool_override_known(self):
1329
 
        conf = self._get_empty_config()
1330
 
        conf.set_user_option('bzr.mergetool.kdiff3', 'kdiff3 blah')
1331
 
        cmdline = conf.find_merge_tool('kdiff3')
1332
 
        self.assertEqual('kdiff3 blah', cmdline)
1333
 
 
1334
 
 
1335
 
class TestGlobalConfigSavingOptions(tests.TestCaseInTempDir):
1336
 
 
1337
 
    def test_empty(self):
1338
 
        my_config = config.GlobalConfig()
1339
 
        self.assertEqual(0, len(my_config.get_aliases()))
1340
 
 
1341
 
    def test_set_alias(self):
1342
 
        my_config = config.GlobalConfig()
1343
 
        alias_value = 'commit --strict'
1344
 
        my_config.set_alias('commit', alias_value)
1345
 
        new_config = config.GlobalConfig()
1346
 
        self.assertEqual(alias_value, new_config.get_alias('commit'))
1347
 
 
1348
 
    def test_remove_alias(self):
1349
 
        my_config = config.GlobalConfig()
1350
 
        my_config.set_alias('commit', 'commit --strict')
1351
 
        # Now remove the alias again.
1352
 
        my_config.unset_alias('commit')
1353
 
        new_config = config.GlobalConfig()
1354
 
        self.assertIs(None, new_config.get_alias('commit'))
1355
 
 
1356
 
 
1357
 
class TestLocationConfig(tests.TestCaseInTempDir, TestOptionsMixin):
 
284
 
 
285
class TestLocationConfig(TestCase):
1358
286
 
1359
287
    def test_constructs(self):
1360
288
        my_config = config.LocationConfig('http://example.com')
1361
289
        self.assertRaises(TypeError, config.LocationConfig)
1362
290
 
1363
291
    def test_branch_calls_read_filenames(self):
1364
 
        # This is testing the correct file names are provided.
1365
 
        # TODO: consolidate with the test for GlobalConfigs filename checks.
1366
 
        #
1367
 
        # replace the class that is constructed, to check its parameters
1368
 
        oldparserclass = config.ConfigObj
1369
 
        config.ConfigObj = InstrumentedConfigObj
 
292
        # replace the class that is constructured, to check its parameters
 
293
        oldparserclass = config.ConfigParser
 
294
        config.ConfigParser = InstrumentedConfigParser
 
295
        my_config = config.LocationConfig('http://www.example.com')
1370
296
        try:
1371
 
            my_config = config.LocationConfig('http://www.example.com')
1372
297
            parser = my_config._get_parser()
1373
298
        finally:
1374
 
            config.ConfigObj = oldparserclass
1375
 
        self.assertIsInstance(parser, InstrumentedConfigObj)
1376
 
        self.assertEqual(parser._calls,
1377
 
                         [('__init__', config.locations_config_filename(),
1378
 
                           'utf-8')])
 
299
            config.ConfigParser = oldparserclass
 
300
        self.failUnless(isinstance(parser, InstrumentedConfigParser))
 
301
        self.assertEqual(parser._calls, [('read', [config.branches_config_filename()])])
1379
302
 
1380
303
    def test_get_global_config(self):
1381
 
        my_config = config.BranchConfig(FakeBranch('http://example.com'))
 
304
        my_config = config.LocationConfig('http://example.com')
1382
305
        global_config = my_config._get_global_config()
1383
 
        self.assertIsInstance(global_config, config.GlobalConfig)
1384
 
        self.assertIs(global_config, my_config._get_global_config())
1385
 
 
1386
 
    def assertLocationMatching(self, expected):
1387
 
        self.assertEqual(expected,
1388
 
                         list(self.my_location_config._get_matching_sections()))
1389
 
 
1390
 
    def test__get_matching_sections_no_match(self):
1391
 
        self.get_branch_config('/')
1392
 
        self.assertLocationMatching([])
1393
 
 
1394
 
    def test__get_matching_sections_exact(self):
1395
 
        self.get_branch_config('http://www.example.com')
1396
 
        self.assertLocationMatching([('http://www.example.com', '')])
1397
 
 
1398
 
    def test__get_matching_sections_suffix_does_not(self):
1399
 
        self.get_branch_config('http://www.example.com-com')
1400
 
        self.assertLocationMatching([])
1401
 
 
1402
 
    def test__get_matching_sections_subdir_recursive(self):
1403
 
        self.get_branch_config('http://www.example.com/com')
1404
 
        self.assertLocationMatching([('http://www.example.com', 'com')])
1405
 
 
1406
 
    def test__get_matching_sections_ignoreparent(self):
1407
 
        self.get_branch_config('http://www.example.com/ignoreparent')
1408
 
        self.assertLocationMatching([('http://www.example.com/ignoreparent',
1409
 
                                      '')])
1410
 
 
1411
 
    def test__get_matching_sections_ignoreparent_subdir(self):
1412
 
        self.get_branch_config(
1413
 
            'http://www.example.com/ignoreparent/childbranch')
1414
 
        self.assertLocationMatching([('http://www.example.com/ignoreparent',
1415
 
                                      'childbranch')])
1416
 
 
1417
 
    def test__get_matching_sections_subdir_trailing_slash(self):
1418
 
        self.get_branch_config('/b')
1419
 
        self.assertLocationMatching([('/b/', '')])
1420
 
 
1421
 
    def test__get_matching_sections_subdir_child(self):
1422
 
        self.get_branch_config('/a/foo')
1423
 
        self.assertLocationMatching([('/a/*', ''), ('/a/', 'foo')])
1424
 
 
1425
 
    def test__get_matching_sections_subdir_child_child(self):
1426
 
        self.get_branch_config('/a/foo/bar')
1427
 
        self.assertLocationMatching([('/a/*', 'bar'), ('/a/', 'foo/bar')])
1428
 
 
1429
 
    def test__get_matching_sections_trailing_slash_with_children(self):
1430
 
        self.get_branch_config('/a/')
1431
 
        self.assertLocationMatching([('/a/', '')])
1432
 
 
1433
 
    def test__get_matching_sections_explicit_over_glob(self):
1434
 
        # XXX: 2006-09-08 jamesh
1435
 
        # This test only passes because ord('c') > ord('*').  If there
1436
 
        # was a config section for '/a/?', it would get precedence
1437
 
        # over '/a/c'.
1438
 
        self.get_branch_config('/a/c')
1439
 
        self.assertLocationMatching([('/a/c', ''), ('/a/*', ''), ('/a/', 'c')])
1440
 
 
1441
 
    def test__get_option_policy_normal(self):
1442
 
        self.get_branch_config('http://www.example.com')
1443
 
        self.assertEqual(
1444
 
            self.my_location_config._get_config_policy(
1445
 
            'http://www.example.com', 'normal_option'),
1446
 
            config.POLICY_NONE)
1447
 
 
1448
 
    def test__get_option_policy_norecurse(self):
1449
 
        self.get_branch_config('http://www.example.com')
1450
 
        self.assertEqual(
1451
 
            self.my_location_config._get_option_policy(
1452
 
            'http://www.example.com', 'norecurse_option'),
1453
 
            config.POLICY_NORECURSE)
1454
 
        # Test old recurse=False setting:
1455
 
        self.assertEqual(
1456
 
            self.my_location_config._get_option_policy(
1457
 
            'http://www.example.com/norecurse', 'normal_option'),
1458
 
            config.POLICY_NORECURSE)
1459
 
 
1460
 
    def test__get_option_policy_normal(self):
1461
 
        self.get_branch_config('http://www.example.com')
1462
 
        self.assertEqual(
1463
 
            self.my_location_config._get_option_policy(
1464
 
            'http://www.example.com', 'appendpath_option'),
1465
 
            config.POLICY_APPENDPATH)
1466
 
 
1467
 
    def test__get_options_with_policy(self):
1468
 
        self.get_branch_config('/dir/subdir',
1469
 
                               location_config="""\
1470
 
[/dir]
1471
 
other_url = /other-dir
1472
 
other_url:policy = appendpath
1473
 
[/dir/subdir]
1474
 
other_url = /other-subdir
1475
 
""")
1476
 
        self.assertOptions(
1477
 
            [(u'other_url', u'/other-subdir', u'/dir/subdir', 'locations'),
1478
 
             (u'other_url', u'/other-dir', u'/dir', 'locations'),
1479
 
             (u'other_url:policy', u'appendpath', u'/dir', 'locations')],
1480
 
            self.my_location_config)
 
306
        self.failUnless(isinstance(global_config, config.GlobalConfig))
 
307
        self.failUnless(global_config is my_config._get_global_config())
 
308
 
 
309
    def test__get_section_no_match(self):
 
310
        self.get_location_config('/')
 
311
        self.assertEqual(None, self.my_config._get_section())
 
312
        
 
313
    def test__get_section_exact(self):
 
314
        self.get_location_config('http://www.example.com')
 
315
        self.assertEqual('http://www.example.com',
 
316
                         self.my_config._get_section())
 
317
   
 
318
    def test__get_section_suffix_does_not(self):
 
319
        self.get_location_config('http://www.example.com-com')
 
320
        self.assertEqual(None, self.my_config._get_section())
 
321
 
 
322
    def test__get_section_subdir_recursive(self):
 
323
        self.get_location_config('http://www.example.com/com')
 
324
        self.assertEqual('http://www.example.com',
 
325
                         self.my_config._get_section())
 
326
 
 
327
    def test__get_section_subdir_matches(self):
 
328
        self.get_location_config('http://www.example.com/useglobal')
 
329
        self.assertEqual('http://www.example.com/useglobal',
 
330
                         self.my_config._get_section())
 
331
 
 
332
    def test__get_section_subdir_nonrecursive(self):
 
333
        self.get_location_config(
 
334
            'http://www.example.com/useglobal/childbranch')
 
335
        self.assertEqual('http://www.example.com',
 
336
                         self.my_config._get_section())
 
337
 
 
338
    def test__get_section_subdir_trailing_slash(self):
 
339
        self.get_location_config('/b')
 
340
        self.assertEqual('/b/', self.my_config._get_section())
 
341
 
 
342
    def test__get_section_subdir_child(self):
 
343
        self.get_location_config('/a/foo')
 
344
        self.assertEqual('/a/*', self.my_config._get_section())
 
345
 
 
346
    def test__get_section_subdir_child_child(self):
 
347
        self.get_location_config('/a/foo/bar')
 
348
        self.assertEqual('/a/', self.my_config._get_section())
 
349
 
 
350
    def test__get_section_trailing_slash_with_children(self):
 
351
        self.get_location_config('/a/')
 
352
        self.assertEqual('/a/', self.my_config._get_section())
 
353
 
 
354
    def test__get_section_explicit_over_glob(self):
 
355
        self.get_location_config('/a/c')
 
356
        self.assertEqual('/a/c', self.my_config._get_section())
 
357
 
 
358
    def get_location_config(self, location, global_config=None):
 
359
        if global_config is None:
 
360
            global_file = StringIO(sample_config_text)
 
361
        else:
 
362
            global_file = StringIO(global_config)
 
363
        branches_file = StringIO(sample_branches_text)
 
364
        self.my_config = config.LocationConfig(location)
 
365
        self.my_config._get_parser(branches_file)
 
366
        self.my_config._get_global_config()._get_parser(global_file)
1481
367
 
1482
368
    def test_location_without_username(self):
1483
 
        self.get_branch_config('http://www.example.com/ignoreparent')
1484
 
        self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
 
369
        self.get_location_config('http://www.example.com/useglobal')
 
370
        self.assertEqual('Robert Collins <robertc@example.com>',
1485
371
                         self.my_config.username())
1486
372
 
1487
373
    def test_location_not_listed(self):
1488
 
        """Test that the global username is used when no location matches"""
1489
 
        self.get_branch_config('/home/robertc/sources')
1490
 
        self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
 
374
        self.get_location_config('/home/robertc/sources')
 
375
        self.assertEqual('Robert Collins <robertc@example.com>',
1491
376
                         self.my_config.username())
1492
377
 
1493
378
    def test_overriding_location(self):
1494
 
        self.get_branch_config('http://www.example.com/foo')
 
379
        self.get_location_config('http://www.example.com/foo')
1495
380
        self.assertEqual('Robert Collins <robertc@example.org>',
1496
381
                         self.my_config.username())
1497
382
 
1498
383
    def test_signatures_not_set(self):
1499
 
        self.get_branch_config('http://www.example.com',
 
384
        self.get_location_config('http://www.example.com',
1500
385
                                 global_config=sample_ignore_signatures)
1501
 
        self.assertEqual(config.CHECK_ALWAYS,
 
386
        self.assertEqual(config.CHECK_NEVER,
1502
387
                         self.my_config.signature_checking())
1503
 
        self.assertEqual(config.SIGN_NEVER,
1504
 
                         self.my_config.signing_policy())
1505
388
 
1506
389
    def test_signatures_never(self):
1507
 
        self.get_branch_config('/a/c')
 
390
        self.get_location_config('/a/c')
1508
391
        self.assertEqual(config.CHECK_NEVER,
1509
392
                         self.my_config.signature_checking())
1510
 
 
 
393
        
1511
394
    def test_signatures_when_available(self):
1512
 
        self.get_branch_config('/a/', global_config=sample_ignore_signatures)
 
395
        self.get_location_config('/a/', global_config=sample_ignore_signatures)
1513
396
        self.assertEqual(config.CHECK_IF_POSSIBLE,
1514
397
                         self.my_config.signature_checking())
1515
 
 
 
398
        
1516
399
    def test_signatures_always(self):
1517
 
        self.get_branch_config('/b')
 
400
        self.get_location_config('/b')
1518
401
        self.assertEqual(config.CHECK_ALWAYS,
1519
402
                         self.my_config.signature_checking())
1520
 
 
 
403
        
1521
404
    def test_gpg_signing_command(self):
1522
 
        self.get_branch_config('/b')
 
405
        self.get_location_config('/b')
1523
406
        self.assertEqual("gnome-gpg", self.my_config.gpg_signing_command())
1524
407
 
1525
408
    def test_gpg_signing_command_missing(self):
1526
 
        self.get_branch_config('/a')
 
409
        self.get_location_config('/a')
1527
410
        self.assertEqual("false", self.my_config.gpg_signing_command())
1528
411
 
1529
 
    def test_gpg_signing_key(self):
1530
 
        self.get_branch_config('/b')
1531
 
        self.assertEqual("DD4D5088", self.my_config.gpg_signing_key())
1532
 
 
1533
 
    def test_gpg_signing_key_default(self):
1534
 
        self.get_branch_config('/a')
1535
 
        self.assertEqual("erik@bagfors.nu", self.my_config.gpg_signing_key())
1536
 
 
1537
 
    def test_get_user_option_global(self):
1538
 
        self.get_branch_config('/a')
1539
 
        self.assertEqual('something',
1540
 
                         self.my_config.get_user_option('user_global_option'))
1541
 
 
1542
 
    def test_get_user_option_local(self):
1543
 
        self.get_branch_config('/a')
1544
 
        self.assertEqual('local',
1545
 
                         self.my_config.get_user_option('user_local_option'))
1546
 
 
1547
 
    def test_get_user_option_appendpath(self):
1548
 
        # returned as is for the base path:
1549
 
        self.get_branch_config('http://www.example.com')
1550
 
        self.assertEqual('append',
1551
 
                         self.my_config.get_user_option('appendpath_option'))
1552
 
        # Extra path components get appended:
1553
 
        self.get_branch_config('http://www.example.com/a/b/c')
1554
 
        self.assertEqual('append/a/b/c',
1555
 
                         self.my_config.get_user_option('appendpath_option'))
1556
 
        # Overriden for http://www.example.com/dir, where it is a
1557
 
        # normal option:
1558
 
        self.get_branch_config('http://www.example.com/dir/a/b/c')
1559
 
        self.assertEqual('normal',
1560
 
                         self.my_config.get_user_option('appendpath_option'))
1561
 
 
1562
 
    def test_get_user_option_norecurse(self):
1563
 
        self.get_branch_config('http://www.example.com')
1564
 
        self.assertEqual('norecurse',
1565
 
                         self.my_config.get_user_option('norecurse_option'))
1566
 
        self.get_branch_config('http://www.example.com/dir')
1567
 
        self.assertEqual(None,
1568
 
                         self.my_config.get_user_option('norecurse_option'))
1569
 
        # http://www.example.com/norecurse is a recurse=False section
1570
 
        # that redefines normal_option.  Subdirectories do not pick up
1571
 
        # this redefinition.
1572
 
        self.get_branch_config('http://www.example.com/norecurse')
1573
 
        self.assertEqual('norecurse',
1574
 
                         self.my_config.get_user_option('normal_option'))
1575
 
        self.get_branch_config('http://www.example.com/norecurse/subdir')
1576
 
        self.assertEqual('normal',
1577
 
                         self.my_config.get_user_option('normal_option'))
1578
 
 
1579
 
    def test_set_user_option_norecurse(self):
1580
 
        self.get_branch_config('http://www.example.com')
1581
 
        self.my_config.set_user_option('foo', 'bar',
1582
 
                                       store=config.STORE_LOCATION_NORECURSE)
1583
 
        self.assertEqual(
1584
 
            self.my_location_config._get_option_policy(
1585
 
            'http://www.example.com', 'foo'),
1586
 
            config.POLICY_NORECURSE)
1587
 
 
1588
 
    def test_set_user_option_appendpath(self):
1589
 
        self.get_branch_config('http://www.example.com')
1590
 
        self.my_config.set_user_option('foo', 'bar',
1591
 
                                       store=config.STORE_LOCATION_APPENDPATH)
1592
 
        self.assertEqual(
1593
 
            self.my_location_config._get_option_policy(
1594
 
            'http://www.example.com', 'foo'),
1595
 
            config.POLICY_APPENDPATH)
1596
 
 
1597
 
    def test_set_user_option_change_policy(self):
1598
 
        self.get_branch_config('http://www.example.com')
1599
 
        self.my_config.set_user_option('norecurse_option', 'normal',
1600
 
                                       store=config.STORE_LOCATION)
1601
 
        self.assertEqual(
1602
 
            self.my_location_config._get_option_policy(
1603
 
            'http://www.example.com', 'norecurse_option'),
1604
 
            config.POLICY_NONE)
1605
 
 
1606
 
    def test_set_user_option_recurse_false_section(self):
1607
 
        # The following section has recurse=False set.  The test is to
1608
 
        # make sure that a normal option can be added to the section,
1609
 
        # converting recurse=False to the norecurse policy.
1610
 
        self.get_branch_config('http://www.example.com/norecurse')
1611
 
        self.callDeprecated(['The recurse option is deprecated as of 0.14.  '
1612
 
                             'The section "http://www.example.com/norecurse" '
1613
 
                             'has been converted to use policies.'],
1614
 
                            self.my_config.set_user_option,
1615
 
                            'foo', 'bar', store=config.STORE_LOCATION)
1616
 
        self.assertEqual(
1617
 
            self.my_location_config._get_option_policy(
1618
 
            'http://www.example.com/norecurse', 'foo'),
1619
 
            config.POLICY_NONE)
1620
 
        # The previously existing option is still norecurse:
1621
 
        self.assertEqual(
1622
 
            self.my_location_config._get_option_policy(
1623
 
            'http://www.example.com/norecurse', 'normal_option'),
1624
 
            config.POLICY_NORECURSE)
1625
 
 
1626
 
    def test_post_commit_default(self):
1627
 
        self.get_branch_config('/a/c')
1628
 
        self.assertEqual('bzrlib.tests.test_config.post_commit',
1629
 
                         self.my_config.post_commit())
1630
 
 
1631
 
    def get_branch_config(self, location, global_config=None,
1632
 
                          location_config=None):
1633
 
        my_branch = FakeBranch(location)
1634
 
        if global_config is None:
1635
 
            global_config = sample_config_text
1636
 
        if location_config is None:
1637
 
            location_config = sample_branches_text
1638
 
 
1639
 
        my_global_config = config.GlobalConfig.from_string(global_config,
1640
 
                                                           save=True)
1641
 
        my_location_config = config.LocationConfig.from_string(
1642
 
            location_config, my_branch.base, save=True)
1643
 
        my_config = config.BranchConfig(my_branch)
1644
 
        self.my_config = my_config
1645
 
        self.my_location_config = my_config._get_location_config()
1646
 
 
1647
 
    def test_set_user_setting_sets_and_saves(self):
1648
 
        self.get_branch_config('/a/c')
1649
 
        record = InstrumentedConfigObj("foo")
1650
 
        self.my_location_config._parser = record
1651
 
 
1652
 
        self.callDeprecated(['The recurse option is deprecated as of '
1653
 
                             '0.14.  The section "/a/c" has been '
1654
 
                             'converted to use policies.'],
1655
 
                            self.my_config.set_user_option,
1656
 
                            'foo', 'bar', store=config.STORE_LOCATION)
1657
 
        self.assertEqual([('reload',),
1658
 
                          ('__contains__', '/a/c'),
1659
 
                          ('__contains__', '/a/c/'),
1660
 
                          ('__setitem__', '/a/c', {}),
1661
 
                          ('__getitem__', '/a/c'),
1662
 
                          ('__setitem__', 'foo', 'bar'),
1663
 
                          ('__getitem__', '/a/c'),
1664
 
                          ('as_bool', 'recurse'),
1665
 
                          ('__getitem__', '/a/c'),
1666
 
                          ('__delitem__', 'recurse'),
1667
 
                          ('__getitem__', '/a/c'),
1668
 
                          ('keys',),
1669
 
                          ('__getitem__', '/a/c'),
1670
 
                          ('__contains__', 'foo:policy'),
1671
 
                          ('write',)],
1672
 
                         record._calls[1:])
1673
 
 
1674
 
    def test_set_user_setting_sets_and_saves2(self):
1675
 
        self.get_branch_config('/a/c')
1676
 
        self.assertIs(self.my_config.get_user_option('foo'), None)
1677
 
        self.my_config.set_user_option('foo', 'bar')
1678
 
        self.assertEqual(
1679
 
            self.my_config.branch.control_files.files['branch.conf'].strip(),
1680
 
            'foo = bar')
1681
 
        self.assertEqual(self.my_config.get_user_option('foo'), 'bar')
1682
 
        self.my_config.set_user_option('foo', 'baz',
1683
 
                                       store=config.STORE_LOCATION)
1684
 
        self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
1685
 
        self.my_config.set_user_option('foo', 'qux')
1686
 
        self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
1687
 
 
1688
 
    def test_get_bzr_remote_path(self):
1689
 
        my_config = config.LocationConfig('/a/c')
1690
 
        self.assertEqual('bzr', my_config.get_bzr_remote_path())
1691
 
        my_config.set_user_option('bzr_remote_path', '/path-bzr')
1692
 
        self.assertEqual('/path-bzr', my_config.get_bzr_remote_path())
1693
 
        self.overrideEnv('BZR_REMOTE_PATH', '/environ-bzr')
1694
 
        self.assertEqual('/environ-bzr', my_config.get_bzr_remote_path())
1695
 
 
1696
 
 
1697
 
precedence_global = 'option = global'
1698
 
precedence_branch = 'option = branch'
1699
 
precedence_location = """
1700
 
[http://]
1701
 
recurse = true
1702
 
option = recurse
1703
 
[http://example.com/specific]
1704
 
option = exact
1705
 
"""
1706
 
 
1707
 
class TestBranchConfigItems(tests.TestCaseInTempDir):
1708
 
 
1709
 
    def get_branch_config(self, global_config=None, location=None,
1710
 
                          location_config=None, branch_data_config=None):
1711
 
        my_branch = FakeBranch(location)
1712
 
        if global_config is not None:
1713
 
            my_global_config = config.GlobalConfig.from_string(global_config,
1714
 
                                                               save=True)
1715
 
        if location_config is not None:
1716
 
            my_location_config = config.LocationConfig.from_string(
1717
 
                location_config, my_branch.base, save=True)
1718
 
        my_config = config.BranchConfig(my_branch)
1719
 
        if branch_data_config is not None:
1720
 
            my_config.branch.control_files.files['branch.conf'] = \
1721
 
                branch_data_config
1722
 
        return my_config
 
412
 
 
413
class TestBranchConfigItems(TestCase):
1723
414
 
1724
415
    def test_user_id(self):
1725
 
        branch = FakeBranch(user_id='Robert Collins <robertc@example.net>')
 
416
        branch = FakeBranch()
1726
417
        my_config = config.BranchConfig(branch)
1727
418
        self.assertEqual("Robert Collins <robertc@example.net>",
1728
 
                         my_config.username())
1729
 
        my_config.branch.control_files.files['email'] = "John"
1730
 
        my_config.set_user_option('email',
1731
 
                                  "Robert Collins <robertc@example.org>")
1732
 
        self.assertEqual("John", my_config.username())
1733
 
        del my_config.branch.control_files.files['email']
1734
 
        self.assertEqual("Robert Collins <robertc@example.org>",
1735
 
                         my_config.username())
 
419
                         my_config._get_user_id())
 
420
        branch.email = "John"
 
421
        self.assertEqual("John", my_config._get_user_id())
1736
422
 
1737
423
    def test_not_set_in_branch(self):
1738
 
        my_config = self.get_branch_config(global_config=sample_config_text)
1739
 
        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
 
424
        branch = FakeBranch()
 
425
        my_config = config.BranchConfig(branch)
 
426
        branch.email = None
 
427
        config_file = StringIO(sample_config_text)
 
428
        (my_config._get_location_config().
 
429
            _get_global_config()._get_parser(config_file))
 
430
        self.assertEqual("Robert Collins <robertc@example.com>",
1740
431
                         my_config._get_user_id())
1741
 
        my_config.branch.control_files.files['email'] = "John"
 
432
        branch.email = "John"
1742
433
        self.assertEqual("John", my_config._get_user_id())
1743
434
 
1744
 
    def test_BZR_EMAIL_OVERRIDES(self):
1745
 
        self.overrideEnv('BZR_EMAIL', "Robert Collins <robertc@example.org>")
 
435
    def test_BZREMAIL_OVERRIDES(self):
 
436
        os.environ['BZREMAIL'] = "Robert Collins <robertc@example.org>"
1746
437
        branch = FakeBranch()
1747
438
        my_config = config.BranchConfig(branch)
1748
439
        self.assertEqual("Robert Collins <robertc@example.org>",
1749
440
                         my_config.username())
1750
 
 
 
441
    
1751
442
    def test_signatures_forced(self):
1752
 
        my_config = self.get_branch_config(
1753
 
            global_config=sample_always_signatures)
1754
 
        self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
1755
 
        self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
1756
 
        self.assertTrue(my_config.signature_needed())
1757
 
 
1758
 
    def test_signatures_forced_branch(self):
1759
 
        my_config = self.get_branch_config(
1760
 
            global_config=sample_ignore_signatures,
1761
 
            branch_data_config=sample_always_signatures)
1762
 
        self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
1763
 
        self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
1764
 
        self.assertTrue(my_config.signature_needed())
 
443
        branch = FakeBranch()
 
444
        my_config = config.BranchConfig(branch)
 
445
        config_file = StringIO(sample_always_signatures)
 
446
        (my_config._get_location_config().
 
447
            _get_global_config()._get_parser(config_file))
 
448
        self.assertEqual(config.CHECK_ALWAYS, my_config.signature_checking())
1765
449
 
1766
450
    def test_gpg_signing_command(self):
1767
 
        my_config = self.get_branch_config(
1768
 
            global_config=sample_config_text,
1769
 
            # branch data cannot set gpg_signing_command
1770
 
            branch_data_config="gpg_signing_command=pgp")
 
451
        branch = FakeBranch()
 
452
        my_config = config.BranchConfig(branch)
 
453
        config_file = StringIO(sample_config_text)
 
454
        (my_config._get_location_config().
 
455
            _get_global_config()._get_parser(config_file))
1771
456
        self.assertEqual('gnome-gpg', my_config.gpg_signing_command())
1772
 
 
1773
 
    def test_get_user_option_global(self):
1774
 
        my_config = self.get_branch_config(global_config=sample_config_text)
1775
 
        self.assertEqual('something',
1776
 
                         my_config.get_user_option('user_global_option'))
1777
 
 
1778
 
    def test_post_commit_default(self):
1779
 
        my_config = self.get_branch_config(global_config=sample_config_text,
1780
 
                                      location='/a/c',
1781
 
                                      location_config=sample_branches_text)
1782
 
        self.assertEqual(my_config.branch.base, '/a/c')
1783
 
        self.assertEqual('bzrlib.tests.test_config.post_commit',
1784
 
                         my_config.post_commit())
1785
 
        my_config.set_user_option('post_commit', 'rmtree_root')
1786
 
        # post-commit is ignored when present in branch data
1787
 
        self.assertEqual('bzrlib.tests.test_config.post_commit',
1788
 
                         my_config.post_commit())
1789
 
        my_config.set_user_option('post_commit', 'rmtree_root',
1790
 
                                  store=config.STORE_LOCATION)
1791
 
        self.assertEqual('rmtree_root', my_config.post_commit())
1792
 
 
1793
 
    def test_config_precedence(self):
1794
 
        # FIXME: eager test, luckily no persitent config file makes it fail
1795
 
        # -- vila 20100716
1796
 
        my_config = self.get_branch_config(global_config=precedence_global)
1797
 
        self.assertEqual(my_config.get_user_option('option'), 'global')
1798
 
        my_config = self.get_branch_config(global_config=precedence_global,
1799
 
                                           branch_data_config=precedence_branch)
1800
 
        self.assertEqual(my_config.get_user_option('option'), 'branch')
1801
 
        my_config = self.get_branch_config(
1802
 
            global_config=precedence_global,
1803
 
            branch_data_config=precedence_branch,
1804
 
            location_config=precedence_location)
1805
 
        self.assertEqual(my_config.get_user_option('option'), 'recurse')
1806
 
        my_config = self.get_branch_config(
1807
 
            global_config=precedence_global,
1808
 
            branch_data_config=precedence_branch,
1809
 
            location_config=precedence_location,
1810
 
            location='http://example.com/specific')
1811
 
        self.assertEqual(my_config.get_user_option('option'), 'exact')
1812
 
 
1813
 
    def test_get_mail_client(self):
1814
 
        config = self.get_branch_config()
1815
 
        client = config.get_mail_client()
1816
 
        self.assertIsInstance(client, mail_client.DefaultMail)
1817
 
 
1818
 
        # Specific clients
1819
 
        config.set_user_option('mail_client', 'evolution')
1820
 
        client = config.get_mail_client()
1821
 
        self.assertIsInstance(client, mail_client.Evolution)
1822
 
 
1823
 
        config.set_user_option('mail_client', 'kmail')
1824
 
        client = config.get_mail_client()
1825
 
        self.assertIsInstance(client, mail_client.KMail)
1826
 
 
1827
 
        config.set_user_option('mail_client', 'mutt')
1828
 
        client = config.get_mail_client()
1829
 
        self.assertIsInstance(client, mail_client.Mutt)
1830
 
 
1831
 
        config.set_user_option('mail_client', 'thunderbird')
1832
 
        client = config.get_mail_client()
1833
 
        self.assertIsInstance(client, mail_client.Thunderbird)
1834
 
 
1835
 
        # Generic options
1836
 
        config.set_user_option('mail_client', 'default')
1837
 
        client = config.get_mail_client()
1838
 
        self.assertIsInstance(client, mail_client.DefaultMail)
1839
 
 
1840
 
        config.set_user_option('mail_client', 'editor')
1841
 
        client = config.get_mail_client()
1842
 
        self.assertIsInstance(client, mail_client.Editor)
1843
 
 
1844
 
        config.set_user_option('mail_client', 'mapi')
1845
 
        client = config.get_mail_client()
1846
 
        self.assertIsInstance(client, mail_client.MAPIClient)
1847
 
 
1848
 
        config.set_user_option('mail_client', 'xdg-email')
1849
 
        client = config.get_mail_client()
1850
 
        self.assertIsInstance(client, mail_client.XDGEmail)
1851
 
 
1852
 
        config.set_user_option('mail_client', 'firebird')
1853
 
        self.assertRaises(errors.UnknownMailClient, config.get_mail_client)
1854
 
 
1855
 
 
1856
 
class TestMailAddressExtraction(tests.TestCase):
1857
 
 
1858
 
    def test_extract_email_address(self):
1859
 
        self.assertEqual('jane@test.com',
1860
 
                         config.extract_email_address('Jane <jane@test.com>'))
1861
 
        self.assertRaises(errors.NoEmailInUsername,
1862
 
                          config.extract_email_address, 'Jane Tester')
1863
 
 
1864
 
    def test_parse_username(self):
1865
 
        self.assertEqual(('', 'jdoe@example.com'),
1866
 
                         config.parse_username('jdoe@example.com'))
1867
 
        self.assertEqual(('', 'jdoe@example.com'),
1868
 
                         config.parse_username('<jdoe@example.com>'))
1869
 
        self.assertEqual(('John Doe', 'jdoe@example.com'),
1870
 
                         config.parse_username('John Doe <jdoe@example.com>'))
1871
 
        self.assertEqual(('John Doe', ''),
1872
 
                         config.parse_username('John Doe'))
1873
 
        self.assertEqual(('John Doe', 'jdoe@example.com'),
1874
 
                         config.parse_username('John Doe jdoe@example.com'))
1875
 
 
1876
 
class TestTreeConfig(tests.TestCaseWithTransport):
1877
 
 
1878
 
    def test_get_value(self):
1879
 
        """Test that retreiving a value from a section is possible"""
1880
 
        branch = self.make_branch('.')
1881
 
        tree_config = config.TreeConfig(branch)
1882
 
        tree_config.set_option('value', 'key', 'SECTION')
1883
 
        tree_config.set_option('value2', 'key2')
1884
 
        tree_config.set_option('value3-top', 'key3')
1885
 
        tree_config.set_option('value3-section', 'key3', 'SECTION')
1886
 
        value = tree_config.get_option('key', 'SECTION')
1887
 
        self.assertEqual(value, 'value')
1888
 
        value = tree_config.get_option('key2')
1889
 
        self.assertEqual(value, 'value2')
1890
 
        self.assertEqual(tree_config.get_option('non-existant'), None)
1891
 
        value = tree_config.get_option('non-existant', 'SECTION')
1892
 
        self.assertEqual(value, None)
1893
 
        value = tree_config.get_option('non-existant', default='default')
1894
 
        self.assertEqual(value, 'default')
1895
 
        self.assertEqual(tree_config.get_option('key2', 'NOSECTION'), None)
1896
 
        value = tree_config.get_option('key2', 'NOSECTION', default='default')
1897
 
        self.assertEqual(value, 'default')
1898
 
        value = tree_config.get_option('key3')
1899
 
        self.assertEqual(value, 'value3-top')
1900
 
        value = tree_config.get_option('key3', 'SECTION')
1901
 
        self.assertEqual(value, 'value3-section')
1902
 
 
1903
 
 
1904
 
class TestTransportConfig(tests.TestCaseWithTransport):
1905
 
 
1906
 
    def test_load_utf8(self):
1907
 
        """Ensure we can load an utf8-encoded file."""
1908
 
        t = self.get_transport()
1909
 
        unicode_user = u'b\N{Euro Sign}ar'
1910
 
        unicode_content = u'user=%s' % (unicode_user,)
1911
 
        utf8_content = unicode_content.encode('utf8')
1912
 
        # Store the raw content in the config file
1913
 
        t.put_bytes('foo.conf', utf8_content)
1914
 
        conf = config.TransportConfig(t, 'foo.conf')
1915
 
        self.assertEquals(unicode_user, conf.get_option('user'))
1916
 
 
1917
 
    def test_load_non_ascii(self):
1918
 
        """Ensure we display a proper error on non-ascii, non utf-8 content."""
1919
 
        t = self.get_transport()
1920
 
        t.put_bytes('foo.conf', 'user=foo\n#\xff\n')
1921
 
        conf = config.TransportConfig(t, 'foo.conf')
1922
 
        self.assertRaises(errors.ConfigContentError, conf._get_configobj)
1923
 
 
1924
 
    def test_load_erroneous_content(self):
1925
 
        """Ensure we display a proper error on content that can't be parsed."""
1926
 
        t = self.get_transport()
1927
 
        t.put_bytes('foo.conf', '[open_section\n')
1928
 
        conf = config.TransportConfig(t, 'foo.conf')
1929
 
        self.assertRaises(errors.ParseConfigError, conf._get_configobj)
1930
 
 
1931
 
    def test_get_value(self):
1932
 
        """Test that retreiving a value from a section is possible"""
1933
 
        bzrdir_config = config.TransportConfig(self.get_transport('.'),
1934
 
                                               'control.conf')
1935
 
        bzrdir_config.set_option('value', 'key', 'SECTION')
1936
 
        bzrdir_config.set_option('value2', 'key2')
1937
 
        bzrdir_config.set_option('value3-top', 'key3')
1938
 
        bzrdir_config.set_option('value3-section', 'key3', 'SECTION')
1939
 
        value = bzrdir_config.get_option('key', 'SECTION')
1940
 
        self.assertEqual(value, 'value')
1941
 
        value = bzrdir_config.get_option('key2')
1942
 
        self.assertEqual(value, 'value2')
1943
 
        self.assertEqual(bzrdir_config.get_option('non-existant'), None)
1944
 
        value = bzrdir_config.get_option('non-existant', 'SECTION')
1945
 
        self.assertEqual(value, None)
1946
 
        value = bzrdir_config.get_option('non-existant', default='default')
1947
 
        self.assertEqual(value, 'default')
1948
 
        self.assertEqual(bzrdir_config.get_option('key2', 'NOSECTION'), None)
1949
 
        value = bzrdir_config.get_option('key2', 'NOSECTION',
1950
 
                                         default='default')
1951
 
        self.assertEqual(value, 'default')
1952
 
        value = bzrdir_config.get_option('key3')
1953
 
        self.assertEqual(value, 'value3-top')
1954
 
        value = bzrdir_config.get_option('key3', 'SECTION')
1955
 
        self.assertEqual(value, 'value3-section')
1956
 
 
1957
 
    def test_set_unset_default_stack_on(self):
1958
 
        my_dir = self.make_bzrdir('.')
1959
 
        bzrdir_config = config.BzrDirConfig(my_dir)
1960
 
        self.assertIs(None, bzrdir_config.get_default_stack_on())
1961
 
        bzrdir_config.set_default_stack_on('Foo')
1962
 
        self.assertEqual('Foo', bzrdir_config._config.get_option(
1963
 
                         'default_stack_on'))
1964
 
        self.assertEqual('Foo', bzrdir_config.get_default_stack_on())
1965
 
        bzrdir_config.set_default_stack_on(None)
1966
 
        self.assertIs(None, bzrdir_config.get_default_stack_on())
1967
 
 
1968
 
 
1969
 
class TestOldConfigHooks(tests.TestCaseWithTransport):
1970
 
 
1971
 
    def setUp(self):
1972
 
        super(TestOldConfigHooks, self).setUp()
1973
 
        create_configs_with_file_option(self)
1974
 
 
1975
 
    def assertGetHook(self, conf, name, value):
1976
 
        calls = []
1977
 
        def hook(*args):
1978
 
            calls.append(args)
1979
 
        config.OldConfigHooks.install_named_hook('get', hook, None)
1980
 
        self.addCleanup(
1981
 
            config.OldConfigHooks.uninstall_named_hook, 'get', None)
1982
 
        self.assertLength(0, calls)
1983
 
        actual_value = conf.get_user_option(name)
1984
 
        self.assertEquals(value, actual_value)
1985
 
        self.assertLength(1, calls)
1986
 
        self.assertEquals((conf, name, value), calls[0])
1987
 
 
1988
 
    def test_get_hook_bazaar(self):
1989
 
        self.assertGetHook(self.bazaar_config, 'file', 'bazaar')
1990
 
 
1991
 
    def test_get_hook_locations(self):
1992
 
        self.assertGetHook(self.locations_config, 'file', 'locations')
1993
 
 
1994
 
    def test_get_hook_branch(self):
1995
 
        # Since locations masks branch, we define a different option
1996
 
        self.branch_config.set_user_option('file2', 'branch')
1997
 
        self.assertGetHook(self.branch_config, 'file2', 'branch')
1998
 
 
1999
 
    def assertSetHook(self, conf, name, value):
2000
 
        calls = []
2001
 
        def hook(*args):
2002
 
            calls.append(args)
2003
 
        config.OldConfigHooks.install_named_hook('set', hook, None)
2004
 
        self.addCleanup(
2005
 
            config.OldConfigHooks.uninstall_named_hook, 'set', None)
2006
 
        self.assertLength(0, calls)
2007
 
        conf.set_user_option(name, value)
2008
 
        self.assertLength(1, calls)
2009
 
        # We can't assert the conf object below as different configs use
2010
 
        # different means to implement set_user_option and we care only about
2011
 
        # coverage here.
2012
 
        self.assertEquals((name, value), calls[0][1:])
2013
 
 
2014
 
    def test_set_hook_bazaar(self):
2015
 
        self.assertSetHook(self.bazaar_config, 'foo', 'bazaar')
2016
 
 
2017
 
    def test_set_hook_locations(self):
2018
 
        self.assertSetHook(self.locations_config, 'foo', 'locations')
2019
 
 
2020
 
    def test_set_hook_branch(self):
2021
 
        self.assertSetHook(self.branch_config, 'foo', 'branch')
2022
 
 
2023
 
    def assertRemoveHook(self, conf, name, section_name=None):
2024
 
        calls = []
2025
 
        def hook(*args):
2026
 
            calls.append(args)
2027
 
        config.OldConfigHooks.install_named_hook('remove', hook, None)
2028
 
        self.addCleanup(
2029
 
            config.OldConfigHooks.uninstall_named_hook, 'remove', None)
2030
 
        self.assertLength(0, calls)
2031
 
        conf.remove_user_option(name, section_name)
2032
 
        self.assertLength(1, calls)
2033
 
        # We can't assert the conf object below as different configs use
2034
 
        # different means to implement remove_user_option and we care only about
2035
 
        # coverage here.
2036
 
        self.assertEquals((name,), calls[0][1:])
2037
 
 
2038
 
    def test_remove_hook_bazaar(self):
2039
 
        self.assertRemoveHook(self.bazaar_config, 'file')
2040
 
 
2041
 
    def test_remove_hook_locations(self):
2042
 
        self.assertRemoveHook(self.locations_config, 'file',
2043
 
                              self.locations_config.location)
2044
 
 
2045
 
    def test_remove_hook_branch(self):
2046
 
        self.assertRemoveHook(self.branch_config, 'file')
2047
 
 
2048
 
    def assertLoadHook(self, name, conf_class, *conf_args):
2049
 
        calls = []
2050
 
        def hook(*args):
2051
 
            calls.append(args)
2052
 
        config.OldConfigHooks.install_named_hook('load', hook, None)
2053
 
        self.addCleanup(
2054
 
            config.OldConfigHooks.uninstall_named_hook, 'load', None)
2055
 
        self.assertLength(0, calls)
2056
 
        # Build a config
2057
 
        conf = conf_class(*conf_args)
2058
 
        # Access an option to trigger a load
2059
 
        conf.get_user_option(name)
2060
 
        self.assertLength(1, calls)
2061
 
        # Since we can't assert about conf, we just use the number of calls ;-/
2062
 
 
2063
 
    def test_load_hook_bazaar(self):
2064
 
        self.assertLoadHook('file', config.GlobalConfig)
2065
 
 
2066
 
    def test_load_hook_locations(self):
2067
 
        self.assertLoadHook('file', config.LocationConfig, self.tree.basedir)
2068
 
 
2069
 
    def test_load_hook_branch(self):
2070
 
        self.assertLoadHook('file', config.BranchConfig, self.tree.branch)
2071
 
 
2072
 
    def assertSaveHook(self, conf):
2073
 
        calls = []
2074
 
        def hook(*args):
2075
 
            calls.append(args)
2076
 
        config.OldConfigHooks.install_named_hook('save', hook, None)
2077
 
        self.addCleanup(
2078
 
            config.OldConfigHooks.uninstall_named_hook, 'save', None)
2079
 
        self.assertLength(0, calls)
2080
 
        # Setting an option triggers a save
2081
 
        conf.set_user_option('foo', 'bar')
2082
 
        self.assertLength(1, calls)
2083
 
        # Since we can't assert about conf, we just use the number of calls ;-/
2084
 
 
2085
 
    def test_save_hook_bazaar(self):
2086
 
        self.assertSaveHook(self.bazaar_config)
2087
 
 
2088
 
    def test_save_hook_locations(self):
2089
 
        self.assertSaveHook(self.locations_config)
2090
 
 
2091
 
    def test_save_hook_branch(self):
2092
 
        self.assertSaveHook(self.branch_config)
2093
 
 
2094
 
 
2095
 
class TestOldConfigHooksForRemote(tests.TestCaseWithTransport):
2096
 
    """Tests config hooks for remote configs.
2097
 
 
2098
 
    No tests for the remove hook as this is not implemented there.
2099
 
    """
2100
 
 
2101
 
    def setUp(self):
2102
 
        super(TestOldConfigHooksForRemote, self).setUp()
2103
 
        self.transport_server = test_server.SmartTCPServer_for_testing
2104
 
        create_configs_with_file_option(self)
2105
 
 
2106
 
    def assertGetHook(self, conf, name, value):
2107
 
        calls = []
2108
 
        def hook(*args):
2109
 
            calls.append(args)
2110
 
        config.OldConfigHooks.install_named_hook('get', hook, None)
2111
 
        self.addCleanup(
2112
 
            config.OldConfigHooks.uninstall_named_hook, 'get', None)
2113
 
        self.assertLength(0, calls)
2114
 
        actual_value = conf.get_option(name)
2115
 
        self.assertEquals(value, actual_value)
2116
 
        self.assertLength(1, calls)
2117
 
        self.assertEquals((conf, name, value), calls[0])
2118
 
 
2119
 
    def test_get_hook_remote_branch(self):
2120
 
        remote_branch = branch.Branch.open(self.get_url('tree'))
2121
 
        self.assertGetHook(remote_branch._get_config(), 'file', 'branch')
2122
 
 
2123
 
    def test_get_hook_remote_bzrdir(self):
2124
 
        remote_bzrdir = bzrdir.BzrDir.open(self.get_url('tree'))
2125
 
        conf = remote_bzrdir._get_config()
2126
 
        conf.set_option('remotedir', 'file')
2127
 
        self.assertGetHook(conf, 'file', 'remotedir')
2128
 
 
2129
 
    def assertSetHook(self, conf, name, value):
2130
 
        calls = []
2131
 
        def hook(*args):
2132
 
            calls.append(args)
2133
 
        config.OldConfigHooks.install_named_hook('set', hook, None)
2134
 
        self.addCleanup(
2135
 
            config.OldConfigHooks.uninstall_named_hook, 'set', None)
2136
 
        self.assertLength(0, calls)
2137
 
        conf.set_option(value, name)
2138
 
        self.assertLength(1, calls)
2139
 
        # We can't assert the conf object below as different configs use
2140
 
        # different means to implement set_user_option and we care only about
2141
 
        # coverage here.
2142
 
        self.assertEquals((name, value), calls[0][1:])
2143
 
 
2144
 
    def test_set_hook_remote_branch(self):
2145
 
        remote_branch = branch.Branch.open(self.get_url('tree'))
2146
 
        self.addCleanup(remote_branch.lock_write().unlock)
2147
 
        self.assertSetHook(remote_branch._get_config(), 'file', 'remote')
2148
 
 
2149
 
    def test_set_hook_remote_bzrdir(self):
2150
 
        remote_branch = branch.Branch.open(self.get_url('tree'))
2151
 
        self.addCleanup(remote_branch.lock_write().unlock)
2152
 
        remote_bzrdir = bzrdir.BzrDir.open(self.get_url('tree'))
2153
 
        self.assertSetHook(remote_bzrdir._get_config(), 'file', 'remotedir')
2154
 
 
2155
 
    def assertLoadHook(self, expected_nb_calls, name, conf_class, *conf_args):
2156
 
        calls = []
2157
 
        def hook(*args):
2158
 
            calls.append(args)
2159
 
        config.OldConfigHooks.install_named_hook('load', hook, None)
2160
 
        self.addCleanup(
2161
 
            config.OldConfigHooks.uninstall_named_hook, 'load', None)
2162
 
        self.assertLength(0, calls)
2163
 
        # Build a config
2164
 
        conf = conf_class(*conf_args)
2165
 
        # Access an option to trigger a load
2166
 
        conf.get_option(name)
2167
 
        self.assertLength(expected_nb_calls, calls)
2168
 
        # Since we can't assert about conf, we just use the number of calls ;-/
2169
 
 
2170
 
    def test_load_hook_remote_branch(self):
2171
 
        remote_branch = branch.Branch.open(self.get_url('tree'))
2172
 
        self.assertLoadHook(1, 'file', remote.RemoteBranchConfig, remote_branch)
2173
 
 
2174
 
    def test_load_hook_remote_bzrdir(self):
2175
 
        remote_bzrdir = bzrdir.BzrDir.open(self.get_url('tree'))
2176
 
        # The config file doesn't exist, set an option to force its creation
2177
 
        conf = remote_bzrdir._get_config()
2178
 
        conf.set_option('remotedir', 'file')
2179
 
        # We get one call for the server and one call for the client, this is
2180
 
        # caused by the differences in implementations betwen
2181
 
        # SmartServerBzrDirRequestConfigFile (in smart/bzrdir.py) and
2182
 
        # SmartServerBranchGetConfigFile (in smart/branch.py)
2183
 
        self.assertLoadHook(2 ,'file', remote.RemoteBzrDirConfig, remote_bzrdir)
2184
 
 
2185
 
    def assertSaveHook(self, conf):
2186
 
        calls = []
2187
 
        def hook(*args):
2188
 
            calls.append(args)
2189
 
        config.OldConfigHooks.install_named_hook('save', hook, None)
2190
 
        self.addCleanup(
2191
 
            config.OldConfigHooks.uninstall_named_hook, 'save', None)
2192
 
        self.assertLength(0, calls)
2193
 
        # Setting an option triggers a save
2194
 
        conf.set_option('foo', 'bar')
2195
 
        self.assertLength(1, calls)
2196
 
        # Since we can't assert about conf, we just use the number of calls ;-/
2197
 
 
2198
 
    def test_save_hook_remote_branch(self):
2199
 
        remote_branch = branch.Branch.open(self.get_url('tree'))
2200
 
        self.addCleanup(remote_branch.lock_write().unlock)
2201
 
        self.assertSaveHook(remote_branch._get_config())
2202
 
 
2203
 
    def test_save_hook_remote_bzrdir(self):
2204
 
        remote_branch = branch.Branch.open(self.get_url('tree'))
2205
 
        self.addCleanup(remote_branch.lock_write().unlock)
2206
 
        remote_bzrdir = bzrdir.BzrDir.open(self.get_url('tree'))
2207
 
        self.assertSaveHook(remote_bzrdir._get_config())
2208
 
 
2209
 
 
2210
 
class TestOption(tests.TestCase):
2211
 
 
2212
 
    def test_default_value(self):
2213
 
        opt = config.Option('foo', default='bar')
2214
 
        self.assertEquals('bar', opt.get_default())
2215
 
 
2216
 
 
2217
 
class TestOptionRegistry(tests.TestCase):
2218
 
 
2219
 
    def setUp(self):
2220
 
        super(TestOptionRegistry, self).setUp()
2221
 
        # Always start with an empty registry
2222
 
        self.overrideAttr(config, 'option_registry', config.OptionRegistry())
2223
 
        self.registry = config.option_registry
2224
 
 
2225
 
    def test_register(self):
2226
 
        opt = config.Option('foo')
2227
 
        self.registry.register(opt)
2228
 
        self.assertIs(opt, self.registry.get('foo'))
2229
 
 
2230
 
    def test_registered_help(self):
2231
 
        opt = config.Option('foo', help='A simple option')
2232
 
        self.registry.register(opt)
2233
 
        self.assertEquals('A simple option', self.registry.get_help('foo'))
2234
 
 
2235
 
    lazy_option = config.Option('lazy_foo', help='Lazy help')
2236
 
 
2237
 
    def test_register_lazy(self):
2238
 
        self.registry.register_lazy('lazy_foo', self.__module__,
2239
 
                                    'TestOptionRegistry.lazy_option')
2240
 
        self.assertIs(self.lazy_option, self.registry.get('lazy_foo'))
2241
 
 
2242
 
    def test_registered_lazy_help(self):
2243
 
        self.registry.register_lazy('lazy_foo', self.__module__,
2244
 
                                    'TestOptionRegistry.lazy_option')
2245
 
        self.assertEquals('Lazy help', self.registry.get_help('lazy_foo'))
2246
 
 
2247
 
 
2248
 
class TestRegisteredOptions(tests.TestCase):
2249
 
    """All registered options should verify some constraints."""
2250
 
 
2251
 
    scenarios = [(key, {'option_name': key, 'option': option}) for key, option
2252
 
                 in config.option_registry.iteritems()]
2253
 
 
2254
 
    def setUp(self):
2255
 
        super(TestRegisteredOptions, self).setUp()
2256
 
        self.registry = config.option_registry
2257
 
 
2258
 
    def test_proper_name(self):
2259
 
        # An option should be registered under its own name, this can't be
2260
 
        # checked at registration time for the lazy ones.
2261
 
        self.assertEquals(self.option_name, self.option.name)
2262
 
 
2263
 
    def test_help_is_set(self):
2264
 
        option_help = self.registry.get_help(self.option_name)
2265
 
        self.assertNotEquals(None, option_help)
2266
 
        # Come on, think about the user, he really wants to know what the
2267
 
        # option is about
2268
 
        self.assertIsNot(None, option_help)
2269
 
        self.assertNotEquals('', option_help)
2270
 
 
2271
 
 
2272
 
class TestSection(tests.TestCase):
2273
 
 
2274
 
    # FIXME: Parametrize so that all sections produced by Stores run these
2275
 
    # tests -- vila 2011-04-01
2276
 
 
2277
 
    def test_get_a_value(self):
2278
 
        a_dict = dict(foo='bar')
2279
 
        section = config.Section('myID', a_dict)
2280
 
        self.assertEquals('bar', section.get('foo'))
2281
 
 
2282
 
    def test_get_unknown_option(self):
2283
 
        a_dict = dict()
2284
 
        section = config.Section(None, a_dict)
2285
 
        self.assertEquals('out of thin air',
2286
 
                          section.get('foo', 'out of thin air'))
2287
 
 
2288
 
    def test_options_is_shared(self):
2289
 
        a_dict = dict()
2290
 
        section = config.Section(None, a_dict)
2291
 
        self.assertIs(a_dict, section.options)
2292
 
 
2293
 
 
2294
 
class TestMutableSection(tests.TestCase):
2295
 
 
2296
 
    # FIXME: Parametrize so that all sections (including os.environ and the
2297
 
    # ones produced by Stores) run these tests -- vila 2011-04-01
2298
 
 
2299
 
    def test_set(self):
2300
 
        a_dict = dict(foo='bar')
2301
 
        section = config.MutableSection('myID', a_dict)
2302
 
        section.set('foo', 'new_value')
2303
 
        self.assertEquals('new_value', section.get('foo'))
2304
 
        # The change appears in the shared section
2305
 
        self.assertEquals('new_value', a_dict.get('foo'))
2306
 
        # We keep track of the change
2307
 
        self.assertTrue('foo' in section.orig)
2308
 
        self.assertEquals('bar', section.orig.get('foo'))
2309
 
 
2310
 
    def test_set_preserve_original_once(self):
2311
 
        a_dict = dict(foo='bar')
2312
 
        section = config.MutableSection('myID', a_dict)
2313
 
        section.set('foo', 'first_value')
2314
 
        section.set('foo', 'second_value')
2315
 
        # We keep track of the original value
2316
 
        self.assertTrue('foo' in section.orig)
2317
 
        self.assertEquals('bar', section.orig.get('foo'))
2318
 
 
2319
 
    def test_remove(self):
2320
 
        a_dict = dict(foo='bar')
2321
 
        section = config.MutableSection('myID', a_dict)
2322
 
        section.remove('foo')
2323
 
        # We get None for unknown options via the default value
2324
 
        self.assertEquals(None, section.get('foo'))
2325
 
        # Or we just get the default value
2326
 
        self.assertEquals('unknown', section.get('foo', 'unknown'))
2327
 
        self.assertFalse('foo' in section.options)
2328
 
        # We keep track of the deletion
2329
 
        self.assertTrue('foo' in section.orig)
2330
 
        self.assertEquals('bar', section.orig.get('foo'))
2331
 
 
2332
 
    def test_remove_new_option(self):
2333
 
        a_dict = dict()
2334
 
        section = config.MutableSection('myID', a_dict)
2335
 
        section.set('foo', 'bar')
2336
 
        section.remove('foo')
2337
 
        self.assertFalse('foo' in section.options)
2338
 
        # The option didn't exist initially so it we need to keep track of it
2339
 
        # with a special value
2340
 
        self.assertTrue('foo' in section.orig)
2341
 
        self.assertEquals(config._NewlyCreatedOption, section.orig['foo'])
2342
 
 
2343
 
 
2344
 
class TestStore(tests.TestCaseWithTransport):
2345
 
 
2346
 
    def assertSectionContent(self, expected, section):
2347
 
        """Assert that some options have the proper values in a section."""
2348
 
        expected_name, expected_options = expected
2349
 
        self.assertEquals(expected_name, section.id)
2350
 
        self.assertEquals(
2351
 
            expected_options,
2352
 
            dict([(k, section.get(k)) for k in expected_options.keys()]))
2353
 
 
2354
 
 
2355
 
class TestReadonlyStore(TestStore):
2356
 
 
2357
 
    scenarios = [(key, {'get_store': builder}) for key, builder
2358
 
                 in config.test_store_builder_registry.iteritems()]
2359
 
 
2360
 
    def setUp(self):
2361
 
        super(TestReadonlyStore, self).setUp()
2362
 
 
2363
 
    def test_building_delays_load(self):
2364
 
        store = self.get_store(self)
2365
 
        self.assertEquals(False, store.is_loaded())
2366
 
        store._load_from_string('')
2367
 
        self.assertEquals(True, store.is_loaded())
2368
 
 
2369
 
    def test_get_no_sections_for_empty(self):
2370
 
        store = self.get_store(self)
2371
 
        store._load_from_string('')
2372
 
        self.assertEquals([], list(store.get_sections()))
2373
 
 
2374
 
    def test_get_default_section(self):
2375
 
        store = self.get_store(self)
2376
 
        store._load_from_string('foo=bar')
2377
 
        sections = list(store.get_sections())
2378
 
        self.assertLength(1, sections)
2379
 
        self.assertSectionContent((None, {'foo': 'bar'}), sections[0])
2380
 
 
2381
 
    def test_get_named_section(self):
2382
 
        store = self.get_store(self)
2383
 
        store._load_from_string('[baz]\nfoo=bar')
2384
 
        sections = list(store.get_sections())
2385
 
        self.assertLength(1, sections)
2386
 
        self.assertSectionContent(('baz', {'foo': 'bar'}), sections[0])
2387
 
 
2388
 
    def test_load_from_string_fails_for_non_empty_store(self):
2389
 
        store = self.get_store(self)
2390
 
        store._load_from_string('foo=bar')
2391
 
        self.assertRaises(AssertionError, store._load_from_string, 'bar=baz')
2392
 
 
2393
 
 
2394
 
class TestIniFileStoreContent(tests.TestCaseWithTransport):
2395
 
    """Simulate loading a config store without content of various encodings.
2396
 
 
2397
 
    All files produced by bzr are in utf8 content.
2398
 
 
2399
 
    Users may modify them manually and end up with a file that can't be
2400
 
    loaded. We need to issue proper error messages in this case.
2401
 
    """
2402
 
 
2403
 
    invalid_utf8_char = '\xff'
2404
 
 
2405
 
    def test_load_utf8(self):
2406
 
        """Ensure we can load an utf8-encoded file."""
2407
 
        t = self.get_transport()
2408
 
        # From http://pad.lv/799212
2409
 
        unicode_user = u'b\N{Euro Sign}ar'
2410
 
        unicode_content = u'user=%s' % (unicode_user,)
2411
 
        utf8_content = unicode_content.encode('utf8')
2412
 
        # Store the raw content in the config file
2413
 
        t.put_bytes('foo.conf', utf8_content)
2414
 
        store = config.IniFileStore(t, 'foo.conf')
2415
 
        store.load()
2416
 
        stack = config.Stack([store.get_sections], store)
2417
 
        self.assertEquals(unicode_user, stack.get('user'))
2418
 
 
2419
 
    def test_load_non_ascii(self):
2420
 
        """Ensure we display a proper error on non-ascii, non utf-8 content."""
2421
 
        t = self.get_transport()
2422
 
        t.put_bytes('foo.conf', 'user=foo\n#%s\n' % (self.invalid_utf8_char,))
2423
 
        store = config.IniFileStore(t, 'foo.conf')
2424
 
        self.assertRaises(errors.ConfigContentError, store.load)
2425
 
 
2426
 
    def test_load_erroneous_content(self):
2427
 
        """Ensure we display a proper error on content that can't be parsed."""
2428
 
        t = self.get_transport()
2429
 
        t.put_bytes('foo.conf', '[open_section\n')
2430
 
        store = config.IniFileStore(t, 'foo.conf')
2431
 
        self.assertRaises(errors.ParseConfigError, store.load)
2432
 
 
2433
 
 
2434
 
class TestIniConfigContent(tests.TestCaseWithTransport):
2435
 
    """Simulate loading a IniBasedConfig without content of various encodings.
2436
 
 
2437
 
    All files produced by bzr are in utf8 content.
2438
 
 
2439
 
    Users may modify them manually and end up with a file that can't be
2440
 
    loaded. We need to issue proper error messages in this case.
2441
 
    """
2442
 
 
2443
 
    invalid_utf8_char = '\xff'
2444
 
 
2445
 
    def test_load_utf8(self):
2446
 
        """Ensure we can load an utf8-encoded file."""
2447
 
        # From http://pad.lv/799212
2448
 
        unicode_user = u'b\N{Euro Sign}ar'
2449
 
        unicode_content = u'user=%s' % (unicode_user,)
2450
 
        utf8_content = unicode_content.encode('utf8')
2451
 
        # Store the raw content in the config file
2452
 
        with open('foo.conf', 'wb') as f:
2453
 
            f.write(utf8_content)
2454
 
        conf = config.IniBasedConfig(file_name='foo.conf')
2455
 
        self.assertEquals(unicode_user, conf.get_user_option('user'))
2456
 
 
2457
 
    def test_load_badly_encoded_content(self):
2458
 
        """Ensure we display a proper error on non-ascii, non utf-8 content."""
2459
 
        with open('foo.conf', 'wb') as f:
2460
 
            f.write('user=foo\n#%s\n' % (self.invalid_utf8_char,))
2461
 
        conf = config.IniBasedConfig(file_name='foo.conf')
2462
 
        self.assertRaises(errors.ConfigContentError, conf._get_parser)
2463
 
 
2464
 
    def test_load_erroneous_content(self):
2465
 
        """Ensure we display a proper error on content that can't be parsed."""
2466
 
        with open('foo.conf', 'wb') as f:
2467
 
            f.write('[open_section\n')
2468
 
        conf = config.IniBasedConfig(file_name='foo.conf')
2469
 
        self.assertRaises(errors.ParseConfigError, conf._get_parser)
2470
 
 
2471
 
 
2472
 
class TestMutableStore(TestStore):
2473
 
 
2474
 
    scenarios = [(key, {'store_id': key, 'get_store': builder}) for key, builder
2475
 
                 in config.test_store_builder_registry.iteritems()]
2476
 
 
2477
 
    def setUp(self):
2478
 
        super(TestMutableStore, self).setUp()
2479
 
        self.transport = self.get_transport()
2480
 
 
2481
 
    def has_store(self, store):
2482
 
        store_basename = urlutils.relative_url(self.transport.external_url(),
2483
 
                                               store.external_url())
2484
 
        return self.transport.has(store_basename)
2485
 
 
2486
 
    def test_save_empty_creates_no_file(self):
2487
 
        # FIXME: There should be a better way than relying on the test
2488
 
        # parametrization to identify branch.conf -- vila 2011-0526
2489
 
        if self.store_id in ('branch', 'remote_branch'):
2490
 
            raise tests.TestNotApplicable(
2491
 
                'branch.conf is *always* created when a branch is initialized')
2492
 
        store = self.get_store(self)
2493
 
        store.save()
2494
 
        self.assertEquals(False, self.has_store(store))
2495
 
 
2496
 
    def test_save_emptied_succeeds(self):
2497
 
        store = self.get_store(self)
2498
 
        store._load_from_string('foo=bar\n')
2499
 
        section = store.get_mutable_section(None)
2500
 
        section.remove('foo')
2501
 
        store.save()
2502
 
        self.assertEquals(True, self.has_store(store))
2503
 
        modified_store = self.get_store(self)
2504
 
        sections = list(modified_store.get_sections())
2505
 
        self.assertLength(0, sections)
2506
 
 
2507
 
    def test_save_with_content_succeeds(self):
2508
 
        # FIXME: There should be a better way than relying on the test
2509
 
        # parametrization to identify branch.conf -- vila 2011-0526
2510
 
        if self.store_id in ('branch', 'remote_branch'):
2511
 
            raise tests.TestNotApplicable(
2512
 
                'branch.conf is *always* created when a branch is initialized')
2513
 
        store = self.get_store(self)
2514
 
        store._load_from_string('foo=bar\n')
2515
 
        self.assertEquals(False, self.has_store(store))
2516
 
        store.save()
2517
 
        self.assertEquals(True, self.has_store(store))
2518
 
        modified_store = self.get_store(self)
2519
 
        sections = list(modified_store.get_sections())
2520
 
        self.assertLength(1, sections)
2521
 
        self.assertSectionContent((None, {'foo': 'bar'}), sections[0])
2522
 
 
2523
 
    def test_set_option_in_empty_store(self):
2524
 
        store = self.get_store(self)
2525
 
        section = store.get_mutable_section(None)
2526
 
        section.set('foo', 'bar')
2527
 
        store.save()
2528
 
        modified_store = self.get_store(self)
2529
 
        sections = list(modified_store.get_sections())
2530
 
        self.assertLength(1, sections)
2531
 
        self.assertSectionContent((None, {'foo': 'bar'}), sections[0])
2532
 
 
2533
 
    def test_set_option_in_default_section(self):
2534
 
        store = self.get_store(self)
2535
 
        store._load_from_string('')
2536
 
        section = store.get_mutable_section(None)
2537
 
        section.set('foo', 'bar')
2538
 
        store.save()
2539
 
        modified_store = self.get_store(self)
2540
 
        sections = list(modified_store.get_sections())
2541
 
        self.assertLength(1, sections)
2542
 
        self.assertSectionContent((None, {'foo': 'bar'}), sections[0])
2543
 
 
2544
 
    def test_set_option_in_named_section(self):
2545
 
        store = self.get_store(self)
2546
 
        store._load_from_string('')
2547
 
        section = store.get_mutable_section('baz')
2548
 
        section.set('foo', 'bar')
2549
 
        store.save()
2550
 
        modified_store = self.get_store(self)
2551
 
        sections = list(modified_store.get_sections())
2552
 
        self.assertLength(1, sections)
2553
 
        self.assertSectionContent(('baz', {'foo': 'bar'}), sections[0])
2554
 
 
2555
 
    def test_load_hook(self):
2556
 
        # We first needs to ensure that the store exists
2557
 
        store = self.get_store(self)
2558
 
        section = store.get_mutable_section('baz')
2559
 
        section.set('foo', 'bar')
2560
 
        store.save()
2561
 
        # Now we can try to load it
2562
 
        store = self.get_store(self)
2563
 
        calls = []
2564
 
        def hook(*args):
2565
 
            calls.append(args)
2566
 
        config.ConfigHooks.install_named_hook('load', hook, None)
2567
 
        self.assertLength(0, calls)
2568
 
        store.load()
2569
 
        self.assertLength(1, calls)
2570
 
        self.assertEquals((store,), calls[0])
2571
 
 
2572
 
    def test_save_hook(self):
2573
 
        calls = []
2574
 
        def hook(*args):
2575
 
            calls.append(args)
2576
 
        config.ConfigHooks.install_named_hook('save', hook, None)
2577
 
        self.assertLength(0, calls)
2578
 
        store = self.get_store(self)
2579
 
        section = store.get_mutable_section('baz')
2580
 
        section.set('foo', 'bar')
2581
 
        store.save()
2582
 
        self.assertLength(1, calls)
2583
 
        self.assertEquals((store,), calls[0])
2584
 
 
2585
 
 
2586
 
class TestIniFileStore(TestStore):
2587
 
 
2588
 
    def test_loading_unknown_file_fails(self):
2589
 
        store = config.IniFileStore(self.get_transport(), 'I-do-not-exist')
2590
 
        self.assertRaises(errors.NoSuchFile, store.load)
2591
 
 
2592
 
    def test_invalid_content(self):
2593
 
        store = config.IniFileStore(self.get_transport(), 'foo.conf', )
2594
 
        self.assertEquals(False, store.is_loaded())
2595
 
        exc = self.assertRaises(
2596
 
            errors.ParseConfigError, store._load_from_string,
2597
 
            'this is invalid !')
2598
 
        self.assertEndsWith(exc.filename, 'foo.conf')
2599
 
        # And the load failed
2600
 
        self.assertEquals(False, store.is_loaded())
2601
 
 
2602
 
    def test_get_embedded_sections(self):
2603
 
        # A more complicated example (which also shows that section names and
2604
 
        # option names share the same name space...)
2605
 
        # FIXME: This should be fixed by forbidding dicts as values ?
2606
 
        # -- vila 2011-04-05
2607
 
        store = config.IniFileStore(self.get_transport(), 'foo.conf', )
2608
 
        store._load_from_string('''
2609
 
foo=bar
2610
 
l=1,2
2611
 
[DEFAULT]
2612
 
foo_in_DEFAULT=foo_DEFAULT
2613
 
[bar]
2614
 
foo_in_bar=barbar
2615
 
[baz]
2616
 
foo_in_baz=barbaz
2617
 
[[qux]]
2618
 
foo_in_qux=quux
2619
 
''')
2620
 
        sections = list(store.get_sections())
2621
 
        self.assertLength(4, sections)
2622
 
        # The default section has no name.
2623
 
        # List values are provided as lists
2624
 
        self.assertSectionContent((None, {'foo': 'bar', 'l': ['1', '2']}),
2625
 
                                  sections[0])
2626
 
        self.assertSectionContent(
2627
 
            ('DEFAULT', {'foo_in_DEFAULT': 'foo_DEFAULT'}), sections[1])
2628
 
        self.assertSectionContent(
2629
 
            ('bar', {'foo_in_bar': 'barbar'}), sections[2])
2630
 
        # sub sections are provided as embedded dicts.
2631
 
        self.assertSectionContent(
2632
 
            ('baz', {'foo_in_baz': 'barbaz', 'qux': {'foo_in_qux': 'quux'}}),
2633
 
            sections[3])
2634
 
 
2635
 
 
2636
 
class TestLockableIniFileStore(TestStore):
2637
 
 
2638
 
    def test_create_store_in_created_dir(self):
2639
 
        self.assertPathDoesNotExist('dir')
2640
 
        t = self.get_transport('dir/subdir')
2641
 
        store = config.LockableIniFileStore(t, 'foo.conf')
2642
 
        store.get_mutable_section(None).set('foo', 'bar')
2643
 
        store.save()
2644
 
        self.assertPathExists('dir/subdir')
2645
 
 
2646
 
 
2647
 
class TestConcurrentStoreUpdates(TestStore):
2648
 
    """Test that Stores properly handle conccurent updates.
2649
 
 
2650
 
    New Store implementation may fail some of these tests but until such
2651
 
    implementations exist it's hard to properly filter them from the scenarios
2652
 
    applied here. If you encounter such a case, contact the bzr devs.
2653
 
    """
2654
 
 
2655
 
    scenarios = [(key, {'get_stack': builder}) for key, builder
2656
 
                 in config.test_stack_builder_registry.iteritems()]
2657
 
 
2658
 
    def setUp(self):
2659
 
        super(TestConcurrentStoreUpdates, self).setUp()
2660
 
        self._content = 'one=1\ntwo=2\n'
2661
 
        self.stack = self.get_stack(self)
2662
 
        if not isinstance(self.stack, config._CompatibleStack):
2663
 
            raise tests.TestNotApplicable(
2664
 
                '%s is not meant to be compatible with the old config design'
2665
 
                % (self.stack,))
2666
 
        self.stack.store._load_from_string(self._content)
2667
 
        # Flush the store
2668
 
        self.stack.store.save()
2669
 
 
2670
 
    def test_simple_read_access(self):
2671
 
        self.assertEquals('1', self.stack.get('one'))
2672
 
 
2673
 
    def test_simple_write_access(self):
2674
 
        self.stack.set('one', 'one')
2675
 
        self.assertEquals('one', self.stack.get('one'))
2676
 
 
2677
 
    def test_listen_to_the_last_speaker(self):
2678
 
        c1 = self.stack
2679
 
        c2 = self.get_stack(self)
2680
 
        c1.set('one', 'ONE')
2681
 
        c2.set('two', 'TWO')
2682
 
        self.assertEquals('ONE', c1.get('one'))
2683
 
        self.assertEquals('TWO', c2.get('two'))
2684
 
        # The second update respect the first one
2685
 
        self.assertEquals('ONE', c2.get('one'))
2686
 
 
2687
 
    def test_last_speaker_wins(self):
2688
 
        # If the same config is not shared, the same variable modified twice
2689
 
        # can only see a single result.
2690
 
        c1 = self.stack
2691
 
        c2 = self.get_stack(self)
2692
 
        c1.set('one', 'c1')
2693
 
        c2.set('one', 'c2')
2694
 
        self.assertEquals('c2', c2.get('one'))
2695
 
        # The first modification is still available until another refresh
2696
 
        # occur
2697
 
        self.assertEquals('c1', c1.get('one'))
2698
 
        c1.set('two', 'done')
2699
 
        self.assertEquals('c2', c1.get('one'))
2700
 
 
2701
 
    def test_writes_are_serialized(self):
2702
 
        c1 = self.stack
2703
 
        c2 = self.get_stack(self)
2704
 
 
2705
 
        # We spawn a thread that will pause *during* the config saving.
2706
 
        before_writing = threading.Event()
2707
 
        after_writing = threading.Event()
2708
 
        writing_done = threading.Event()
2709
 
        c1_save_without_locking_orig = c1.store.save_without_locking
2710
 
        def c1_save_without_locking():
2711
 
            before_writing.set()
2712
 
            c1_save_without_locking_orig()
2713
 
            # The lock is held. We wait for the main thread to decide when to
2714
 
            # continue
2715
 
            after_writing.wait()
2716
 
        c1.store.save_without_locking = c1_save_without_locking
2717
 
        def c1_set():
2718
 
            c1.set('one', 'c1')
2719
 
            writing_done.set()
2720
 
        t1 = threading.Thread(target=c1_set)
2721
 
        # Collect the thread after the test
2722
 
        self.addCleanup(t1.join)
2723
 
        # Be ready to unblock the thread if the test goes wrong
2724
 
        self.addCleanup(after_writing.set)
2725
 
        t1.start()
2726
 
        before_writing.wait()
2727
 
        self.assertRaises(errors.LockContention,
2728
 
                          c2.set, 'one', 'c2')
2729
 
        self.assertEquals('c1', c1.get('one'))
2730
 
        # Let the lock be released
2731
 
        after_writing.set()
2732
 
        writing_done.wait()
2733
 
        c2.set('one', 'c2')
2734
 
        self.assertEquals('c2', c2.get('one'))
2735
 
 
2736
 
    def test_read_while_writing(self):
2737
 
       c1 = self.stack
2738
 
       # We spawn a thread that will pause *during* the write
2739
 
       ready_to_write = threading.Event()
2740
 
       do_writing = threading.Event()
2741
 
       writing_done = threading.Event()
2742
 
       # We override the _save implementation so we know the store is locked
2743
 
       c1_save_without_locking_orig = c1.store.save_without_locking
2744
 
       def c1_save_without_locking():
2745
 
           ready_to_write.set()
2746
 
           # The lock is held. We wait for the main thread to decide when to
2747
 
           # continue
2748
 
           do_writing.wait()
2749
 
           c1_save_without_locking_orig()
2750
 
           writing_done.set()
2751
 
       c1.store.save_without_locking = c1_save_without_locking
2752
 
       def c1_set():
2753
 
           c1.set('one', 'c1')
2754
 
       t1 = threading.Thread(target=c1_set)
2755
 
       # Collect the thread after the test
2756
 
       self.addCleanup(t1.join)
2757
 
       # Be ready to unblock the thread if the test goes wrong
2758
 
       self.addCleanup(do_writing.set)
2759
 
       t1.start()
2760
 
       # Ensure the thread is ready to write
2761
 
       ready_to_write.wait()
2762
 
       self.assertEquals('c1', c1.get('one'))
2763
 
       # If we read during the write, we get the old value
2764
 
       c2 = self.get_stack(self)
2765
 
       self.assertEquals('1', c2.get('one'))
2766
 
       # Let the writing occur and ensure it occurred
2767
 
       do_writing.set()
2768
 
       writing_done.wait()
2769
 
       # Now we get the updated value
2770
 
       c3 = self.get_stack(self)
2771
 
       self.assertEquals('c1', c3.get('one'))
2772
 
 
2773
 
    # FIXME: It may be worth looking into removing the lock dir when it's not
2774
 
    # needed anymore and look at possible fallouts for concurrent lockers. This
2775
 
    # will matter if/when we use config files outside of bazaar directories
2776
 
    # (.bazaar or .bzr) -- vila 20110-04-11
2777
 
 
2778
 
 
2779
 
class TestSectionMatcher(TestStore):
2780
 
 
2781
 
    scenarios = [('location', {'matcher': config.LocationMatcher})]
2782
 
 
2783
 
    def get_store(self, file_name):
2784
 
        return config.IniFileStore(self.get_readonly_transport(), file_name)
2785
 
 
2786
 
    def test_no_matches_for_empty_stores(self):
2787
 
        store = self.get_store('foo.conf')
2788
 
        store._load_from_string('')
2789
 
        matcher = self.matcher(store, '/bar')
2790
 
        self.assertEquals([], list(matcher.get_sections()))
2791
 
 
2792
 
    def test_build_doesnt_load_store(self):
2793
 
        store = self.get_store('foo.conf')
2794
 
        matcher = self.matcher(store, '/bar')
2795
 
        self.assertFalse(store.is_loaded())
2796
 
 
2797
 
 
2798
 
class TestLocationSection(tests.TestCase):
2799
 
 
2800
 
    def get_section(self, options, extra_path):
2801
 
        section = config.Section('foo', options)
2802
 
        # We don't care about the length so we use '0'
2803
 
        return config.LocationSection(section, 0, extra_path)
2804
 
 
2805
 
    def test_simple_option(self):
2806
 
        section = self.get_section({'foo': 'bar'}, '')
2807
 
        self.assertEquals('bar', section.get('foo'))
2808
 
 
2809
 
    def test_option_with_extra_path(self):
2810
 
        section = self.get_section({'foo': 'bar', 'foo:policy': 'appendpath'},
2811
 
                                   'baz')
2812
 
        self.assertEquals('bar/baz', section.get('foo'))
2813
 
 
2814
 
    def test_invalid_policy(self):
2815
 
        section = self.get_section({'foo': 'bar', 'foo:policy': 'die'},
2816
 
                                   'baz')
2817
 
        # invalid policies are ignored
2818
 
        self.assertEquals('bar', section.get('foo'))
2819
 
 
2820
 
 
2821
 
class TestLocationMatcher(TestStore):
2822
 
 
2823
 
    def get_store(self, file_name):
2824
 
        return config.IniFileStore(self.get_readonly_transport(), file_name)
2825
 
 
2826
 
    def test_more_specific_sections_first(self):
2827
 
        store = self.get_store('foo.conf')
2828
 
        store._load_from_string('''
2829
 
[/foo]
2830
 
section=/foo
2831
 
[/foo/bar]
2832
 
section=/foo/bar
2833
 
''')
2834
 
        self.assertEquals(['/foo', '/foo/bar'],
2835
 
                          [section.id for section in store.get_sections()])
2836
 
        matcher = config.LocationMatcher(store, '/foo/bar/baz')
2837
 
        sections = list(matcher.get_sections())
2838
 
        self.assertEquals([3, 2],
2839
 
                          [section.length for section in sections])
2840
 
        self.assertEquals(['/foo/bar', '/foo'],
2841
 
                          [section.id for section in sections])
2842
 
        self.assertEquals(['baz', 'bar/baz'],
2843
 
                          [section.extra_path for section in sections])
2844
 
 
2845
 
    def test_appendpath_in_no_name_section(self):
2846
 
        # It's a bit weird to allow appendpath in a no-name section, but
2847
 
        # someone may found a use for it
2848
 
        store = self.get_store('foo.conf')
2849
 
        store._load_from_string('''
2850
 
foo=bar
2851
 
foo:policy = appendpath
2852
 
''')
2853
 
        matcher = config.LocationMatcher(store, 'dir/subdir')
2854
 
        sections = list(matcher.get_sections())
2855
 
        self.assertLength(1, sections)
2856
 
        self.assertEquals('bar/dir/subdir', sections[0].get('foo'))
2857
 
 
2858
 
    def test_file_urls_are_normalized(self):
2859
 
        store = self.get_store('foo.conf')
2860
 
        if sys.platform == 'win32':
2861
 
            expected_url = 'file:///C:/dir/subdir'
2862
 
            expected_location = 'C:/dir/subdir'
2863
 
        else:
2864
 
            expected_url = 'file:///dir/subdir'
2865
 
            expected_location = '/dir/subdir'
2866
 
        matcher = config.LocationMatcher(store, expected_url)
2867
 
        self.assertEquals(expected_location, matcher.location)
2868
 
 
2869
 
 
2870
 
class TestStackGet(tests.TestCase):
2871
 
 
2872
 
    # FIXME: This should be parametrized for all known Stack or dedicated
2873
 
    # paramerized tests created to avoid bloating -- vila 2011-03-31
2874
 
 
2875
 
    def overrideOptionRegistry(self):
2876
 
        self.overrideAttr(config, 'option_registry', config.OptionRegistry())
2877
 
 
2878
 
    def test_single_config_get(self):
2879
 
        conf = dict(foo='bar')
2880
 
        conf_stack = config.Stack([conf])
2881
 
        self.assertEquals('bar', conf_stack.get('foo'))
2882
 
 
2883
 
    def test_get_with_registered_default_value(self):
2884
 
        conf_stack = config.Stack([dict()])
2885
 
        opt = config.Option('foo', default='bar')
2886
 
        self.overrideOptionRegistry()
2887
 
        config.option_registry.register('foo', opt)
2888
 
        self.assertEquals('bar', conf_stack.get('foo'))
2889
 
 
2890
 
    def test_get_without_registered_default_value(self):
2891
 
        conf_stack = config.Stack([dict()])
2892
 
        opt = config.Option('foo')
2893
 
        self.overrideOptionRegistry()
2894
 
        config.option_registry.register('foo', opt)
2895
 
        self.assertEquals(None, conf_stack.get('foo'))
2896
 
 
2897
 
    def test_get_without_default_value_for_not_registered(self):
2898
 
        conf_stack = config.Stack([dict()])
2899
 
        opt = config.Option('foo')
2900
 
        self.overrideOptionRegistry()
2901
 
        self.assertEquals(None, conf_stack.get('foo'))
2902
 
 
2903
 
    def test_get_first_definition(self):
2904
 
        conf1 = dict(foo='bar')
2905
 
        conf2 = dict(foo='baz')
2906
 
        conf_stack = config.Stack([conf1, conf2])
2907
 
        self.assertEquals('bar', conf_stack.get('foo'))
2908
 
 
2909
 
    def test_get_embedded_definition(self):
2910
 
        conf1 = dict(yy='12')
2911
 
        conf2 = config.Stack([dict(xx='42'), dict(foo='baz')])
2912
 
        conf_stack = config.Stack([conf1, conf2])
2913
 
        self.assertEquals('baz', conf_stack.get('foo'))
2914
 
 
2915
 
    def test_get_for_empty_section_callable(self):
2916
 
        conf_stack = config.Stack([lambda : []])
2917
 
        self.assertEquals(None, conf_stack.get('foo'))
2918
 
 
2919
 
    def test_get_for_broken_callable(self):
2920
 
        # Trying to use and invalid callable raises an exception on first use
2921
 
        conf_stack = config.Stack([lambda : object()])
2922
 
        self.assertRaises(TypeError, conf_stack.get, 'foo')
2923
 
 
2924
 
 
2925
 
class TestStackWithTransport(tests.TestCaseWithTransport):
2926
 
 
2927
 
    scenarios = [(key, {'get_stack': builder}) for key, builder
2928
 
                 in config.test_stack_builder_registry.iteritems()]
2929
 
 
2930
 
 
2931
 
class TestConcreteStacks(TestStackWithTransport):
2932
 
 
2933
 
    def test_build_stack(self):
2934
 
        # Just a smoke test to help debug builders
2935
 
        stack = self.get_stack(self)
2936
 
 
2937
 
 
2938
 
class TestStackGet(TestStackWithTransport):
2939
 
 
2940
 
    def setUp(self):
2941
 
        super(TestStackGet, self).setUp()
2942
 
        self.conf = self.get_stack(self)
2943
 
 
2944
 
    def test_get_for_empty_stack(self):
2945
 
        self.assertEquals(None, self.conf.get('foo'))
2946
 
 
2947
 
    def test_get_hook(self):
2948
 
        self.conf.store._load_from_string('foo=bar')
2949
 
        calls = []
2950
 
        def hook(*args):
2951
 
            calls.append(args)
2952
 
        config.ConfigHooks.install_named_hook('get', hook, None)
2953
 
        self.assertLength(0, calls)
2954
 
        value = self.conf.get('foo')
2955
 
        self.assertEquals('bar', value)
2956
 
        self.assertLength(1, calls)
2957
 
        self.assertEquals((self.conf, 'foo', 'bar'), calls[0])
2958
 
 
2959
 
 
2960
 
class TestStackGetWithConverter(TestStackGet):
2961
 
 
2962
 
    def setUp(self):
2963
 
        super(TestStackGetWithConverter, self).setUp()
2964
 
        self.overrideAttr(config, 'option_registry', config.OptionRegistry())
2965
 
        self.registry = config.option_registry
2966
 
 
2967
 
    def register_bool_option(self, name, default, invalid=None):
2968
 
        b = config.Option(name, default=default, help='A boolean.',
2969
 
                          from_unicode=config.bool_from_store,
2970
 
                          invalid=invalid)
2971
 
        self.registry.register(b)
2972
 
 
2973
 
    def test_get_with_bool_not_defined_default_true(self):
2974
 
        self.register_bool_option('foo', True)
2975
 
        self.assertEquals(True, self.conf.get('foo'))
2976
 
 
2977
 
    def test_get_with_bool_not_defined_default_false(self):
2978
 
        self.register_bool_option('foo', False)
2979
 
        self.assertEquals(False, self.conf.get('foo'))
2980
 
 
2981
 
    def test_get_with_bool_converter_not_default(self):
2982
 
        self.register_bool_option('foo', False)
2983
 
        self.conf.store._load_from_string('foo=yes')
2984
 
        self.assertEquals(True, self.conf.get('foo'))
2985
 
 
2986
 
    def test_get_with_bool_converter_invalid_string(self):
2987
 
        self.register_bool_option('foo', False)
2988
 
        self.conf.store._load_from_string('foo=not-a-boolean')
2989
 
        self.assertEquals(False, self.conf.get('foo'))
2990
 
 
2991
 
    def test_get_with_bool_converter_invalid_list(self):
2992
 
        self.register_bool_option('foo', False)
2993
 
        self.conf.store._load_from_string('foo=not,a,boolean')
2994
 
        self.assertEquals(False, self.conf.get('foo'))
2995
 
 
2996
 
    def test_get_invalid_warns(self):
2997
 
        self.register_bool_option('foo', False, invalid='warning')
2998
 
        self.conf.store._load_from_string('foo=not-a-boolean')
2999
 
        warnings = []
3000
 
        def warning(*args):
3001
 
            warnings.append(args[0] % args[1:])
3002
 
        self.overrideAttr(trace, 'warning', warning)
3003
 
        self.assertEquals(False, self.conf.get('foo'))
3004
 
        self.assertLength(1, warnings)
3005
 
        self.assertEquals('Value "not-a-boolean" is not valid for "foo"',
3006
 
                          warnings[0])
3007
 
 
3008
 
    def test_get_invalid_errors(self):
3009
 
        self.register_bool_option('foo', False, invalid='error')
3010
 
        self.conf.store._load_from_string('foo=not-a-boolean')
3011
 
        self.assertRaises(errors.ConfigOptionValueError, self.conf.get, 'foo')
3012
 
 
3013
 
    def register_integer_option(self, name, default):
3014
 
        i = config.Option(name, default=default, help='An integer.',
3015
 
                          from_unicode=config.int_from_store)
3016
 
        self.registry.register(i)
3017
 
 
3018
 
    def test_get_with_integer_not_defined_returns_default(self):
3019
 
        self.register_integer_option('foo', 42)
3020
 
        self.assertEquals(42, self.conf.get('foo'))
3021
 
 
3022
 
    def test_get_with_integer_converter_not_default(self):
3023
 
        self.register_integer_option('foo', 42)
3024
 
        self.conf.store._load_from_string('foo=16')
3025
 
        self.assertEquals(16, self.conf.get('foo'))
3026
 
 
3027
 
    def test_get_with_integer_converter_invalid_string(self):
3028
 
        # We don't set a default value
3029
 
        self.register_integer_option('foo', None)
3030
 
        self.conf.store._load_from_string('foo=forty-two')
3031
 
        # No default value, so we should get None
3032
 
        self.assertEquals(None, self.conf.get('foo'))
3033
 
 
3034
 
    def test_get_with_integer_converter_invalid_list(self):
3035
 
        # We don't set a default value
3036
 
        self.register_integer_option('foo', None)
3037
 
        self.conf.store._load_from_string('foo=a,list')
3038
 
        # No default value, so we should get None
3039
 
        self.assertEquals(None, self.conf.get('foo'))
3040
 
 
3041
 
    def register_list_option(self, name, default):
3042
 
        l = config.Option(name, default=default, help='A list.',
3043
 
                          from_unicode=config.list_from_store)
3044
 
        self.registry.register(l)
3045
 
 
3046
 
    def test_get_with_list_not_defined_returns_default(self):
3047
 
        self.register_list_option('foo', [])
3048
 
        self.assertEquals([], self.conf.get('foo'))
3049
 
 
3050
 
    def test_get_with_list_converter_nothing(self):
3051
 
        self.register_list_option('foo', [1])
3052
 
        self.conf.store._load_from_string('foo=')
3053
 
        self.assertEquals([], self.conf.get('foo'))
3054
 
 
3055
 
    def test_get_with_list_converter_no_item(self):
3056
 
        self.register_list_option('foo', [1])
3057
 
        self.conf.store._load_from_string('foo=,')
3058
 
        self.assertEquals([], self.conf.get('foo'))
3059
 
 
3060
 
    def test_get_with_list_converter_one_boolean(self):
3061
 
        self.register_list_option('foo', [1])
3062
 
        self.conf.store._load_from_string('foo=True')
3063
 
        # We get a list of one string
3064
 
        self.assertEquals(['True'], self.conf.get('foo'))
3065
 
 
3066
 
    def test_get_with_list_converter_one_integer(self):
3067
 
        self.register_list_option('foo', [1])
3068
 
        self.conf.store._load_from_string('foo=2')
3069
 
        # We get a list of one string
3070
 
        self.assertEquals(['2'], self.conf.get('foo'))
3071
 
 
3072
 
    def test_get_with_list_converter_one_string(self):
3073
 
        self.register_list_option('foo', ['foo'])
3074
 
        self.conf.store._load_from_string('foo=bar')
3075
 
        # We get a list of one string
3076
 
        self.assertEquals(['bar'], self.conf.get('foo'))
3077
 
 
3078
 
    def test_get_with_list_converter_many_items(self):
3079
 
        self.register_list_option('foo', [1])
3080
 
        self.conf.store._load_from_string('foo=m,o,r,e')
3081
 
        self.assertEquals(['m', 'o', 'r', 'e'], self.conf.get('foo'))
3082
 
 
3083
 
 
3084
 
class TestStackSet(TestStackWithTransport):
3085
 
 
3086
 
    def test_simple_set(self):
3087
 
        conf = self.get_stack(self)
3088
 
        conf.store._load_from_string('foo=bar')
3089
 
        self.assertEquals('bar', conf.get('foo'))
3090
 
        conf.set('foo', 'baz')
3091
 
        # Did we get it back ?
3092
 
        self.assertEquals('baz', conf.get('foo'))
3093
 
 
3094
 
    def test_set_creates_a_new_section(self):
3095
 
        conf = self.get_stack(self)
3096
 
        conf.set('foo', 'baz')
3097
 
        self.assertEquals, 'baz', conf.get('foo')
3098
 
 
3099
 
    def test_set_hook(self):
3100
 
        calls = []
3101
 
        def hook(*args):
3102
 
            calls.append(args)
3103
 
        config.ConfigHooks.install_named_hook('set', hook, None)
3104
 
        self.assertLength(0, calls)
3105
 
        conf = self.get_stack(self)
3106
 
        conf.set('foo', 'bar')
3107
 
        self.assertLength(1, calls)
3108
 
        self.assertEquals((conf, 'foo', 'bar'), calls[0])
3109
 
 
3110
 
 
3111
 
class TestStackRemove(TestStackWithTransport):
3112
 
 
3113
 
    def test_remove_existing(self):
3114
 
        conf = self.get_stack(self)
3115
 
        conf.store._load_from_string('foo=bar')
3116
 
        self.assertEquals('bar', conf.get('foo'))
3117
 
        conf.remove('foo')
3118
 
        # Did we get it back ?
3119
 
        self.assertEquals(None, conf.get('foo'))
3120
 
 
3121
 
    def test_remove_unknown(self):
3122
 
        conf = self.get_stack(self)
3123
 
        self.assertRaises(KeyError, conf.remove, 'I_do_not_exist')
3124
 
 
3125
 
    def test_remove_hook(self):
3126
 
        calls = []
3127
 
        def hook(*args):
3128
 
            calls.append(args)
3129
 
        config.ConfigHooks.install_named_hook('remove', hook, None)
3130
 
        self.assertLength(0, calls)
3131
 
        conf = self.get_stack(self)
3132
 
        conf.store._load_from_string('foo=bar')
3133
 
        conf.remove('foo')
3134
 
        self.assertLength(1, calls)
3135
 
        self.assertEquals((conf, 'foo'), calls[0])
3136
 
 
3137
 
 
3138
 
class TestConfigGetOptions(tests.TestCaseWithTransport, TestOptionsMixin):
3139
 
 
3140
 
    def setUp(self):
3141
 
        super(TestConfigGetOptions, self).setUp()
3142
 
        create_configs(self)
3143
 
 
3144
 
    def test_no_variable(self):
3145
 
        # Using branch should query branch, locations and bazaar
3146
 
        self.assertOptions([], self.branch_config)
3147
 
 
3148
 
    def test_option_in_bazaar(self):
3149
 
        self.bazaar_config.set_user_option('file', 'bazaar')
3150
 
        self.assertOptions([('file', 'bazaar', 'DEFAULT', 'bazaar')],
3151
 
                           self.bazaar_config)
3152
 
 
3153
 
    def test_option_in_locations(self):
3154
 
        self.locations_config.set_user_option('file', 'locations')
3155
 
        self.assertOptions(
3156
 
            [('file', 'locations', self.tree.basedir, 'locations')],
3157
 
            self.locations_config)
3158
 
 
3159
 
    def test_option_in_branch(self):
3160
 
        self.branch_config.set_user_option('file', 'branch')
3161
 
        self.assertOptions([('file', 'branch', 'DEFAULT', 'branch')],
3162
 
                           self.branch_config)
3163
 
 
3164
 
    def test_option_in_bazaar_and_branch(self):
3165
 
        self.bazaar_config.set_user_option('file', 'bazaar')
3166
 
        self.branch_config.set_user_option('file', 'branch')
3167
 
        self.assertOptions([('file', 'branch', 'DEFAULT', 'branch'),
3168
 
                            ('file', 'bazaar', 'DEFAULT', 'bazaar'),],
3169
 
                           self.branch_config)
3170
 
 
3171
 
    def test_option_in_branch_and_locations(self):
3172
 
        # Hmm, locations override branch :-/
3173
 
        self.locations_config.set_user_option('file', 'locations')
3174
 
        self.branch_config.set_user_option('file', 'branch')
3175
 
        self.assertOptions(
3176
 
            [('file', 'locations', self.tree.basedir, 'locations'),
3177
 
             ('file', 'branch', 'DEFAULT', 'branch'),],
3178
 
            self.branch_config)
3179
 
 
3180
 
    def test_option_in_bazaar_locations_and_branch(self):
3181
 
        self.bazaar_config.set_user_option('file', 'bazaar')
3182
 
        self.locations_config.set_user_option('file', 'locations')
3183
 
        self.branch_config.set_user_option('file', 'branch')
3184
 
        self.assertOptions(
3185
 
            [('file', 'locations', self.tree.basedir, 'locations'),
3186
 
             ('file', 'branch', 'DEFAULT', 'branch'),
3187
 
             ('file', 'bazaar', 'DEFAULT', 'bazaar'),],
3188
 
            self.branch_config)
3189
 
 
3190
 
 
3191
 
class TestConfigRemoveOption(tests.TestCaseWithTransport, TestOptionsMixin):
3192
 
 
3193
 
    def setUp(self):
3194
 
        super(TestConfigRemoveOption, self).setUp()
3195
 
        create_configs_with_file_option(self)
3196
 
 
3197
 
    def test_remove_in_locations(self):
3198
 
        self.locations_config.remove_user_option('file', self.tree.basedir)
3199
 
        self.assertOptions(
3200
 
            [('file', 'branch', 'DEFAULT', 'branch'),
3201
 
             ('file', 'bazaar', 'DEFAULT', 'bazaar'),],
3202
 
            self.branch_config)
3203
 
 
3204
 
    def test_remove_in_branch(self):
3205
 
        self.branch_config.remove_user_option('file')
3206
 
        self.assertOptions(
3207
 
            [('file', 'locations', self.tree.basedir, 'locations'),
3208
 
             ('file', 'bazaar', 'DEFAULT', 'bazaar'),],
3209
 
            self.branch_config)
3210
 
 
3211
 
    def test_remove_in_bazaar(self):
3212
 
        self.bazaar_config.remove_user_option('file')
3213
 
        self.assertOptions(
3214
 
            [('file', 'locations', self.tree.basedir, 'locations'),
3215
 
             ('file', 'branch', 'DEFAULT', 'branch'),],
3216
 
            self.branch_config)
3217
 
 
3218
 
 
3219
 
class TestConfigGetSections(tests.TestCaseWithTransport):
3220
 
 
3221
 
    def setUp(self):
3222
 
        super(TestConfigGetSections, self).setUp()
3223
 
        create_configs(self)
3224
 
 
3225
 
    def assertSectionNames(self, expected, conf, name=None):
3226
 
        """Check which sections are returned for a given config.
3227
 
 
3228
 
        If fallback configurations exist their sections can be included.
3229
 
 
3230
 
        :param expected: A list of section names.
3231
 
 
3232
 
        :param conf: The configuration that will be queried.
3233
 
 
3234
 
        :param name: An optional section name that will be passed to
3235
 
            get_sections().
3236
 
        """
3237
 
        sections = list(conf._get_sections(name))
3238
 
        self.assertLength(len(expected), sections)
3239
 
        self.assertEqual(expected, [name for name, _, _ in sections])
3240
 
 
3241
 
    def test_bazaar_default_section(self):
3242
 
        self.assertSectionNames(['DEFAULT'], self.bazaar_config)
3243
 
 
3244
 
    def test_locations_default_section(self):
3245
 
        # No sections are defined in an empty file
3246
 
        self.assertSectionNames([], self.locations_config)
3247
 
 
3248
 
    def test_locations_named_section(self):
3249
 
        self.locations_config.set_user_option('file', 'locations')
3250
 
        self.assertSectionNames([self.tree.basedir], self.locations_config)
3251
 
 
3252
 
    def test_locations_matching_sections(self):
3253
 
        loc_config = self.locations_config
3254
 
        loc_config.set_user_option('file', 'locations')
3255
 
        # We need to cheat a bit here to create an option in sections above and
3256
 
        # below the 'location' one.
3257
 
        parser = loc_config._get_parser()
3258
 
        # locations.cong deals with '/' ignoring native os.sep
3259
 
        location_names = self.tree.basedir.split('/')
3260
 
        parent = '/'.join(location_names[:-1])
3261
 
        child = '/'.join(location_names + ['child'])
3262
 
        parser[parent] = {}
3263
 
        parser[parent]['file'] = 'parent'
3264
 
        parser[child] = {}
3265
 
        parser[child]['file'] = 'child'
3266
 
        self.assertSectionNames([self.tree.basedir, parent], loc_config)
3267
 
 
3268
 
    def test_branch_data_default_section(self):
3269
 
        self.assertSectionNames([None],
3270
 
                                self.branch_config._get_branch_data_config())
3271
 
 
3272
 
    def test_branch_default_sections(self):
3273
 
        # No sections are defined in an empty locations file
3274
 
        self.assertSectionNames([None, 'DEFAULT'],
3275
 
                                self.branch_config)
3276
 
        # Unless we define an option
3277
 
        self.branch_config._get_location_config().set_user_option(
3278
 
            'file', 'locations')
3279
 
        self.assertSectionNames([self.tree.basedir, None, 'DEFAULT'],
3280
 
                                self.branch_config)
3281
 
 
3282
 
    def test_bazaar_named_section(self):
3283
 
        # We need to cheat as the API doesn't give direct access to sections
3284
 
        # other than DEFAULT.
3285
 
        self.bazaar_config.set_alias('bazaar', 'bzr')
3286
 
        self.assertSectionNames(['ALIASES'], self.bazaar_config, 'ALIASES')
3287
 
 
3288
 
 
3289
 
class TestAuthenticationConfigFile(tests.TestCase):
3290
 
    """Test the authentication.conf file matching"""
3291
 
 
3292
 
    def _got_user_passwd(self, expected_user, expected_password,
3293
 
                         config, *args, **kwargs):
3294
 
        credentials = config.get_credentials(*args, **kwargs)
3295
 
        if credentials is None:
3296
 
            user = None
3297
 
            password = None
3298
 
        else:
3299
 
            user = credentials['user']
3300
 
            password = credentials['password']
3301
 
        self.assertEquals(expected_user, user)
3302
 
        self.assertEquals(expected_password, password)
3303
 
 
3304
 
    def test_empty_config(self):
3305
 
        conf = config.AuthenticationConfig(_file=StringIO())
3306
 
        self.assertEquals({}, conf._get_config())
3307
 
        self._got_user_passwd(None, None, conf, 'http', 'foo.net')
3308
 
 
3309
 
    def test_non_utf8_config(self):
3310
 
        conf = config.AuthenticationConfig(_file=StringIO(
3311
 
                'foo = bar\xff'))
3312
 
        self.assertRaises(errors.ConfigContentError, conf._get_config)
3313
 
 
3314
 
    def test_missing_auth_section_header(self):
3315
 
        conf = config.AuthenticationConfig(_file=StringIO('foo = bar'))
3316
 
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
3317
 
 
3318
 
    def test_auth_section_header_not_closed(self):
3319
 
        conf = config.AuthenticationConfig(_file=StringIO('[DEF'))
3320
 
        self.assertRaises(errors.ParseConfigError, conf._get_config)
3321
 
 
3322
 
    def test_auth_value_not_boolean(self):
3323
 
        conf = config.AuthenticationConfig(_file=StringIO(
3324
 
                """[broken]
3325
 
scheme=ftp
3326
 
user=joe
3327
 
verify_certificates=askme # Error: Not a boolean
3328
 
"""))
3329
 
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
3330
 
 
3331
 
    def test_auth_value_not_int(self):
3332
 
        conf = config.AuthenticationConfig(_file=StringIO(
3333
 
                """[broken]
3334
 
scheme=ftp
3335
 
user=joe
3336
 
port=port # Error: Not an int
3337
 
"""))
3338
 
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
3339
 
 
3340
 
    def test_unknown_password_encoding(self):
3341
 
        conf = config.AuthenticationConfig(_file=StringIO(
3342
 
                """[broken]
3343
 
scheme=ftp
3344
 
user=joe
3345
 
password_encoding=unknown
3346
 
"""))
3347
 
        self.assertRaises(ValueError, conf.get_password,
3348
 
                          'ftp', 'foo.net', 'joe')
3349
 
 
3350
 
    def test_credentials_for_scheme_host(self):
3351
 
        conf = config.AuthenticationConfig(_file=StringIO(
3352
 
                """# Identity on foo.net
3353
 
[ftp definition]
3354
 
scheme=ftp
3355
 
host=foo.net
3356
 
user=joe
3357
 
password=secret-pass
3358
 
"""))
3359
 
        # Basic matching
3360
 
        self._got_user_passwd('joe', 'secret-pass', conf, 'ftp', 'foo.net')
3361
 
        # different scheme
3362
 
        self._got_user_passwd(None, None, conf, 'http', 'foo.net')
3363
 
        # different host
3364
 
        self._got_user_passwd(None, None, conf, 'ftp', 'bar.net')
3365
 
 
3366
 
    def test_credentials_for_host_port(self):
3367
 
        conf = config.AuthenticationConfig(_file=StringIO(
3368
 
                """# Identity on foo.net
3369
 
[ftp definition]
3370
 
scheme=ftp
3371
 
port=10021
3372
 
host=foo.net
3373
 
user=joe
3374
 
password=secret-pass
3375
 
"""))
3376
 
        # No port
3377
 
        self._got_user_passwd('joe', 'secret-pass',
3378
 
                              conf, 'ftp', 'foo.net', port=10021)
3379
 
        # different port
3380
 
        self._got_user_passwd(None, None, conf, 'ftp', 'foo.net')
3381
 
 
3382
 
    def test_for_matching_host(self):
3383
 
        conf = config.AuthenticationConfig(_file=StringIO(
3384
 
                """# Identity on foo.net
3385
 
[sourceforge]
3386
 
scheme=bzr
3387
 
host=bzr.sf.net
3388
 
user=joe
3389
 
password=joepass
3390
 
[sourceforge domain]
3391
 
scheme=bzr
3392
 
host=.bzr.sf.net
3393
 
user=georges
3394
 
password=bendover
3395
 
"""))
3396
 
        # matching domain
3397
 
        self._got_user_passwd('georges', 'bendover',
3398
 
                              conf, 'bzr', 'foo.bzr.sf.net')
3399
 
        # phishing attempt
3400
 
        self._got_user_passwd(None, None,
3401
 
                              conf, 'bzr', 'bbzr.sf.net')
3402
 
 
3403
 
    def test_for_matching_host_None(self):
3404
 
        conf = config.AuthenticationConfig(_file=StringIO(
3405
 
                """# Identity on foo.net
3406
 
[catchup bzr]
3407
 
scheme=bzr
3408
 
user=joe
3409
 
password=joepass
3410
 
[DEFAULT]
3411
 
user=georges
3412
 
password=bendover
3413
 
"""))
3414
 
        # match no host
3415
 
        self._got_user_passwd('joe', 'joepass',
3416
 
                              conf, 'bzr', 'quux.net')
3417
 
        # no host but different scheme
3418
 
        self._got_user_passwd('georges', 'bendover',
3419
 
                              conf, 'ftp', 'quux.net')
3420
 
 
3421
 
    def test_credentials_for_path(self):
3422
 
        conf = config.AuthenticationConfig(_file=StringIO(
3423
 
                """
3424
 
[http dir1]
3425
 
scheme=http
3426
 
host=bar.org
3427
 
path=/dir1
3428
 
user=jim
3429
 
password=jimpass
3430
 
[http dir2]
3431
 
scheme=http
3432
 
host=bar.org
3433
 
path=/dir2
3434
 
user=georges
3435
 
password=bendover
3436
 
"""))
3437
 
        # no path no dice
3438
 
        self._got_user_passwd(None, None,
3439
 
                              conf, 'http', host='bar.org', path='/dir3')
3440
 
        # matching path
3441
 
        self._got_user_passwd('georges', 'bendover',
3442
 
                              conf, 'http', host='bar.org', path='/dir2')
3443
 
        # matching subdir
3444
 
        self._got_user_passwd('jim', 'jimpass',
3445
 
                              conf, 'http', host='bar.org',path='/dir1/subdir')
3446
 
 
3447
 
    def test_credentials_for_user(self):
3448
 
        conf = config.AuthenticationConfig(_file=StringIO(
3449
 
                """
3450
 
[with user]
3451
 
scheme=http
3452
 
host=bar.org
3453
 
user=jim
3454
 
password=jimpass
3455
 
"""))
3456
 
        # Get user
3457
 
        self._got_user_passwd('jim', 'jimpass',
3458
 
                              conf, 'http', 'bar.org')
3459
 
        # Get same user
3460
 
        self._got_user_passwd('jim', 'jimpass',
3461
 
                              conf, 'http', 'bar.org', user='jim')
3462
 
        # Don't get a different user if one is specified
3463
 
        self._got_user_passwd(None, None,
3464
 
                              conf, 'http', 'bar.org', user='georges')
3465
 
 
3466
 
    def test_credentials_for_user_without_password(self):
3467
 
        conf = config.AuthenticationConfig(_file=StringIO(
3468
 
                """
3469
 
[without password]
3470
 
scheme=http
3471
 
host=bar.org
3472
 
user=jim
3473
 
"""))
3474
 
        # Get user but no password
3475
 
        self._got_user_passwd('jim', None,
3476
 
                              conf, 'http', 'bar.org')
3477
 
 
3478
 
    def test_verify_certificates(self):
3479
 
        conf = config.AuthenticationConfig(_file=StringIO(
3480
 
                """
3481
 
[self-signed]
3482
 
scheme=https
3483
 
host=bar.org
3484
 
user=jim
3485
 
password=jimpass
3486
 
verify_certificates=False
3487
 
[normal]
3488
 
scheme=https
3489
 
host=foo.net
3490
 
user=georges
3491
 
password=bendover
3492
 
"""))
3493
 
        credentials = conf.get_credentials('https', 'bar.org')
3494
 
        self.assertEquals(False, credentials.get('verify_certificates'))
3495
 
        credentials = conf.get_credentials('https', 'foo.net')
3496
 
        self.assertEquals(True, credentials.get('verify_certificates'))
3497
 
 
3498
 
 
3499
 
class TestAuthenticationStorage(tests.TestCaseInTempDir):
3500
 
 
3501
 
    def test_set_credentials(self):
3502
 
        conf = config.AuthenticationConfig()
3503
 
        conf.set_credentials('name', 'host', 'user', 'scheme', 'password',
3504
 
        99, path='/foo', verify_certificates=False, realm='realm')
3505
 
        credentials = conf.get_credentials(host='host', scheme='scheme',
3506
 
                                           port=99, path='/foo',
3507
 
                                           realm='realm')
3508
 
        CREDENTIALS = {'name': 'name', 'user': 'user', 'password': 'password',
3509
 
                       'verify_certificates': False, 'scheme': 'scheme', 
3510
 
                       'host': 'host', 'port': 99, 'path': '/foo', 
3511
 
                       'realm': 'realm'}
3512
 
        self.assertEqual(CREDENTIALS, credentials)
3513
 
        credentials_from_disk = config.AuthenticationConfig().get_credentials(
3514
 
            host='host', scheme='scheme', port=99, path='/foo', realm='realm')
3515
 
        self.assertEqual(CREDENTIALS, credentials_from_disk)
3516
 
 
3517
 
    def test_reset_credentials_different_name(self):
3518
 
        conf = config.AuthenticationConfig()
3519
 
        conf.set_credentials('name', 'host', 'user', 'scheme', 'password'),
3520
 
        conf.set_credentials('name2', 'host', 'user2', 'scheme', 'password'),
3521
 
        self.assertIs(None, conf._get_config().get('name'))
3522
 
        credentials = conf.get_credentials(host='host', scheme='scheme')
3523
 
        CREDENTIALS = {'name': 'name2', 'user': 'user2', 'password':
3524
 
                       'password', 'verify_certificates': True, 
3525
 
                       'scheme': 'scheme', 'host': 'host', 'port': None, 
3526
 
                       'path': None, 'realm': None}
3527
 
        self.assertEqual(CREDENTIALS, credentials)
3528
 
 
3529
 
 
3530
 
class TestAuthenticationConfig(tests.TestCase):
3531
 
    """Test AuthenticationConfig behaviour"""
3532
 
 
3533
 
    def _check_default_password_prompt(self, expected_prompt_format, scheme,
3534
 
                                       host=None, port=None, realm=None,
3535
 
                                       path=None):
3536
 
        if host is None:
3537
 
            host = 'bar.org'
3538
 
        user, password = 'jim', 'precious'
3539
 
        expected_prompt = expected_prompt_format % {
3540
 
            'scheme': scheme, 'host': host, 'port': port,
3541
 
            'user': user, 'realm': realm}
3542
 
 
3543
 
        stdout = tests.StringIOWrapper()
3544
 
        stderr = tests.StringIOWrapper()
3545
 
        ui.ui_factory = tests.TestUIFactory(stdin=password + '\n',
3546
 
                                            stdout=stdout, stderr=stderr)
3547
 
        # We use an empty conf so that the user is always prompted
3548
 
        conf = config.AuthenticationConfig()
3549
 
        self.assertEquals(password,
3550
 
                          conf.get_password(scheme, host, user, port=port,
3551
 
                                            realm=realm, path=path))
3552
 
        self.assertEquals(expected_prompt, stderr.getvalue())
3553
 
        self.assertEquals('', stdout.getvalue())
3554
 
 
3555
 
    def _check_default_username_prompt(self, expected_prompt_format, scheme,
3556
 
                                       host=None, port=None, realm=None,
3557
 
                                       path=None):
3558
 
        if host is None:
3559
 
            host = 'bar.org'
3560
 
        username = 'jim'
3561
 
        expected_prompt = expected_prompt_format % {
3562
 
            'scheme': scheme, 'host': host, 'port': port,
3563
 
            'realm': realm}
3564
 
        stdout = tests.StringIOWrapper()
3565
 
        stderr = tests.StringIOWrapper()
3566
 
        ui.ui_factory = tests.TestUIFactory(stdin=username+ '\n',
3567
 
                                            stdout=stdout, stderr=stderr)
3568
 
        # We use an empty conf so that the user is always prompted
3569
 
        conf = config.AuthenticationConfig()
3570
 
        self.assertEquals(username, conf.get_user(scheme, host, port=port,
3571
 
                          realm=realm, path=path, ask=True))
3572
 
        self.assertEquals(expected_prompt, stderr.getvalue())
3573
 
        self.assertEquals('', stdout.getvalue())
3574
 
 
3575
 
    def test_username_defaults_prompts(self):
3576
 
        # HTTP prompts can't be tested here, see test_http.py
3577
 
        self._check_default_username_prompt(u'FTP %(host)s username: ', 'ftp')
3578
 
        self._check_default_username_prompt(
3579
 
            u'FTP %(host)s:%(port)d username: ', 'ftp', port=10020)
3580
 
        self._check_default_username_prompt(
3581
 
            u'SSH %(host)s:%(port)d username: ', 'ssh', port=12345)
3582
 
 
3583
 
    def test_username_default_no_prompt(self):
3584
 
        conf = config.AuthenticationConfig()
3585
 
        self.assertEquals(None,
3586
 
            conf.get_user('ftp', 'example.com'))
3587
 
        self.assertEquals("explicitdefault",
3588
 
            conf.get_user('ftp', 'example.com', default="explicitdefault"))
3589
 
 
3590
 
    def test_password_default_prompts(self):
3591
 
        # HTTP prompts can't be tested here, see test_http.py
3592
 
        self._check_default_password_prompt(
3593
 
            u'FTP %(user)s@%(host)s password: ', 'ftp')
3594
 
        self._check_default_password_prompt(
3595
 
            u'FTP %(user)s@%(host)s:%(port)d password: ', 'ftp', port=10020)
3596
 
        self._check_default_password_prompt(
3597
 
            u'SSH %(user)s@%(host)s:%(port)d password: ', 'ssh', port=12345)
3598
 
        # SMTP port handling is a bit special (it's handled if embedded in the
3599
 
        # host too)
3600
 
        # FIXME: should we: forbid that, extend it to other schemes, leave
3601
 
        # things as they are that's fine thank you ?
3602
 
        self._check_default_password_prompt(
3603
 
            u'SMTP %(user)s@%(host)s password: ', 'smtp')
3604
 
        self._check_default_password_prompt(
3605
 
            u'SMTP %(user)s@%(host)s password: ', 'smtp', host='bar.org:10025')
3606
 
        self._check_default_password_prompt(
3607
 
            u'SMTP %(user)s@%(host)s:%(port)d password: ', 'smtp', port=10025)
3608
 
 
3609
 
    def test_ssh_password_emits_warning(self):
3610
 
        conf = config.AuthenticationConfig(_file=StringIO(
3611
 
                """
3612
 
[ssh with password]
3613
 
scheme=ssh
3614
 
host=bar.org
3615
 
user=jim
3616
 
password=jimpass
3617
 
"""))
3618
 
        entered_password = 'typed-by-hand'
3619
 
        stdout = tests.StringIOWrapper()
3620
 
        stderr = tests.StringIOWrapper()
3621
 
        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
3622
 
                                            stdout=stdout, stderr=stderr)
3623
 
 
3624
 
        # Since the password defined in the authentication config is ignored,
3625
 
        # the user is prompted
3626
 
        self.assertEquals(entered_password,
3627
 
                          conf.get_password('ssh', 'bar.org', user='jim'))
3628
 
        self.assertContainsRe(
3629
 
            self.get_log(),
3630
 
            'password ignored in section \[ssh with password\]')
3631
 
 
3632
 
    def test_ssh_without_password_doesnt_emit_warning(self):
3633
 
        conf = config.AuthenticationConfig(_file=StringIO(
3634
 
                """
3635
 
[ssh with password]
3636
 
scheme=ssh
3637
 
host=bar.org
3638
 
user=jim
3639
 
"""))
3640
 
        entered_password = 'typed-by-hand'
3641
 
        stdout = tests.StringIOWrapper()
3642
 
        stderr = tests.StringIOWrapper()
3643
 
        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
3644
 
                                            stdout=stdout,
3645
 
                                            stderr=stderr)
3646
 
 
3647
 
        # Since the password defined in the authentication config is ignored,
3648
 
        # the user is prompted
3649
 
        self.assertEquals(entered_password,
3650
 
                          conf.get_password('ssh', 'bar.org', user='jim'))
3651
 
        # No warning shoud be emitted since there is no password. We are only
3652
 
        # providing "user".
3653
 
        self.assertNotContainsRe(
3654
 
            self.get_log(),
3655
 
            'password ignored in section \[ssh with password\]')
3656
 
 
3657
 
    def test_uses_fallback_stores(self):
3658
 
        self.overrideAttr(config, 'credential_store_registry',
3659
 
                          config.CredentialStoreRegistry())
3660
 
        store = StubCredentialStore()
3661
 
        store.add_credentials("http", "example.com", "joe", "secret")
3662
 
        config.credential_store_registry.register("stub", store, fallback=True)
3663
 
        conf = config.AuthenticationConfig(_file=StringIO())
3664
 
        creds = conf.get_credentials("http", "example.com")
3665
 
        self.assertEquals("joe", creds["user"])
3666
 
        self.assertEquals("secret", creds["password"])
3667
 
 
3668
 
 
3669
 
class StubCredentialStore(config.CredentialStore):
3670
 
 
3671
 
    def __init__(self):
3672
 
        self._username = {}
3673
 
        self._password = {}
3674
 
 
3675
 
    def add_credentials(self, scheme, host, user, password=None):
3676
 
        self._username[(scheme, host)] = user
3677
 
        self._password[(scheme, host)] = password
3678
 
 
3679
 
    def get_credentials(self, scheme, host, port=None, user=None,
3680
 
        path=None, realm=None):
3681
 
        key = (scheme, host)
3682
 
        if not key in self._username:
3683
 
            return None
3684
 
        return { "scheme": scheme, "host": host, "port": port,
3685
 
                "user": self._username[key], "password": self._password[key]}
3686
 
 
3687
 
 
3688
 
class CountingCredentialStore(config.CredentialStore):
3689
 
 
3690
 
    def __init__(self):
3691
 
        self._calls = 0
3692
 
 
3693
 
    def get_credentials(self, scheme, host, port=None, user=None,
3694
 
        path=None, realm=None):
3695
 
        self._calls += 1
3696
 
        return None
3697
 
 
3698
 
 
3699
 
class TestCredentialStoreRegistry(tests.TestCase):
3700
 
 
3701
 
    def _get_cs_registry(self):
3702
 
        return config.credential_store_registry
3703
 
 
3704
 
    def test_default_credential_store(self):
3705
 
        r = self._get_cs_registry()
3706
 
        default = r.get_credential_store(None)
3707
 
        self.assertIsInstance(default, config.PlainTextCredentialStore)
3708
 
 
3709
 
    def test_unknown_credential_store(self):
3710
 
        r = self._get_cs_registry()
3711
 
        # It's hard to imagine someone creating a credential store named
3712
 
        # 'unknown' so we use that as an never registered key.
3713
 
        self.assertRaises(KeyError, r.get_credential_store, 'unknown')
3714
 
 
3715
 
    def test_fallback_none_registered(self):
3716
 
        r = config.CredentialStoreRegistry()
3717
 
        self.assertEquals(None,
3718
 
                          r.get_fallback_credentials("http", "example.com"))
3719
 
 
3720
 
    def test_register(self):
3721
 
        r = config.CredentialStoreRegistry()
3722
 
        r.register("stub", StubCredentialStore(), fallback=False)
3723
 
        r.register("another", StubCredentialStore(), fallback=True)
3724
 
        self.assertEquals(["another", "stub"], r.keys())
3725
 
 
3726
 
    def test_register_lazy(self):
3727
 
        r = config.CredentialStoreRegistry()
3728
 
        r.register_lazy("stub", "bzrlib.tests.test_config",
3729
 
                        "StubCredentialStore", fallback=False)
3730
 
        self.assertEquals(["stub"], r.keys())
3731
 
        self.assertIsInstance(r.get_credential_store("stub"),
3732
 
                              StubCredentialStore)
3733
 
 
3734
 
    def test_is_fallback(self):
3735
 
        r = config.CredentialStoreRegistry()
3736
 
        r.register("stub1", None, fallback=False)
3737
 
        r.register("stub2", None, fallback=True)
3738
 
        self.assertEquals(False, r.is_fallback("stub1"))
3739
 
        self.assertEquals(True, r.is_fallback("stub2"))
3740
 
 
3741
 
    def test_no_fallback(self):
3742
 
        r = config.CredentialStoreRegistry()
3743
 
        store = CountingCredentialStore()
3744
 
        r.register("count", store, fallback=False)
3745
 
        self.assertEquals(None,
3746
 
                          r.get_fallback_credentials("http", "example.com"))
3747
 
        self.assertEquals(0, store._calls)
3748
 
 
3749
 
    def test_fallback_credentials(self):
3750
 
        r = config.CredentialStoreRegistry()
3751
 
        store = StubCredentialStore()
3752
 
        store.add_credentials("http", "example.com",
3753
 
                              "somebody", "geheim")
3754
 
        r.register("stub", store, fallback=True)
3755
 
        creds = r.get_fallback_credentials("http", "example.com")
3756
 
        self.assertEquals("somebody", creds["user"])
3757
 
        self.assertEquals("geheim", creds["password"])
3758
 
 
3759
 
    def test_fallback_first_wins(self):
3760
 
        r = config.CredentialStoreRegistry()
3761
 
        stub1 = StubCredentialStore()
3762
 
        stub1.add_credentials("http", "example.com",
3763
 
                              "somebody", "stub1")
3764
 
        r.register("stub1", stub1, fallback=True)
3765
 
        stub2 = StubCredentialStore()
3766
 
        stub2.add_credentials("http", "example.com",
3767
 
                              "somebody", "stub2")
3768
 
        r.register("stub2", stub1, fallback=True)
3769
 
        creds = r.get_fallback_credentials("http", "example.com")
3770
 
        self.assertEquals("somebody", creds["user"])
3771
 
        self.assertEquals("stub1", creds["password"])
3772
 
 
3773
 
 
3774
 
class TestPlainTextCredentialStore(tests.TestCase):
3775
 
 
3776
 
    def test_decode_password(self):
3777
 
        r = config.credential_store_registry
3778
 
        plain_text = r.get_credential_store()
3779
 
        decoded = plain_text.decode_password(dict(password='secret'))
3780
 
        self.assertEquals('secret', decoded)
3781
 
 
3782
 
 
3783
 
# FIXME: Once we have a way to declare authentication to all test servers, we
3784
 
# can implement generic tests.
3785
 
# test_user_password_in_url
3786
 
# test_user_in_url_password_from_config
3787
 
# test_user_in_url_password_prompted
3788
 
# test_user_in_config
3789
 
# test_user_getpass.getuser
3790
 
# test_user_prompted ?
3791
 
class TestAuthenticationRing(tests.TestCaseWithTransport):
3792
 
    pass
3793
 
 
3794
 
 
3795
 
class TestAutoUserId(tests.TestCase):
3796
 
    """Test inferring an automatic user name."""
3797
 
 
3798
 
    def test_auto_user_id(self):
3799
 
        """Automatic inference of user name.
3800
 
        
3801
 
        This is a bit hard to test in an isolated way, because it depends on
3802
 
        system functions that go direct to /etc or perhaps somewhere else.
3803
 
        But it's reasonable to say that on Unix, with an /etc/mailname, we ought
3804
 
        to be able to choose a user name with no configuration.
3805
 
        """
3806
 
        if sys.platform == 'win32':
3807
 
            raise tests.TestSkipped(
3808
 
                "User name inference not implemented on win32")
3809
 
        realname, address = config._auto_user_id()
3810
 
        if os.path.exists('/etc/mailname'):
3811
 
            self.assertIsNot(None, realname)
3812
 
            self.assertIsNot(None, address)
3813
 
        else:
3814
 
            self.assertEquals((None, None), (realname, address))
3815