← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_config.py

  • Committer: Jelmer Vernooij
  • Date: 2012-01-28 02:10:19 UTC
  • mto: This revision was merged to the branch mainline in revision 6450.
  • Revision ID: jelmer@samba.org-20120128021019-047mhvjsr9t72xfi
Fix reading weave files.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_config.py
1
 
# Copyright (C) 2005, 2006 by Canonical Ltd
2
 
#   Authors: Robert Collins <robert.collins@canonical.com>
 
1
# Copyright (C) 2005-2011 Canonical Ltd
3
2
#
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
13
12
#
14
13
# You should have received a copy of the GNU General Public License
15
14
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
16
 
18
17
"""Tests for finding and reading the bzr config file[s]."""
19
18
# import system imports here
20
 
from bzrlib.util.configobj.configobj import ConfigObj, ConfigObjError
21
19
from cStringIO import StringIO
22
20
import os
23
21
import sys
 
22
import threading
 
23
 
 
24
 
 
25
from testtools import matchers
24
26
 
25
27
#import bzrlib specific imports here
26
28
from bzrlib import (
 
29
    branch,
 
30
    bzrdir,
27
31
    config,
 
32
    diff,
28
33
    errors,
29
34
    osutils,
 
35
    mail_client,
 
36
    ui,
30
37
    urlutils,
31
 
    )
32
 
from bzrlib.branch import Branch
33
 
from bzrlib.bzrdir import BzrDir
34
 
from bzrlib.tests import TestCase, TestCaseInTempDir, TestCaseWithTransport
 
38
    remote,
 
39
    tests,
 
40
    trace,
 
41
    )
 
42
from bzrlib.symbol_versioning import (
 
43
    deprecated_in,
 
44
    )
 
45
from bzrlib.transport import remote as transport_remote
 
46
from bzrlib.tests import (
 
47
    features,
 
48
    scenarios,
 
49
    test_server,
 
50
    )
 
51
from bzrlib.util.configobj import configobj
 
52
 
 
53
 
 
54
def lockable_config_scenarios():
 
55
    return [
 
56
        ('global',
 
57
         {'config_class': config.GlobalConfig,
 
58
          'config_args': [],
 
59
          'config_section': 'DEFAULT'}),
 
60
        ('locations',
 
61
         {'config_class': config.LocationConfig,
 
62
          'config_args': ['.'],
 
63
          'config_section': '.'}),]
 
64
 
 
65
 
 
66
load_tests = scenarios.load_tests_apply_scenarios
 
67
 
 
68
# Register helpers to build stores
 
69
config.test_store_builder_registry.register(
 
70
    'configobj', lambda test: config.TransportIniFileStore(
 
71
        test.get_transport(), 'configobj.conf'))
 
72
config.test_store_builder_registry.register(
 
73
    'bazaar', lambda test: config.GlobalStore())
 
74
config.test_store_builder_registry.register(
 
75
    'location', lambda test: config.LocationStore())
 
76
 
 
77
 
 
78
def build_backing_branch(test, relpath,
 
79
                         transport_class=None, server_class=None):
 
80
    """Test helper to create a backing branch only once.
 
81
 
 
82
    Some tests needs multiple stores/stacks to check concurrent update
 
83
    behaviours. As such, they need to build different branch *objects* even if
 
84
    they share the branch on disk.
 
85
 
 
86
    :param relpath: The relative path to the branch. (Note that the helper
 
87
        should always specify the same relpath).
 
88
 
 
89
    :param transport_class: The Transport class the test needs to use.
 
90
 
 
91
    :param server_class: The server associated with the ``transport_class``
 
92
        above.
 
93
 
 
94
    Either both or neither of ``transport_class`` and ``server_class`` should
 
95
    be specified.
 
96
    """
 
97
    if transport_class is not None and server_class is not None:
 
98
        test.transport_class = transport_class
 
99
        test.transport_server = server_class
 
100
    elif not (transport_class is None and server_class is None):
 
101
        raise AssertionError('Specify both ``transport_class`` and '
 
102
                             '``server_class`` or neither of them')
 
103
    if getattr(test, 'backing_branch', None) is None:
 
104
        # First call, let's build the branch on disk
 
105
        test.backing_branch = test.make_branch(relpath)
 
106
 
 
107
 
 
108
def build_branch_store(test):
 
109
    build_backing_branch(test, 'branch')
 
110
    b = branch.Branch.open('branch')
 
111
    return config.BranchStore(b)
 
112
config.test_store_builder_registry.register('branch', build_branch_store)
 
113
 
 
114
 
 
115
def build_control_store(test):
 
116
    build_backing_branch(test, 'branch')
 
117
    b = bzrdir.BzrDir.open('branch')
 
118
    return config.ControlStore(b)
 
119
config.test_store_builder_registry.register('control', build_control_store)
 
120
 
 
121
 
 
122
def build_remote_branch_store(test):
 
123
    # There is only one permutation (but we won't be able to handle more with
 
124
    # this design anyway)
 
125
    (transport_class,
 
126
     server_class) = transport_remote.get_test_permutations()[0]
 
127
    build_backing_branch(test, 'branch', transport_class, server_class)
 
128
    b = branch.Branch.open(test.get_url('branch'))
 
129
    return config.BranchStore(b)
 
130
config.test_store_builder_registry.register('remote_branch',
 
131
                                            build_remote_branch_store)
 
132
 
 
133
 
 
134
config.test_stack_builder_registry.register(
 
135
    'bazaar', lambda test: config.GlobalStack())
 
136
config.test_stack_builder_registry.register(
 
137
    'location', lambda test: config.LocationStack('.'))
 
138
 
 
139
 
 
140
def build_branch_stack(test):
 
141
    build_backing_branch(test, 'branch')
 
142
    b = branch.Branch.open('branch')
 
143
    return config.BranchStack(b)
 
144
config.test_stack_builder_registry.register('branch', build_branch_stack)
 
145
 
 
146
 
 
147
def build_branch_only_stack(test):
 
148
    # There is only one permutation (but we won't be able to handle more with
 
149
    # this design anyway)
 
150
    (transport_class,
 
151
     server_class) = transport_remote.get_test_permutations()[0]
 
152
    build_backing_branch(test, 'branch', transport_class, server_class)
 
153
    b = branch.Branch.open(test.get_url('branch'))
 
154
    return config.BranchOnlyStack(b)
 
155
config.test_stack_builder_registry.register('branch_only',
 
156
                                            build_branch_only_stack)
 
157
 
 
158
def build_remote_control_stack(test):
 
159
    # There is only one permutation (but we won't be able to handle more with
 
160
    # this design anyway)
 
161
    (transport_class,
 
162
     server_class) = transport_remote.get_test_permutations()[0]
 
163
    # We need only a bzrdir for this, not a full branch, but it's not worth
 
164
    # creating a dedicated helper to create only the bzrdir
 
165
    build_backing_branch(test, 'branch', transport_class, server_class)
 
166
    b = branch.Branch.open(test.get_url('branch'))
 
167
    return config.RemoteControlStack(b.bzrdir)
 
168
config.test_stack_builder_registry.register('remote_control',
 
169
                                            build_remote_control_stack)
35
170
 
36
171
 
37
172
sample_long_alias="log -r-15..-1 --line"
38
 
sample_config_text = ("[DEFAULT]\n"
39
 
                      u"email=Erik B\u00e5gfors <erik@bagfors.nu>\n"
40
 
                      "editor=vim\n"
41
 
                      "gpg_signing_command=gnome-gpg\n"
42
 
                      "log_format=short\n"
43
 
                      "user_global_option=something\n"
44
 
                      "[ALIASES]\n"
45
 
                      "h=help\n"
46
 
                      "ll=" + sample_long_alias + "\n")
47
 
 
48
 
 
49
 
sample_always_signatures = ("[DEFAULT]\n"
50
 
                            "check_signatures=ignore\n"
51
 
                            "create_signatures=always")
52
 
 
53
 
 
54
 
sample_ignore_signatures = ("[DEFAULT]\n"
55
 
                            "check_signatures=require\n"
56
 
                            "create_signatures=never")
57
 
 
58
 
 
59
 
sample_maybe_signatures = ("[DEFAULT]\n"
60
 
                            "check_signatures=ignore\n"
61
 
                            "create_signatures=when-required")
62
 
 
63
 
 
64
 
sample_branches_text = ("[http://www.example.com]\n"
65
 
                        "# Top level policy\n"
66
 
                        "email=Robert Collins <robertc@example.org>\n"
67
 
                        "[http://www.example.com/useglobal]\n"
68
 
                        "# different project, forces global lookup\n"
69
 
                        "recurse=false\n"
70
 
                        "[/b/]\n"
71
 
                        "check_signatures=require\n"
72
 
                        "# test trailing / matching with no children\n"
73
 
                        "[/a/]\n"
74
 
                        "check_signatures=check-available\n"
75
 
                        "gpg_signing_command=false\n"
76
 
                        "user_local_option=local\n"
77
 
                        "# test trailing / matching\n"
78
 
                        "[/a/*]\n"
79
 
                        "#subdirs will match but not the parent\n"
80
 
                        "recurse=False\n"
81
 
                        "[/a/c]\n"
82
 
                        "check_signatures=ignore\n"
83
 
                        "post_commit=bzrlib.tests.test_config.post_commit\n"
84
 
                        "#testing explicit beats globs\n")
85
 
 
 
173
sample_config_text = u"""
 
174
[DEFAULT]
 
175
email=Erik B\u00e5gfors <erik@bagfors.nu>
 
176
editor=vim
 
177
change_editor=vimdiff -of @new_path @old_path
 
178
gpg_signing_command=gnome-gpg
 
179
gpg_signing_key=DD4D5088
 
180
log_format=short
 
181
validate_signatures_in_log=true
 
182
acceptable_keys=amy
 
183
user_global_option=something
 
184
bzr.mergetool.sometool=sometool {base} {this} {other} -o {result}
 
185
bzr.mergetool.funkytool=funkytool "arg with spaces" {this_temp}
 
186
bzr.mergetool.newtool='"newtool with spaces" {this_temp}'
 
187
bzr.default_mergetool=sometool
 
188
[ALIASES]
 
189
h=help
 
190
ll=""" + sample_long_alias + "\n"
 
191
 
 
192
 
 
193
sample_always_signatures = """
 
194
[DEFAULT]
 
195
check_signatures=ignore
 
196
create_signatures=always
 
197
"""
 
198
 
 
199
sample_ignore_signatures = """
 
200
[DEFAULT]
 
201
check_signatures=require
 
202
create_signatures=never
 
203
"""
 
204
 
 
205
sample_maybe_signatures = """
 
206
[DEFAULT]
 
207
check_signatures=ignore
 
208
create_signatures=when-required
 
209
"""
 
210
 
 
211
sample_branches_text = """
 
212
[http://www.example.com]
 
213
# Top level policy
 
214
email=Robert Collins <robertc@example.org>
 
215
normal_option = normal
 
216
appendpath_option = append
 
217
appendpath_option:policy = appendpath
 
218
norecurse_option = norecurse
 
219
norecurse_option:policy = norecurse
 
220
[http://www.example.com/ignoreparent]
 
221
# different project: ignore parent dir config
 
222
ignore_parents=true
 
223
[http://www.example.com/norecurse]
 
224
# configuration items that only apply to this dir
 
225
recurse=false
 
226
normal_option = norecurse
 
227
[http://www.example.com/dir]
 
228
appendpath_option = normal
 
229
[/b/]
 
230
check_signatures=require
 
231
# test trailing / matching with no children
 
232
[/a/]
 
233
check_signatures=check-available
 
234
gpg_signing_command=false
 
235
gpg_signing_key=default
 
236
user_local_option=local
 
237
# test trailing / matching
 
238
[/a/*]
 
239
#subdirs will match but not the parent
 
240
[/a/c]
 
241
check_signatures=ignore
 
242
post_commit=bzrlib.tests.test_config.post_commit
 
243
#testing explicit beats globs
 
244
"""
 
245
 
 
246
 
 
247
def create_configs(test):
 
248
    """Create configuration files for a given test.
 
249
 
 
250
    This requires creating a tree (and populate the ``test.tree`` attribute)
 
251
    and its associated branch and will populate the following attributes:
 
252
 
 
253
    - branch_config: A BranchConfig for the associated branch.
 
254
 
 
255
    - locations_config : A LocationConfig for the associated branch
 
256
 
 
257
    - bazaar_config: A GlobalConfig.
 
258
 
 
259
    The tree and branch are created in a 'tree' subdirectory so the tests can
 
260
    still use the test directory to stay outside of the branch.
 
261
    """
 
262
    tree = test.make_branch_and_tree('tree')
 
263
    test.tree = tree
 
264
    test.branch_config = config.BranchConfig(tree.branch)
 
265
    test.locations_config = config.LocationConfig(tree.basedir)
 
266
    test.bazaar_config = config.GlobalConfig()
 
267
 
 
268
 
 
269
def create_configs_with_file_option(test):
 
270
    """Create configuration files with a ``file`` option set in each.
 
271
 
 
272
    This builds on ``create_configs`` and add one ``file`` option in each
 
273
    configuration with a value which allows identifying the configuration file.
 
274
    """
 
275
    create_configs(test)
 
276
    test.bazaar_config.set_user_option('file', 'bazaar')
 
277
    test.locations_config.set_user_option('file', 'locations')
 
278
    test.branch_config.set_user_option('file', 'branch')
 
279
 
 
280
 
 
281
class TestOptionsMixin:
 
282
 
 
283
    def assertOptions(self, expected, conf):
 
284
        # We don't care about the parser (as it will make tests hard to write
 
285
        # and error-prone anyway)
 
286
        self.assertThat([opt[:4] for opt in conf._get_options()],
 
287
                        matchers.Equals(expected))
86
288
 
87
289
 
88
290
class InstrumentedConfigObj(object):
102
304
    def __setitem__(self, key, value):
103
305
        self._calls.append(('__setitem__', key, value))
104
306
 
 
307
    def __delitem__(self, key):
 
308
        self._calls.append(('__delitem__', key))
 
309
 
 
310
    def keys(self):
 
311
        self._calls.append(('keys',))
 
312
        return []
 
313
 
 
314
    def reload(self):
 
315
        self._calls.append(('reload',))
 
316
 
105
317
    def write(self, arg):
106
318
        self._calls.append(('write',))
107
319
 
 
320
    def as_bool(self, value):
 
321
        self._calls.append(('as_bool', value))
 
322
        return False
 
323
 
 
324
    def get_value(self, section, name):
 
325
        self._calls.append(('get_value', section, name))
 
326
        return None
 
327
 
108
328
 
109
329
class FakeBranch(object):
110
330
 
111
 
    def __init__(self, base=None, user_id=None):
 
331
    def __init__(self, base=None):
112
332
        if base is None:
113
333
            self.base = "http://example.com/branches/demo"
114
334
        else:
115
335
            self.base = base
116
 
        self.control_files = FakeControlFiles(user_id=user_id)
 
336
        self._transport = self.control_files = \
 
337
            FakeControlFilesAndTransport()
 
338
 
 
339
    def _get_config(self):
 
340
        return config.TransportConfig(self._transport, 'branch.conf')
117
341
 
118
342
    def lock_write(self):
119
343
        pass
122
346
        pass
123
347
 
124
348
 
125
 
class FakeControlFiles(object):
 
349
class FakeControlFilesAndTransport(object):
126
350
 
127
 
    def __init__(self, user_id=None):
128
 
        self.email = user_id
 
351
    def __init__(self):
129
352
        self.files = {}
130
 
 
131
 
    def get_utf8(self, filename):
132
 
        if filename != 'email':
133
 
            raise NotImplementedError
134
 
        if self.email is not None:
135
 
            return StringIO(self.email)
136
 
        raise errors.NoSuchFile(filename)
 
353
        self._transport = self
137
354
 
138
355
    def get(self, filename):
 
356
        # from Transport
139
357
        try:
140
358
            return StringIO(self.files[filename])
141
359
        except KeyError:
142
360
            raise errors.NoSuchFile(filename)
143
361
 
 
362
    def get_bytes(self, filename):
 
363
        # from Transport
 
364
        try:
 
365
            return self.files[filename]
 
366
        except KeyError:
 
367
            raise errors.NoSuchFile(filename)
 
368
 
144
369
    def put(self, filename, fileobj):
145
370
        self.files[filename] = fileobj.read()
146
371
 
 
372
    def put_file(self, filename, fileobj):
 
373
        return self.put(filename, fileobj)
 
374
 
147
375
 
148
376
class InstrumentedConfig(config.Config):
149
377
    """An instrumented config that supplies stubs for template methods."""
150
 
    
 
378
 
151
379
    def __init__(self):
152
380
        super(InstrumentedConfig, self).__init__()
153
381
        self._calls = []
161
389
        self._calls.append('_get_signature_checking')
162
390
        return self._signatures
163
391
 
 
392
    def _get_change_editor(self):
 
393
        self._calls.append('_get_change_editor')
 
394
        return 'vimdiff -fo @new_path @old_path'
 
395
 
164
396
 
165
397
bool_config = """[DEFAULT]
166
398
active = true
169
401
active = True
170
402
nonactive = False
171
403
"""
172
 
class TestConfigObj(TestCase):
 
404
 
 
405
 
 
406
class TestConfigObj(tests.TestCase):
 
407
 
173
408
    def test_get_bool(self):
174
 
        from bzrlib.config import ConfigObj
175
 
        co = ConfigObj(StringIO(bool_config))
 
409
        co = config.ConfigObj(StringIO(bool_config))
176
410
        self.assertIs(co.get_bool('DEFAULT', 'active'), True)
177
411
        self.assertIs(co.get_bool('DEFAULT', 'inactive'), False)
178
412
        self.assertIs(co.get_bool('UPPERCASE', 'active'), True)
179
413
        self.assertIs(co.get_bool('UPPERCASE', 'nonactive'), False)
180
414
 
181
 
 
182
 
class TestConfig(TestCase):
 
415
    def test_hash_sign_in_value(self):
 
416
        """
 
417
        Before 4.5.0, ConfigObj did not quote # signs in values, so they'd be
 
418
        treated as comments when read in again. (#86838)
 
419
        """
 
420
        co = config.ConfigObj()
 
421
        co['test'] = 'foo#bar'
 
422
        outfile = StringIO()
 
423
        co.write(outfile=outfile)
 
424
        lines = outfile.getvalue().splitlines()
 
425
        self.assertEqual(lines, ['test = "foo#bar"'])
 
426
        co2 = config.ConfigObj(lines)
 
427
        self.assertEqual(co2['test'], 'foo#bar')
 
428
 
 
429
    def test_triple_quotes(self):
 
430
        # Bug #710410: if the value string has triple quotes
 
431
        # then ConfigObj versions up to 4.7.2 will quote them wrong
 
432
        # and won't able to read them back
 
433
        triple_quotes_value = '''spam
 
434
""" that's my spam """
 
435
eggs'''
 
436
        co = config.ConfigObj()
 
437
        co['test'] = triple_quotes_value
 
438
        # While writing this test another bug in ConfigObj has been found:
 
439
        # method co.write() without arguments produces list of lines
 
440
        # one option per line, and multiline values are not split
 
441
        # across multiple lines,
 
442
        # and that breaks the parsing these lines back by ConfigObj.
 
443
        # This issue only affects test, but it's better to avoid
 
444
        # `co.write()` construct at all.
 
445
        # [bialix 20110222] bug report sent to ConfigObj's author
 
446
        outfile = StringIO()
 
447
        co.write(outfile=outfile)
 
448
        output = outfile.getvalue()
 
449
        # now we're trying to read it back
 
450
        co2 = config.ConfigObj(StringIO(output))
 
451
        self.assertEquals(triple_quotes_value, co2['test'])
 
452
 
 
453
 
 
454
erroneous_config = """[section] # line 1
 
455
good=good # line 2
 
456
[section] # line 3
 
457
whocares=notme # line 4
 
458
"""
 
459
 
 
460
 
 
461
class TestConfigObjErrors(tests.TestCase):
 
462
 
 
463
    def test_duplicate_section_name_error_line(self):
 
464
        try:
 
465
            co = configobj.ConfigObj(StringIO(erroneous_config),
 
466
                                     raise_errors=True)
 
467
        except config.configobj.DuplicateError, e:
 
468
            self.assertEqual(3, e.line_number)
 
469
        else:
 
470
            self.fail('Error in config file not detected')
 
471
 
 
472
 
 
473
class TestConfig(tests.TestCase):
183
474
 
184
475
    def test_constructs(self):
185
476
        config.Config()
186
 
 
 
477
 
187
478
    def test_no_default_editor(self):
188
 
        self.assertRaises(NotImplementedError, config.Config().get_editor)
 
479
        self.assertRaises(
 
480
            NotImplementedError,
 
481
            self.applyDeprecated, deprecated_in((2, 4, 0)),
 
482
            config.Config().get_editor)
189
483
 
190
484
    def test_user_email(self):
191
485
        my_config = InstrumentedConfig()
200
494
 
201
495
    def test_signatures_default(self):
202
496
        my_config = config.Config()
203
 
        self.assertFalse(my_config.signature_needed())
 
497
        self.assertFalse(
 
498
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
499
                my_config.signature_needed))
204
500
        self.assertEqual(config.CHECK_IF_POSSIBLE,
205
 
                         my_config.signature_checking())
 
501
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
502
                my_config.signature_checking))
206
503
        self.assertEqual(config.SIGN_WHEN_REQUIRED,
207
 
                         my_config.signing_policy())
 
504
                self.applyDeprecated(deprecated_in((2, 5, 0)),
 
505
                    my_config.signing_policy))
208
506
 
209
507
    def test_signatures_template_method(self):
210
508
        my_config = InstrumentedConfig()
211
 
        self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
 
509
        self.assertEqual(config.CHECK_NEVER,
 
510
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
511
                my_config.signature_checking))
212
512
        self.assertEqual(['_get_signature_checking'], my_config._calls)
213
513
 
214
514
    def test_signatures_template_method_none(self):
215
515
        my_config = InstrumentedConfig()
216
516
        my_config._signatures = None
217
517
        self.assertEqual(config.CHECK_IF_POSSIBLE,
218
 
                         my_config.signature_checking())
 
518
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
519
                             my_config.signature_checking))
219
520
        self.assertEqual(['_get_signature_checking'], my_config._calls)
220
521
 
221
522
    def test_gpg_signing_command_default(self):
222
523
        my_config = config.Config()
223
 
        self.assertEqual('gpg', my_config.gpg_signing_command())
 
524
        self.assertEqual('gpg',
 
525
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
526
                my_config.gpg_signing_command))
224
527
 
225
528
    def test_get_user_option_default(self):
226
529
        my_config = config.Config()
228
531
 
229
532
    def test_post_commit_default(self):
230
533
        my_config = config.Config()
231
 
        self.assertEqual(None, my_config.post_commit())
 
534
        self.assertEqual(None, self.applyDeprecated(deprecated_in((2, 5, 0)),
 
535
                                                    my_config.post_commit))
 
536
 
232
537
 
233
538
    def test_log_format_default(self):
234
539
        my_config = config.Config()
235
 
        self.assertEqual('long', my_config.log_format())
236
 
 
237
 
 
238
 
class TestConfigPath(TestCase):
 
540
        self.assertEqual('long',
 
541
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
542
                                              my_config.log_format))
 
543
 
 
544
    def test_acceptable_keys_default(self):
 
545
        my_config = config.Config()
 
546
        self.assertEqual(None, self.applyDeprecated(deprecated_in((2, 5, 0)),
 
547
            my_config.acceptable_keys))
 
548
 
 
549
    def test_validate_signatures_in_log_default(self):
 
550
        my_config = config.Config()
 
551
        self.assertEqual(False, my_config.validate_signatures_in_log())
 
552
 
 
553
    def test_get_change_editor(self):
 
554
        my_config = InstrumentedConfig()
 
555
        change_editor = my_config.get_change_editor('old_tree', 'new_tree')
 
556
        self.assertEqual(['_get_change_editor'], my_config._calls)
 
557
        self.assertIs(diff.DiffFromTool, change_editor.__class__)
 
558
        self.assertEqual(['vimdiff', '-fo', '@new_path', '@old_path'],
 
559
                         change_editor.command_template)
 
560
 
 
561
 
 
562
class TestConfigPath(tests.TestCase):
239
563
 
240
564
    def setUp(self):
241
565
        super(TestConfigPath, self).setUp()
242
 
        self.old_home = os.environ.get('HOME', None)
243
 
        self.old_appdata = os.environ.get('APPDATA', None)
244
 
        os.environ['HOME'] = '/home/bogus'
245
 
        os.environ['APPDATA'] = \
246
 
            r'C:\Documents and Settings\bogus\Application Data'
 
566
        self.overrideEnv('HOME', '/home/bogus')
 
567
        self.overrideEnv('XDG_CACHE_DIR', '')
 
568
        if sys.platform == 'win32':
 
569
            self.overrideEnv(
 
570
                'BZR_HOME', r'C:\Documents and Settings\bogus\Application Data')
 
571
            self.bzr_home = \
 
572
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0'
 
573
        else:
 
574
            self.bzr_home = '/home/bogus/.bazaar'
247
575
 
248
 
    def tearDown(self):
249
 
        if self.old_home is None:
250
 
            del os.environ['HOME']
251
 
        else:
252
 
            os.environ['HOME'] = self.old_home
253
 
        if self.old_appdata is None:
254
 
            del os.environ['APPDATA']
255
 
        else:
256
 
            os.environ['APPDATA'] = self.old_appdata
257
 
        super(TestConfigPath, self).tearDown()
258
 
    
259
576
    def test_config_dir(self):
260
 
        if sys.platform == 'win32':
261
 
            self.assertEqual(config.config_dir(), 
262
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0')
263
 
        else:
264
 
            self.assertEqual(config.config_dir(), '/home/bogus/.bazaar')
 
577
        self.assertEqual(config.config_dir(), self.bzr_home)
265
578
 
266
579
    def test_config_filename(self):
267
 
        if sys.platform == 'win32':
268
 
            self.assertEqual(config.config_filename(), 
269
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/bazaar.conf')
270
 
        else:
271
 
            self.assertEqual(config.config_filename(),
272
 
                             '/home/bogus/.bazaar/bazaar.conf')
273
 
 
274
 
    def test_branches_config_filename(self):
275
 
        if sys.platform == 'win32':
276
 
            self.assertEqual(config.branches_config_filename(), 
277
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/branches.conf')
278
 
        else:
279
 
            self.assertEqual(config.branches_config_filename(),
280
 
                             '/home/bogus/.bazaar/branches.conf')
 
580
        self.assertEqual(config.config_filename(),
 
581
                         self.bzr_home + '/bazaar.conf')
281
582
 
282
583
    def test_locations_config_filename(self):
283
 
        if sys.platform == 'win32':
284
 
            self.assertEqual(config.locations_config_filename(), 
285
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/locations.conf')
286
 
        else:
287
 
            self.assertEqual(config.locations_config_filename(),
288
 
                             '/home/bogus/.bazaar/locations.conf')
289
 
 
290
 
class TestIniConfig(TestCase):
 
584
        self.assertEqual(config.locations_config_filename(),
 
585
                         self.bzr_home + '/locations.conf')
 
586
 
 
587
    def test_authentication_config_filename(self):
 
588
        self.assertEqual(config.authentication_config_filename(),
 
589
                         self.bzr_home + '/authentication.conf')
 
590
 
 
591
    def test_xdg_cache_dir(self):
 
592
        self.assertEqual(config.xdg_cache_dir(),
 
593
            '/home/bogus/.cache')
 
594
 
 
595
 
 
596
class TestXDGConfigDir(tests.TestCaseInTempDir):
 
597
    # must be in temp dir because config tests for the existence of the bazaar
 
598
    # subdirectory of $XDG_CONFIG_HOME
 
599
 
 
600
    def setUp(self):
 
601
        if sys.platform in ('darwin', 'win32'):
 
602
            raise tests.TestNotApplicable(
 
603
                'XDG config dir not used on this platform')
 
604
        super(TestXDGConfigDir, self).setUp()
 
605
        self.overrideEnv('HOME', self.test_home_dir)
 
606
        # BZR_HOME overrides everything we want to test so unset it.
 
607
        self.overrideEnv('BZR_HOME', None)
 
608
 
 
609
    def test_xdg_config_dir_exists(self):
 
610
        """When ~/.config/bazaar exists, use it as the config dir."""
 
611
        newdir = osutils.pathjoin(self.test_home_dir, '.config', 'bazaar')
 
612
        os.makedirs(newdir)
 
613
        self.assertEqual(config.config_dir(), newdir)
 
614
 
 
615
    def test_xdg_config_home(self):
 
616
        """When XDG_CONFIG_HOME is set, use it."""
 
617
        xdgconfigdir = osutils.pathjoin(self.test_home_dir, 'xdgconfig')
 
618
        self.overrideEnv('XDG_CONFIG_HOME', xdgconfigdir)
 
619
        newdir = osutils.pathjoin(xdgconfigdir, 'bazaar')
 
620
        os.makedirs(newdir)
 
621
        self.assertEqual(config.config_dir(), newdir)
 
622
 
 
623
 
 
624
class TestIniConfig(tests.TestCaseInTempDir):
 
625
 
 
626
    def make_config_parser(self, s):
 
627
        conf = config.IniBasedConfig.from_string(s)
 
628
        return conf, conf._get_parser()
 
629
 
 
630
 
 
631
class TestIniConfigBuilding(TestIniConfig):
291
632
 
292
633
    def test_contructs(self):
293
 
        my_config = config.IniBasedConfig("nothing")
 
634
        my_config = config.IniBasedConfig()
294
635
 
295
636
    def test_from_fp(self):
296
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
297
 
        my_config = config.IniBasedConfig(None)
298
 
        self.failUnless(
299
 
            isinstance(my_config._get_parser(file=config_file),
300
 
                        ConfigObj))
 
637
        my_config = config.IniBasedConfig.from_string(sample_config_text)
 
638
        self.assertIsInstance(my_config._get_parser(), configobj.ConfigObj)
301
639
 
302
640
    def test_cached(self):
 
641
        my_config = config.IniBasedConfig.from_string(sample_config_text)
 
642
        parser = my_config._get_parser()
 
643
        self.assertTrue(my_config._get_parser() is parser)
 
644
 
 
645
    def _dummy_chown(self, path, uid, gid):
 
646
        self.path, self.uid, self.gid = path, uid, gid
 
647
 
 
648
    def test_ini_config_ownership(self):
 
649
        """Ensure that chown is happening during _write_config_file"""
 
650
        self.requireFeature(features.chown_feature)
 
651
        self.overrideAttr(os, 'chown', self._dummy_chown)
 
652
        self.path = self.uid = self.gid = None
 
653
        conf = config.IniBasedConfig(file_name='./foo.conf')
 
654
        conf._write_config_file()
 
655
        self.assertEquals(self.path, './foo.conf')
 
656
        self.assertTrue(isinstance(self.uid, int))
 
657
        self.assertTrue(isinstance(self.gid, int))
 
658
 
 
659
    def test_get_filename_parameter_is_deprecated_(self):
 
660
        conf = self.callDeprecated([
 
661
            'IniBasedConfig.__init__(get_filename) was deprecated in 2.3.'
 
662
            ' Use file_name instead.'],
 
663
            config.IniBasedConfig, lambda: 'ini.conf')
 
664
        self.assertEqual('ini.conf', conf.file_name)
 
665
 
 
666
    def test_get_parser_file_parameter_is_deprecated_(self):
303
667
        config_file = StringIO(sample_config_text.encode('utf-8'))
304
 
        my_config = config.IniBasedConfig(None)
305
 
        parser = my_config._get_parser(file=config_file)
306
 
        self.failUnless(my_config._get_parser() is parser)
307
 
 
308
 
 
309
 
class TestGetConfig(TestCase):
 
668
        conf = config.IniBasedConfig.from_string(sample_config_text)
 
669
        conf = self.callDeprecated([
 
670
            'IniBasedConfig._get_parser(file=xxx) was deprecated in 2.3.'
 
671
            ' Use IniBasedConfig(_content=xxx) instead.'],
 
672
            conf._get_parser, file=config_file)
 
673
 
 
674
 
 
675
class TestIniConfigSaving(tests.TestCaseInTempDir):
 
676
 
 
677
    def test_cant_save_without_a_file_name(self):
 
678
        conf = config.IniBasedConfig()
 
679
        self.assertRaises(AssertionError, conf._write_config_file)
 
680
 
 
681
    def test_saved_with_content(self):
 
682
        content = 'foo = bar\n'
 
683
        conf = config.IniBasedConfig.from_string(
 
684
            content, file_name='./test.conf', save=True)
 
685
        self.assertFileEqual(content, 'test.conf')
 
686
 
 
687
 
 
688
class TestIniConfigOptionExpansionDefaultValue(tests.TestCaseInTempDir):
 
689
    """What is the default value of expand for config options.
 
690
 
 
691
    This is an opt-in beta feature used to evaluate whether or not option
 
692
    references can appear in dangerous place raising exceptions, disapearing
 
693
    (and as such corrupting data) or if it's safe to activate the option by
 
694
    default.
 
695
 
 
696
    Note that these tests relies on config._expand_default_value being already
 
697
    overwritten in the parent class setUp.
 
698
    """
 
699
 
 
700
    def setUp(self):
 
701
        super(TestIniConfigOptionExpansionDefaultValue, self).setUp()
 
702
        self.config = None
 
703
        self.warnings = []
 
704
        def warning(*args):
 
705
            self.warnings.append(args[0] % args[1:])
 
706
        self.overrideAttr(trace, 'warning', warning)
 
707
 
 
708
    def get_config(self, expand):
 
709
        c = config.GlobalConfig.from_string('bzr.config.expand=%s' % (expand,),
 
710
                                            save=True)
 
711
        return c
 
712
 
 
713
    def assertExpandIs(self, expected):
 
714
        actual = config._get_expand_default_value()
 
715
        #self.config.get_user_option_as_bool('bzr.config.expand')
 
716
        self.assertEquals(expected, actual)
 
717
 
 
718
    def test_default_is_None(self):
 
719
        self.assertEquals(None, config._expand_default_value)
 
720
 
 
721
    def test_default_is_False_even_if_None(self):
 
722
        self.config = self.get_config(None)
 
723
        self.assertExpandIs(False)
 
724
 
 
725
    def test_default_is_False_even_if_invalid(self):
 
726
        self.config = self.get_config('<your choice>')
 
727
        self.assertExpandIs(False)
 
728
        # ...
 
729
        # Huh ? My choice is False ? Thanks, always happy to hear that :D
 
730
        # Wait, you've been warned !
 
731
        self.assertLength(1, self.warnings)
 
732
        self.assertEquals(
 
733
            'Value "<your choice>" is not a boolean for "bzr.config.expand"',
 
734
            self.warnings[0])
 
735
 
 
736
    def test_default_is_True(self):
 
737
        self.config = self.get_config(True)
 
738
        self.assertExpandIs(True)
 
739
 
 
740
    def test_default_is_False(self):
 
741
        self.config = self.get_config(False)
 
742
        self.assertExpandIs(False)
 
743
 
 
744
 
 
745
class TestIniConfigOptionExpansion(tests.TestCase):
 
746
    """Test option expansion from the IniConfig level.
 
747
 
 
748
    What we really want here is to test the Config level, but the class being
 
749
    abstract as far as storing values is concerned, this can't be done
 
750
    properly (yet).
 
751
    """
 
752
    # FIXME: This should be rewritten when all configs share a storage
 
753
    # implementation -- vila 2011-02-18
 
754
 
 
755
    def get_config(self, string=None):
 
756
        if string is None:
 
757
            string = ''
 
758
        c = config.IniBasedConfig.from_string(string)
 
759
        return c
 
760
 
 
761
    def assertExpansion(self, expected, conf, string, env=None):
 
762
        self.assertEquals(expected, conf.expand_options(string, env))
 
763
 
 
764
    def test_no_expansion(self):
 
765
        c = self.get_config('')
 
766
        self.assertExpansion('foo', c, 'foo')
 
767
 
 
768
    def test_env_adding_options(self):
 
769
        c = self.get_config('')
 
770
        self.assertExpansion('bar', c, '{foo}', {'foo': 'bar'})
 
771
 
 
772
    def test_env_overriding_options(self):
 
773
        c = self.get_config('foo=baz')
 
774
        self.assertExpansion('bar', c, '{foo}', {'foo': 'bar'})
 
775
 
 
776
    def test_simple_ref(self):
 
777
        c = self.get_config('foo=xxx')
 
778
        self.assertExpansion('xxx', c, '{foo}')
 
779
 
 
780
    def test_unknown_ref(self):
 
781
        c = self.get_config('')
 
782
        self.assertRaises(errors.ExpandingUnknownOption,
 
783
                          c.expand_options, '{foo}')
 
784
 
 
785
    def test_indirect_ref(self):
 
786
        c = self.get_config('''
 
787
foo=xxx
 
788
bar={foo}
 
789
''')
 
790
        self.assertExpansion('xxx', c, '{bar}')
 
791
 
 
792
    def test_embedded_ref(self):
 
793
        c = self.get_config('''
 
794
foo=xxx
 
795
bar=foo
 
796
''')
 
797
        self.assertExpansion('xxx', c, '{{bar}}')
 
798
 
 
799
    def test_simple_loop(self):
 
800
        c = self.get_config('foo={foo}')
 
801
        self.assertRaises(errors.OptionExpansionLoop, c.expand_options, '{foo}')
 
802
 
 
803
    def test_indirect_loop(self):
 
804
        c = self.get_config('''
 
805
foo={bar}
 
806
bar={baz}
 
807
baz={foo}''')
 
808
        e = self.assertRaises(errors.OptionExpansionLoop,
 
809
                              c.expand_options, '{foo}')
 
810
        self.assertEquals('foo->bar->baz', e.refs)
 
811
        self.assertEquals('{foo}', e.string)
 
812
 
 
813
    def test_list(self):
 
814
        conf = self.get_config('''
 
815
foo=start
 
816
bar=middle
 
817
baz=end
 
818
list={foo},{bar},{baz}
 
819
''')
 
820
        self.assertEquals(['start', 'middle', 'end'],
 
821
                           conf.get_user_option('list', expand=True))
 
822
 
 
823
    def test_cascading_list(self):
 
824
        conf = self.get_config('''
 
825
foo=start,{bar}
 
826
bar=middle,{baz}
 
827
baz=end
 
828
list={foo}
 
829
''')
 
830
        self.assertEquals(['start', 'middle', 'end'],
 
831
                           conf.get_user_option('list', expand=True))
 
832
 
 
833
    def test_pathological_hidden_list(self):
 
834
        conf = self.get_config('''
 
835
foo=bin
 
836
bar=go
 
837
start={foo
 
838
middle=},{
 
839
end=bar}
 
840
hidden={start}{middle}{end}
 
841
''')
 
842
        # Nope, it's either a string or a list, and the list wins as soon as a
 
843
        # ',' appears, so the string concatenation never occur.
 
844
        self.assertEquals(['{foo', '}', '{', 'bar}'],
 
845
                          conf.get_user_option('hidden', expand=True))
 
846
 
 
847
 
 
848
class TestLocationConfigOptionExpansion(tests.TestCaseInTempDir):
 
849
 
 
850
    def get_config(self, location, string=None):
 
851
        if string is None:
 
852
            string = ''
 
853
        # Since we don't save the config we won't strictly require to inherit
 
854
        # from TestCaseInTempDir, but an error occurs so quickly...
 
855
        c = config.LocationConfig.from_string(string, location)
 
856
        return c
 
857
 
 
858
    def test_dont_cross_unrelated_section(self):
 
859
        c = self.get_config('/another/branch/path','''
 
860
[/one/branch/path]
 
861
foo = hello
 
862
bar = {foo}/2
 
863
 
 
864
[/another/branch/path]
 
865
bar = {foo}/2
 
866
''')
 
867
        self.assertRaises(errors.ExpandingUnknownOption,
 
868
                          c.get_user_option, 'bar', expand=True)
 
869
 
 
870
    def test_cross_related_sections(self):
 
871
        c = self.get_config('/project/branch/path','''
 
872
[/project]
 
873
foo = qu
 
874
 
 
875
[/project/branch/path]
 
876
bar = {foo}ux
 
877
''')
 
878
        self.assertEquals('quux', c.get_user_option('bar', expand=True))
 
879
 
 
880
 
 
881
class TestIniBaseConfigOnDisk(tests.TestCaseInTempDir):
 
882
 
 
883
    def test_cannot_reload_without_name(self):
 
884
        conf = config.IniBasedConfig.from_string(sample_config_text)
 
885
        self.assertRaises(AssertionError, conf.reload)
 
886
 
 
887
    def test_reload_see_new_value(self):
 
888
        c1 = config.IniBasedConfig.from_string('editor=vim\n',
 
889
                                               file_name='./test/conf')
 
890
        c1._write_config_file()
 
891
        c2 = config.IniBasedConfig.from_string('editor=emacs\n',
 
892
                                               file_name='./test/conf')
 
893
        c2._write_config_file()
 
894
        self.assertEqual('vim', c1.get_user_option('editor'))
 
895
        self.assertEqual('emacs', c2.get_user_option('editor'))
 
896
        # Make sure we get the Right value
 
897
        c1.reload()
 
898
        self.assertEqual('emacs', c1.get_user_option('editor'))
 
899
 
 
900
 
 
901
class TestLockableConfig(tests.TestCaseInTempDir):
 
902
 
 
903
    scenarios = lockable_config_scenarios()
 
904
 
 
905
    # Set by load_tests
 
906
    config_class = None
 
907
    config_args = None
 
908
    config_section = None
 
909
 
 
910
    def setUp(self):
 
911
        super(TestLockableConfig, self).setUp()
 
912
        self._content = '[%s]\none=1\ntwo=2\n' % (self.config_section,)
 
913
        self.config = self.create_config(self._content)
 
914
 
 
915
    def get_existing_config(self):
 
916
        return self.config_class(*self.config_args)
 
917
 
 
918
    def create_config(self, content):
 
919
        kwargs = dict(save=True)
 
920
        c = self.config_class.from_string(content, *self.config_args, **kwargs)
 
921
        return c
 
922
 
 
923
    def test_simple_read_access(self):
 
924
        self.assertEquals('1', self.config.get_user_option('one'))
 
925
 
 
926
    def test_simple_write_access(self):
 
927
        self.config.set_user_option('one', 'one')
 
928
        self.assertEquals('one', self.config.get_user_option('one'))
 
929
 
 
930
    def test_listen_to_the_last_speaker(self):
 
931
        c1 = self.config
 
932
        c2 = self.get_existing_config()
 
933
        c1.set_user_option('one', 'ONE')
 
934
        c2.set_user_option('two', 'TWO')
 
935
        self.assertEquals('ONE', c1.get_user_option('one'))
 
936
        self.assertEquals('TWO', c2.get_user_option('two'))
 
937
        # The second update respect the first one
 
938
        self.assertEquals('ONE', c2.get_user_option('one'))
 
939
 
 
940
    def test_last_speaker_wins(self):
 
941
        # If the same config is not shared, the same variable modified twice
 
942
        # can only see a single result.
 
943
        c1 = self.config
 
944
        c2 = self.get_existing_config()
 
945
        c1.set_user_option('one', 'c1')
 
946
        c2.set_user_option('one', 'c2')
 
947
        self.assertEquals('c2', c2._get_user_option('one'))
 
948
        # The first modification is still available until another refresh
 
949
        # occur
 
950
        self.assertEquals('c1', c1._get_user_option('one'))
 
951
        c1.set_user_option('two', 'done')
 
952
        self.assertEquals('c2', c1._get_user_option('one'))
 
953
 
 
954
    def test_writes_are_serialized(self):
 
955
        c1 = self.config
 
956
        c2 = self.get_existing_config()
 
957
 
 
958
        # We spawn a thread that will pause *during* the write
 
959
        before_writing = threading.Event()
 
960
        after_writing = threading.Event()
 
961
        writing_done = threading.Event()
 
962
        c1_orig = c1._write_config_file
 
963
        def c1_write_config_file():
 
964
            before_writing.set()
 
965
            c1_orig()
 
966
            # The lock is held. We wait for the main thread to decide when to
 
967
            # continue
 
968
            after_writing.wait()
 
969
        c1._write_config_file = c1_write_config_file
 
970
        def c1_set_option():
 
971
            c1.set_user_option('one', 'c1')
 
972
            writing_done.set()
 
973
        t1 = threading.Thread(target=c1_set_option)
 
974
        # Collect the thread after the test
 
975
        self.addCleanup(t1.join)
 
976
        # Be ready to unblock the thread if the test goes wrong
 
977
        self.addCleanup(after_writing.set)
 
978
        t1.start()
 
979
        before_writing.wait()
 
980
        self.assertTrue(c1._lock.is_held)
 
981
        self.assertRaises(errors.LockContention,
 
982
                          c2.set_user_option, 'one', 'c2')
 
983
        self.assertEquals('c1', c1.get_user_option('one'))
 
984
        # Let the lock be released
 
985
        after_writing.set()
 
986
        writing_done.wait()
 
987
        c2.set_user_option('one', 'c2')
 
988
        self.assertEquals('c2', c2.get_user_option('one'))
 
989
 
 
990
    def test_read_while_writing(self):
 
991
       c1 = self.config
 
992
       # We spawn a thread that will pause *during* the write
 
993
       ready_to_write = threading.Event()
 
994
       do_writing = threading.Event()
 
995
       writing_done = threading.Event()
 
996
       c1_orig = c1._write_config_file
 
997
       def c1_write_config_file():
 
998
           ready_to_write.set()
 
999
           # The lock is held. We wait for the main thread to decide when to
 
1000
           # continue
 
1001
           do_writing.wait()
 
1002
           c1_orig()
 
1003
           writing_done.set()
 
1004
       c1._write_config_file = c1_write_config_file
 
1005
       def c1_set_option():
 
1006
           c1.set_user_option('one', 'c1')
 
1007
       t1 = threading.Thread(target=c1_set_option)
 
1008
       # Collect the thread after the test
 
1009
       self.addCleanup(t1.join)
 
1010
       # Be ready to unblock the thread if the test goes wrong
 
1011
       self.addCleanup(do_writing.set)
 
1012
       t1.start()
 
1013
       # Ensure the thread is ready to write
 
1014
       ready_to_write.wait()
 
1015
       self.assertTrue(c1._lock.is_held)
 
1016
       self.assertEquals('c1', c1.get_user_option('one'))
 
1017
       # If we read during the write, we get the old value
 
1018
       c2 = self.get_existing_config()
 
1019
       self.assertEquals('1', c2.get_user_option('one'))
 
1020
       # Let the writing occur and ensure it occurred
 
1021
       do_writing.set()
 
1022
       writing_done.wait()
 
1023
       # Now we get the updated value
 
1024
       c3 = self.get_existing_config()
 
1025
       self.assertEquals('c1', c3.get_user_option('one'))
 
1026
 
 
1027
 
 
1028
class TestGetUserOptionAs(TestIniConfig):
 
1029
 
 
1030
    def test_get_user_option_as_bool(self):
 
1031
        conf, parser = self.make_config_parser("""
 
1032
a_true_bool = true
 
1033
a_false_bool = 0
 
1034
an_invalid_bool = maybe
 
1035
a_list = hmm, who knows ? # This is interpreted as a list !
 
1036
""")
 
1037
        get_bool = conf.get_user_option_as_bool
 
1038
        self.assertEqual(True, get_bool('a_true_bool'))
 
1039
        self.assertEqual(False, get_bool('a_false_bool'))
 
1040
        warnings = []
 
1041
        def warning(*args):
 
1042
            warnings.append(args[0] % args[1:])
 
1043
        self.overrideAttr(trace, 'warning', warning)
 
1044
        msg = 'Value "%s" is not a boolean for "%s"'
 
1045
        self.assertIs(None, get_bool('an_invalid_bool'))
 
1046
        self.assertEquals(msg % ('maybe', 'an_invalid_bool'), warnings[0])
 
1047
        warnings = []
 
1048
        self.assertIs(None, get_bool('not_defined_in_this_config'))
 
1049
        self.assertEquals([], warnings)
 
1050
 
 
1051
    def test_get_user_option_as_list(self):
 
1052
        conf, parser = self.make_config_parser("""
 
1053
a_list = a,b,c
 
1054
length_1 = 1,
 
1055
one_item = x
 
1056
""")
 
1057
        get_list = conf.get_user_option_as_list
 
1058
        self.assertEqual(['a', 'b', 'c'], get_list('a_list'))
 
1059
        self.assertEqual(['1'], get_list('length_1'))
 
1060
        self.assertEqual('x', conf.get_user_option('one_item'))
 
1061
        # automatically cast to list
 
1062
        self.assertEqual(['x'], get_list('one_item'))
 
1063
 
 
1064
    def test_get_user_option_as_int_from_SI(self):
 
1065
        conf, parser = self.make_config_parser("""
 
1066
plain = 100
 
1067
si_k = 5k,
 
1068
si_kb = 5kb,
 
1069
si_m = 5M,
 
1070
si_mb = 5MB,
 
1071
si_g = 5g,
 
1072
si_gb = 5gB,
 
1073
""")
 
1074
        def get_si(s, default=None):
 
1075
            return self.applyDeprecated(
 
1076
                deprecated_in((2, 5, 0)),
 
1077
                conf.get_user_option_as_int_from_SI, s, default)
 
1078
        self.assertEqual(100, get_si('plain'))
 
1079
        self.assertEqual(5000, get_si('si_k'))
 
1080
        self.assertEqual(5000, get_si('si_kb'))
 
1081
        self.assertEqual(5000000, get_si('si_m'))
 
1082
        self.assertEqual(5000000, get_si('si_mb'))
 
1083
        self.assertEqual(5000000000, get_si('si_g'))
 
1084
        self.assertEqual(5000000000, get_si('si_gb'))
 
1085
        self.assertEqual(None, get_si('non-exist'))
 
1086
        self.assertEqual(42, get_si('non-exist-with-default',  42))
 
1087
 
 
1088
 
 
1089
class TestSupressWarning(TestIniConfig):
 
1090
 
 
1091
    def make_warnings_config(self, s):
 
1092
        conf, parser = self.make_config_parser(s)
 
1093
        return conf.suppress_warning
 
1094
 
 
1095
    def test_suppress_warning_unknown(self):
 
1096
        suppress_warning = self.make_warnings_config('')
 
1097
        self.assertEqual(False, suppress_warning('unknown_warning'))
 
1098
 
 
1099
    def test_suppress_warning_known(self):
 
1100
        suppress_warning = self.make_warnings_config('suppress_warnings=a,b')
 
1101
        self.assertEqual(False, suppress_warning('c'))
 
1102
        self.assertEqual(True, suppress_warning('a'))
 
1103
        self.assertEqual(True, suppress_warning('b'))
 
1104
 
 
1105
 
 
1106
class TestGetConfig(tests.TestCase):
310
1107
 
311
1108
    def test_constructs(self):
312
1109
        my_config = config.GlobalConfig()
313
1110
 
314
1111
    def test_calls_read_filenames(self):
315
 
        # replace the class that is constructured, to check its parameters
 
1112
        # replace the class that is constructed, to check its parameters
316
1113
        oldparserclass = config.ConfigObj
317
1114
        config.ConfigObj = InstrumentedConfigObj
318
1115
        my_config = config.GlobalConfig()
320
1117
            parser = my_config._get_parser()
321
1118
        finally:
322
1119
            config.ConfigObj = oldparserclass
323
 
        self.failUnless(isinstance(parser, InstrumentedConfigObj))
 
1120
        self.assertIsInstance(parser, InstrumentedConfigObj)
324
1121
        self.assertEqual(parser._calls, [('__init__', config.config_filename(),
325
1122
                                          'utf-8')])
326
1123
 
327
1124
 
328
 
class TestBranchConfig(TestCaseWithTransport):
 
1125
class TestBranchConfig(tests.TestCaseWithTransport):
329
1126
 
330
1127
    def test_constructs(self):
331
1128
        branch = FakeBranch()
337
1134
        my_config = config.BranchConfig(branch)
338
1135
        location_config = my_config._get_location_config()
339
1136
        self.assertEqual(branch.base, location_config.location)
340
 
        self.failUnless(location_config is my_config._get_location_config())
 
1137
        self.assertIs(location_config, my_config._get_location_config())
341
1138
 
342
1139
    def test_get_config(self):
343
1140
        """The Branch.get_config method works properly"""
344
 
        b = BzrDir.create_standalone_workingtree('.').branch
 
1141
        b = bzrdir.BzrDir.create_standalone_workingtree('.').branch
345
1142
        my_config = b.get_config()
346
1143
        self.assertIs(my_config.get_user_option('wacky'), None)
347
1144
        my_config.set_user_option('wacky', 'unlikely')
348
1145
        self.assertEqual(my_config.get_user_option('wacky'), 'unlikely')
349
1146
 
350
1147
        # Ensure we get the same thing if we start again
351
 
        b2 = Branch.open('.')
 
1148
        b2 = branch.Branch.open('.')
352
1149
        my_config2 = b2.get_config()
353
1150
        self.assertEqual(my_config2.get_user_option('wacky'), 'unlikely')
354
1151
 
363
1160
        branch = self.make_branch('branch')
364
1161
        self.assertEqual('branch', branch.nick)
365
1162
 
366
 
        locations = config.locations_config_filename()
367
 
        config.ensure_config_dir_exists()
368
1163
        local_url = urlutils.local_path_to_url('branch')
369
 
        open(locations, 'wb').write('[%s]\nnickname = foobar' 
370
 
                                    % (local_url,))
 
1164
        conf = config.LocationConfig.from_string(
 
1165
            '[%s]\nnickname = foobar' % (local_url,),
 
1166
            local_url, save=True)
371
1167
        self.assertEqual('foobar', branch.nick)
372
1168
 
373
1169
    def test_config_local_path(self):
375
1171
        branch = self.make_branch('branch')
376
1172
        self.assertEqual('branch', branch.nick)
377
1173
 
378
 
        locations = config.locations_config_filename()
379
 
        config.ensure_config_dir_exists()
380
 
        open(locations, 'wb').write('[%s/branch]\nnickname = barry' 
381
 
                                    % (osutils.getcwd().encode('utf8'),))
 
1174
        local_path = osutils.getcwd().encode('utf8')
 
1175
        conf = config.LocationConfig.from_string(
 
1176
            '[%s/branch]\nnickname = barry' % (local_path,),
 
1177
            'branch',  save=True)
382
1178
        self.assertEqual('barry', branch.nick)
383
1179
 
384
1180
    def test_config_creates_local(self):
385
1181
        """Creating a new entry in config uses a local path."""
386
 
        branch = self.make_branch('branch')
 
1182
        branch = self.make_branch('branch', format='knit')
387
1183
        branch.set_push_location('http://foobar')
388
 
        locations = config.locations_config_filename()
389
1184
        local_path = osutils.getcwd().encode('utf8')
390
1185
        # Surprisingly ConfigObj doesn't create a trailing newline
391
 
        self.check_file_contents(locations,
392
 
            '[%s/branch]\npush_location = http://foobar' % (local_path,))
393
 
 
394
 
 
395
 
class TestGlobalConfigItems(TestCase):
 
1186
        self.check_file_contents(config.locations_config_filename(),
 
1187
                                 '[%s/branch]\n'
 
1188
                                 'push_location = http://foobar\n'
 
1189
                                 'push_location:policy = norecurse\n'
 
1190
                                 % (local_path,))
 
1191
 
 
1192
    def test_autonick_urlencoded(self):
 
1193
        b = self.make_branch('!repo')
 
1194
        self.assertEqual('!repo', b.get_config().get_nickname())
 
1195
 
 
1196
    def test_warn_if_masked(self):
 
1197
        warnings = []
 
1198
        def warning(*args):
 
1199
            warnings.append(args[0] % args[1:])
 
1200
        self.overrideAttr(trace, 'warning', warning)
 
1201
 
 
1202
        def set_option(store, warn_masked=True):
 
1203
            warnings[:] = []
 
1204
            conf.set_user_option('example_option', repr(store), store=store,
 
1205
                                 warn_masked=warn_masked)
 
1206
        def assertWarning(warning):
 
1207
            if warning is None:
 
1208
                self.assertEqual(0, len(warnings))
 
1209
            else:
 
1210
                self.assertEqual(1, len(warnings))
 
1211
                self.assertEqual(warning, warnings[0])
 
1212
        branch = self.make_branch('.')
 
1213
        conf = branch.get_config()
 
1214
        set_option(config.STORE_GLOBAL)
 
1215
        assertWarning(None)
 
1216
        set_option(config.STORE_BRANCH)
 
1217
        assertWarning(None)
 
1218
        set_option(config.STORE_GLOBAL)
 
1219
        assertWarning('Value "4" is masked by "3" from branch.conf')
 
1220
        set_option(config.STORE_GLOBAL, warn_masked=False)
 
1221
        assertWarning(None)
 
1222
        set_option(config.STORE_LOCATION)
 
1223
        assertWarning(None)
 
1224
        set_option(config.STORE_BRANCH)
 
1225
        assertWarning('Value "3" is masked by "0" from locations.conf')
 
1226
        set_option(config.STORE_BRANCH, warn_masked=False)
 
1227
        assertWarning(None)
 
1228
 
 
1229
 
 
1230
class TestGlobalConfigItems(tests.TestCaseInTempDir):
396
1231
 
397
1232
    def test_user_id(self):
398
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
399
 
        my_config = config.GlobalConfig()
400
 
        my_config._parser = my_config._get_parser(file=config_file)
 
1233
        my_config = config.GlobalConfig.from_string(sample_config_text)
401
1234
        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
402
1235
                         my_config._get_user_id())
403
1236
 
404
1237
    def test_absent_user_id(self):
405
 
        config_file = StringIO("")
406
1238
        my_config = config.GlobalConfig()
407
 
        my_config._parser = my_config._get_parser(file=config_file)
408
1239
        self.assertEqual(None, my_config._get_user_id())
409
1240
 
410
1241
    def test_configured_editor(self):
411
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
412
 
        my_config = config.GlobalConfig()
413
 
        my_config._parser = my_config._get_parser(file=config_file)
414
 
        self.assertEqual("vim", my_config.get_editor())
 
1242
        my_config = config.GlobalConfig.from_string(sample_config_text)
 
1243
        editor = self.applyDeprecated(
 
1244
            deprecated_in((2, 4, 0)), my_config.get_editor)
 
1245
        self.assertEqual('vim', editor)
415
1246
 
416
1247
    def test_signatures_always(self):
417
 
        config_file = StringIO(sample_always_signatures)
418
 
        my_config = config.GlobalConfig()
419
 
        my_config._parser = my_config._get_parser(file=config_file)
 
1248
        my_config = config.GlobalConfig.from_string(sample_always_signatures)
420
1249
        self.assertEqual(config.CHECK_NEVER,
421
 
                         my_config.signature_checking())
 
1250
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1251
                             my_config.signature_checking))
422
1252
        self.assertEqual(config.SIGN_ALWAYS,
423
 
                         my_config.signing_policy())
424
 
        self.assertEqual(True, my_config.signature_needed())
 
1253
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1254
                             my_config.signing_policy))
 
1255
        self.assertEqual(True,
 
1256
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1257
                my_config.signature_needed))
425
1258
 
426
1259
    def test_signatures_if_possible(self):
427
 
        config_file = StringIO(sample_maybe_signatures)
428
 
        my_config = config.GlobalConfig()
429
 
        my_config._parser = my_config._get_parser(file=config_file)
 
1260
        my_config = config.GlobalConfig.from_string(sample_maybe_signatures)
430
1261
        self.assertEqual(config.CHECK_NEVER,
431
 
                         my_config.signature_checking())
 
1262
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1263
                             my_config.signature_checking))
432
1264
        self.assertEqual(config.SIGN_WHEN_REQUIRED,
433
 
                         my_config.signing_policy())
434
 
        self.assertEqual(False, my_config.signature_needed())
 
1265
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1266
                             my_config.signing_policy))
 
1267
        self.assertEqual(False, self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1268
            my_config.signature_needed))
435
1269
 
436
1270
    def test_signatures_ignore(self):
437
 
        config_file = StringIO(sample_ignore_signatures)
438
 
        my_config = config.GlobalConfig()
439
 
        my_config._parser = my_config._get_parser(file=config_file)
 
1271
        my_config = config.GlobalConfig.from_string(sample_ignore_signatures)
440
1272
        self.assertEqual(config.CHECK_ALWAYS,
441
 
                         my_config.signature_checking())
 
1273
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1274
                             my_config.signature_checking))
442
1275
        self.assertEqual(config.SIGN_NEVER,
443
 
                         my_config.signing_policy())
444
 
        self.assertEqual(False, my_config.signature_needed())
 
1276
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1277
                             my_config.signing_policy))
 
1278
        self.assertEqual(False, self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1279
            my_config.signature_needed))
445
1280
 
446
1281
    def _get_sample_config(self):
447
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
448
 
        my_config = config.GlobalConfig()
449
 
        my_config._parser = my_config._get_parser(file=config_file)
 
1282
        my_config = config.GlobalConfig.from_string(sample_config_text)
450
1283
        return my_config
451
1284
 
452
1285
    def test_gpg_signing_command(self):
453
1286
        my_config = self._get_sample_config()
454
 
        self.assertEqual("gnome-gpg", my_config.gpg_signing_command())
455
 
        self.assertEqual(False, my_config.signature_needed())
 
1287
        self.assertEqual("gnome-gpg",
 
1288
            self.applyDeprecated(
 
1289
                deprecated_in((2, 5, 0)), my_config.gpg_signing_command))
 
1290
        self.assertEqual(False, self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1291
            my_config.signature_needed))
 
1292
 
 
1293
    def test_gpg_signing_key(self):
 
1294
        my_config = self._get_sample_config()
 
1295
        self.assertEqual("DD4D5088",
 
1296
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1297
                my_config.gpg_signing_key))
456
1298
 
457
1299
    def _get_empty_config(self):
458
 
        config_file = StringIO("")
459
1300
        my_config = config.GlobalConfig()
460
 
        my_config._parser = my_config._get_parser(file=config_file)
461
1301
        return my_config
462
1302
 
463
1303
    def test_gpg_signing_command_unset(self):
464
1304
        my_config = self._get_empty_config()
465
 
        self.assertEqual("gpg", my_config.gpg_signing_command())
 
1305
        self.assertEqual("gpg",
 
1306
            self.applyDeprecated(
 
1307
                deprecated_in((2, 5, 0)), my_config.gpg_signing_command))
466
1308
 
467
1309
    def test_get_user_option_default(self):
468
1310
        my_config = self._get_empty_config()
472
1314
        my_config = self._get_sample_config()
473
1315
        self.assertEqual("something",
474
1316
                         my_config.get_user_option('user_global_option'))
475
 
        
 
1317
 
476
1318
    def test_post_commit_default(self):
477
1319
        my_config = self._get_sample_config()
478
 
        self.assertEqual(None, my_config.post_commit())
 
1320
        self.assertEqual(None,
 
1321
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1322
                                              my_config.post_commit))
479
1323
 
480
1324
    def test_configured_logformat(self):
481
1325
        my_config = self._get_sample_config()
482
 
        self.assertEqual("short", my_config.log_format())
 
1326
        self.assertEqual("short",
 
1327
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1328
                                              my_config.log_format))
 
1329
 
 
1330
    def test_configured_acceptable_keys(self):
 
1331
        my_config = self._get_sample_config()
 
1332
        self.assertEqual("amy",
 
1333
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1334
                my_config.acceptable_keys))
 
1335
 
 
1336
    def test_configured_validate_signatures_in_log(self):
 
1337
        my_config = self._get_sample_config()
 
1338
        self.assertEqual(True, my_config.validate_signatures_in_log())
483
1339
 
484
1340
    def test_get_alias(self):
485
1341
        my_config = self._get_sample_config()
486
1342
        self.assertEqual('help', my_config.get_alias('h'))
487
1343
 
 
1344
    def test_get_aliases(self):
 
1345
        my_config = self._get_sample_config()
 
1346
        aliases = my_config.get_aliases()
 
1347
        self.assertEqual(2, len(aliases))
 
1348
        sorted_keys = sorted(aliases)
 
1349
        self.assertEqual('help', aliases[sorted_keys[0]])
 
1350
        self.assertEqual(sample_long_alias, aliases[sorted_keys[1]])
 
1351
 
488
1352
    def test_get_no_alias(self):
489
1353
        my_config = self._get_sample_config()
490
1354
        self.assertEqual(None, my_config.get_alias('foo'))
493
1357
        my_config = self._get_sample_config()
494
1358
        self.assertEqual(sample_long_alias, my_config.get_alias('ll'))
495
1359
 
496
 
 
497
 
class TestLocationConfig(TestCaseInTempDir):
 
1360
    def test_get_change_editor(self):
 
1361
        my_config = self._get_sample_config()
 
1362
        change_editor = my_config.get_change_editor('old', 'new')
 
1363
        self.assertIs(diff.DiffFromTool, change_editor.__class__)
 
1364
        self.assertEqual('vimdiff -of @new_path @old_path',
 
1365
                         ' '.join(change_editor.command_template))
 
1366
 
 
1367
    def test_get_no_change_editor(self):
 
1368
        my_config = self._get_empty_config()
 
1369
        change_editor = my_config.get_change_editor('old', 'new')
 
1370
        self.assertIs(None, change_editor)
 
1371
 
 
1372
    def test_get_merge_tools(self):
 
1373
        conf = self._get_sample_config()
 
1374
        tools = conf.get_merge_tools()
 
1375
        self.log(repr(tools))
 
1376
        self.assertEqual(
 
1377
            {u'funkytool' : u'funkytool "arg with spaces" {this_temp}',
 
1378
            u'sometool' : u'sometool {base} {this} {other} -o {result}',
 
1379
            u'newtool' : u'"newtool with spaces" {this_temp}'},
 
1380
            tools)
 
1381
 
 
1382
    def test_get_merge_tools_empty(self):
 
1383
        conf = self._get_empty_config()
 
1384
        tools = conf.get_merge_tools()
 
1385
        self.assertEqual({}, tools)
 
1386
 
 
1387
    def test_find_merge_tool(self):
 
1388
        conf = self._get_sample_config()
 
1389
        cmdline = conf.find_merge_tool('sometool')
 
1390
        self.assertEqual('sometool {base} {this} {other} -o {result}', cmdline)
 
1391
 
 
1392
    def test_find_merge_tool_not_found(self):
 
1393
        conf = self._get_sample_config()
 
1394
        cmdline = conf.find_merge_tool('DOES NOT EXIST')
 
1395
        self.assertIs(cmdline, None)
 
1396
 
 
1397
    def test_find_merge_tool_known(self):
 
1398
        conf = self._get_empty_config()
 
1399
        cmdline = conf.find_merge_tool('kdiff3')
 
1400
        self.assertEquals('kdiff3 {base} {this} {other} -o {result}', cmdline)
 
1401
 
 
1402
    def test_find_merge_tool_override_known(self):
 
1403
        conf = self._get_empty_config()
 
1404
        conf.set_user_option('bzr.mergetool.kdiff3', 'kdiff3 blah')
 
1405
        cmdline = conf.find_merge_tool('kdiff3')
 
1406
        self.assertEqual('kdiff3 blah', cmdline)
 
1407
 
 
1408
 
 
1409
class TestGlobalConfigSavingOptions(tests.TestCaseInTempDir):
 
1410
 
 
1411
    def test_empty(self):
 
1412
        my_config = config.GlobalConfig()
 
1413
        self.assertEqual(0, len(my_config.get_aliases()))
 
1414
 
 
1415
    def test_set_alias(self):
 
1416
        my_config = config.GlobalConfig()
 
1417
        alias_value = 'commit --strict'
 
1418
        my_config.set_alias('commit', alias_value)
 
1419
        new_config = config.GlobalConfig()
 
1420
        self.assertEqual(alias_value, new_config.get_alias('commit'))
 
1421
 
 
1422
    def test_remove_alias(self):
 
1423
        my_config = config.GlobalConfig()
 
1424
        my_config.set_alias('commit', 'commit --strict')
 
1425
        # Now remove the alias again.
 
1426
        my_config.unset_alias('commit')
 
1427
        new_config = config.GlobalConfig()
 
1428
        self.assertIs(None, new_config.get_alias('commit'))
 
1429
 
 
1430
 
 
1431
class TestLocationConfig(tests.TestCaseInTempDir, TestOptionsMixin):
498
1432
 
499
1433
    def test_constructs(self):
500
1434
        my_config = config.LocationConfig('http://example.com')
504
1438
        # This is testing the correct file names are provided.
505
1439
        # TODO: consolidate with the test for GlobalConfigs filename checks.
506
1440
        #
507
 
        # replace the class that is constructured, to check its parameters
 
1441
        # replace the class that is constructed, to check its parameters
508
1442
        oldparserclass = config.ConfigObj
509
1443
        config.ConfigObj = InstrumentedConfigObj
510
1444
        try:
512
1446
            parser = my_config._get_parser()
513
1447
        finally:
514
1448
            config.ConfigObj = oldparserclass
515
 
        self.failUnless(isinstance(parser, InstrumentedConfigObj))
 
1449
        self.assertIsInstance(parser, InstrumentedConfigObj)
516
1450
        self.assertEqual(parser._calls,
517
1451
                         [('__init__', config.locations_config_filename(),
518
1452
                           'utf-8')])
519
 
        config.ensure_config_dir_exists()
520
 
        #os.mkdir(config.config_dir())
521
 
        f = file(config.branches_config_filename(), 'wb')
522
 
        f.write('')
523
 
        f.close()
524
 
        oldparserclass = config.ConfigObj
525
 
        config.ConfigObj = InstrumentedConfigObj
526
 
        try:
527
 
            my_config = config.LocationConfig('http://www.example.com')
528
 
            parser = my_config._get_parser()
529
 
        finally:
530
 
            config.ConfigObj = oldparserclass
531
1453
 
532
1454
    def test_get_global_config(self):
533
1455
        my_config = config.BranchConfig(FakeBranch('http://example.com'))
534
1456
        global_config = my_config._get_global_config()
535
 
        self.failUnless(isinstance(global_config, config.GlobalConfig))
536
 
        self.failUnless(global_config is my_config._get_global_config())
537
 
 
538
 
    def test__get_section_no_match(self):
 
1457
        self.assertIsInstance(global_config, config.GlobalConfig)
 
1458
        self.assertIs(global_config, my_config._get_global_config())
 
1459
 
 
1460
    def assertLocationMatching(self, expected):
 
1461
        self.assertEqual(expected,
 
1462
                         list(self.my_location_config._get_matching_sections()))
 
1463
 
 
1464
    def test__get_matching_sections_no_match(self):
539
1465
        self.get_branch_config('/')
540
 
        self.assertEqual(None, self.my_location_config._get_section())
541
 
        
542
 
    def test__get_section_exact(self):
 
1466
        self.assertLocationMatching([])
 
1467
 
 
1468
    def test__get_matching_sections_exact(self):
543
1469
        self.get_branch_config('http://www.example.com')
544
 
        self.assertEqual('http://www.example.com',
545
 
                         self.my_location_config._get_section())
546
 
   
547
 
    def test__get_section_suffix_does_not(self):
 
1470
        self.assertLocationMatching([('http://www.example.com', '')])
 
1471
 
 
1472
    def test__get_matching_sections_suffix_does_not(self):
548
1473
        self.get_branch_config('http://www.example.com-com')
549
 
        self.assertEqual(None, self.my_location_config._get_section())
 
1474
        self.assertLocationMatching([])
550
1475
 
551
 
    def test__get_section_subdir_recursive(self):
 
1476
    def test__get_matching_sections_subdir_recursive(self):
552
1477
        self.get_branch_config('http://www.example.com/com')
553
 
        self.assertEqual('http://www.example.com',
554
 
                         self.my_location_config._get_section())
555
 
 
556
 
    def test__get_section_subdir_matches(self):
557
 
        self.get_branch_config('http://www.example.com/useglobal')
558
 
        self.assertEqual('http://www.example.com/useglobal',
559
 
                         self.my_location_config._get_section())
560
 
 
561
 
    def test__get_section_subdir_nonrecursive(self):
 
1478
        self.assertLocationMatching([('http://www.example.com', 'com')])
 
1479
 
 
1480
    def test__get_matching_sections_ignoreparent(self):
 
1481
        self.get_branch_config('http://www.example.com/ignoreparent')
 
1482
        self.assertLocationMatching([('http://www.example.com/ignoreparent',
 
1483
                                      '')])
 
1484
 
 
1485
    def test__get_matching_sections_ignoreparent_subdir(self):
562
1486
        self.get_branch_config(
563
 
            'http://www.example.com/useglobal/childbranch')
564
 
        self.assertEqual('http://www.example.com',
565
 
                         self.my_location_config._get_section())
 
1487
            'http://www.example.com/ignoreparent/childbranch')
 
1488
        self.assertLocationMatching([('http://www.example.com/ignoreparent',
 
1489
                                      'childbranch')])
566
1490
 
567
 
    def test__get_section_subdir_trailing_slash(self):
 
1491
    def test__get_matching_sections_subdir_trailing_slash(self):
568
1492
        self.get_branch_config('/b')
569
 
        self.assertEqual('/b/', self.my_location_config._get_section())
 
1493
        self.assertLocationMatching([('/b/', '')])
570
1494
 
571
 
    def test__get_section_subdir_child(self):
 
1495
    def test__get_matching_sections_subdir_child(self):
572
1496
        self.get_branch_config('/a/foo')
573
 
        self.assertEqual('/a/*', self.my_location_config._get_section())
 
1497
        self.assertLocationMatching([('/a/*', ''), ('/a/', 'foo')])
574
1498
 
575
 
    def test__get_section_subdir_child_child(self):
 
1499
    def test__get_matching_sections_subdir_child_child(self):
576
1500
        self.get_branch_config('/a/foo/bar')
577
 
        self.assertEqual('/a/', self.my_location_config._get_section())
 
1501
        self.assertLocationMatching([('/a/*', 'bar'), ('/a/', 'foo/bar')])
578
1502
 
579
 
    def test__get_section_trailing_slash_with_children(self):
 
1503
    def test__get_matching_sections_trailing_slash_with_children(self):
580
1504
        self.get_branch_config('/a/')
581
 
        self.assertEqual('/a/', self.my_location_config._get_section())
 
1505
        self.assertLocationMatching([('/a/', '')])
582
1506
 
583
 
    def test__get_section_explicit_over_glob(self):
 
1507
    def test__get_matching_sections_explicit_over_glob(self):
 
1508
        # XXX: 2006-09-08 jamesh
 
1509
        # This test only passes because ord('c') > ord('*').  If there
 
1510
        # was a config section for '/a/?', it would get precedence
 
1511
        # over '/a/c'.
584
1512
        self.get_branch_config('/a/c')
585
 
        self.assertEqual('/a/c', self.my_location_config._get_section())
586
 
 
 
1513
        self.assertLocationMatching([('/a/c', ''), ('/a/*', ''), ('/a/', 'c')])
 
1514
 
 
1515
    def test__get_option_policy_normal(self):
 
1516
        self.get_branch_config('http://www.example.com')
 
1517
        self.assertEqual(
 
1518
            self.my_location_config._get_config_policy(
 
1519
            'http://www.example.com', 'normal_option'),
 
1520
            config.POLICY_NONE)
 
1521
 
 
1522
    def test__get_option_policy_norecurse(self):
 
1523
        self.get_branch_config('http://www.example.com')
 
1524
        self.assertEqual(
 
1525
            self.my_location_config._get_option_policy(
 
1526
            'http://www.example.com', 'norecurse_option'),
 
1527
            config.POLICY_NORECURSE)
 
1528
        # Test old recurse=False setting:
 
1529
        self.assertEqual(
 
1530
            self.my_location_config._get_option_policy(
 
1531
            'http://www.example.com/norecurse', 'normal_option'),
 
1532
            config.POLICY_NORECURSE)
 
1533
 
 
1534
    def test__get_option_policy_normal(self):
 
1535
        self.get_branch_config('http://www.example.com')
 
1536
        self.assertEqual(
 
1537
            self.my_location_config._get_option_policy(
 
1538
            'http://www.example.com', 'appendpath_option'),
 
1539
            config.POLICY_APPENDPATH)
 
1540
 
 
1541
    def test__get_options_with_policy(self):
 
1542
        self.get_branch_config('/dir/subdir',
 
1543
                               location_config="""\
 
1544
[/dir]
 
1545
other_url = /other-dir
 
1546
other_url:policy = appendpath
 
1547
[/dir/subdir]
 
1548
other_url = /other-subdir
 
1549
""")
 
1550
        self.assertOptions(
 
1551
            [(u'other_url', u'/other-subdir', u'/dir/subdir', 'locations'),
 
1552
             (u'other_url', u'/other-dir', u'/dir', 'locations'),
 
1553
             (u'other_url:policy', u'appendpath', u'/dir', 'locations')],
 
1554
            self.my_location_config)
587
1555
 
588
1556
    def test_location_without_username(self):
589
 
        self.get_branch_config('http://www.example.com/useglobal')
 
1557
        self.get_branch_config('http://www.example.com/ignoreparent')
590
1558
        self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
591
1559
                         self.my_config.username())
592
1560
 
605
1573
        self.get_branch_config('http://www.example.com',
606
1574
                                 global_config=sample_ignore_signatures)
607
1575
        self.assertEqual(config.CHECK_ALWAYS,
608
 
                         self.my_config.signature_checking())
 
1576
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1577
                             self.my_config.signature_checking))
609
1578
        self.assertEqual(config.SIGN_NEVER,
610
 
                         self.my_config.signing_policy())
 
1579
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1580
                             self.my_config.signing_policy))
611
1581
 
612
1582
    def test_signatures_never(self):
613
1583
        self.get_branch_config('/a/c')
614
1584
        self.assertEqual(config.CHECK_NEVER,
615
 
                         self.my_config.signature_checking())
616
 
        
 
1585
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1586
                             self.my_config.signature_checking))
 
1587
 
617
1588
    def test_signatures_when_available(self):
618
1589
        self.get_branch_config('/a/', global_config=sample_ignore_signatures)
619
1590
        self.assertEqual(config.CHECK_IF_POSSIBLE,
620
 
                         self.my_config.signature_checking())
621
 
        
 
1591
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1592
                             self.my_config.signature_checking))
 
1593
 
622
1594
    def test_signatures_always(self):
623
1595
        self.get_branch_config('/b')
624
1596
        self.assertEqual(config.CHECK_ALWAYS,
625
 
                         self.my_config.signature_checking())
626
 
        
 
1597
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1598
                         self.my_config.signature_checking))
 
1599
 
627
1600
    def test_gpg_signing_command(self):
628
1601
        self.get_branch_config('/b')
629
 
        self.assertEqual("gnome-gpg", self.my_config.gpg_signing_command())
 
1602
        self.assertEqual("gnome-gpg",
 
1603
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1604
                self.my_config.gpg_signing_command))
630
1605
 
631
1606
    def test_gpg_signing_command_missing(self):
632
1607
        self.get_branch_config('/a')
633
 
        self.assertEqual("false", self.my_config.gpg_signing_command())
 
1608
        self.assertEqual("false",
 
1609
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1610
                self.my_config.gpg_signing_command))
 
1611
 
 
1612
    def test_gpg_signing_key(self):
 
1613
        self.get_branch_config('/b')
 
1614
        self.assertEqual("DD4D5088", self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1615
            self.my_config.gpg_signing_key))
 
1616
 
 
1617
    def test_gpg_signing_key_default(self):
 
1618
        self.get_branch_config('/a')
 
1619
        self.assertEqual("erik@bagfors.nu",
 
1620
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1621
                self.my_config.gpg_signing_key))
634
1622
 
635
1623
    def test_get_user_option_global(self):
636
1624
        self.get_branch_config('/a')
641
1629
        self.get_branch_config('/a')
642
1630
        self.assertEqual('local',
643
1631
                         self.my_config.get_user_option('user_local_option'))
644
 
        
 
1632
 
 
1633
    def test_get_user_option_appendpath(self):
 
1634
        # returned as is for the base path:
 
1635
        self.get_branch_config('http://www.example.com')
 
1636
        self.assertEqual('append',
 
1637
                         self.my_config.get_user_option('appendpath_option'))
 
1638
        # Extra path components get appended:
 
1639
        self.get_branch_config('http://www.example.com/a/b/c')
 
1640
        self.assertEqual('append/a/b/c',
 
1641
                         self.my_config.get_user_option('appendpath_option'))
 
1642
        # Overriden for http://www.example.com/dir, where it is a
 
1643
        # normal option:
 
1644
        self.get_branch_config('http://www.example.com/dir/a/b/c')
 
1645
        self.assertEqual('normal',
 
1646
                         self.my_config.get_user_option('appendpath_option'))
 
1647
 
 
1648
    def test_get_user_option_norecurse(self):
 
1649
        self.get_branch_config('http://www.example.com')
 
1650
        self.assertEqual('norecurse',
 
1651
                         self.my_config.get_user_option('norecurse_option'))
 
1652
        self.get_branch_config('http://www.example.com/dir')
 
1653
        self.assertEqual(None,
 
1654
                         self.my_config.get_user_option('norecurse_option'))
 
1655
        # http://www.example.com/norecurse is a recurse=False section
 
1656
        # that redefines normal_option.  Subdirectories do not pick up
 
1657
        # this redefinition.
 
1658
        self.get_branch_config('http://www.example.com/norecurse')
 
1659
        self.assertEqual('norecurse',
 
1660
                         self.my_config.get_user_option('normal_option'))
 
1661
        self.get_branch_config('http://www.example.com/norecurse/subdir')
 
1662
        self.assertEqual('normal',
 
1663
                         self.my_config.get_user_option('normal_option'))
 
1664
 
 
1665
    def test_set_user_option_norecurse(self):
 
1666
        self.get_branch_config('http://www.example.com')
 
1667
        self.my_config.set_user_option('foo', 'bar',
 
1668
                                       store=config.STORE_LOCATION_NORECURSE)
 
1669
        self.assertEqual(
 
1670
            self.my_location_config._get_option_policy(
 
1671
            'http://www.example.com', 'foo'),
 
1672
            config.POLICY_NORECURSE)
 
1673
 
 
1674
    def test_set_user_option_appendpath(self):
 
1675
        self.get_branch_config('http://www.example.com')
 
1676
        self.my_config.set_user_option('foo', 'bar',
 
1677
                                       store=config.STORE_LOCATION_APPENDPATH)
 
1678
        self.assertEqual(
 
1679
            self.my_location_config._get_option_policy(
 
1680
            'http://www.example.com', 'foo'),
 
1681
            config.POLICY_APPENDPATH)
 
1682
 
 
1683
    def test_set_user_option_change_policy(self):
 
1684
        self.get_branch_config('http://www.example.com')
 
1685
        self.my_config.set_user_option('norecurse_option', 'normal',
 
1686
                                       store=config.STORE_LOCATION)
 
1687
        self.assertEqual(
 
1688
            self.my_location_config._get_option_policy(
 
1689
            'http://www.example.com', 'norecurse_option'),
 
1690
            config.POLICY_NONE)
 
1691
 
 
1692
    def test_set_user_option_recurse_false_section(self):
 
1693
        # The following section has recurse=False set.  The test is to
 
1694
        # make sure that a normal option can be added to the section,
 
1695
        # converting recurse=False to the norecurse policy.
 
1696
        self.get_branch_config('http://www.example.com/norecurse')
 
1697
        self.callDeprecated(['The recurse option is deprecated as of 0.14.  '
 
1698
                             'The section "http://www.example.com/norecurse" '
 
1699
                             'has been converted to use policies.'],
 
1700
                            self.my_config.set_user_option,
 
1701
                            'foo', 'bar', store=config.STORE_LOCATION)
 
1702
        self.assertEqual(
 
1703
            self.my_location_config._get_option_policy(
 
1704
            'http://www.example.com/norecurse', 'foo'),
 
1705
            config.POLICY_NONE)
 
1706
        # The previously existing option is still norecurse:
 
1707
        self.assertEqual(
 
1708
            self.my_location_config._get_option_policy(
 
1709
            'http://www.example.com/norecurse', 'normal_option'),
 
1710
            config.POLICY_NORECURSE)
 
1711
 
645
1712
    def test_post_commit_default(self):
646
1713
        self.get_branch_config('/a/c')
647
1714
        self.assertEqual('bzrlib.tests.test_config.post_commit',
648
 
                         self.my_config.post_commit())
 
1715
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1716
                                              self.my_config.post_commit))
649
1717
 
650
 
    def get_branch_config(self, location, global_config=None):
 
1718
    def get_branch_config(self, location, global_config=None,
 
1719
                          location_config=None):
 
1720
        my_branch = FakeBranch(location)
651
1721
        if global_config is None:
652
 
            global_file = StringIO(sample_config_text.encode('utf-8'))
653
 
        else:
654
 
            global_file = StringIO(global_config.encode('utf-8'))
655
 
        branches_file = StringIO(sample_branches_text.encode('utf-8'))
656
 
        self.my_config = config.BranchConfig(FakeBranch(location))
657
 
        # Force location config to use specified file
658
 
        self.my_location_config = self.my_config._get_location_config()
659
 
        self.my_location_config._get_parser(branches_file)
660
 
        # Force global config to use specified file
661
 
        self.my_config._get_global_config()._get_parser(global_file)
 
1722
            global_config = sample_config_text
 
1723
        if location_config is None:
 
1724
            location_config = sample_branches_text
 
1725
 
 
1726
        my_global_config = config.GlobalConfig.from_string(global_config,
 
1727
                                                           save=True)
 
1728
        my_location_config = config.LocationConfig.from_string(
 
1729
            location_config, my_branch.base, save=True)
 
1730
        my_config = config.BranchConfig(my_branch)
 
1731
        self.my_config = my_config
 
1732
        self.my_location_config = my_config._get_location_config()
662
1733
 
663
1734
    def test_set_user_setting_sets_and_saves(self):
664
1735
        self.get_branch_config('/a/c')
665
1736
        record = InstrumentedConfigObj("foo")
666
1737
        self.my_location_config._parser = record
667
1738
 
668
 
        real_mkdir = os.mkdir
669
 
        self.created = False
670
 
        def checked_mkdir(path, mode=0777):
671
 
            self.log('making directory: %s', path)
672
 
            real_mkdir(path, mode)
673
 
            self.created = True
674
 
 
675
 
        os.mkdir = checked_mkdir
676
 
        try:
677
 
            self.my_config.set_user_option('foo', 'bar', local=True)
678
 
        finally:
679
 
            os.mkdir = real_mkdir
680
 
 
681
 
        self.failUnless(self.created, 'Failed to create ~/.bazaar')
682
 
        self.assertEqual([('__contains__', '/a/c'),
 
1739
        self.callDeprecated(['The recurse option is deprecated as of '
 
1740
                             '0.14.  The section "/a/c" has been '
 
1741
                             'converted to use policies.'],
 
1742
                            self.my_config.set_user_option,
 
1743
                            'foo', 'bar', store=config.STORE_LOCATION)
 
1744
        self.assertEqual([('reload',),
 
1745
                          ('__contains__', '/a/c'),
683
1746
                          ('__contains__', '/a/c/'),
684
1747
                          ('__setitem__', '/a/c', {}),
685
1748
                          ('__getitem__', '/a/c'),
686
1749
                          ('__setitem__', 'foo', 'bar'),
 
1750
                          ('__getitem__', '/a/c'),
 
1751
                          ('as_bool', 'recurse'),
 
1752
                          ('__getitem__', '/a/c'),
 
1753
                          ('__delitem__', 'recurse'),
 
1754
                          ('__getitem__', '/a/c'),
 
1755
                          ('keys',),
 
1756
                          ('__getitem__', '/a/c'),
 
1757
                          ('__contains__', 'foo:policy'),
687
1758
                          ('write',)],
688
1759
                         record._calls[1:])
689
1760
 
692
1763
        self.assertIs(self.my_config.get_user_option('foo'), None)
693
1764
        self.my_config.set_user_option('foo', 'bar')
694
1765
        self.assertEqual(
695
 
            self.my_config.branch.control_files.files['branch.conf'], 
 
1766
            self.my_config.branch.control_files.files['branch.conf'].strip(),
696
1767
            'foo = bar')
697
1768
        self.assertEqual(self.my_config.get_user_option('foo'), 'bar')
698
 
        self.my_config.set_user_option('foo', 'baz', local=True)
 
1769
        self.my_config.set_user_option('foo', 'baz',
 
1770
                                       store=config.STORE_LOCATION)
699
1771
        self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
700
1772
        self.my_config.set_user_option('foo', 'qux')
701
1773
        self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
702
 
        
 
1774
 
 
1775
    def test_get_bzr_remote_path(self):
 
1776
        my_config = config.LocationConfig('/a/c')
 
1777
        self.assertEqual('bzr', my_config.get_bzr_remote_path())
 
1778
        my_config.set_user_option('bzr_remote_path', '/path-bzr')
 
1779
        self.assertEqual('/path-bzr', my_config.get_bzr_remote_path())
 
1780
        self.overrideEnv('BZR_REMOTE_PATH', '/environ-bzr')
 
1781
        self.assertEqual('/environ-bzr', my_config.get_bzr_remote_path())
 
1782
 
703
1783
 
704
1784
precedence_global = 'option = global'
705
1785
precedence_branch = 'option = branch'
711
1791
option = exact
712
1792
"""
713
1793
 
714
 
 
715
 
class TestBranchConfigItems(TestCaseInTempDir):
716
 
 
717
 
    def get_branch_config(self, global_config=None, location=None, 
 
1794
class TestBranchConfigItems(tests.TestCaseInTempDir):
 
1795
 
 
1796
    def get_branch_config(self, global_config=None, location=None,
718
1797
                          location_config=None, branch_data_config=None):
719
 
        my_config = config.BranchConfig(FakeBranch(location))
 
1798
        my_branch = FakeBranch(location)
720
1799
        if global_config is not None:
721
 
            global_file = StringIO(global_config.encode('utf-8'))
722
 
            my_config._get_global_config()._get_parser(global_file)
723
 
        self.my_location_config = my_config._get_location_config()
 
1800
            my_global_config = config.GlobalConfig.from_string(global_config,
 
1801
                                                               save=True)
724
1802
        if location_config is not None:
725
 
            location_file = StringIO(location_config.encode('utf-8'))
726
 
            self.my_location_config._get_parser(location_file)
 
1803
            my_location_config = config.LocationConfig.from_string(
 
1804
                location_config, my_branch.base, save=True)
 
1805
        my_config = config.BranchConfig(my_branch)
727
1806
        if branch_data_config is not None:
728
1807
            my_config.branch.control_files.files['branch.conf'] = \
729
1808
                branch_data_config
730
1809
        return my_config
731
1810
 
732
1811
    def test_user_id(self):
733
 
        branch = FakeBranch(user_id='Robert Collins <robertc@example.net>')
 
1812
        branch = FakeBranch()
734
1813
        my_config = config.BranchConfig(branch)
735
 
        self.assertEqual("Robert Collins <robertc@example.net>",
736
 
                         my_config.username())
737
 
        branch.control_files.email = "John"
738
 
        my_config.set_user_option('email', 
 
1814
        self.assertIsNot(None, my_config.username())
 
1815
        my_config.branch.control_files.files['email'] = "John"
 
1816
        my_config.set_user_option('email',
739
1817
                                  "Robert Collins <robertc@example.org>")
740
 
        self.assertEqual("John", my_config.username())
741
 
        branch.control_files.email = None
742
1818
        self.assertEqual("Robert Collins <robertc@example.org>",
743
 
                         my_config.username())
744
 
 
745
 
    def test_not_set_in_branch(self):
746
 
        my_config = self.get_branch_config(sample_config_text)
747
 
        my_config.branch.control_files.email = None
748
 
        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
749
 
                         my_config._get_user_id())
750
 
        my_config.branch.control_files.email = "John"
751
 
        self.assertEqual("John", my_config._get_user_id())
 
1819
                        my_config.username())
752
1820
 
753
1821
    def test_BZR_EMAIL_OVERRIDES(self):
754
 
        os.environ['BZR_EMAIL'] = "Robert Collins <robertc@example.org>"
 
1822
        self.overrideEnv('BZR_EMAIL', "Robert Collins <robertc@example.org>")
755
1823
        branch = FakeBranch()
756
1824
        my_config = config.BranchConfig(branch)
757
1825
        self.assertEqual("Robert Collins <robertc@example.org>",
758
1826
                         my_config.username())
759
 
    
 
1827
 
760
1828
    def test_signatures_forced(self):
761
1829
        my_config = self.get_branch_config(
762
1830
            global_config=sample_always_signatures)
763
 
        self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
764
 
        self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
765
 
        self.assertTrue(my_config.signature_needed())
 
1831
        self.assertEqual(config.CHECK_NEVER,
 
1832
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1833
                my_config.signature_checking))
 
1834
        self.assertEqual(config.SIGN_ALWAYS,
 
1835
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1836
                my_config.signing_policy))
 
1837
        self.assertTrue(self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1838
            my_config.signature_needed))
766
1839
 
767
1840
    def test_signatures_forced_branch(self):
768
1841
        my_config = self.get_branch_config(
769
1842
            global_config=sample_ignore_signatures,
770
1843
            branch_data_config=sample_always_signatures)
771
 
        self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
772
 
        self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
773
 
        self.assertTrue(my_config.signature_needed())
 
1844
        self.assertEqual(config.CHECK_NEVER,
 
1845
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1846
                my_config.signature_checking))
 
1847
        self.assertEqual(config.SIGN_ALWAYS,
 
1848
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1849
                my_config.signing_policy))
 
1850
        self.assertTrue(self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1851
            my_config.signature_needed))
774
1852
 
775
1853
    def test_gpg_signing_command(self):
776
1854
        my_config = self.get_branch_config(
 
1855
            global_config=sample_config_text,
777
1856
            # branch data cannot set gpg_signing_command
778
1857
            branch_data_config="gpg_signing_command=pgp")
779
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
780
 
        my_config._get_global_config()._get_parser(config_file)
781
 
        self.assertEqual('gnome-gpg', my_config.gpg_signing_command())
 
1858
        self.assertEqual('gnome-gpg',
 
1859
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1860
                my_config.gpg_signing_command))
782
1861
 
783
1862
    def test_get_user_option_global(self):
784
 
        branch = FakeBranch()
785
 
        my_config = config.BranchConfig(branch)
786
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
787
 
        (my_config._get_global_config()._get_parser(config_file))
 
1863
        my_config = self.get_branch_config(global_config=sample_config_text)
788
1864
        self.assertEqual('something',
789
1865
                         my_config.get_user_option('user_global_option'))
790
1866
 
791
1867
    def test_post_commit_default(self):
792
 
        branch = FakeBranch()
793
 
        my_config = self.get_branch_config(sample_config_text, '/a/c',
794
 
                                           sample_branches_text)
 
1868
        my_config = self.get_branch_config(global_config=sample_config_text,
 
1869
                                      location='/a/c',
 
1870
                                      location_config=sample_branches_text)
795
1871
        self.assertEqual(my_config.branch.base, '/a/c')
796
1872
        self.assertEqual('bzrlib.tests.test_config.post_commit',
797
 
                         my_config.post_commit())
 
1873
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1874
                                              my_config.post_commit))
798
1875
        my_config.set_user_option('post_commit', 'rmtree_root')
799
 
        # post-commit is ignored when bresent in branch data
 
1876
        # post-commit is ignored when present in branch data
800
1877
        self.assertEqual('bzrlib.tests.test_config.post_commit',
801
 
                         my_config.post_commit())
802
 
        my_config.set_user_option('post_commit', 'rmtree_root', local=True)
803
 
        self.assertEqual('rmtree_root', my_config.post_commit())
 
1878
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1879
                                              my_config.post_commit))
 
1880
        my_config.set_user_option('post_commit', 'rmtree_root',
 
1881
                                  store=config.STORE_LOCATION)
 
1882
        self.assertEqual('rmtree_root',
 
1883
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1884
                                              my_config.post_commit))
804
1885
 
805
1886
    def test_config_precedence(self):
 
1887
        # FIXME: eager test, luckily no persitent config file makes it fail
 
1888
        # -- vila 20100716
806
1889
        my_config = self.get_branch_config(global_config=precedence_global)
807
1890
        self.assertEqual(my_config.get_user_option('option'), 'global')
808
 
        my_config = self.get_branch_config(global_config=precedence_global, 
809
 
                                      branch_data_config=precedence_branch)
 
1891
        my_config = self.get_branch_config(global_config=precedence_global,
 
1892
                                           branch_data_config=precedence_branch)
810
1893
        self.assertEqual(my_config.get_user_option('option'), 'branch')
811
 
        my_config = self.get_branch_config(global_config=precedence_global, 
812
 
                                      branch_data_config=precedence_branch,
813
 
                                      location_config=precedence_location)
 
1894
        my_config = self.get_branch_config(
 
1895
            global_config=precedence_global,
 
1896
            branch_data_config=precedence_branch,
 
1897
            location_config=precedence_location)
814
1898
        self.assertEqual(my_config.get_user_option('option'), 'recurse')
815
 
        my_config = self.get_branch_config(global_config=precedence_global, 
816
 
                                      branch_data_config=precedence_branch,
817
 
                                      location_config=precedence_location,
818
 
                                      location='http://example.com/specific')
 
1899
        my_config = self.get_branch_config(
 
1900
            global_config=precedence_global,
 
1901
            branch_data_config=precedence_branch,
 
1902
            location_config=precedence_location,
 
1903
            location='http://example.com/specific')
819
1904
        self.assertEqual(my_config.get_user_option('option'), 'exact')
820
1905
 
821
 
 
822
 
class TestMailAddressExtraction(TestCase):
 
1906
    def test_get_mail_client(self):
 
1907
        config = self.get_branch_config()
 
1908
        client = config.get_mail_client()
 
1909
        self.assertIsInstance(client, mail_client.DefaultMail)
 
1910
 
 
1911
        # Specific clients
 
1912
        config.set_user_option('mail_client', 'evolution')
 
1913
        client = config.get_mail_client()
 
1914
        self.assertIsInstance(client, mail_client.Evolution)
 
1915
 
 
1916
        config.set_user_option('mail_client', 'kmail')
 
1917
        client = config.get_mail_client()
 
1918
        self.assertIsInstance(client, mail_client.KMail)
 
1919
 
 
1920
        config.set_user_option('mail_client', 'mutt')
 
1921
        client = config.get_mail_client()
 
1922
        self.assertIsInstance(client, mail_client.Mutt)
 
1923
 
 
1924
        config.set_user_option('mail_client', 'thunderbird')
 
1925
        client = config.get_mail_client()
 
1926
        self.assertIsInstance(client, mail_client.Thunderbird)
 
1927
 
 
1928
        # Generic options
 
1929
        config.set_user_option('mail_client', 'default')
 
1930
        client = config.get_mail_client()
 
1931
        self.assertIsInstance(client, mail_client.DefaultMail)
 
1932
 
 
1933
        config.set_user_option('mail_client', 'editor')
 
1934
        client = config.get_mail_client()
 
1935
        self.assertIsInstance(client, mail_client.Editor)
 
1936
 
 
1937
        config.set_user_option('mail_client', 'mapi')
 
1938
        client = config.get_mail_client()
 
1939
        self.assertIsInstance(client, mail_client.MAPIClient)
 
1940
 
 
1941
        config.set_user_option('mail_client', 'xdg-email')
 
1942
        client = config.get_mail_client()
 
1943
        self.assertIsInstance(client, mail_client.XDGEmail)
 
1944
 
 
1945
        config.set_user_option('mail_client', 'firebird')
 
1946
        self.assertRaises(errors.UnknownMailClient, config.get_mail_client)
 
1947
 
 
1948
 
 
1949
class TestMailAddressExtraction(tests.TestCase):
823
1950
 
824
1951
    def test_extract_email_address(self):
825
1952
        self.assertEqual('jane@test.com',
826
1953
                         config.extract_email_address('Jane <jane@test.com>'))
827
 
        self.assertRaises(errors.BzrError,
 
1954
        self.assertRaises(errors.NoEmailInUsername,
828
1955
                          config.extract_email_address, 'Jane Tester')
 
1956
 
 
1957
    def test_parse_username(self):
 
1958
        self.assertEqual(('', 'jdoe@example.com'),
 
1959
                         config.parse_username('jdoe@example.com'))
 
1960
        self.assertEqual(('', 'jdoe@example.com'),
 
1961
                         config.parse_username('<jdoe@example.com>'))
 
1962
        self.assertEqual(('John Doe', 'jdoe@example.com'),
 
1963
                         config.parse_username('John Doe <jdoe@example.com>'))
 
1964
        self.assertEqual(('John Doe', ''),
 
1965
                         config.parse_username('John Doe'))
 
1966
        self.assertEqual(('John Doe', 'jdoe@example.com'),
 
1967
                         config.parse_username('John Doe jdoe@example.com'))
 
1968
 
 
1969
class TestTreeConfig(tests.TestCaseWithTransport):
 
1970
 
 
1971
    def test_get_value(self):
 
1972
        """Test that retreiving a value from a section is possible"""
 
1973
        branch = self.make_branch('.')
 
1974
        tree_config = config.TreeConfig(branch)
 
1975
        tree_config.set_option('value', 'key', 'SECTION')
 
1976
        tree_config.set_option('value2', 'key2')
 
1977
        tree_config.set_option('value3-top', 'key3')
 
1978
        tree_config.set_option('value3-section', 'key3', 'SECTION')
 
1979
        value = tree_config.get_option('key', 'SECTION')
 
1980
        self.assertEqual(value, 'value')
 
1981
        value = tree_config.get_option('key2')
 
1982
        self.assertEqual(value, 'value2')
 
1983
        self.assertEqual(tree_config.get_option('non-existant'), None)
 
1984
        value = tree_config.get_option('non-existant', 'SECTION')
 
1985
        self.assertEqual(value, None)
 
1986
        value = tree_config.get_option('non-existant', default='default')
 
1987
        self.assertEqual(value, 'default')
 
1988
        self.assertEqual(tree_config.get_option('key2', 'NOSECTION'), None)
 
1989
        value = tree_config.get_option('key2', 'NOSECTION', default='default')
 
1990
        self.assertEqual(value, 'default')
 
1991
        value = tree_config.get_option('key3')
 
1992
        self.assertEqual(value, 'value3-top')
 
1993
        value = tree_config.get_option('key3', 'SECTION')
 
1994
        self.assertEqual(value, 'value3-section')
 
1995
 
 
1996
 
 
1997
class TestTransportConfig(tests.TestCaseWithTransport):
 
1998
 
 
1999
    def test_load_utf8(self):
 
2000
        """Ensure we can load an utf8-encoded file."""
 
2001
        t = self.get_transport()
 
2002
        unicode_user = u'b\N{Euro Sign}ar'
 
2003
        unicode_content = u'user=%s' % (unicode_user,)
 
2004
        utf8_content = unicode_content.encode('utf8')
 
2005
        # Store the raw content in the config file
 
2006
        t.put_bytes('foo.conf', utf8_content)
 
2007
        conf = config.TransportConfig(t, 'foo.conf')
 
2008
        self.assertEquals(unicode_user, conf.get_option('user'))
 
2009
 
 
2010
    def test_load_non_ascii(self):
 
2011
        """Ensure we display a proper error on non-ascii, non utf-8 content."""
 
2012
        t = self.get_transport()
 
2013
        t.put_bytes('foo.conf', 'user=foo\n#\xff\n')
 
2014
        conf = config.TransportConfig(t, 'foo.conf')
 
2015
        self.assertRaises(errors.ConfigContentError, conf._get_configobj)
 
2016
 
 
2017
    def test_load_erroneous_content(self):
 
2018
        """Ensure we display a proper error on content that can't be parsed."""
 
2019
        t = self.get_transport()
 
2020
        t.put_bytes('foo.conf', '[open_section\n')
 
2021
        conf = config.TransportConfig(t, 'foo.conf')
 
2022
        self.assertRaises(errors.ParseConfigError, conf._get_configobj)
 
2023
 
 
2024
    def test_load_permission_denied(self):
 
2025
        """Ensure we get an empty config file if the file is inaccessible."""
 
2026
        warnings = []
 
2027
        def warning(*args):
 
2028
            warnings.append(args[0] % args[1:])
 
2029
        self.overrideAttr(trace, 'warning', warning)
 
2030
 
 
2031
        class DenyingTransport(object):
 
2032
 
 
2033
            def __init__(self, base):
 
2034
                self.base = base
 
2035
 
 
2036
            def get_bytes(self, relpath):
 
2037
                raise errors.PermissionDenied(relpath, "")
 
2038
 
 
2039
        cfg = config.TransportConfig(
 
2040
            DenyingTransport("nonexisting://"), 'control.conf')
 
2041
        self.assertIs(None, cfg.get_option('non-existant', 'SECTION'))
 
2042
        self.assertEquals(
 
2043
            warnings,
 
2044
            [u'Permission denied while trying to open configuration file '
 
2045
             u'nonexisting:///control.conf.'])
 
2046
 
 
2047
    def test_get_value(self):
 
2048
        """Test that retreiving a value from a section is possible"""
 
2049
        bzrdir_config = config.TransportConfig(self.get_transport('.'),
 
2050
                                               'control.conf')
 
2051
        bzrdir_config.set_option('value', 'key', 'SECTION')
 
2052
        bzrdir_config.set_option('value2', 'key2')
 
2053
        bzrdir_config.set_option('value3-top', 'key3')
 
2054
        bzrdir_config.set_option('value3-section', 'key3', 'SECTION')
 
2055
        value = bzrdir_config.get_option('key', 'SECTION')
 
2056
        self.assertEqual(value, 'value')
 
2057
        value = bzrdir_config.get_option('key2')
 
2058
        self.assertEqual(value, 'value2')
 
2059
        self.assertEqual(bzrdir_config.get_option('non-existant'), None)
 
2060
        value = bzrdir_config.get_option('non-existant', 'SECTION')
 
2061
        self.assertEqual(value, None)
 
2062
        value = bzrdir_config.get_option('non-existant', default='default')
 
2063
        self.assertEqual(value, 'default')
 
2064
        self.assertEqual(bzrdir_config.get_option('key2', 'NOSECTION'), None)
 
2065
        value = bzrdir_config.get_option('key2', 'NOSECTION',
 
2066
                                         default='default')
 
2067
        self.assertEqual(value, 'default')
 
2068
        value = bzrdir_config.get_option('key3')
 
2069
        self.assertEqual(value, 'value3-top')
 
2070
        value = bzrdir_config.get_option('key3', 'SECTION')
 
2071
        self.assertEqual(value, 'value3-section')
 
2072
 
 
2073
    def test_set_unset_default_stack_on(self):
 
2074
        my_dir = self.make_bzrdir('.')
 
2075
        bzrdir_config = config.BzrDirConfig(my_dir)
 
2076
        self.assertIs(None, bzrdir_config.get_default_stack_on())
 
2077
        bzrdir_config.set_default_stack_on('Foo')
 
2078
        self.assertEqual('Foo', bzrdir_config._config.get_option(
 
2079
                         'default_stack_on'))
 
2080
        self.assertEqual('Foo', bzrdir_config.get_default_stack_on())
 
2081
        bzrdir_config.set_default_stack_on(None)
 
2082
        self.assertIs(None, bzrdir_config.get_default_stack_on())
 
2083
 
 
2084
 
 
2085
class TestOldConfigHooks(tests.TestCaseWithTransport):
 
2086
 
 
2087
    def setUp(self):
 
2088
        super(TestOldConfigHooks, self).setUp()
 
2089
        create_configs_with_file_option(self)
 
2090
 
 
2091
    def assertGetHook(self, conf, name, value):
 
2092
        calls = []
 
2093
        def hook(*args):
 
2094
            calls.append(args)
 
2095
        config.OldConfigHooks.install_named_hook('get', hook, None)
 
2096
        self.addCleanup(
 
2097
            config.OldConfigHooks.uninstall_named_hook, 'get', None)
 
2098
        self.assertLength(0, calls)
 
2099
        actual_value = conf.get_user_option(name)
 
2100
        self.assertEquals(value, actual_value)
 
2101
        self.assertLength(1, calls)
 
2102
        self.assertEquals((conf, name, value), calls[0])
 
2103
 
 
2104
    def test_get_hook_bazaar(self):
 
2105
        self.assertGetHook(self.bazaar_config, 'file', 'bazaar')
 
2106
 
 
2107
    def test_get_hook_locations(self):
 
2108
        self.assertGetHook(self.locations_config, 'file', 'locations')
 
2109
 
 
2110
    def test_get_hook_branch(self):
 
2111
        # Since locations masks branch, we define a different option
 
2112
        self.branch_config.set_user_option('file2', 'branch')
 
2113
        self.assertGetHook(self.branch_config, 'file2', 'branch')
 
2114
 
 
2115
    def assertSetHook(self, conf, name, value):
 
2116
        calls = []
 
2117
        def hook(*args):
 
2118
            calls.append(args)
 
2119
        config.OldConfigHooks.install_named_hook('set', hook, None)
 
2120
        self.addCleanup(
 
2121
            config.OldConfigHooks.uninstall_named_hook, 'set', None)
 
2122
        self.assertLength(0, calls)
 
2123
        conf.set_user_option(name, value)
 
2124
        self.assertLength(1, calls)
 
2125
        # We can't assert the conf object below as different configs use
 
2126
        # different means to implement set_user_option and we care only about
 
2127
        # coverage here.
 
2128
        self.assertEquals((name, value), calls[0][1:])
 
2129
 
 
2130
    def test_set_hook_bazaar(self):
 
2131
        self.assertSetHook(self.bazaar_config, 'foo', 'bazaar')
 
2132
 
 
2133
    def test_set_hook_locations(self):
 
2134
        self.assertSetHook(self.locations_config, 'foo', 'locations')
 
2135
 
 
2136
    def test_set_hook_branch(self):
 
2137
        self.assertSetHook(self.branch_config, 'foo', 'branch')
 
2138
 
 
2139
    def assertRemoveHook(self, conf, name, section_name=None):
 
2140
        calls = []
 
2141
        def hook(*args):
 
2142
            calls.append(args)
 
2143
        config.OldConfigHooks.install_named_hook('remove', hook, None)
 
2144
        self.addCleanup(
 
2145
            config.OldConfigHooks.uninstall_named_hook, 'remove', None)
 
2146
        self.assertLength(0, calls)
 
2147
        conf.remove_user_option(name, section_name)
 
2148
        self.assertLength(1, calls)
 
2149
        # We can't assert the conf object below as different configs use
 
2150
        # different means to implement remove_user_option and we care only about
 
2151
        # coverage here.
 
2152
        self.assertEquals((name,), calls[0][1:])
 
2153
 
 
2154
    def test_remove_hook_bazaar(self):
 
2155
        self.assertRemoveHook(self.bazaar_config, 'file')
 
2156
 
 
2157
    def test_remove_hook_locations(self):
 
2158
        self.assertRemoveHook(self.locations_config, 'file',
 
2159
                              self.locations_config.location)
 
2160
 
 
2161
    def test_remove_hook_branch(self):
 
2162
        self.assertRemoveHook(self.branch_config, 'file')
 
2163
 
 
2164
    def assertLoadHook(self, name, conf_class, *conf_args):
 
2165
        calls = []
 
2166
        def hook(*args):
 
2167
            calls.append(args)
 
2168
        config.OldConfigHooks.install_named_hook('load', hook, None)
 
2169
        self.addCleanup(
 
2170
            config.OldConfigHooks.uninstall_named_hook, 'load', None)
 
2171
        self.assertLength(0, calls)
 
2172
        # Build a config
 
2173
        conf = conf_class(*conf_args)
 
2174
        # Access an option to trigger a load
 
2175
        conf.get_user_option(name)
 
2176
        self.assertLength(1, calls)
 
2177
        # Since we can't assert about conf, we just use the number of calls ;-/
 
2178
 
 
2179
    def test_load_hook_bazaar(self):
 
2180
        self.assertLoadHook('file', config.GlobalConfig)
 
2181
 
 
2182
    def test_load_hook_locations(self):
 
2183
        self.assertLoadHook('file', config.LocationConfig, self.tree.basedir)
 
2184
 
 
2185
    def test_load_hook_branch(self):
 
2186
        self.assertLoadHook('file', config.BranchConfig, self.tree.branch)
 
2187
 
 
2188
    def assertSaveHook(self, conf):
 
2189
        calls = []
 
2190
        def hook(*args):
 
2191
            calls.append(args)
 
2192
        config.OldConfigHooks.install_named_hook('save', hook, None)
 
2193
        self.addCleanup(
 
2194
            config.OldConfigHooks.uninstall_named_hook, 'save', None)
 
2195
        self.assertLength(0, calls)
 
2196
        # Setting an option triggers a save
 
2197
        conf.set_user_option('foo', 'bar')
 
2198
        self.assertLength(1, calls)
 
2199
        # Since we can't assert about conf, we just use the number of calls ;-/
 
2200
 
 
2201
    def test_save_hook_bazaar(self):
 
2202
        self.assertSaveHook(self.bazaar_config)
 
2203
 
 
2204
    def test_save_hook_locations(self):
 
2205
        self.assertSaveHook(self.locations_config)
 
2206
 
 
2207
    def test_save_hook_branch(self):
 
2208
        self.assertSaveHook(self.branch_config)
 
2209
 
 
2210
 
 
2211
class TestOldConfigHooksForRemote(tests.TestCaseWithTransport):
 
2212
    """Tests config hooks for remote configs.
 
2213
 
 
2214
    No tests for the remove hook as this is not implemented there.
 
2215
    """
 
2216
 
 
2217
    def setUp(self):
 
2218
        super(TestOldConfigHooksForRemote, self).setUp()
 
2219
        self.transport_server = test_server.SmartTCPServer_for_testing
 
2220
        create_configs_with_file_option(self)
 
2221
 
 
2222
    def assertGetHook(self, conf, name, value):
 
2223
        calls = []
 
2224
        def hook(*args):
 
2225
            calls.append(args)
 
2226
        config.OldConfigHooks.install_named_hook('get', hook, None)
 
2227
        self.addCleanup(
 
2228
            config.OldConfigHooks.uninstall_named_hook, 'get', None)
 
2229
        self.assertLength(0, calls)
 
2230
        actual_value = conf.get_option(name)
 
2231
        self.assertEquals(value, actual_value)
 
2232
        self.assertLength(1, calls)
 
2233
        self.assertEquals((conf, name, value), calls[0])
 
2234
 
 
2235
    def test_get_hook_remote_branch(self):
 
2236
        remote_branch = branch.Branch.open(self.get_url('tree'))
 
2237
        self.assertGetHook(remote_branch._get_config(), 'file', 'branch')
 
2238
 
 
2239
    def test_get_hook_remote_bzrdir(self):
 
2240
        remote_bzrdir = bzrdir.BzrDir.open(self.get_url('tree'))
 
2241
        conf = remote_bzrdir._get_config()
 
2242
        conf.set_option('remotedir', 'file')
 
2243
        self.assertGetHook(conf, 'file', 'remotedir')
 
2244
 
 
2245
    def assertSetHook(self, conf, name, value):
 
2246
        calls = []
 
2247
        def hook(*args):
 
2248
            calls.append(args)
 
2249
        config.OldConfigHooks.install_named_hook('set', hook, None)
 
2250
        self.addCleanup(
 
2251
            config.OldConfigHooks.uninstall_named_hook, 'set', None)
 
2252
        self.assertLength(0, calls)
 
2253
        conf.set_option(value, name)
 
2254
        self.assertLength(1, calls)
 
2255
        # We can't assert the conf object below as different configs use
 
2256
        # different means to implement set_user_option and we care only about
 
2257
        # coverage here.
 
2258
        self.assertEquals((name, value), calls[0][1:])
 
2259
 
 
2260
    def test_set_hook_remote_branch(self):
 
2261
        remote_branch = branch.Branch.open(self.get_url('tree'))
 
2262
        self.addCleanup(remote_branch.lock_write().unlock)
 
2263
        self.assertSetHook(remote_branch._get_config(), 'file', 'remote')
 
2264
 
 
2265
    def test_set_hook_remote_bzrdir(self):
 
2266
        remote_branch = branch.Branch.open(self.get_url('tree'))
 
2267
        self.addCleanup(remote_branch.lock_write().unlock)
 
2268
        remote_bzrdir = bzrdir.BzrDir.open(self.get_url('tree'))
 
2269
        self.assertSetHook(remote_bzrdir._get_config(), 'file', 'remotedir')
 
2270
 
 
2271
    def assertLoadHook(self, expected_nb_calls, name, conf_class, *conf_args):
 
2272
        calls = []
 
2273
        def hook(*args):
 
2274
            calls.append(args)
 
2275
        config.OldConfigHooks.install_named_hook('load', hook, None)
 
2276
        self.addCleanup(
 
2277
            config.OldConfigHooks.uninstall_named_hook, 'load', None)
 
2278
        self.assertLength(0, calls)
 
2279
        # Build a config
 
2280
        conf = conf_class(*conf_args)
 
2281
        # Access an option to trigger a load
 
2282
        conf.get_option(name)
 
2283
        self.assertLength(expected_nb_calls, calls)
 
2284
        # Since we can't assert about conf, we just use the number of calls ;-/
 
2285
 
 
2286
    def test_load_hook_remote_branch(self):
 
2287
        remote_branch = branch.Branch.open(self.get_url('tree'))
 
2288
        self.assertLoadHook(1, 'file', remote.RemoteBranchConfig, remote_branch)
 
2289
 
 
2290
    def test_load_hook_remote_bzrdir(self):
 
2291
        remote_bzrdir = bzrdir.BzrDir.open(self.get_url('tree'))
 
2292
        # The config file doesn't exist, set an option to force its creation
 
2293
        conf = remote_bzrdir._get_config()
 
2294
        conf.set_option('remotedir', 'file')
 
2295
        # We get one call for the server and one call for the client, this is
 
2296
        # caused by the differences in implementations betwen
 
2297
        # SmartServerBzrDirRequestConfigFile (in smart/bzrdir.py) and
 
2298
        # SmartServerBranchGetConfigFile (in smart/branch.py)
 
2299
        self.assertLoadHook(2 ,'file', remote.RemoteBzrDirConfig, remote_bzrdir)
 
2300
 
 
2301
    def assertSaveHook(self, conf):
 
2302
        calls = []
 
2303
        def hook(*args):
 
2304
            calls.append(args)
 
2305
        config.OldConfigHooks.install_named_hook('save', hook, None)
 
2306
        self.addCleanup(
 
2307
            config.OldConfigHooks.uninstall_named_hook, 'save', None)
 
2308
        self.assertLength(0, calls)
 
2309
        # Setting an option triggers a save
 
2310
        conf.set_option('foo', 'bar')
 
2311
        self.assertLength(1, calls)
 
2312
        # Since we can't assert about conf, we just use the number of calls ;-/
 
2313
 
 
2314
    def test_save_hook_remote_branch(self):
 
2315
        remote_branch = branch.Branch.open(self.get_url('tree'))
 
2316
        self.addCleanup(remote_branch.lock_write().unlock)
 
2317
        self.assertSaveHook(remote_branch._get_config())
 
2318
 
 
2319
    def test_save_hook_remote_bzrdir(self):
 
2320
        remote_branch = branch.Branch.open(self.get_url('tree'))
 
2321
        self.addCleanup(remote_branch.lock_write().unlock)
 
2322
        remote_bzrdir = bzrdir.BzrDir.open(self.get_url('tree'))
 
2323
        self.assertSaveHook(remote_bzrdir._get_config())
 
2324
 
 
2325
 
 
2326
class TestOption(tests.TestCase):
 
2327
 
 
2328
    def test_default_value(self):
 
2329
        opt = config.Option('foo', default='bar')
 
2330
        self.assertEquals('bar', opt.get_default())
 
2331
 
 
2332
    def test_callable_default_value(self):
 
2333
        def bar_as_unicode():
 
2334
            return u'bar'
 
2335
        opt = config.Option('foo', default=bar_as_unicode)
 
2336
        self.assertEquals('bar', opt.get_default())
 
2337
 
 
2338
    def test_default_value_from_env(self):
 
2339
        opt = config.Option('foo', default='bar', default_from_env=['FOO'])
 
2340
        self.overrideEnv('FOO', 'quux')
 
2341
        # Env variable provides a default taking over the option one
 
2342
        self.assertEquals('quux', opt.get_default())
 
2343
 
 
2344
    def test_first_default_value_from_env_wins(self):
 
2345
        opt = config.Option('foo', default='bar',
 
2346
                            default_from_env=['NO_VALUE', 'FOO', 'BAZ'])
 
2347
        self.overrideEnv('FOO', 'foo')
 
2348
        self.overrideEnv('BAZ', 'baz')
 
2349
        # The first env var set wins
 
2350
        self.assertEquals('foo', opt.get_default())
 
2351
 
 
2352
    def test_not_supported_list_default_value(self):
 
2353
        self.assertRaises(AssertionError, config.Option, 'foo', default=[1])
 
2354
 
 
2355
    def test_not_supported_object_default_value(self):
 
2356
        self.assertRaises(AssertionError, config.Option, 'foo',
 
2357
                          default=object())
 
2358
 
 
2359
    def test_not_supported_callable_default_value_not_unicode(self):
 
2360
        def bar_not_unicode():
 
2361
            return 'bar'
 
2362
        opt = config.Option('foo', default=bar_not_unicode)
 
2363
        self.assertRaises(AssertionError, opt.get_default)
 
2364
 
 
2365
 
 
2366
class TestOptionConverterMixin(object):
 
2367
 
 
2368
    def assertConverted(self, expected, opt, value):
 
2369
        self.assertEquals(expected, opt.convert_from_unicode(None, value))
 
2370
 
 
2371
    def assertWarns(self, opt, value):
 
2372
        warnings = []
 
2373
        def warning(*args):
 
2374
            warnings.append(args[0] % args[1:])
 
2375
        self.overrideAttr(trace, 'warning', warning)
 
2376
        self.assertEquals(None, opt.convert_from_unicode(None, value))
 
2377
        self.assertLength(1, warnings)
 
2378
        self.assertEquals(
 
2379
            'Value "%s" is not valid for "%s"' % (value, opt.name),
 
2380
            warnings[0])
 
2381
 
 
2382
    def assertErrors(self, opt, value):
 
2383
        self.assertRaises(errors.ConfigOptionValueError,
 
2384
                          opt.convert_from_unicode, None, value)
 
2385
 
 
2386
    def assertConvertInvalid(self, opt, invalid_value):
 
2387
        opt.invalid = None
 
2388
        self.assertEquals(None, opt.convert_from_unicode(None, invalid_value))
 
2389
        opt.invalid = 'warning'
 
2390
        self.assertWarns(opt, invalid_value)
 
2391
        opt.invalid = 'error'
 
2392
        self.assertErrors(opt, invalid_value)
 
2393
 
 
2394
 
 
2395
class TestOptionWithBooleanConverter(tests.TestCase, TestOptionConverterMixin):
 
2396
 
 
2397
    def get_option(self):
 
2398
        return config.Option('foo', help='A boolean.',
 
2399
                             from_unicode=config.bool_from_store)
 
2400
 
 
2401
    def test_convert_invalid(self):
 
2402
        opt = self.get_option()
 
2403
        # A string that is not recognized as a boolean
 
2404
        self.assertConvertInvalid(opt, u'invalid-boolean')
 
2405
        # A list of strings is never recognized as a boolean
 
2406
        self.assertConvertInvalid(opt, [u'not', u'a', u'boolean'])
 
2407
 
 
2408
    def test_convert_valid(self):
 
2409
        opt = self.get_option()
 
2410
        self.assertConverted(True, opt, u'True')
 
2411
        self.assertConverted(True, opt, u'1')
 
2412
        self.assertConverted(False, opt, u'False')
 
2413
 
 
2414
 
 
2415
class TestOptionWithIntegerConverter(tests.TestCase, TestOptionConverterMixin):
 
2416
 
 
2417
    def get_option(self):
 
2418
        return config.Option('foo', help='An integer.',
 
2419
                             from_unicode=config.int_from_store)
 
2420
 
 
2421
    def test_convert_invalid(self):
 
2422
        opt = self.get_option()
 
2423
        # A string that is not recognized as an integer
 
2424
        self.assertConvertInvalid(opt, u'forty-two')
 
2425
        # A list of strings is never recognized as an integer
 
2426
        self.assertConvertInvalid(opt, [u'a', u'list'])
 
2427
 
 
2428
    def test_convert_valid(self):
 
2429
        opt = self.get_option()
 
2430
        self.assertConverted(16, opt, u'16')
 
2431
 
 
2432
 
 
2433
class TestOptionWithSIUnitConverter(tests.TestCase, TestOptionConverterMixin):
 
2434
 
 
2435
    def get_option(self):
 
2436
        return config.Option('foo', help='An integer in SI units.',
 
2437
                             from_unicode=config.int_SI_from_store)
 
2438
 
 
2439
    def test_convert_invalid(self):
 
2440
        opt = self.get_option()
 
2441
        self.assertConvertInvalid(opt, u'not-a-unit')
 
2442
        self.assertConvertInvalid(opt, u'Gb') # Forgot the int
 
2443
        self.assertConvertInvalid(opt, u'1b') # Forgot the unit
 
2444
        self.assertConvertInvalid(opt, u'1GG')
 
2445
        self.assertConvertInvalid(opt, u'1Mbb')
 
2446
        self.assertConvertInvalid(opt, u'1MM')
 
2447
 
 
2448
    def test_convert_valid(self):
 
2449
        opt = self.get_option()
 
2450
        self.assertConverted(int(5e3), opt, u'5kb')
 
2451
        self.assertConverted(int(5e6), opt, u'5M')
 
2452
        self.assertConverted(int(5e6), opt, u'5MB')
 
2453
        self.assertConverted(int(5e9), opt, u'5g')
 
2454
        self.assertConverted(int(5e9), opt, u'5gB')
 
2455
        self.assertConverted(100, opt, u'100')
 
2456
 
 
2457
 
 
2458
class TestListOption(tests.TestCase, TestOptionConverterMixin):
 
2459
 
 
2460
    def get_option(self):
 
2461
        return config.ListOption('foo', help='A list.')
 
2462
 
 
2463
    def test_convert_invalid(self):
 
2464
        opt = self.get_option()
 
2465
        # We don't even try to convert a list into a list, we only expect
 
2466
        # strings
 
2467
        self.assertConvertInvalid(opt, [1])
 
2468
        # No string is invalid as all forms can be converted to a list
 
2469
 
 
2470
    def test_convert_valid(self):
 
2471
        opt = self.get_option()
 
2472
        # An empty string is an empty list
 
2473
        self.assertConverted([], opt, '') # Using a bare str() just in case
 
2474
        self.assertConverted([], opt, u'')
 
2475
        # A boolean
 
2476
        self.assertConverted([u'True'], opt, u'True')
 
2477
        # An integer
 
2478
        self.assertConverted([u'42'], opt, u'42')
 
2479
        # A single string
 
2480
        self.assertConverted([u'bar'], opt, u'bar')
 
2481
 
 
2482
 
 
2483
class TestOptionRegistry(tests.TestCase):
 
2484
 
 
2485
    def setUp(self):
 
2486
        super(TestOptionRegistry, self).setUp()
 
2487
        # Always start with an empty registry
 
2488
        self.overrideAttr(config, 'option_registry', config.OptionRegistry())
 
2489
        self.registry = config.option_registry
 
2490
 
 
2491
    def test_register(self):
 
2492
        opt = config.Option('foo')
 
2493
        self.registry.register(opt)
 
2494
        self.assertIs(opt, self.registry.get('foo'))
 
2495
 
 
2496
    def test_registered_help(self):
 
2497
        opt = config.Option('foo', help='A simple option')
 
2498
        self.registry.register(opt)
 
2499
        self.assertEquals('A simple option', self.registry.get_help('foo'))
 
2500
 
 
2501
    lazy_option = config.Option('lazy_foo', help='Lazy help')
 
2502
 
 
2503
    def test_register_lazy(self):
 
2504
        self.registry.register_lazy('lazy_foo', self.__module__,
 
2505
                                    'TestOptionRegistry.lazy_option')
 
2506
        self.assertIs(self.lazy_option, self.registry.get('lazy_foo'))
 
2507
 
 
2508
    def test_registered_lazy_help(self):
 
2509
        self.registry.register_lazy('lazy_foo', self.__module__,
 
2510
                                    'TestOptionRegistry.lazy_option')
 
2511
        self.assertEquals('Lazy help', self.registry.get_help('lazy_foo'))
 
2512
 
 
2513
 
 
2514
class TestRegisteredOptions(tests.TestCase):
 
2515
    """All registered options should verify some constraints."""
 
2516
 
 
2517
    scenarios = [(key, {'option_name': key, 'option': option}) for key, option
 
2518
                 in config.option_registry.iteritems()]
 
2519
 
 
2520
    def setUp(self):
 
2521
        super(TestRegisteredOptions, self).setUp()
 
2522
        self.registry = config.option_registry
 
2523
 
 
2524
    def test_proper_name(self):
 
2525
        # An option should be registered under its own name, this can't be
 
2526
        # checked at registration time for the lazy ones.
 
2527
        self.assertEquals(self.option_name, self.option.name)
 
2528
 
 
2529
    def test_help_is_set(self):
 
2530
        option_help = self.registry.get_help(self.option_name)
 
2531
        self.assertNotEquals(None, option_help)
 
2532
        # Come on, think about the user, he really wants to know what the
 
2533
        # option is about
 
2534
        self.assertIsNot(None, option_help)
 
2535
        self.assertNotEquals('', option_help)
 
2536
 
 
2537
 
 
2538
class TestSection(tests.TestCase):
 
2539
 
 
2540
    # FIXME: Parametrize so that all sections produced by Stores run these
 
2541
    # tests -- vila 2011-04-01
 
2542
 
 
2543
    def test_get_a_value(self):
 
2544
        a_dict = dict(foo='bar')
 
2545
        section = config.Section('myID', a_dict)
 
2546
        self.assertEquals('bar', section.get('foo'))
 
2547
 
 
2548
    def test_get_unknown_option(self):
 
2549
        a_dict = dict()
 
2550
        section = config.Section(None, a_dict)
 
2551
        self.assertEquals('out of thin air',
 
2552
                          section.get('foo', 'out of thin air'))
 
2553
 
 
2554
    def test_options_is_shared(self):
 
2555
        a_dict = dict()
 
2556
        section = config.Section(None, a_dict)
 
2557
        self.assertIs(a_dict, section.options)
 
2558
 
 
2559
 
 
2560
class TestMutableSection(tests.TestCase):
 
2561
 
 
2562
    scenarios = [('mutable',
 
2563
                  {'get_section':
 
2564
                       lambda opts: config.MutableSection('myID', opts)},),
 
2565
        ]
 
2566
 
 
2567
    def test_set(self):
 
2568
        a_dict = dict(foo='bar')
 
2569
        section = self.get_section(a_dict)
 
2570
        section.set('foo', 'new_value')
 
2571
        self.assertEquals('new_value', section.get('foo'))
 
2572
        # The change appears in the shared section
 
2573
        self.assertEquals('new_value', a_dict.get('foo'))
 
2574
        # We keep track of the change
 
2575
        self.assertTrue('foo' in section.orig)
 
2576
        self.assertEquals('bar', section.orig.get('foo'))
 
2577
 
 
2578
    def test_set_preserve_original_once(self):
 
2579
        a_dict = dict(foo='bar')
 
2580
        section = self.get_section(a_dict)
 
2581
        section.set('foo', 'first_value')
 
2582
        section.set('foo', 'second_value')
 
2583
        # We keep track of the original value
 
2584
        self.assertTrue('foo' in section.orig)
 
2585
        self.assertEquals('bar', section.orig.get('foo'))
 
2586
 
 
2587
    def test_remove(self):
 
2588
        a_dict = dict(foo='bar')
 
2589
        section = self.get_section(a_dict)
 
2590
        section.remove('foo')
 
2591
        # We get None for unknown options via the default value
 
2592
        self.assertEquals(None, section.get('foo'))
 
2593
        # Or we just get the default value
 
2594
        self.assertEquals('unknown', section.get('foo', 'unknown'))
 
2595
        self.assertFalse('foo' in section.options)
 
2596
        # We keep track of the deletion
 
2597
        self.assertTrue('foo' in section.orig)
 
2598
        self.assertEquals('bar', section.orig.get('foo'))
 
2599
 
 
2600
    def test_remove_new_option(self):
 
2601
        a_dict = dict()
 
2602
        section = self.get_section(a_dict)
 
2603
        section.set('foo', 'bar')
 
2604
        section.remove('foo')
 
2605
        self.assertFalse('foo' in section.options)
 
2606
        # The option didn't exist initially so it we need to keep track of it
 
2607
        # with a special value
 
2608
        self.assertTrue('foo' in section.orig)
 
2609
        self.assertEquals(config._NewlyCreatedOption, section.orig['foo'])
 
2610
 
 
2611
 
 
2612
class TestCommandLineStore(tests.TestCase):
 
2613
 
 
2614
    def setUp(self):
 
2615
        super(TestCommandLineStore, self).setUp()
 
2616
        self.store = config.CommandLineStore()
 
2617
        self.overrideAttr(config, 'option_registry', config.OptionRegistry())
 
2618
 
 
2619
    def get_section(self):
 
2620
        """Get the unique section for the command line overrides."""
 
2621
        sections = list(self.store.get_sections())
 
2622
        self.assertLength(1, sections)
 
2623
        store, section = sections[0]
 
2624
        self.assertEquals(self.store, store)
 
2625
        return section
 
2626
 
 
2627
    def test_no_override(self):
 
2628
        self.store._from_cmdline([])
 
2629
        section = self.get_section()
 
2630
        self.assertLength(0, list(section.iter_option_names()))
 
2631
 
 
2632
    def test_simple_override(self):
 
2633
        self.store._from_cmdline(['a=b'])
 
2634
        section = self.get_section()
 
2635
        self.assertEqual('b', section.get('a'))
 
2636
 
 
2637
    def test_list_override(self):
 
2638
        opt = config.ListOption('l')
 
2639
        config.option_registry.register(opt)
 
2640
        self.store._from_cmdline(['l=1,2,3'])
 
2641
        val = self.get_section().get('l')
 
2642
        self.assertEqual('1,2,3', val)
 
2643
        # Reminder: lists should be registered as such explicitely, otherwise
 
2644
        # the conversion needs to be done afterwards.
 
2645
        self.assertEqual(['1', '2', '3'],
 
2646
                         opt.convert_from_unicode(self.store, val))
 
2647
 
 
2648
    def test_multiple_overrides(self):
 
2649
        self.store._from_cmdline(['a=b', 'x=y'])
 
2650
        section = self.get_section()
 
2651
        self.assertEquals('b', section.get('a'))
 
2652
        self.assertEquals('y', section.get('x'))
 
2653
 
 
2654
    def test_wrong_syntax(self):
 
2655
        self.assertRaises(errors.BzrCommandError,
 
2656
                          self.store._from_cmdline, ['a=b', 'c'])
 
2657
 
 
2658
class TestStoreMinimalAPI(tests.TestCaseWithTransport):
 
2659
 
 
2660
    scenarios = [(key, {'get_store': builder}) for key, builder
 
2661
                 in config.test_store_builder_registry.iteritems()] + [
 
2662
        ('cmdline', {'get_store': lambda test: config.CommandLineStore()})]
 
2663
 
 
2664
    def test_id(self):
 
2665
        store = self.get_store(self)
 
2666
        if type(store) == config.TransportIniFileStore:
 
2667
            raise tests.TestNotApplicable(
 
2668
                "%s is not a concrete Store implementation"
 
2669
                " so it doesn't need an id" % (store.__class__.__name__,))
 
2670
        self.assertIsNot(None, store.id)
 
2671
 
 
2672
 
 
2673
class TestStore(tests.TestCaseWithTransport):
 
2674
 
 
2675
    def assertSectionContent(self, expected, (store, section)):
 
2676
        """Assert that some options have the proper values in a section."""
 
2677
        expected_name, expected_options = expected
 
2678
        self.assertEquals(expected_name, section.id)
 
2679
        self.assertEquals(
 
2680
            expected_options,
 
2681
            dict([(k, section.get(k)) for k in expected_options.keys()]))
 
2682
 
 
2683
 
 
2684
class TestReadonlyStore(TestStore):
 
2685
 
 
2686
    scenarios = [(key, {'get_store': builder}) for key, builder
 
2687
                 in config.test_store_builder_registry.iteritems()]
 
2688
 
 
2689
    def test_building_delays_load(self):
 
2690
        store = self.get_store(self)
 
2691
        self.assertEquals(False, store.is_loaded())
 
2692
        store._load_from_string('')
 
2693
        self.assertEquals(True, store.is_loaded())
 
2694
 
 
2695
    def test_get_no_sections_for_empty(self):
 
2696
        store = self.get_store(self)
 
2697
        store._load_from_string('')
 
2698
        self.assertEquals([], list(store.get_sections()))
 
2699
 
 
2700
    def test_get_default_section(self):
 
2701
        store = self.get_store(self)
 
2702
        store._load_from_string('foo=bar')
 
2703
        sections = list(store.get_sections())
 
2704
        self.assertLength(1, sections)
 
2705
        self.assertSectionContent((None, {'foo': 'bar'}), sections[0])
 
2706
 
 
2707
    def test_get_named_section(self):
 
2708
        store = self.get_store(self)
 
2709
        store._load_from_string('[baz]\nfoo=bar')
 
2710
        sections = list(store.get_sections())
 
2711
        self.assertLength(1, sections)
 
2712
        self.assertSectionContent(('baz', {'foo': 'bar'}), sections[0])
 
2713
 
 
2714
    def test_load_from_string_fails_for_non_empty_store(self):
 
2715
        store = self.get_store(self)
 
2716
        store._load_from_string('foo=bar')
 
2717
        self.assertRaises(AssertionError, store._load_from_string, 'bar=baz')
 
2718
 
 
2719
 
 
2720
class TestStoreQuoting(TestStore):
 
2721
 
 
2722
    scenarios = [(key, {'get_store': builder}) for key, builder
 
2723
                 in config.test_store_builder_registry.iteritems()]
 
2724
 
 
2725
    def setUp(self):
 
2726
        super(TestStoreQuoting, self).setUp()
 
2727
        self.store = self.get_store(self)
 
2728
        # We need a loaded store but any content will do
 
2729
        self.store._load_from_string('')
 
2730
 
 
2731
    def assertIdempotent(self, s):
 
2732
        """Assert that quoting an unquoted string is a no-op and vice-versa.
 
2733
 
 
2734
        What matters here is that option values, as they appear in a store, can
 
2735
        be safely round-tripped out of the store and back.
 
2736
 
 
2737
        :param s: A string, quoted if required.
 
2738
        """
 
2739
        self.assertEquals(s, self.store.quote(self.store.unquote(s)))
 
2740
        self.assertEquals(s, self.store.unquote(self.store.quote(s)))
 
2741
 
 
2742
    def test_empty_string(self):
 
2743
        if isinstance(self.store, config.IniFileStore):
 
2744
            # configobj._quote doesn't handle empty values
 
2745
            self.assertRaises(AssertionError,
 
2746
                              self.assertIdempotent, '')
 
2747
        else:
 
2748
            self.assertIdempotent('')
 
2749
        # But quoted empty strings are ok
 
2750
        self.assertIdempotent('""')
 
2751
 
 
2752
    def test_embedded_spaces(self):
 
2753
        self.assertIdempotent('" a b c "')
 
2754
 
 
2755
    def test_embedded_commas(self):
 
2756
        self.assertIdempotent('" a , b c "')
 
2757
 
 
2758
    def test_simple_comma(self):
 
2759
        if isinstance(self.store, config.IniFileStore):
 
2760
            # configobj requires that lists are special-cased
 
2761
           self.assertRaises(AssertionError,
 
2762
                             self.assertIdempotent, ',')
 
2763
        else:
 
2764
            self.assertIdempotent(',')
 
2765
        # When a single comma is required, quoting is also required
 
2766
        self.assertIdempotent('","')
 
2767
 
 
2768
    def test_list(self):
 
2769
        if isinstance(self.store, config.IniFileStore):
 
2770
            # configobj requires that lists are special-cased
 
2771
            self.assertRaises(AssertionError,
 
2772
                              self.assertIdempotent, 'a,b')
 
2773
        else:
 
2774
            self.assertIdempotent('a,b')
 
2775
 
 
2776
 
 
2777
class TestDictFromStore(tests.TestCase):
 
2778
 
 
2779
    def test_unquote_not_string(self):
 
2780
        conf = config.MemoryStack('x=2\n[a_section]\na=1\n')
 
2781
        value = conf.get('a_section')
 
2782
        # Urgh, despite 'conf' asking for the no-name section, we get the
 
2783
        # content of another section as a dict o_O
 
2784
        self.assertEquals({'a': '1'}, value)
 
2785
        unquoted = conf.store.unquote(value)
 
2786
        # Which cannot be unquoted but shouldn't crash either (the use cases
 
2787
        # are getting the value or displaying it. In the later case, '%s' will
 
2788
        # do).
 
2789
        self.assertEquals({'a': '1'}, unquoted)
 
2790
        self.assertEquals("{u'a': u'1'}", '%s' % (unquoted,))
 
2791
 
 
2792
 
 
2793
class TestIniFileStoreContent(tests.TestCaseWithTransport):
 
2794
    """Simulate loading a config store with content of various encodings.
 
2795
 
 
2796
    All files produced by bzr are in utf8 content.
 
2797
 
 
2798
    Users may modify them manually and end up with a file that can't be
 
2799
    loaded. We need to issue proper error messages in this case.
 
2800
    """
 
2801
 
 
2802
    invalid_utf8_char = '\xff'
 
2803
 
 
2804
    def test_load_utf8(self):
 
2805
        """Ensure we can load an utf8-encoded file."""
 
2806
        t = self.get_transport()
 
2807
        # From http://pad.lv/799212
 
2808
        unicode_user = u'b\N{Euro Sign}ar'
 
2809
        unicode_content = u'user=%s' % (unicode_user,)
 
2810
        utf8_content = unicode_content.encode('utf8')
 
2811
        # Store the raw content in the config file
 
2812
        t.put_bytes('foo.conf', utf8_content)
 
2813
        store = config.TransportIniFileStore(t, 'foo.conf')
 
2814
        store.load()
 
2815
        stack = config.Stack([store.get_sections], store)
 
2816
        self.assertEquals(unicode_user, stack.get('user'))
 
2817
 
 
2818
    def test_load_non_ascii(self):
 
2819
        """Ensure we display a proper error on non-ascii, non utf-8 content."""
 
2820
        t = self.get_transport()
 
2821
        t.put_bytes('foo.conf', 'user=foo\n#%s\n' % (self.invalid_utf8_char,))
 
2822
        store = config.TransportIniFileStore(t, 'foo.conf')
 
2823
        self.assertRaises(errors.ConfigContentError, store.load)
 
2824
 
 
2825
    def test_load_erroneous_content(self):
 
2826
        """Ensure we display a proper error on content that can't be parsed."""
 
2827
        t = self.get_transport()
 
2828
        t.put_bytes('foo.conf', '[open_section\n')
 
2829
        store = config.TransportIniFileStore(t, 'foo.conf')
 
2830
        self.assertRaises(errors.ParseConfigError, store.load)
 
2831
 
 
2832
    def test_load_permission_denied(self):
 
2833
        """Ensure we get warned when trying to load an inaccessible file."""
 
2834
        warnings = []
 
2835
        def warning(*args):
 
2836
            warnings.append(args[0] % args[1:])
 
2837
        self.overrideAttr(trace, 'warning', warning)
 
2838
 
 
2839
        t = self.get_transport()
 
2840
 
 
2841
        def get_bytes(relpath):
 
2842
            raise errors.PermissionDenied(relpath, "")
 
2843
        t.get_bytes = get_bytes
 
2844
        store = config.TransportIniFileStore(t, 'foo.conf')
 
2845
        self.assertRaises(errors.PermissionDenied, store.load)
 
2846
        self.assertEquals(
 
2847
            warnings,
 
2848
            [u'Permission denied while trying to load configuration store %s.'
 
2849
             % store.external_url()])
 
2850
 
 
2851
 
 
2852
class TestIniConfigContent(tests.TestCaseWithTransport):
 
2853
    """Simulate loading a IniBasedConfig with content of various encodings.
 
2854
 
 
2855
    All files produced by bzr are in utf8 content.
 
2856
 
 
2857
    Users may modify them manually and end up with a file that can't be
 
2858
    loaded. We need to issue proper error messages in this case.
 
2859
    """
 
2860
 
 
2861
    invalid_utf8_char = '\xff'
 
2862
 
 
2863
    def test_load_utf8(self):
 
2864
        """Ensure we can load an utf8-encoded file."""
 
2865
        # From http://pad.lv/799212
 
2866
        unicode_user = u'b\N{Euro Sign}ar'
 
2867
        unicode_content = u'user=%s' % (unicode_user,)
 
2868
        utf8_content = unicode_content.encode('utf8')
 
2869
        # Store the raw content in the config file
 
2870
        with open('foo.conf', 'wb') as f:
 
2871
            f.write(utf8_content)
 
2872
        conf = config.IniBasedConfig(file_name='foo.conf')
 
2873
        self.assertEquals(unicode_user, conf.get_user_option('user'))
 
2874
 
 
2875
    def test_load_badly_encoded_content(self):
 
2876
        """Ensure we display a proper error on non-ascii, non utf-8 content."""
 
2877
        with open('foo.conf', 'wb') as f:
 
2878
            f.write('user=foo\n#%s\n' % (self.invalid_utf8_char,))
 
2879
        conf = config.IniBasedConfig(file_name='foo.conf')
 
2880
        self.assertRaises(errors.ConfigContentError, conf._get_parser)
 
2881
 
 
2882
    def test_load_erroneous_content(self):
 
2883
        """Ensure we display a proper error on content that can't be parsed."""
 
2884
        with open('foo.conf', 'wb') as f:
 
2885
            f.write('[open_section\n')
 
2886
        conf = config.IniBasedConfig(file_name='foo.conf')
 
2887
        self.assertRaises(errors.ParseConfigError, conf._get_parser)
 
2888
 
 
2889
 
 
2890
class TestMutableStore(TestStore):
 
2891
 
 
2892
    scenarios = [(key, {'store_id': key, 'get_store': builder}) for key, builder
 
2893
                 in config.test_store_builder_registry.iteritems()]
 
2894
 
 
2895
    def setUp(self):
 
2896
        super(TestMutableStore, self).setUp()
 
2897
        self.transport = self.get_transport()
 
2898
 
 
2899
    def has_store(self, store):
 
2900
        store_basename = urlutils.relative_url(self.transport.external_url(),
 
2901
                                               store.external_url())
 
2902
        return self.transport.has(store_basename)
 
2903
 
 
2904
    def test_save_empty_creates_no_file(self):
 
2905
        # FIXME: There should be a better way than relying on the test
 
2906
        # parametrization to identify branch.conf -- vila 2011-0526
 
2907
        if self.store_id in ('branch', 'remote_branch'):
 
2908
            raise tests.TestNotApplicable(
 
2909
                'branch.conf is *always* created when a branch is initialized')
 
2910
        store = self.get_store(self)
 
2911
        store.save()
 
2912
        self.assertEquals(False, self.has_store(store))
 
2913
 
 
2914
    def test_save_emptied_succeeds(self):
 
2915
        store = self.get_store(self)
 
2916
        store._load_from_string('foo=bar\n')
 
2917
        section = store.get_mutable_section(None)
 
2918
        section.remove('foo')
 
2919
        store.save()
 
2920
        self.assertEquals(True, self.has_store(store))
 
2921
        modified_store = self.get_store(self)
 
2922
        sections = list(modified_store.get_sections())
 
2923
        self.assertLength(0, sections)
 
2924
 
 
2925
    def test_save_with_content_succeeds(self):
 
2926
        # FIXME: There should be a better way than relying on the test
 
2927
        # parametrization to identify branch.conf -- vila 2011-0526
 
2928
        if self.store_id in ('branch', 'remote_branch'):
 
2929
            raise tests.TestNotApplicable(
 
2930
                'branch.conf is *always* created when a branch is initialized')
 
2931
        store = self.get_store(self)
 
2932
        store._load_from_string('foo=bar\n')
 
2933
        self.assertEquals(False, self.has_store(store))
 
2934
        store.save()
 
2935
        self.assertEquals(True, self.has_store(store))
 
2936
        modified_store = self.get_store(self)
 
2937
        sections = list(modified_store.get_sections())
 
2938
        self.assertLength(1, sections)
 
2939
        self.assertSectionContent((None, {'foo': 'bar'}), sections[0])
 
2940
 
 
2941
    def test_set_option_in_empty_store(self):
 
2942
        store = self.get_store(self)
 
2943
        section = store.get_mutable_section(None)
 
2944
        section.set('foo', 'bar')
 
2945
        store.save()
 
2946
        modified_store = self.get_store(self)
 
2947
        sections = list(modified_store.get_sections())
 
2948
        self.assertLength(1, sections)
 
2949
        self.assertSectionContent((None, {'foo': 'bar'}), sections[0])
 
2950
 
 
2951
    def test_set_option_in_default_section(self):
 
2952
        store = self.get_store(self)
 
2953
        store._load_from_string('')
 
2954
        section = store.get_mutable_section(None)
 
2955
        section.set('foo', 'bar')
 
2956
        store.save()
 
2957
        modified_store = self.get_store(self)
 
2958
        sections = list(modified_store.get_sections())
 
2959
        self.assertLength(1, sections)
 
2960
        self.assertSectionContent((None, {'foo': 'bar'}), sections[0])
 
2961
 
 
2962
    def test_set_option_in_named_section(self):
 
2963
        store = self.get_store(self)
 
2964
        store._load_from_string('')
 
2965
        section = store.get_mutable_section('baz')
 
2966
        section.set('foo', 'bar')
 
2967
        store.save()
 
2968
        modified_store = self.get_store(self)
 
2969
        sections = list(modified_store.get_sections())
 
2970
        self.assertLength(1, sections)
 
2971
        self.assertSectionContent(('baz', {'foo': 'bar'}), sections[0])
 
2972
 
 
2973
    def test_load_hook(self):
 
2974
        # We first needs to ensure that the store exists
 
2975
        store = self.get_store(self)
 
2976
        section = store.get_mutable_section('baz')
 
2977
        section.set('foo', 'bar')
 
2978
        store.save()
 
2979
        # Now we can try to load it
 
2980
        store = self.get_store(self)
 
2981
        calls = []
 
2982
        def hook(*args):
 
2983
            calls.append(args)
 
2984
        config.ConfigHooks.install_named_hook('load', hook, None)
 
2985
        self.assertLength(0, calls)
 
2986
        store.load()
 
2987
        self.assertLength(1, calls)
 
2988
        self.assertEquals((store,), calls[0])
 
2989
 
 
2990
    def test_save_hook(self):
 
2991
        calls = []
 
2992
        def hook(*args):
 
2993
            calls.append(args)
 
2994
        config.ConfigHooks.install_named_hook('save', hook, None)
 
2995
        self.assertLength(0, calls)
 
2996
        store = self.get_store(self)
 
2997
        section = store.get_mutable_section('baz')
 
2998
        section.set('foo', 'bar')
 
2999
        store.save()
 
3000
        self.assertLength(1, calls)
 
3001
        self.assertEquals((store,), calls[0])
 
3002
 
 
3003
    def test_set_mark_dirty(self):
 
3004
        stack = config.MemoryStack('')
 
3005
        self.assertLength(0, stack.store.dirty_sections)
 
3006
        stack.set('foo', 'baz')
 
3007
        self.assertLength(1, stack.store.dirty_sections)
 
3008
        self.assertTrue(stack.store._need_saving())
 
3009
 
 
3010
    def test_remove_mark_dirty(self):
 
3011
        stack = config.MemoryStack('foo=bar')
 
3012
        self.assertLength(0, stack.store.dirty_sections)
 
3013
        stack.remove('foo')
 
3014
        self.assertLength(1, stack.store.dirty_sections)
 
3015
        self.assertTrue(stack.store._need_saving())
 
3016
 
 
3017
 
 
3018
class TestStoreSaveChanges(tests.TestCaseWithTransport):
 
3019
    """Tests that config changes are kept in memory and saved on-demand."""
 
3020
 
 
3021
    def setUp(self):
 
3022
        super(TestStoreSaveChanges, self).setUp()
 
3023
        self.transport = self.get_transport()
 
3024
        # Most of the tests involve two stores pointing to the same persistent
 
3025
        # storage to observe the effects of concurrent changes
 
3026
        self.st1 = config.TransportIniFileStore(self.transport, 'foo.conf')
 
3027
        self.st2 = config.TransportIniFileStore(self.transport, 'foo.conf')
 
3028
        self.warnings = []
 
3029
        def warning(*args):
 
3030
            self.warnings.append(args[0] % args[1:])
 
3031
        self.overrideAttr(trace, 'warning', warning)
 
3032
 
 
3033
    def has_store(self, store):
 
3034
        store_basename = urlutils.relative_url(self.transport.external_url(),
 
3035
                                               store.external_url())
 
3036
        return self.transport.has(store_basename)
 
3037
 
 
3038
    def get_stack(self, store):
 
3039
        # Any stack will do as long as it uses the right store, just a single
 
3040
        # no-name section is enough
 
3041
        return config.Stack([store.get_sections], store)
 
3042
 
 
3043
    def test_no_changes_no_save(self):
 
3044
        s = self.get_stack(self.st1)
 
3045
        s.store.save_changes()
 
3046
        self.assertEquals(False, self.has_store(self.st1))
 
3047
 
 
3048
    def test_unrelated_concurrent_update(self):
 
3049
        s1 = self.get_stack(self.st1)
 
3050
        s2 = self.get_stack(self.st2)
 
3051
        s1.set('foo', 'bar')
 
3052
        s2.set('baz', 'quux')
 
3053
        s1.store.save()
 
3054
        # Changes don't propagate magically
 
3055
        self.assertEquals(None, s1.get('baz'))
 
3056
        s2.store.save_changes()
 
3057
        self.assertEquals('quux', s2.get('baz'))
 
3058
        # Changes are acquired when saving
 
3059
        self.assertEquals('bar', s2.get('foo'))
 
3060
        # Since there is no overlap, no warnings are emitted
 
3061
        self.assertLength(0, self.warnings)
 
3062
 
 
3063
    def test_concurrent_update_modified(self):
 
3064
        s1 = self.get_stack(self.st1)
 
3065
        s2 = self.get_stack(self.st2)
 
3066
        s1.set('foo', 'bar')
 
3067
        s2.set('foo', 'baz')
 
3068
        s1.store.save()
 
3069
        # Last speaker wins
 
3070
        s2.store.save_changes()
 
3071
        self.assertEquals('baz', s2.get('foo'))
 
3072
        # But the user get a warning
 
3073
        self.assertLength(1, self.warnings)
 
3074
        warning = self.warnings[0]
 
3075
        self.assertStartsWith(warning, 'Option foo in section None')
 
3076
        self.assertEndsWith(warning, 'was changed from <CREATED> to bar.'
 
3077
                            ' The baz value will be saved.')
 
3078
 
 
3079
    def test_concurrent_deletion(self):
 
3080
        self.st1._load_from_string('foo=bar')
 
3081
        self.st1.save()
 
3082
        s1 = self.get_stack(self.st1)
 
3083
        s2 = self.get_stack(self.st2)
 
3084
        s1.remove('foo')
 
3085
        s2.remove('foo')
 
3086
        s1.store.save_changes()
 
3087
        # No warning yet
 
3088
        self.assertLength(0, self.warnings)
 
3089
        s2.store.save_changes()
 
3090
        # Now we get one
 
3091
        self.assertLength(1, self.warnings)
 
3092
        warning = self.warnings[0]
 
3093
        self.assertStartsWith(warning, 'Option foo in section None')
 
3094
        self.assertEndsWith(warning, 'was changed from bar to <CREATED>.'
 
3095
                            ' The <DELETED> value will be saved.')
 
3096
 
 
3097
 
 
3098
class TestQuotingIniFileStore(tests.TestCaseWithTransport):
 
3099
 
 
3100
    def get_store(self):
 
3101
        return config.TransportIniFileStore(self.get_transport(), 'foo.conf')
 
3102
 
 
3103
    def test_get_quoted_string(self):
 
3104
        store = self.get_store()
 
3105
        store._load_from_string('foo= " abc "')
 
3106
        stack = config.Stack([store.get_sections])
 
3107
        self.assertEquals(' abc ', stack.get('foo'))
 
3108
 
 
3109
    def test_set_quoted_string(self):
 
3110
        store = self.get_store()
 
3111
        stack = config.Stack([store.get_sections], store)
 
3112
        stack.set('foo', ' a b c ')
 
3113
        store.save()
 
3114
        self.assertFileEqual('foo = " a b c "' + os.linesep, 'foo.conf')
 
3115
 
 
3116
 
 
3117
class TestTransportIniFileStore(TestStore):
 
3118
 
 
3119
    def test_loading_unknown_file_fails(self):
 
3120
        store = config.TransportIniFileStore(self.get_transport(),
 
3121
            'I-do-not-exist')
 
3122
        self.assertRaises(errors.NoSuchFile, store.load)
 
3123
 
 
3124
    def test_invalid_content(self):
 
3125
        store = config.TransportIniFileStore(self.get_transport(), 'foo.conf')
 
3126
        self.assertEquals(False, store.is_loaded())
 
3127
        exc = self.assertRaises(
 
3128
            errors.ParseConfigError, store._load_from_string,
 
3129
            'this is invalid !')
 
3130
        self.assertEndsWith(exc.filename, 'foo.conf')
 
3131
        # And the load failed
 
3132
        self.assertEquals(False, store.is_loaded())
 
3133
 
 
3134
    def test_get_embedded_sections(self):
 
3135
        # A more complicated example (which also shows that section names and
 
3136
        # option names share the same name space...)
 
3137
        # FIXME: This should be fixed by forbidding dicts as values ?
 
3138
        # -- vila 2011-04-05
 
3139
        store = config.TransportIniFileStore(self.get_transport(), 'foo.conf')
 
3140
        store._load_from_string('''
 
3141
foo=bar
 
3142
l=1,2
 
3143
[DEFAULT]
 
3144
foo_in_DEFAULT=foo_DEFAULT
 
3145
[bar]
 
3146
foo_in_bar=barbar
 
3147
[baz]
 
3148
foo_in_baz=barbaz
 
3149
[[qux]]
 
3150
foo_in_qux=quux
 
3151
''')
 
3152
        sections = list(store.get_sections())
 
3153
        self.assertLength(4, sections)
 
3154
        # The default section has no name.
 
3155
        # List values are provided as strings and need to be explicitly
 
3156
        # converted by specifying from_unicode=list_from_store at option
 
3157
        # registration
 
3158
        self.assertSectionContent((None, {'foo': 'bar', 'l': u'1,2'}),
 
3159
                                  sections[0])
 
3160
        self.assertSectionContent(
 
3161
            ('DEFAULT', {'foo_in_DEFAULT': 'foo_DEFAULT'}), sections[1])
 
3162
        self.assertSectionContent(
 
3163
            ('bar', {'foo_in_bar': 'barbar'}), sections[2])
 
3164
        # sub sections are provided as embedded dicts.
 
3165
        self.assertSectionContent(
 
3166
            ('baz', {'foo_in_baz': 'barbaz', 'qux': {'foo_in_qux': 'quux'}}),
 
3167
            sections[3])
 
3168
 
 
3169
 
 
3170
class TestLockableIniFileStore(TestStore):
 
3171
 
 
3172
    def test_create_store_in_created_dir(self):
 
3173
        self.assertPathDoesNotExist('dir')
 
3174
        t = self.get_transport('dir/subdir')
 
3175
        store = config.LockableIniFileStore(t, 'foo.conf')
 
3176
        store.get_mutable_section(None).set('foo', 'bar')
 
3177
        store.save()
 
3178
        self.assertPathExists('dir/subdir')
 
3179
 
 
3180
 
 
3181
class TestConcurrentStoreUpdates(TestStore):
 
3182
    """Test that Stores properly handle conccurent updates.
 
3183
 
 
3184
    New Store implementation may fail some of these tests but until such
 
3185
    implementations exist it's hard to properly filter them from the scenarios
 
3186
    applied here. If you encounter such a case, contact the bzr devs.
 
3187
    """
 
3188
 
 
3189
    scenarios = [(key, {'get_stack': builder}) for key, builder
 
3190
                 in config.test_stack_builder_registry.iteritems()]
 
3191
 
 
3192
    def setUp(self):
 
3193
        super(TestConcurrentStoreUpdates, self).setUp()
 
3194
        self.stack = self.get_stack(self)
 
3195
        if not isinstance(self.stack, config._CompatibleStack):
 
3196
            raise tests.TestNotApplicable(
 
3197
                '%s is not meant to be compatible with the old config design'
 
3198
                % (self.stack,))
 
3199
        self.stack.set('one', '1')
 
3200
        self.stack.set('two', '2')
 
3201
        # Flush the store
 
3202
        self.stack.store.save()
 
3203
 
 
3204
    def test_simple_read_access(self):
 
3205
        self.assertEquals('1', self.stack.get('one'))
 
3206
 
 
3207
    def test_simple_write_access(self):
 
3208
        self.stack.set('one', 'one')
 
3209
        self.assertEquals('one', self.stack.get('one'))
 
3210
 
 
3211
    def test_listen_to_the_last_speaker(self):
 
3212
        c1 = self.stack
 
3213
        c2 = self.get_stack(self)
 
3214
        c1.set('one', 'ONE')
 
3215
        c2.set('two', 'TWO')
 
3216
        self.assertEquals('ONE', c1.get('one'))
 
3217
        self.assertEquals('TWO', c2.get('two'))
 
3218
        # The second update respect the first one
 
3219
        self.assertEquals('ONE', c2.get('one'))
 
3220
 
 
3221
    def test_last_speaker_wins(self):
 
3222
        # If the same config is not shared, the same variable modified twice
 
3223
        # can only see a single result.
 
3224
        c1 = self.stack
 
3225
        c2 = self.get_stack(self)
 
3226
        c1.set('one', 'c1')
 
3227
        c2.set('one', 'c2')
 
3228
        self.assertEquals('c2', c2.get('one'))
 
3229
        # The first modification is still available until another refresh
 
3230
        # occur
 
3231
        self.assertEquals('c1', c1.get('one'))
 
3232
        c1.set('two', 'done')
 
3233
        self.assertEquals('c2', c1.get('one'))
 
3234
 
 
3235
    def test_writes_are_serialized(self):
 
3236
        c1 = self.stack
 
3237
        c2 = self.get_stack(self)
 
3238
 
 
3239
        # We spawn a thread that will pause *during* the config saving.
 
3240
        before_writing = threading.Event()
 
3241
        after_writing = threading.Event()
 
3242
        writing_done = threading.Event()
 
3243
        c1_save_without_locking_orig = c1.store.save_without_locking
 
3244
        def c1_save_without_locking():
 
3245
            before_writing.set()
 
3246
            c1_save_without_locking_orig()
 
3247
            # The lock is held. We wait for the main thread to decide when to
 
3248
            # continue
 
3249
            after_writing.wait()
 
3250
        c1.store.save_without_locking = c1_save_without_locking
 
3251
        def c1_set():
 
3252
            c1.set('one', 'c1')
 
3253
            writing_done.set()
 
3254
        t1 = threading.Thread(target=c1_set)
 
3255
        # Collect the thread after the test
 
3256
        self.addCleanup(t1.join)
 
3257
        # Be ready to unblock the thread if the test goes wrong
 
3258
        self.addCleanup(after_writing.set)
 
3259
        t1.start()
 
3260
        before_writing.wait()
 
3261
        self.assertRaises(errors.LockContention,
 
3262
                          c2.set, 'one', 'c2')
 
3263
        self.assertEquals('c1', c1.get('one'))
 
3264
        # Let the lock be released
 
3265
        after_writing.set()
 
3266
        writing_done.wait()
 
3267
        c2.set('one', 'c2')
 
3268
        self.assertEquals('c2', c2.get('one'))
 
3269
 
 
3270
    def test_read_while_writing(self):
 
3271
       c1 = self.stack
 
3272
       # We spawn a thread that will pause *during* the write
 
3273
       ready_to_write = threading.Event()
 
3274
       do_writing = threading.Event()
 
3275
       writing_done = threading.Event()
 
3276
       # We override the _save implementation so we know the store is locked
 
3277
       c1_save_without_locking_orig = c1.store.save_without_locking
 
3278
       def c1_save_without_locking():
 
3279
           ready_to_write.set()
 
3280
           # The lock is held. We wait for the main thread to decide when to
 
3281
           # continue
 
3282
           do_writing.wait()
 
3283
           c1_save_without_locking_orig()
 
3284
           writing_done.set()
 
3285
       c1.store.save_without_locking = c1_save_without_locking
 
3286
       def c1_set():
 
3287
           c1.set('one', 'c1')
 
3288
       t1 = threading.Thread(target=c1_set)
 
3289
       # Collect the thread after the test
 
3290
       self.addCleanup(t1.join)
 
3291
       # Be ready to unblock the thread if the test goes wrong
 
3292
       self.addCleanup(do_writing.set)
 
3293
       t1.start()
 
3294
       # Ensure the thread is ready to write
 
3295
       ready_to_write.wait()
 
3296
       self.assertEquals('c1', c1.get('one'))
 
3297
       # If we read during the write, we get the old value
 
3298
       c2 = self.get_stack(self)
 
3299
       self.assertEquals('1', c2.get('one'))
 
3300
       # Let the writing occur and ensure it occurred
 
3301
       do_writing.set()
 
3302
       writing_done.wait()
 
3303
       # Now we get the updated value
 
3304
       c3 = self.get_stack(self)
 
3305
       self.assertEquals('c1', c3.get('one'))
 
3306
 
 
3307
    # FIXME: It may be worth looking into removing the lock dir when it's not
 
3308
    # needed anymore and look at possible fallouts for concurrent lockers. This
 
3309
    # will matter if/when we use config files outside of bazaar directories
 
3310
    # (.bazaar or .bzr) -- vila 20110-04-111
 
3311
 
 
3312
 
 
3313
class TestSectionMatcher(TestStore):
 
3314
 
 
3315
    scenarios = [('location', {'matcher': config.LocationMatcher}),
 
3316
                 ('id', {'matcher': config.NameMatcher}),]
 
3317
 
 
3318
    def setUp(self):
 
3319
        super(TestSectionMatcher, self).setUp()
 
3320
        # Any simple store is good enough
 
3321
        self.get_store = config.test_store_builder_registry.get('configobj')
 
3322
 
 
3323
    def test_no_matches_for_empty_stores(self):
 
3324
        store = self.get_store(self)
 
3325
        store._load_from_string('')
 
3326
        matcher = self.matcher(store, '/bar')
 
3327
        self.assertEquals([], list(matcher.get_sections()))
 
3328
 
 
3329
    def test_build_doesnt_load_store(self):
 
3330
        store = self.get_store(self)
 
3331
        matcher = self.matcher(store, '/bar')
 
3332
        self.assertFalse(store.is_loaded())
 
3333
 
 
3334
 
 
3335
class TestLocationSection(tests.TestCase):
 
3336
 
 
3337
    def get_section(self, options, extra_path):
 
3338
        section = config.Section('foo', options)
 
3339
        return config.LocationSection(section, extra_path)
 
3340
 
 
3341
    def test_simple_option(self):
 
3342
        section = self.get_section({'foo': 'bar'}, '')
 
3343
        self.assertEquals('bar', section.get('foo'))
 
3344
 
 
3345
    def test_option_with_extra_path(self):
 
3346
        section = self.get_section({'foo': 'bar', 'foo:policy': 'appendpath'},
 
3347
                                   'baz')
 
3348
        self.assertEquals('bar/baz', section.get('foo'))
 
3349
 
 
3350
    def test_invalid_policy(self):
 
3351
        section = self.get_section({'foo': 'bar', 'foo:policy': 'die'},
 
3352
                                   'baz')
 
3353
        # invalid policies are ignored
 
3354
        self.assertEquals('bar', section.get('foo'))
 
3355
 
 
3356
 
 
3357
class TestLocationMatcher(TestStore):
 
3358
 
 
3359
    def setUp(self):
 
3360
        super(TestLocationMatcher, self).setUp()
 
3361
        # Any simple store is good enough
 
3362
        self.get_store = config.test_store_builder_registry.get('configobj')
 
3363
 
 
3364
    def test_unrelated_section_excluded(self):
 
3365
        store = self.get_store(self)
 
3366
        store._load_from_string('''
 
3367
[/foo]
 
3368
section=/foo
 
3369
[/foo/baz]
 
3370
section=/foo/baz
 
3371
[/foo/bar]
 
3372
section=/foo/bar
 
3373
[/foo/bar/baz]
 
3374
section=/foo/bar/baz
 
3375
[/quux/quux]
 
3376
section=/quux/quux
 
3377
''')
 
3378
        self.assertEquals(['/foo', '/foo/baz', '/foo/bar', '/foo/bar/baz',
 
3379
                           '/quux/quux'],
 
3380
                          [section.id for _, section in store.get_sections()])
 
3381
        matcher = config.LocationMatcher(store, '/foo/bar/quux')
 
3382
        sections = [section for _, section in matcher.get_sections()]
 
3383
        self.assertEquals(['/foo/bar', '/foo'],
 
3384
                          [section.id for section in sections])
 
3385
        self.assertEquals(['quux', 'bar/quux'],
 
3386
                          [section.extra_path for section in sections])
 
3387
 
 
3388
    def test_more_specific_sections_first(self):
 
3389
        store = self.get_store(self)
 
3390
        store._load_from_string('''
 
3391
[/foo]
 
3392
section=/foo
 
3393
[/foo/bar]
 
3394
section=/foo/bar
 
3395
''')
 
3396
        self.assertEquals(['/foo', '/foo/bar'],
 
3397
                          [section.id for _, section in store.get_sections()])
 
3398
        matcher = config.LocationMatcher(store, '/foo/bar/baz')
 
3399
        sections = [section for _, section in matcher.get_sections()]
 
3400
        self.assertEquals(['/foo/bar', '/foo'],
 
3401
                          [section.id for section in sections])
 
3402
        self.assertEquals(['baz', 'bar/baz'],
 
3403
                          [section.extra_path for section in sections])
 
3404
 
 
3405
    def test_appendpath_in_no_name_section(self):
 
3406
        # It's a bit weird to allow appendpath in a no-name section, but
 
3407
        # someone may found a use for it
 
3408
        store = self.get_store(self)
 
3409
        store._load_from_string('''
 
3410
foo=bar
 
3411
foo:policy = appendpath
 
3412
''')
 
3413
        matcher = config.LocationMatcher(store, 'dir/subdir')
 
3414
        sections = list(matcher.get_sections())
 
3415
        self.assertLength(1, sections)
 
3416
        self.assertEquals('bar/dir/subdir', sections[0][1].get('foo'))
 
3417
 
 
3418
    def test_file_urls_are_normalized(self):
 
3419
        store = self.get_store(self)
 
3420
        if sys.platform == 'win32':
 
3421
            expected_url = 'file:///C:/dir/subdir'
 
3422
            expected_location = 'C:/dir/subdir'
 
3423
        else:
 
3424
            expected_url = 'file:///dir/subdir'
 
3425
            expected_location = '/dir/subdir'
 
3426
        matcher = config.LocationMatcher(store, expected_url)
 
3427
        self.assertEquals(expected_location, matcher.location)
 
3428
 
 
3429
 
 
3430
class TestStartingPathMatcher(TestStore):
 
3431
 
 
3432
    def setUp(self):
 
3433
        super(TestStartingPathMatcher, self).setUp()
 
3434
        # Any simple store is good enough
 
3435
        self.store = config.IniFileStore()
 
3436
 
 
3437
    def assertSectionIDs(self, expected, location, content):
 
3438
        self.store._load_from_string(content)
 
3439
        matcher = config.StartingPathMatcher(self.store, location)
 
3440
        sections = list(matcher.get_sections())
 
3441
        self.assertLength(len(expected), sections)
 
3442
        self.assertEqual(expected, [section.id for _, section in sections])
 
3443
        return sections
 
3444
 
 
3445
    def test_empty(self):
 
3446
        self.assertSectionIDs([], self.get_url(), '')
 
3447
 
 
3448
    def test_url_vs_local_paths(self):
 
3449
        # The matcher location is an url and the section names are local paths
 
3450
        sections = self.assertSectionIDs(['/foo/bar', '/foo'],
 
3451
                                         'file:///foo/bar/baz', '''\
 
3452
[/foo]
 
3453
[/foo/bar]
 
3454
''')
 
3455
 
 
3456
    def test_local_path_vs_url(self):
 
3457
        # The matcher location is a local path and the section names are urls
 
3458
        sections = self.assertSectionIDs(['file:///foo/bar', 'file:///foo'],
 
3459
                                         '/foo/bar/baz', '''\
 
3460
[file:///foo]
 
3461
[file:///foo/bar]
 
3462
''')
 
3463
 
 
3464
 
 
3465
    def test_no_name_section_included_when_present(self):
 
3466
        # Note that other tests will cover the case where the no-name section
 
3467
        # is empty and as such, not included.
 
3468
        sections = self.assertSectionIDs(['/foo/bar', '/foo', None],
 
3469
                                         '/foo/bar/baz', '''\
 
3470
option = defined so the no-name section exists
 
3471
[/foo]
 
3472
[/foo/bar]
 
3473
''')
 
3474
        self.assertEquals(['baz', 'bar/baz', '/foo/bar/baz'],
 
3475
                          [s.locals['relpath'] for _, s in sections])
 
3476
 
 
3477
    def test_order_reversed(self):
 
3478
        self.assertSectionIDs(['/foo/bar', '/foo'], '/foo/bar/baz', '''\
 
3479
[/foo]
 
3480
[/foo/bar]
 
3481
''')
 
3482
 
 
3483
    def test_unrelated_section_excluded(self):
 
3484
        self.assertSectionIDs(['/foo/bar', '/foo'], '/foo/bar/baz', '''\
 
3485
[/foo]
 
3486
[/foo/qux]
 
3487
[/foo/bar]
 
3488
''')
 
3489
 
 
3490
    def test_glob_included(self):
 
3491
        sections = self.assertSectionIDs(['/foo/*/baz', '/foo/b*', '/foo'],
 
3492
                                         '/foo/bar/baz', '''\
 
3493
[/foo]
 
3494
[/foo/qux]
 
3495
[/foo/b*]
 
3496
[/foo/*/baz]
 
3497
''')
 
3498
        # Note that 'baz' as a relpath for /foo/b* is not fully correct, but
 
3499
        # nothing really is... as far using {relpath} to append it to something
 
3500
        # else, this seems good enough though.
 
3501
        self.assertEquals(['', 'baz', 'bar/baz'],
 
3502
                          [s.locals['relpath'] for _, s in sections])
 
3503
 
 
3504
    def test_respect_order(self):
 
3505
        self.assertSectionIDs(['/foo', '/foo/b*', '/foo/*/baz'],
 
3506
                              '/foo/bar/baz', '''\
 
3507
[/foo/*/baz]
 
3508
[/foo/qux]
 
3509
[/foo/b*]
 
3510
[/foo]
 
3511
''')
 
3512
 
 
3513
 
 
3514
class TestNameMatcher(TestStore):
 
3515
 
 
3516
    def setUp(self):
 
3517
        super(TestNameMatcher, self).setUp()
 
3518
        self.matcher = config.NameMatcher
 
3519
        # Any simple store is good enough
 
3520
        self.get_store = config.test_store_builder_registry.get('configobj')
 
3521
 
 
3522
    def get_matching_sections(self, name):
 
3523
        store = self.get_store(self)
 
3524
        store._load_from_string('''
 
3525
[foo]
 
3526
option=foo
 
3527
[foo/baz]
 
3528
option=foo/baz
 
3529
[bar]
 
3530
option=bar
 
3531
''')
 
3532
        matcher = self.matcher(store, name)
 
3533
        return list(matcher.get_sections())
 
3534
 
 
3535
    def test_matching(self):
 
3536
        sections = self.get_matching_sections('foo')
 
3537
        self.assertLength(1, sections)
 
3538
        self.assertSectionContent(('foo', {'option': 'foo'}), sections[0])
 
3539
 
 
3540
    def test_not_matching(self):
 
3541
        sections = self.get_matching_sections('baz')
 
3542
        self.assertLength(0, sections)
 
3543
 
 
3544
 
 
3545
class TestBaseStackGet(tests.TestCase):
 
3546
 
 
3547
    def setUp(self):
 
3548
        super(TestBaseStackGet, self).setUp()
 
3549
        self.overrideAttr(config, 'option_registry', config.OptionRegistry())
 
3550
 
 
3551
    def test_get_first_definition(self):
 
3552
        store1 = config.IniFileStore()
 
3553
        store1._load_from_string('foo=bar')
 
3554
        store2 = config.IniFileStore()
 
3555
        store2._load_from_string('foo=baz')
 
3556
        conf = config.Stack([store1.get_sections, store2.get_sections])
 
3557
        self.assertEquals('bar', conf.get('foo'))
 
3558
 
 
3559
    def test_get_with_registered_default_value(self):
 
3560
        config.option_registry.register(config.Option('foo', default='bar'))
 
3561
        conf_stack = config.Stack([])
 
3562
        self.assertEquals('bar', conf_stack.get('foo'))
 
3563
 
 
3564
    def test_get_without_registered_default_value(self):
 
3565
        config.option_registry.register(config.Option('foo'))
 
3566
        conf_stack = config.Stack([])
 
3567
        self.assertEquals(None, conf_stack.get('foo'))
 
3568
 
 
3569
    def test_get_without_default_value_for_not_registered(self):
 
3570
        conf_stack = config.Stack([])
 
3571
        self.assertEquals(None, conf_stack.get('foo'))
 
3572
 
 
3573
    def test_get_for_empty_section_callable(self):
 
3574
        conf_stack = config.Stack([lambda : []])
 
3575
        self.assertEquals(None, conf_stack.get('foo'))
 
3576
 
 
3577
    def test_get_for_broken_callable(self):
 
3578
        # Trying to use and invalid callable raises an exception on first use
 
3579
        conf_stack = config.Stack([object])
 
3580
        self.assertRaises(TypeError, conf_stack.get, 'foo')
 
3581
 
 
3582
 
 
3583
class TestStackWithSimpleStore(tests.TestCase):
 
3584
 
 
3585
    def setUp(self):
 
3586
        super(TestStackWithSimpleStore, self).setUp()
 
3587
        self.overrideAttr(config, 'option_registry', config.OptionRegistry())
 
3588
        self.registry = config.option_registry
 
3589
 
 
3590
    def get_conf(self, content=None):
 
3591
        return config.MemoryStack(content)
 
3592
 
 
3593
    def test_override_value_from_env(self):
 
3594
        self.registry.register(
 
3595
            config.Option('foo', default='bar', override_from_env=['FOO']))
 
3596
        self.overrideEnv('FOO', 'quux')
 
3597
        # Env variable provides a default taking over the option one
 
3598
        conf = self.get_conf('foo=store')
 
3599
        self.assertEquals('quux', conf.get('foo'))
 
3600
 
 
3601
    def test_first_override_value_from_env_wins(self):
 
3602
        self.registry.register(
 
3603
            config.Option('foo', default='bar',
 
3604
                          override_from_env=['NO_VALUE', 'FOO', 'BAZ']))
 
3605
        self.overrideEnv('FOO', 'foo')
 
3606
        self.overrideEnv('BAZ', 'baz')
 
3607
        # The first env var set wins
 
3608
        conf = self.get_conf('foo=store')
 
3609
        self.assertEquals('foo', conf.get('foo'))
 
3610
 
 
3611
 
 
3612
class TestMemoryStack(tests.TestCase):
 
3613
 
 
3614
    def test_get(self):
 
3615
        conf = config.MemoryStack('foo=bar')
 
3616
        self.assertEquals('bar', conf.get('foo'))
 
3617
 
 
3618
    def test_set(self):
 
3619
        conf = config.MemoryStack('foo=bar')
 
3620
        conf.set('foo', 'baz')
 
3621
        self.assertEquals('baz', conf.get('foo'))
 
3622
 
 
3623
    def test_no_content(self):
 
3624
        conf = config.MemoryStack()
 
3625
        # No content means no loading
 
3626
        self.assertFalse(conf.store.is_loaded())
 
3627
        self.assertRaises(NotImplementedError, conf.get, 'foo')
 
3628
        # But a content can still be provided
 
3629
        conf.store._load_from_string('foo=bar')
 
3630
        self.assertEquals('bar', conf.get('foo'))
 
3631
 
 
3632
 
 
3633
class TestStackWithTransport(tests.TestCaseWithTransport):
 
3634
 
 
3635
    scenarios = [(key, {'get_stack': builder}) for key, builder
 
3636
                 in config.test_stack_builder_registry.iteritems()]
 
3637
 
 
3638
 
 
3639
class TestConcreteStacks(TestStackWithTransport):
 
3640
 
 
3641
    def test_build_stack(self):
 
3642
        # Just a smoke test to help debug builders
 
3643
        stack = self.get_stack(self)
 
3644
 
 
3645
 
 
3646
class TestStackGet(TestStackWithTransport):
 
3647
 
 
3648
    def setUp(self):
 
3649
        super(TestStackGet, self).setUp()
 
3650
        self.conf = self.get_stack(self)
 
3651
 
 
3652
    def test_get_for_empty_stack(self):
 
3653
        self.assertEquals(None, self.conf.get('foo'))
 
3654
 
 
3655
    def test_get_hook(self):
 
3656
        self.conf.set('foo', 'bar')
 
3657
        calls = []
 
3658
        def hook(*args):
 
3659
            calls.append(args)
 
3660
        config.ConfigHooks.install_named_hook('get', hook, None)
 
3661
        self.assertLength(0, calls)
 
3662
        value = self.conf.get('foo')
 
3663
        self.assertEquals('bar', value)
 
3664
        self.assertLength(1, calls)
 
3665
        self.assertEquals((self.conf, 'foo', 'bar'), calls[0])
 
3666
 
 
3667
 
 
3668
class TestStackGetWithConverter(tests.TestCase):
 
3669
 
 
3670
    def setUp(self):
 
3671
        super(TestStackGetWithConverter, self).setUp()
 
3672
        self.overrideAttr(config, 'option_registry', config.OptionRegistry())
 
3673
        self.registry = config.option_registry
 
3674
 
 
3675
    def get_conf(self, content=None):
 
3676
        return config.MemoryStack(content)
 
3677
 
 
3678
    def register_bool_option(self, name, default=None, default_from_env=None):
 
3679
        b = config.Option(name, help='A boolean.',
 
3680
                          default=default, default_from_env=default_from_env,
 
3681
                          from_unicode=config.bool_from_store)
 
3682
        self.registry.register(b)
 
3683
 
 
3684
    def test_get_default_bool_None(self):
 
3685
        self.register_bool_option('foo')
 
3686
        conf = self.get_conf('')
 
3687
        self.assertEquals(None, conf.get('foo'))
 
3688
 
 
3689
    def test_get_default_bool_True(self):
 
3690
        self.register_bool_option('foo', u'True')
 
3691
        conf = self.get_conf('')
 
3692
        self.assertEquals(True, conf.get('foo'))
 
3693
 
 
3694
    def test_get_default_bool_False(self):
 
3695
        self.register_bool_option('foo', False)
 
3696
        conf = self.get_conf('')
 
3697
        self.assertEquals(False, conf.get('foo'))
 
3698
 
 
3699
    def test_get_default_bool_False_as_string(self):
 
3700
        self.register_bool_option('foo', u'False')
 
3701
        conf = self.get_conf('')
 
3702
        self.assertEquals(False, conf.get('foo'))
 
3703
 
 
3704
    def test_get_default_bool_from_env_converted(self):
 
3705
        self.register_bool_option('foo', u'True', default_from_env=['FOO'])
 
3706
        self.overrideEnv('FOO', 'False')
 
3707
        conf = self.get_conf('')
 
3708
        self.assertEquals(False, conf.get('foo'))
 
3709
 
 
3710
    def test_get_default_bool_when_conversion_fails(self):
 
3711
        self.register_bool_option('foo', default='True')
 
3712
        conf = self.get_conf('foo=invalid boolean')
 
3713
        self.assertEquals(True, conf.get('foo'))
 
3714
 
 
3715
    def register_integer_option(self, name,
 
3716
                                default=None, default_from_env=None):
 
3717
        i = config.Option(name, help='An integer.',
 
3718
                          default=default, default_from_env=default_from_env,
 
3719
                          from_unicode=config.int_from_store)
 
3720
        self.registry.register(i)
 
3721
 
 
3722
    def test_get_default_integer_None(self):
 
3723
        self.register_integer_option('foo')
 
3724
        conf = self.get_conf('')
 
3725
        self.assertEquals(None, conf.get('foo'))
 
3726
 
 
3727
    def test_get_default_integer(self):
 
3728
        self.register_integer_option('foo', 42)
 
3729
        conf = self.get_conf('')
 
3730
        self.assertEquals(42, conf.get('foo'))
 
3731
 
 
3732
    def test_get_default_integer_as_string(self):
 
3733
        self.register_integer_option('foo', u'42')
 
3734
        conf = self.get_conf('')
 
3735
        self.assertEquals(42, conf.get('foo'))
 
3736
 
 
3737
    def test_get_default_integer_from_env(self):
 
3738
        self.register_integer_option('foo', default_from_env=['FOO'])
 
3739
        self.overrideEnv('FOO', '18')
 
3740
        conf = self.get_conf('')
 
3741
        self.assertEquals(18, conf.get('foo'))
 
3742
 
 
3743
    def test_get_default_integer_when_conversion_fails(self):
 
3744
        self.register_integer_option('foo', default='12')
 
3745
        conf = self.get_conf('foo=invalid integer')
 
3746
        self.assertEquals(12, conf.get('foo'))
 
3747
 
 
3748
    def register_list_option(self, name, default=None, default_from_env=None):
 
3749
        l = config.ListOption(name, help='A list.', default=default,
 
3750
                              default_from_env=default_from_env)
 
3751
        self.registry.register(l)
 
3752
 
 
3753
    def test_get_default_list_None(self):
 
3754
        self.register_list_option('foo')
 
3755
        conf = self.get_conf('')
 
3756
        self.assertEquals(None, conf.get('foo'))
 
3757
 
 
3758
    def test_get_default_list_empty(self):
 
3759
        self.register_list_option('foo', '')
 
3760
        conf = self.get_conf('')
 
3761
        self.assertEquals([], conf.get('foo'))
 
3762
 
 
3763
    def test_get_default_list_from_env(self):
 
3764
        self.register_list_option('foo', default_from_env=['FOO'])
 
3765
        self.overrideEnv('FOO', '')
 
3766
        conf = self.get_conf('')
 
3767
        self.assertEquals([], conf.get('foo'))
 
3768
 
 
3769
    def test_get_with_list_converter_no_item(self):
 
3770
        self.register_list_option('foo', None)
 
3771
        conf = self.get_conf('foo=,')
 
3772
        self.assertEquals([], conf.get('foo'))
 
3773
 
 
3774
    def test_get_with_list_converter_many_items(self):
 
3775
        self.register_list_option('foo', None)
 
3776
        conf = self.get_conf('foo=m,o,r,e')
 
3777
        self.assertEquals(['m', 'o', 'r', 'e'], conf.get('foo'))
 
3778
 
 
3779
    def test_get_with_list_converter_embedded_spaces_many_items(self):
 
3780
        self.register_list_option('foo', None)
 
3781
        conf = self.get_conf('foo=" bar", "baz "')
 
3782
        self.assertEquals([' bar', 'baz '], conf.get('foo'))
 
3783
 
 
3784
    def test_get_with_list_converter_stripped_spaces_many_items(self):
 
3785
        self.register_list_option('foo', None)
 
3786
        conf = self.get_conf('foo= bar ,  baz ')
 
3787
        self.assertEquals(['bar', 'baz'], conf.get('foo'))
 
3788
 
 
3789
 
 
3790
class TestIterOptionRefs(tests.TestCase):
 
3791
    """iter_option_refs is a bit unusual, document some cases."""
 
3792
 
 
3793
    def assertRefs(self, expected, string):
 
3794
        self.assertEquals(expected, list(config.iter_option_refs(string)))
 
3795
 
 
3796
    def test_empty(self):
 
3797
        self.assertRefs([(False, '')], '')
 
3798
 
 
3799
    def test_no_refs(self):
 
3800
        self.assertRefs([(False, 'foo bar')], 'foo bar')
 
3801
 
 
3802
    def test_single_ref(self):
 
3803
        self.assertRefs([(False, ''), (True, '{foo}'), (False, '')], '{foo}')
 
3804
 
 
3805
    def test_broken_ref(self):
 
3806
        self.assertRefs([(False, '{foo')], '{foo')
 
3807
 
 
3808
    def test_embedded_ref(self):
 
3809
        self.assertRefs([(False, '{'), (True, '{foo}'), (False, '}')],
 
3810
                        '{{foo}}')
 
3811
 
 
3812
    def test_two_refs(self):
 
3813
        self.assertRefs([(False, ''), (True, '{foo}'),
 
3814
                         (False, ''), (True, '{bar}'),
 
3815
                         (False, ''),],
 
3816
                        '{foo}{bar}')
 
3817
 
 
3818
    def test_newline_in_refs_are_not_matched(self):
 
3819
        self.assertRefs([(False, '{\nxx}{xx\n}{{\n}}')], '{\nxx}{xx\n}{{\n}}')
 
3820
 
 
3821
 
 
3822
class TestStackExpandOptions(tests.TestCaseWithTransport):
 
3823
 
 
3824
    def setUp(self):
 
3825
        super(TestStackExpandOptions, self).setUp()
 
3826
        self.overrideAttr(config, 'option_registry', config.OptionRegistry())
 
3827
        self.registry = config.option_registry
 
3828
        self.conf = build_branch_stack(self)
 
3829
 
 
3830
    def assertExpansion(self, expected, string, env=None):
 
3831
        self.assertEquals(expected, self.conf.expand_options(string, env))
 
3832
 
 
3833
    def test_no_expansion(self):
 
3834
        self.assertExpansion('foo', 'foo')
 
3835
 
 
3836
    def test_expand_default_value(self):
 
3837
        self.conf.store._load_from_string('bar=baz')
 
3838
        self.registry.register(config.Option('foo', default=u'{bar}'))
 
3839
        self.assertEquals('baz', self.conf.get('foo', expand=True))
 
3840
 
 
3841
    def test_expand_default_from_env(self):
 
3842
        self.conf.store._load_from_string('bar=baz')
 
3843
        self.registry.register(config.Option('foo', default_from_env=['FOO']))
 
3844
        self.overrideEnv('FOO', '{bar}')
 
3845
        self.assertEquals('baz', self.conf.get('foo', expand=True))
 
3846
 
 
3847
    def test_expand_default_on_failed_conversion(self):
 
3848
        self.conf.store._load_from_string('baz=bogus\nbar=42\nfoo={baz}')
 
3849
        self.registry.register(
 
3850
            config.Option('foo', default=u'{bar}',
 
3851
                          from_unicode=config.int_from_store))
 
3852
        self.assertEquals(42, self.conf.get('foo', expand=True))
 
3853
 
 
3854
    def test_env_adding_options(self):
 
3855
        self.assertExpansion('bar', '{foo}', {'foo': 'bar'})
 
3856
 
 
3857
    def test_env_overriding_options(self):
 
3858
        self.conf.store._load_from_string('foo=baz')
 
3859
        self.assertExpansion('bar', '{foo}', {'foo': 'bar'})
 
3860
 
 
3861
    def test_simple_ref(self):
 
3862
        self.conf.store._load_from_string('foo=xxx')
 
3863
        self.assertExpansion('xxx', '{foo}')
 
3864
 
 
3865
    def test_unknown_ref(self):
 
3866
        self.assertRaises(errors.ExpandingUnknownOption,
 
3867
                          self.conf.expand_options, '{foo}')
 
3868
 
 
3869
    def test_indirect_ref(self):
 
3870
        self.conf.store._load_from_string('''
 
3871
foo=xxx
 
3872
bar={foo}
 
3873
''')
 
3874
        self.assertExpansion('xxx', '{bar}')
 
3875
 
 
3876
    def test_embedded_ref(self):
 
3877
        self.conf.store._load_from_string('''
 
3878
foo=xxx
 
3879
bar=foo
 
3880
''')
 
3881
        self.assertExpansion('xxx', '{{bar}}')
 
3882
 
 
3883
    def test_simple_loop(self):
 
3884
        self.conf.store._load_from_string('foo={foo}')
 
3885
        self.assertRaises(errors.OptionExpansionLoop,
 
3886
                          self.conf.expand_options, '{foo}')
 
3887
 
 
3888
    def test_indirect_loop(self):
 
3889
        self.conf.store._load_from_string('''
 
3890
foo={bar}
 
3891
bar={baz}
 
3892
baz={foo}''')
 
3893
        e = self.assertRaises(errors.OptionExpansionLoop,
 
3894
                              self.conf.expand_options, '{foo}')
 
3895
        self.assertEquals('foo->bar->baz', e.refs)
 
3896
        self.assertEquals('{foo}', e.string)
 
3897
 
 
3898
    def test_list(self):
 
3899
        self.conf.store._load_from_string('''
 
3900
foo=start
 
3901
bar=middle
 
3902
baz=end
 
3903
list={foo},{bar},{baz}
 
3904
''')
 
3905
        self.registry.register(
 
3906
            config.ListOption('list'))
 
3907
        self.assertEquals(['start', 'middle', 'end'],
 
3908
                           self.conf.get('list', expand=True))
 
3909
 
 
3910
    def test_cascading_list(self):
 
3911
        self.conf.store._load_from_string('''
 
3912
foo=start,{bar}
 
3913
bar=middle,{baz}
 
3914
baz=end
 
3915
list={foo}
 
3916
''')
 
3917
        self.registry.register(
 
3918
            config.ListOption('list'))
 
3919
        self.assertEquals(['start', 'middle', 'end'],
 
3920
                           self.conf.get('list', expand=True))
 
3921
 
 
3922
    def test_pathologically_hidden_list(self):
 
3923
        self.conf.store._load_from_string('''
 
3924
foo=bin
 
3925
bar=go
 
3926
start={foo
 
3927
middle=},{
 
3928
end=bar}
 
3929
hidden={start}{middle}{end}
 
3930
''')
 
3931
        # What matters is what the registration says, the conversion happens
 
3932
        # only after all expansions have been performed
 
3933
        self.registry.register(config.ListOption('hidden'))
 
3934
        self.assertEquals(['bin', 'go'],
 
3935
                          self.conf.get('hidden', expand=True))
 
3936
 
 
3937
 
 
3938
class TestStackCrossSectionsExpand(tests.TestCaseWithTransport):
 
3939
 
 
3940
    def setUp(self):
 
3941
        super(TestStackCrossSectionsExpand, self).setUp()
 
3942
 
 
3943
    def get_config(self, location, string):
 
3944
        if string is None:
 
3945
            string = ''
 
3946
        # Since we don't save the config we won't strictly require to inherit
 
3947
        # from TestCaseInTempDir, but an error occurs so quickly...
 
3948
        c = config.LocationStack(location)
 
3949
        c.store._load_from_string(string)
 
3950
        return c
 
3951
 
 
3952
    def test_dont_cross_unrelated_section(self):
 
3953
        c = self.get_config('/another/branch/path','''
 
3954
[/one/branch/path]
 
3955
foo = hello
 
3956
bar = {foo}/2
 
3957
 
 
3958
[/another/branch/path]
 
3959
bar = {foo}/2
 
3960
''')
 
3961
        self.assertRaises(errors.ExpandingUnknownOption,
 
3962
                          c.get, 'bar', expand=True)
 
3963
 
 
3964
    def test_cross_related_sections(self):
 
3965
        c = self.get_config('/project/branch/path','''
 
3966
[/project]
 
3967
foo = qu
 
3968
 
 
3969
[/project/branch/path]
 
3970
bar = {foo}ux
 
3971
''')
 
3972
        self.assertEquals('quux', c.get('bar', expand=True))
 
3973
 
 
3974
 
 
3975
class TestStackCrossStoresExpand(tests.TestCaseWithTransport):
 
3976
 
 
3977
    def test_cross_global_locations(self):
 
3978
        l_store = config.LocationStore()
 
3979
        l_store._load_from_string('''
 
3980
[/branch]
 
3981
lfoo = loc-foo
 
3982
lbar = {gbar}
 
3983
''')
 
3984
        l_store.save()
 
3985
        g_store = config.GlobalStore()
 
3986
        g_store._load_from_string('''
 
3987
[DEFAULT]
 
3988
gfoo = {lfoo}
 
3989
gbar = glob-bar
 
3990
''')
 
3991
        g_store.save()
 
3992
        stack = config.LocationStack('/branch')
 
3993
        self.assertEquals('glob-bar', stack.get('lbar', expand=True))
 
3994
        self.assertEquals('loc-foo', stack.get('gfoo', expand=True))
 
3995
 
 
3996
 
 
3997
class TestStackExpandSectionLocals(tests.TestCaseWithTransport):
 
3998
 
 
3999
    def test_expand_locals_empty(self):
 
4000
        l_store = config.LocationStore()
 
4001
        l_store._load_from_string('''
 
4002
[/home/user/project]
 
4003
base = {basename}
 
4004
rel = {relpath}
 
4005
''')
 
4006
        l_store.save()
 
4007
        stack = config.LocationStack('/home/user/project/')
 
4008
        self.assertEquals('', stack.get('base', expand=True))
 
4009
        self.assertEquals('', stack.get('rel', expand=True))
 
4010
 
 
4011
    def test_expand_basename_locally(self):
 
4012
        l_store = config.LocationStore()
 
4013
        l_store._load_from_string('''
 
4014
[/home/user/project]
 
4015
bfoo = {basename}
 
4016
''')
 
4017
        l_store.save()
 
4018
        stack = config.LocationStack('/home/user/project/branch')
 
4019
        self.assertEquals('branch', stack.get('bfoo', expand=True))
 
4020
 
 
4021
    def test_expand_basename_locally_longer_path(self):
 
4022
        l_store = config.LocationStore()
 
4023
        l_store._load_from_string('''
 
4024
[/home/user]
 
4025
bfoo = {basename}
 
4026
''')
 
4027
        l_store.save()
 
4028
        stack = config.LocationStack('/home/user/project/dir/branch')
 
4029
        self.assertEquals('branch', stack.get('bfoo', expand=True))
 
4030
 
 
4031
    def test_expand_relpath_locally(self):
 
4032
        l_store = config.LocationStore()
 
4033
        l_store._load_from_string('''
 
4034
[/home/user/project]
 
4035
lfoo = loc-foo/{relpath}
 
4036
''')
 
4037
        l_store.save()
 
4038
        stack = config.LocationStack('/home/user/project/branch')
 
4039
        self.assertEquals('loc-foo/branch', stack.get('lfoo', expand=True))
 
4040
 
 
4041
    def test_expand_relpath_unknonw_in_global(self):
 
4042
        g_store = config.GlobalStore()
 
4043
        g_store._load_from_string('''
 
4044
[DEFAULT]
 
4045
gfoo = {relpath}
 
4046
''')
 
4047
        g_store.save()
 
4048
        stack = config.LocationStack('/home/user/project/branch')
 
4049
        self.assertRaises(errors.ExpandingUnknownOption,
 
4050
                          stack.get, 'gfoo', expand=True)
 
4051
 
 
4052
    def test_expand_local_option_locally(self):
 
4053
        l_store = config.LocationStore()
 
4054
        l_store._load_from_string('''
 
4055
[/home/user/project]
 
4056
lfoo = loc-foo/{relpath}
 
4057
lbar = {gbar}
 
4058
''')
 
4059
        l_store.save()
 
4060
        g_store = config.GlobalStore()
 
4061
        g_store._load_from_string('''
 
4062
[DEFAULT]
 
4063
gfoo = {lfoo}
 
4064
gbar = glob-bar
 
4065
''')
 
4066
        g_store.save()
 
4067
        stack = config.LocationStack('/home/user/project/branch')
 
4068
        self.assertEquals('glob-bar', stack.get('lbar', expand=True))
 
4069
        self.assertEquals('loc-foo/branch', stack.get('gfoo', expand=True))
 
4070
 
 
4071
    def test_locals_dont_leak(self):
 
4072
        """Make sure we chose the right local in presence of several sections.
 
4073
        """
 
4074
        l_store = config.LocationStore()
 
4075
        l_store._load_from_string('''
 
4076
[/home/user]
 
4077
lfoo = loc-foo/{relpath}
 
4078
[/home/user/project]
 
4079
lfoo = loc-foo/{relpath}
 
4080
''')
 
4081
        l_store.save()
 
4082
        stack = config.LocationStack('/home/user/project/branch')
 
4083
        self.assertEquals('loc-foo/branch', stack.get('lfoo', expand=True))
 
4084
        stack = config.LocationStack('/home/user/bar/baz')
 
4085
        self.assertEquals('loc-foo/bar/baz', stack.get('lfoo', expand=True))
 
4086
 
 
4087
 
 
4088
 
 
4089
class TestStackSet(TestStackWithTransport):
 
4090
 
 
4091
    def test_simple_set(self):
 
4092
        conf = self.get_stack(self)
 
4093
        self.assertEquals(None, conf.get('foo'))
 
4094
        conf.set('foo', 'baz')
 
4095
        # Did we get it back ?
 
4096
        self.assertEquals('baz', conf.get('foo'))
 
4097
 
 
4098
    def test_set_creates_a_new_section(self):
 
4099
        conf = self.get_stack(self)
 
4100
        conf.set('foo', 'baz')
 
4101
        self.assertEquals, 'baz', conf.get('foo')
 
4102
 
 
4103
    def test_set_hook(self):
 
4104
        calls = []
 
4105
        def hook(*args):
 
4106
            calls.append(args)
 
4107
        config.ConfigHooks.install_named_hook('set', hook, None)
 
4108
        self.assertLength(0, calls)
 
4109
        conf = self.get_stack(self)
 
4110
        conf.set('foo', 'bar')
 
4111
        self.assertLength(1, calls)
 
4112
        self.assertEquals((conf, 'foo', 'bar'), calls[0])
 
4113
 
 
4114
 
 
4115
class TestStackRemove(TestStackWithTransport):
 
4116
 
 
4117
    def test_remove_existing(self):
 
4118
        conf = self.get_stack(self)
 
4119
        conf.set('foo', 'bar')
 
4120
        self.assertEquals('bar', conf.get('foo'))
 
4121
        conf.remove('foo')
 
4122
        # Did we get it back ?
 
4123
        self.assertEquals(None, conf.get('foo'))
 
4124
 
 
4125
    def test_remove_unknown(self):
 
4126
        conf = self.get_stack(self)
 
4127
        self.assertRaises(KeyError, conf.remove, 'I_do_not_exist')
 
4128
 
 
4129
    def test_remove_hook(self):
 
4130
        calls = []
 
4131
        def hook(*args):
 
4132
            calls.append(args)
 
4133
        config.ConfigHooks.install_named_hook('remove', hook, None)
 
4134
        self.assertLength(0, calls)
 
4135
        conf = self.get_stack(self)
 
4136
        conf.set('foo', 'bar')
 
4137
        conf.remove('foo')
 
4138
        self.assertLength(1, calls)
 
4139
        self.assertEquals((conf, 'foo'), calls[0])
 
4140
 
 
4141
 
 
4142
class TestConfigGetOptions(tests.TestCaseWithTransport, TestOptionsMixin):
 
4143
 
 
4144
    def setUp(self):
 
4145
        super(TestConfigGetOptions, self).setUp()
 
4146
        create_configs(self)
 
4147
 
 
4148
    def test_no_variable(self):
 
4149
        # Using branch should query branch, locations and bazaar
 
4150
        self.assertOptions([], self.branch_config)
 
4151
 
 
4152
    def test_option_in_bazaar(self):
 
4153
        self.bazaar_config.set_user_option('file', 'bazaar')
 
4154
        self.assertOptions([('file', 'bazaar', 'DEFAULT', 'bazaar')],
 
4155
                           self.bazaar_config)
 
4156
 
 
4157
    def test_option_in_locations(self):
 
4158
        self.locations_config.set_user_option('file', 'locations')
 
4159
        self.assertOptions(
 
4160
            [('file', 'locations', self.tree.basedir, 'locations')],
 
4161
            self.locations_config)
 
4162
 
 
4163
    def test_option_in_branch(self):
 
4164
        self.branch_config.set_user_option('file', 'branch')
 
4165
        self.assertOptions([('file', 'branch', 'DEFAULT', 'branch')],
 
4166
                           self.branch_config)
 
4167
 
 
4168
    def test_option_in_bazaar_and_branch(self):
 
4169
        self.bazaar_config.set_user_option('file', 'bazaar')
 
4170
        self.branch_config.set_user_option('file', 'branch')
 
4171
        self.assertOptions([('file', 'branch', 'DEFAULT', 'branch'),
 
4172
                            ('file', 'bazaar', 'DEFAULT', 'bazaar'),],
 
4173
                           self.branch_config)
 
4174
 
 
4175
    def test_option_in_branch_and_locations(self):
 
4176
        # Hmm, locations override branch :-/
 
4177
        self.locations_config.set_user_option('file', 'locations')
 
4178
        self.branch_config.set_user_option('file', 'branch')
 
4179
        self.assertOptions(
 
4180
            [('file', 'locations', self.tree.basedir, 'locations'),
 
4181
             ('file', 'branch', 'DEFAULT', 'branch'),],
 
4182
            self.branch_config)
 
4183
 
 
4184
    def test_option_in_bazaar_locations_and_branch(self):
 
4185
        self.bazaar_config.set_user_option('file', 'bazaar')
 
4186
        self.locations_config.set_user_option('file', 'locations')
 
4187
        self.branch_config.set_user_option('file', 'branch')
 
4188
        self.assertOptions(
 
4189
            [('file', 'locations', self.tree.basedir, 'locations'),
 
4190
             ('file', 'branch', 'DEFAULT', 'branch'),
 
4191
             ('file', 'bazaar', 'DEFAULT', 'bazaar'),],
 
4192
            self.branch_config)
 
4193
 
 
4194
 
 
4195
class TestConfigRemoveOption(tests.TestCaseWithTransport, TestOptionsMixin):
 
4196
 
 
4197
    def setUp(self):
 
4198
        super(TestConfigRemoveOption, self).setUp()
 
4199
        create_configs_with_file_option(self)
 
4200
 
 
4201
    def test_remove_in_locations(self):
 
4202
        self.locations_config.remove_user_option('file', self.tree.basedir)
 
4203
        self.assertOptions(
 
4204
            [('file', 'branch', 'DEFAULT', 'branch'),
 
4205
             ('file', 'bazaar', 'DEFAULT', 'bazaar'),],
 
4206
            self.branch_config)
 
4207
 
 
4208
    def test_remove_in_branch(self):
 
4209
        self.branch_config.remove_user_option('file')
 
4210
        self.assertOptions(
 
4211
            [('file', 'locations', self.tree.basedir, 'locations'),
 
4212
             ('file', 'bazaar', 'DEFAULT', 'bazaar'),],
 
4213
            self.branch_config)
 
4214
 
 
4215
    def test_remove_in_bazaar(self):
 
4216
        self.bazaar_config.remove_user_option('file')
 
4217
        self.assertOptions(
 
4218
            [('file', 'locations', self.tree.basedir, 'locations'),
 
4219
             ('file', 'branch', 'DEFAULT', 'branch'),],
 
4220
            self.branch_config)
 
4221
 
 
4222
 
 
4223
class TestConfigGetSections(tests.TestCaseWithTransport):
 
4224
 
 
4225
    def setUp(self):
 
4226
        super(TestConfigGetSections, self).setUp()
 
4227
        create_configs(self)
 
4228
 
 
4229
    def assertSectionNames(self, expected, conf, name=None):
 
4230
        """Check which sections are returned for a given config.
 
4231
 
 
4232
        If fallback configurations exist their sections can be included.
 
4233
 
 
4234
        :param expected: A list of section names.
 
4235
 
 
4236
        :param conf: The configuration that will be queried.
 
4237
 
 
4238
        :param name: An optional section name that will be passed to
 
4239
            get_sections().
 
4240
        """
 
4241
        sections = list(conf._get_sections(name))
 
4242
        self.assertLength(len(expected), sections)
 
4243
        self.assertEqual(expected, [name for name, _, _ in sections])
 
4244
 
 
4245
    def test_bazaar_default_section(self):
 
4246
        self.assertSectionNames(['DEFAULT'], self.bazaar_config)
 
4247
 
 
4248
    def test_locations_default_section(self):
 
4249
        # No sections are defined in an empty file
 
4250
        self.assertSectionNames([], self.locations_config)
 
4251
 
 
4252
    def test_locations_named_section(self):
 
4253
        self.locations_config.set_user_option('file', 'locations')
 
4254
        self.assertSectionNames([self.tree.basedir], self.locations_config)
 
4255
 
 
4256
    def test_locations_matching_sections(self):
 
4257
        loc_config = self.locations_config
 
4258
        loc_config.set_user_option('file', 'locations')
 
4259
        # We need to cheat a bit here to create an option in sections above and
 
4260
        # below the 'location' one.
 
4261
        parser = loc_config._get_parser()
 
4262
        # locations.cong deals with '/' ignoring native os.sep
 
4263
        location_names = self.tree.basedir.split('/')
 
4264
        parent = '/'.join(location_names[:-1])
 
4265
        child = '/'.join(location_names + ['child'])
 
4266
        parser[parent] = {}
 
4267
        parser[parent]['file'] = 'parent'
 
4268
        parser[child] = {}
 
4269
        parser[child]['file'] = 'child'
 
4270
        self.assertSectionNames([self.tree.basedir, parent], loc_config)
 
4271
 
 
4272
    def test_branch_data_default_section(self):
 
4273
        self.assertSectionNames([None],
 
4274
                                self.branch_config._get_branch_data_config())
 
4275
 
 
4276
    def test_branch_default_sections(self):
 
4277
        # No sections are defined in an empty locations file
 
4278
        self.assertSectionNames([None, 'DEFAULT'],
 
4279
                                self.branch_config)
 
4280
        # Unless we define an option
 
4281
        self.branch_config._get_location_config().set_user_option(
 
4282
            'file', 'locations')
 
4283
        self.assertSectionNames([self.tree.basedir, None, 'DEFAULT'],
 
4284
                                self.branch_config)
 
4285
 
 
4286
    def test_bazaar_named_section(self):
 
4287
        # We need to cheat as the API doesn't give direct access to sections
 
4288
        # other than DEFAULT.
 
4289
        self.bazaar_config.set_alias('bazaar', 'bzr')
 
4290
        self.assertSectionNames(['ALIASES'], self.bazaar_config, 'ALIASES')
 
4291
 
 
4292
 
 
4293
class TestAuthenticationConfigFile(tests.TestCase):
 
4294
    """Test the authentication.conf file matching"""
 
4295
 
 
4296
    def _got_user_passwd(self, expected_user, expected_password,
 
4297
                         config, *args, **kwargs):
 
4298
        credentials = config.get_credentials(*args, **kwargs)
 
4299
        if credentials is None:
 
4300
            user = None
 
4301
            password = None
 
4302
        else:
 
4303
            user = credentials['user']
 
4304
            password = credentials['password']
 
4305
        self.assertEquals(expected_user, user)
 
4306
        self.assertEquals(expected_password, password)
 
4307
 
 
4308
    def test_empty_config(self):
 
4309
        conf = config.AuthenticationConfig(_file=StringIO())
 
4310
        self.assertEquals({}, conf._get_config())
 
4311
        self._got_user_passwd(None, None, conf, 'http', 'foo.net')
 
4312
 
 
4313
    def test_non_utf8_config(self):
 
4314
        conf = config.AuthenticationConfig(_file=StringIO(
 
4315
                'foo = bar\xff'))
 
4316
        self.assertRaises(errors.ConfigContentError, conf._get_config)
 
4317
 
 
4318
    def test_missing_auth_section_header(self):
 
4319
        conf = config.AuthenticationConfig(_file=StringIO('foo = bar'))
 
4320
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
 
4321
 
 
4322
    def test_auth_section_header_not_closed(self):
 
4323
        conf = config.AuthenticationConfig(_file=StringIO('[DEF'))
 
4324
        self.assertRaises(errors.ParseConfigError, conf._get_config)
 
4325
 
 
4326
    def test_auth_value_not_boolean(self):
 
4327
        conf = config.AuthenticationConfig(_file=StringIO(
 
4328
                """[broken]
 
4329
scheme=ftp
 
4330
user=joe
 
4331
verify_certificates=askme # Error: Not a boolean
 
4332
"""))
 
4333
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
 
4334
 
 
4335
    def test_auth_value_not_int(self):
 
4336
        conf = config.AuthenticationConfig(_file=StringIO(
 
4337
                """[broken]
 
4338
scheme=ftp
 
4339
user=joe
 
4340
port=port # Error: Not an int
 
4341
"""))
 
4342
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
 
4343
 
 
4344
    def test_unknown_password_encoding(self):
 
4345
        conf = config.AuthenticationConfig(_file=StringIO(
 
4346
                """[broken]
 
4347
scheme=ftp
 
4348
user=joe
 
4349
password_encoding=unknown
 
4350
"""))
 
4351
        self.assertRaises(ValueError, conf.get_password,
 
4352
                          'ftp', 'foo.net', 'joe')
 
4353
 
 
4354
    def test_credentials_for_scheme_host(self):
 
4355
        conf = config.AuthenticationConfig(_file=StringIO(
 
4356
                """# Identity on foo.net
 
4357
[ftp definition]
 
4358
scheme=ftp
 
4359
host=foo.net
 
4360
user=joe
 
4361
password=secret-pass
 
4362
"""))
 
4363
        # Basic matching
 
4364
        self._got_user_passwd('joe', 'secret-pass', conf, 'ftp', 'foo.net')
 
4365
        # different scheme
 
4366
        self._got_user_passwd(None, None, conf, 'http', 'foo.net')
 
4367
        # different host
 
4368
        self._got_user_passwd(None, None, conf, 'ftp', 'bar.net')
 
4369
 
 
4370
    def test_credentials_for_host_port(self):
 
4371
        conf = config.AuthenticationConfig(_file=StringIO(
 
4372
                """# Identity on foo.net
 
4373
[ftp definition]
 
4374
scheme=ftp
 
4375
port=10021
 
4376
host=foo.net
 
4377
user=joe
 
4378
password=secret-pass
 
4379
"""))
 
4380
        # No port
 
4381
        self._got_user_passwd('joe', 'secret-pass',
 
4382
                              conf, 'ftp', 'foo.net', port=10021)
 
4383
        # different port
 
4384
        self._got_user_passwd(None, None, conf, 'ftp', 'foo.net')
 
4385
 
 
4386
    def test_for_matching_host(self):
 
4387
        conf = config.AuthenticationConfig(_file=StringIO(
 
4388
                """# Identity on foo.net
 
4389
[sourceforge]
 
4390
scheme=bzr
 
4391
host=bzr.sf.net
 
4392
user=joe
 
4393
password=joepass
 
4394
[sourceforge domain]
 
4395
scheme=bzr
 
4396
host=.bzr.sf.net
 
4397
user=georges
 
4398
password=bendover
 
4399
"""))
 
4400
        # matching domain
 
4401
        self._got_user_passwd('georges', 'bendover',
 
4402
                              conf, 'bzr', 'foo.bzr.sf.net')
 
4403
        # phishing attempt
 
4404
        self._got_user_passwd(None, None,
 
4405
                              conf, 'bzr', 'bbzr.sf.net')
 
4406
 
 
4407
    def test_for_matching_host_None(self):
 
4408
        conf = config.AuthenticationConfig(_file=StringIO(
 
4409
                """# Identity on foo.net
 
4410
[catchup bzr]
 
4411
scheme=bzr
 
4412
user=joe
 
4413
password=joepass
 
4414
[DEFAULT]
 
4415
user=georges
 
4416
password=bendover
 
4417
"""))
 
4418
        # match no host
 
4419
        self._got_user_passwd('joe', 'joepass',
 
4420
                              conf, 'bzr', 'quux.net')
 
4421
        # no host but different scheme
 
4422
        self._got_user_passwd('georges', 'bendover',
 
4423
                              conf, 'ftp', 'quux.net')
 
4424
 
 
4425
    def test_credentials_for_path(self):
 
4426
        conf = config.AuthenticationConfig(_file=StringIO(
 
4427
                """
 
4428
[http dir1]
 
4429
scheme=http
 
4430
host=bar.org
 
4431
path=/dir1
 
4432
user=jim
 
4433
password=jimpass
 
4434
[http dir2]
 
4435
scheme=http
 
4436
host=bar.org
 
4437
path=/dir2
 
4438
user=georges
 
4439
password=bendover
 
4440
"""))
 
4441
        # no path no dice
 
4442
        self._got_user_passwd(None, None,
 
4443
                              conf, 'http', host='bar.org', path='/dir3')
 
4444
        # matching path
 
4445
        self._got_user_passwd('georges', 'bendover',
 
4446
                              conf, 'http', host='bar.org', path='/dir2')
 
4447
        # matching subdir
 
4448
        self._got_user_passwd('jim', 'jimpass',
 
4449
                              conf, 'http', host='bar.org',path='/dir1/subdir')
 
4450
 
 
4451
    def test_credentials_for_user(self):
 
4452
        conf = config.AuthenticationConfig(_file=StringIO(
 
4453
                """
 
4454
[with user]
 
4455
scheme=http
 
4456
host=bar.org
 
4457
user=jim
 
4458
password=jimpass
 
4459
"""))
 
4460
        # Get user
 
4461
        self._got_user_passwd('jim', 'jimpass',
 
4462
                              conf, 'http', 'bar.org')
 
4463
        # Get same user
 
4464
        self._got_user_passwd('jim', 'jimpass',
 
4465
                              conf, 'http', 'bar.org', user='jim')
 
4466
        # Don't get a different user if one is specified
 
4467
        self._got_user_passwd(None, None,
 
4468
                              conf, 'http', 'bar.org', user='georges')
 
4469
 
 
4470
    def test_credentials_for_user_without_password(self):
 
4471
        conf = config.AuthenticationConfig(_file=StringIO(
 
4472
                """
 
4473
[without password]
 
4474
scheme=http
 
4475
host=bar.org
 
4476
user=jim
 
4477
"""))
 
4478
        # Get user but no password
 
4479
        self._got_user_passwd('jim', None,
 
4480
                              conf, 'http', 'bar.org')
 
4481
 
 
4482
    def test_verify_certificates(self):
 
4483
        conf = config.AuthenticationConfig(_file=StringIO(
 
4484
                """
 
4485
[self-signed]
 
4486
scheme=https
 
4487
host=bar.org
 
4488
user=jim
 
4489
password=jimpass
 
4490
verify_certificates=False
 
4491
[normal]
 
4492
scheme=https
 
4493
host=foo.net
 
4494
user=georges
 
4495
password=bendover
 
4496
"""))
 
4497
        credentials = conf.get_credentials('https', 'bar.org')
 
4498
        self.assertEquals(False, credentials.get('verify_certificates'))
 
4499
        credentials = conf.get_credentials('https', 'foo.net')
 
4500
        self.assertEquals(True, credentials.get('verify_certificates'))
 
4501
 
 
4502
 
 
4503
class TestAuthenticationStorage(tests.TestCaseInTempDir):
 
4504
 
 
4505
    def test_set_credentials(self):
 
4506
        conf = config.AuthenticationConfig()
 
4507
        conf.set_credentials('name', 'host', 'user', 'scheme', 'password',
 
4508
        99, path='/foo', verify_certificates=False, realm='realm')
 
4509
        credentials = conf.get_credentials(host='host', scheme='scheme',
 
4510
                                           port=99, path='/foo',
 
4511
                                           realm='realm')
 
4512
        CREDENTIALS = {'name': 'name', 'user': 'user', 'password': 'password',
 
4513
                       'verify_certificates': False, 'scheme': 'scheme', 
 
4514
                       'host': 'host', 'port': 99, 'path': '/foo', 
 
4515
                       'realm': 'realm'}
 
4516
        self.assertEqual(CREDENTIALS, credentials)
 
4517
        credentials_from_disk = config.AuthenticationConfig().get_credentials(
 
4518
            host='host', scheme='scheme', port=99, path='/foo', realm='realm')
 
4519
        self.assertEqual(CREDENTIALS, credentials_from_disk)
 
4520
 
 
4521
    def test_reset_credentials_different_name(self):
 
4522
        conf = config.AuthenticationConfig()
 
4523
        conf.set_credentials('name', 'host', 'user', 'scheme', 'password'),
 
4524
        conf.set_credentials('name2', 'host', 'user2', 'scheme', 'password'),
 
4525
        self.assertIs(None, conf._get_config().get('name'))
 
4526
        credentials = conf.get_credentials(host='host', scheme='scheme')
 
4527
        CREDENTIALS = {'name': 'name2', 'user': 'user2', 'password':
 
4528
                       'password', 'verify_certificates': True, 
 
4529
                       'scheme': 'scheme', 'host': 'host', 'port': None, 
 
4530
                       'path': None, 'realm': None}
 
4531
        self.assertEqual(CREDENTIALS, credentials)
 
4532
 
 
4533
 
 
4534
class TestAuthenticationConfig(tests.TestCase):
 
4535
    """Test AuthenticationConfig behaviour"""
 
4536
 
 
4537
    def _check_default_password_prompt(self, expected_prompt_format, scheme,
 
4538
                                       host=None, port=None, realm=None,
 
4539
                                       path=None):
 
4540
        if host is None:
 
4541
            host = 'bar.org'
 
4542
        user, password = 'jim', 'precious'
 
4543
        expected_prompt = expected_prompt_format % {
 
4544
            'scheme': scheme, 'host': host, 'port': port,
 
4545
            'user': user, 'realm': realm}
 
4546
 
 
4547
        stdout = tests.StringIOWrapper()
 
4548
        stderr = tests.StringIOWrapper()
 
4549
        ui.ui_factory = tests.TestUIFactory(stdin=password + '\n',
 
4550
                                            stdout=stdout, stderr=stderr)
 
4551
        # We use an empty conf so that the user is always prompted
 
4552
        conf = config.AuthenticationConfig()
 
4553
        self.assertEquals(password,
 
4554
                          conf.get_password(scheme, host, user, port=port,
 
4555
                                            realm=realm, path=path))
 
4556
        self.assertEquals(expected_prompt, stderr.getvalue())
 
4557
        self.assertEquals('', stdout.getvalue())
 
4558
 
 
4559
    def _check_default_username_prompt(self, expected_prompt_format, scheme,
 
4560
                                       host=None, port=None, realm=None,
 
4561
                                       path=None):
 
4562
        if host is None:
 
4563
            host = 'bar.org'
 
4564
        username = 'jim'
 
4565
        expected_prompt = expected_prompt_format % {
 
4566
            'scheme': scheme, 'host': host, 'port': port,
 
4567
            'realm': realm}
 
4568
        stdout = tests.StringIOWrapper()
 
4569
        stderr = tests.StringIOWrapper()
 
4570
        ui.ui_factory = tests.TestUIFactory(stdin=username+ '\n',
 
4571
                                            stdout=stdout, stderr=stderr)
 
4572
        # We use an empty conf so that the user is always prompted
 
4573
        conf = config.AuthenticationConfig()
 
4574
        self.assertEquals(username, conf.get_user(scheme, host, port=port,
 
4575
                          realm=realm, path=path, ask=True))
 
4576
        self.assertEquals(expected_prompt, stderr.getvalue())
 
4577
        self.assertEquals('', stdout.getvalue())
 
4578
 
 
4579
    def test_username_defaults_prompts(self):
 
4580
        # HTTP prompts can't be tested here, see test_http.py
 
4581
        self._check_default_username_prompt(u'FTP %(host)s username: ', 'ftp')
 
4582
        self._check_default_username_prompt(
 
4583
            u'FTP %(host)s:%(port)d username: ', 'ftp', port=10020)
 
4584
        self._check_default_username_prompt(
 
4585
            u'SSH %(host)s:%(port)d username: ', 'ssh', port=12345)
 
4586
 
 
4587
    def test_username_default_no_prompt(self):
 
4588
        conf = config.AuthenticationConfig()
 
4589
        self.assertEquals(None,
 
4590
            conf.get_user('ftp', 'example.com'))
 
4591
        self.assertEquals("explicitdefault",
 
4592
            conf.get_user('ftp', 'example.com', default="explicitdefault"))
 
4593
 
 
4594
    def test_password_default_prompts(self):
 
4595
        # HTTP prompts can't be tested here, see test_http.py
 
4596
        self._check_default_password_prompt(
 
4597
            u'FTP %(user)s@%(host)s password: ', 'ftp')
 
4598
        self._check_default_password_prompt(
 
4599
            u'FTP %(user)s@%(host)s:%(port)d password: ', 'ftp', port=10020)
 
4600
        self._check_default_password_prompt(
 
4601
            u'SSH %(user)s@%(host)s:%(port)d password: ', 'ssh', port=12345)
 
4602
        # SMTP port handling is a bit special (it's handled if embedded in the
 
4603
        # host too)
 
4604
        # FIXME: should we: forbid that, extend it to other schemes, leave
 
4605
        # things as they are that's fine thank you ?
 
4606
        self._check_default_password_prompt(
 
4607
            u'SMTP %(user)s@%(host)s password: ', 'smtp')
 
4608
        self._check_default_password_prompt(
 
4609
            u'SMTP %(user)s@%(host)s password: ', 'smtp', host='bar.org:10025')
 
4610
        self._check_default_password_prompt(
 
4611
            u'SMTP %(user)s@%(host)s:%(port)d password: ', 'smtp', port=10025)
 
4612
 
 
4613
    def test_ssh_password_emits_warning(self):
 
4614
        conf = config.AuthenticationConfig(_file=StringIO(
 
4615
                """
 
4616
[ssh with password]
 
4617
scheme=ssh
 
4618
host=bar.org
 
4619
user=jim
 
4620
password=jimpass
 
4621
"""))
 
4622
        entered_password = 'typed-by-hand'
 
4623
        stdout = tests.StringIOWrapper()
 
4624
        stderr = tests.StringIOWrapper()
 
4625
        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
 
4626
                                            stdout=stdout, stderr=stderr)
 
4627
 
 
4628
        # Since the password defined in the authentication config is ignored,
 
4629
        # the user is prompted
 
4630
        self.assertEquals(entered_password,
 
4631
                          conf.get_password('ssh', 'bar.org', user='jim'))
 
4632
        self.assertContainsRe(
 
4633
            self.get_log(),
 
4634
            'password ignored in section \[ssh with password\]')
 
4635
 
 
4636
    def test_ssh_without_password_doesnt_emit_warning(self):
 
4637
        conf = config.AuthenticationConfig(_file=StringIO(
 
4638
                """
 
4639
[ssh with password]
 
4640
scheme=ssh
 
4641
host=bar.org
 
4642
user=jim
 
4643
"""))
 
4644
        entered_password = 'typed-by-hand'
 
4645
        stdout = tests.StringIOWrapper()
 
4646
        stderr = tests.StringIOWrapper()
 
4647
        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
 
4648
                                            stdout=stdout,
 
4649
                                            stderr=stderr)
 
4650
 
 
4651
        # Since the password defined in the authentication config is ignored,
 
4652
        # the user is prompted
 
4653
        self.assertEquals(entered_password,
 
4654
                          conf.get_password('ssh', 'bar.org', user='jim'))
 
4655
        # No warning shoud be emitted since there is no password. We are only
 
4656
        # providing "user".
 
4657
        self.assertNotContainsRe(
 
4658
            self.get_log(),
 
4659
            'password ignored in section \[ssh with password\]')
 
4660
 
 
4661
    def test_uses_fallback_stores(self):
 
4662
        self.overrideAttr(config, 'credential_store_registry',
 
4663
                          config.CredentialStoreRegistry())
 
4664
        store = StubCredentialStore()
 
4665
        store.add_credentials("http", "example.com", "joe", "secret")
 
4666
        config.credential_store_registry.register("stub", store, fallback=True)
 
4667
        conf = config.AuthenticationConfig(_file=StringIO())
 
4668
        creds = conf.get_credentials("http", "example.com")
 
4669
        self.assertEquals("joe", creds["user"])
 
4670
        self.assertEquals("secret", creds["password"])
 
4671
 
 
4672
 
 
4673
class StubCredentialStore(config.CredentialStore):
 
4674
 
 
4675
    def __init__(self):
 
4676
        self._username = {}
 
4677
        self._password = {}
 
4678
 
 
4679
    def add_credentials(self, scheme, host, user, password=None):
 
4680
        self._username[(scheme, host)] = user
 
4681
        self._password[(scheme, host)] = password
 
4682
 
 
4683
    def get_credentials(self, scheme, host, port=None, user=None,
 
4684
        path=None, realm=None):
 
4685
        key = (scheme, host)
 
4686
        if not key in self._username:
 
4687
            return None
 
4688
        return { "scheme": scheme, "host": host, "port": port,
 
4689
                "user": self._username[key], "password": self._password[key]}
 
4690
 
 
4691
 
 
4692
class CountingCredentialStore(config.CredentialStore):
 
4693
 
 
4694
    def __init__(self):
 
4695
        self._calls = 0
 
4696
 
 
4697
    def get_credentials(self, scheme, host, port=None, user=None,
 
4698
        path=None, realm=None):
 
4699
        self._calls += 1
 
4700
        return None
 
4701
 
 
4702
 
 
4703
class TestCredentialStoreRegistry(tests.TestCase):
 
4704
 
 
4705
    def _get_cs_registry(self):
 
4706
        return config.credential_store_registry
 
4707
 
 
4708
    def test_default_credential_store(self):
 
4709
        r = self._get_cs_registry()
 
4710
        default = r.get_credential_store(None)
 
4711
        self.assertIsInstance(default, config.PlainTextCredentialStore)
 
4712
 
 
4713
    def test_unknown_credential_store(self):
 
4714
        r = self._get_cs_registry()
 
4715
        # It's hard to imagine someone creating a credential store named
 
4716
        # 'unknown' so we use that as an never registered key.
 
4717
        self.assertRaises(KeyError, r.get_credential_store, 'unknown')
 
4718
 
 
4719
    def test_fallback_none_registered(self):
 
4720
        r = config.CredentialStoreRegistry()
 
4721
        self.assertEquals(None,
 
4722
                          r.get_fallback_credentials("http", "example.com"))
 
4723
 
 
4724
    def test_register(self):
 
4725
        r = config.CredentialStoreRegistry()
 
4726
        r.register("stub", StubCredentialStore(), fallback=False)
 
4727
        r.register("another", StubCredentialStore(), fallback=True)
 
4728
        self.assertEquals(["another", "stub"], r.keys())
 
4729
 
 
4730
    def test_register_lazy(self):
 
4731
        r = config.CredentialStoreRegistry()
 
4732
        r.register_lazy("stub", "bzrlib.tests.test_config",
 
4733
                        "StubCredentialStore", fallback=False)
 
4734
        self.assertEquals(["stub"], r.keys())
 
4735
        self.assertIsInstance(r.get_credential_store("stub"),
 
4736
                              StubCredentialStore)
 
4737
 
 
4738
    def test_is_fallback(self):
 
4739
        r = config.CredentialStoreRegistry()
 
4740
        r.register("stub1", None, fallback=False)
 
4741
        r.register("stub2", None, fallback=True)
 
4742
        self.assertEquals(False, r.is_fallback("stub1"))
 
4743
        self.assertEquals(True, r.is_fallback("stub2"))
 
4744
 
 
4745
    def test_no_fallback(self):
 
4746
        r = config.CredentialStoreRegistry()
 
4747
        store = CountingCredentialStore()
 
4748
        r.register("count", store, fallback=False)
 
4749
        self.assertEquals(None,
 
4750
                          r.get_fallback_credentials("http", "example.com"))
 
4751
        self.assertEquals(0, store._calls)
 
4752
 
 
4753
    def test_fallback_credentials(self):
 
4754
        r = config.CredentialStoreRegistry()
 
4755
        store = StubCredentialStore()
 
4756
        store.add_credentials("http", "example.com",
 
4757
                              "somebody", "geheim")
 
4758
        r.register("stub", store, fallback=True)
 
4759
        creds = r.get_fallback_credentials("http", "example.com")
 
4760
        self.assertEquals("somebody", creds["user"])
 
4761
        self.assertEquals("geheim", creds["password"])
 
4762
 
 
4763
    def test_fallback_first_wins(self):
 
4764
        r = config.CredentialStoreRegistry()
 
4765
        stub1 = StubCredentialStore()
 
4766
        stub1.add_credentials("http", "example.com",
 
4767
                              "somebody", "stub1")
 
4768
        r.register("stub1", stub1, fallback=True)
 
4769
        stub2 = StubCredentialStore()
 
4770
        stub2.add_credentials("http", "example.com",
 
4771
                              "somebody", "stub2")
 
4772
        r.register("stub2", stub1, fallback=True)
 
4773
        creds = r.get_fallback_credentials("http", "example.com")
 
4774
        self.assertEquals("somebody", creds["user"])
 
4775
        self.assertEquals("stub1", creds["password"])
 
4776
 
 
4777
 
 
4778
class TestPlainTextCredentialStore(tests.TestCase):
 
4779
 
 
4780
    def test_decode_password(self):
 
4781
        r = config.credential_store_registry
 
4782
        plain_text = r.get_credential_store()
 
4783
        decoded = plain_text.decode_password(dict(password='secret'))
 
4784
        self.assertEquals('secret', decoded)
 
4785
 
 
4786
 
 
4787
# FIXME: Once we have a way to declare authentication to all test servers, we
 
4788
# can implement generic tests.
 
4789
# test_user_password_in_url
 
4790
# test_user_in_url_password_from_config
 
4791
# test_user_in_url_password_prompted
 
4792
# test_user_in_config
 
4793
# test_user_getpass.getuser
 
4794
# test_user_prompted ?
 
4795
class TestAuthenticationRing(tests.TestCaseWithTransport):
 
4796
    pass
 
4797
 
 
4798
 
 
4799
class TestAutoUserId(tests.TestCase):
 
4800
    """Test inferring an automatic user name."""
 
4801
 
 
4802
    def test_auto_user_id(self):
 
4803
        """Automatic inference of user name.
 
4804
 
 
4805
        This is a bit hard to test in an isolated way, because it depends on
 
4806
        system functions that go direct to /etc or perhaps somewhere else.
 
4807
        But it's reasonable to say that on Unix, with an /etc/mailname, we ought
 
4808
        to be able to choose a user name with no configuration.
 
4809
        """
 
4810
        if sys.platform == 'win32':
 
4811
            raise tests.TestSkipped(
 
4812
                "User name inference not implemented on win32")
 
4813
        realname, address = config._auto_user_id()
 
4814
        if os.path.exists('/etc/mailname'):
 
4815
            self.assertIsNot(None, realname)
 
4816
            self.assertIsNot(None, address)
 
4817
        else:
 
4818
            self.assertEquals((None, None), (realname, address))
 
4819
 
 
4820
 
 
4821
class EmailOptionTests(tests.TestCase):
 
4822
 
 
4823
    def test_default_email_uses_BZR_EMAIL(self):
 
4824
        conf = config.MemoryStack('email=jelmer@debian.org')
 
4825
        # BZR_EMAIL takes precedence over EMAIL
 
4826
        self.overrideEnv('BZR_EMAIL', 'jelmer@samba.org')
 
4827
        self.overrideEnv('EMAIL', 'jelmer@apache.org')
 
4828
        self.assertEquals('jelmer@samba.org', conf.get('email'))
 
4829
 
 
4830
    def test_default_email_uses_EMAIL(self):
 
4831
        conf = config.MemoryStack('')
 
4832
        self.overrideEnv('BZR_EMAIL', None)
 
4833
        self.overrideEnv('EMAIL', 'jelmer@apache.org')
 
4834
        self.assertEquals('jelmer@apache.org', conf.get('email'))
 
4835
 
 
4836
    def test_BZR_EMAIL_overrides(self):
 
4837
        conf = config.MemoryStack('email=jelmer@debian.org')
 
4838
        self.overrideEnv('BZR_EMAIL', 'jelmer@apache.org')
 
4839
        self.assertEquals('jelmer@apache.org', conf.get('email'))
 
4840
        self.overrideEnv('BZR_EMAIL', None)
 
4841
        self.overrideEnv('EMAIL', 'jelmer@samba.org')
 
4842
        self.assertEquals('jelmer@debian.org', conf.get('email'))