← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/testconfig.py

Update news and readme

- better explanation of dependencies

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/testconfig.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005 by Canonical Ltd
2
2
#   Authors: Robert Collins <robert.collins@canonical.com>
3
3
#
4
4
# This program is free software; you can redistribute it and/or modify
17
17
 
18
18
"""Tests for finding and reading the bzr config file[s]."""
19
19
# import system imports here
20
 
from bzrlib.util.configobj.configobj import ConfigObj, ConfigObjError
 
20
from ConfigParser import ConfigParser
21
21
from cStringIO import StringIO
22
22
import os
23
23
import sys
24
24
 
25
25
#import bzrlib specific imports here
26
 
from bzrlib import (
27
 
    config,
28
 
    errors,
29
 
    osutils,
30
 
    urlutils,
31
 
    trace,
32
 
    )
33
 
from bzrlib.branch import Branch
34
 
from bzrlib.bzrdir import BzrDir
35
 
from bzrlib.tests import TestCase, TestCaseInTempDir, TestCaseWithTransport
36
 
 
37
 
 
38
 
sample_long_alias="log -r-15..-1 --line"
39
 
sample_config_text = u"""
40
 
[DEFAULT]
41
 
email=Erik B\u00e5gfors <erik@bagfors.nu>
42
 
editor=vim
43
 
gpg_signing_command=gnome-gpg
44
 
log_format=short
45
 
user_global_option=something
46
 
[ALIASES]
47
 
h=help
48
 
ll=""" + sample_long_alias + "\n"
49
 
 
50
 
 
51
 
sample_always_signatures = """
52
 
[DEFAULT]
53
 
check_signatures=ignore
54
 
create_signatures=always
55
 
"""
56
 
 
57
 
sample_ignore_signatures = """
58
 
[DEFAULT]
59
 
check_signatures=require
60
 
create_signatures=never
61
 
"""
62
 
 
63
 
sample_maybe_signatures = """
64
 
[DEFAULT]
65
 
check_signatures=ignore
66
 
create_signatures=when-required
67
 
"""
68
 
 
69
 
sample_branches_text = """
70
 
[http://www.example.com]
71
 
# Top level policy
72
 
email=Robert Collins <robertc@example.org>
73
 
normal_option = normal
74
 
appendpath_option = append
75
 
appendpath_option:policy = appendpath
76
 
norecurse_option = norecurse
77
 
norecurse_option:policy = norecurse
78
 
[http://www.example.com/ignoreparent]
79
 
# different project: ignore parent dir config
80
 
ignore_parents=true
81
 
[http://www.example.com/norecurse]
82
 
# configuration items that only apply to this dir
83
 
recurse=false
84
 
normal_option = norecurse
85
 
[http://www.example.com/dir]
86
 
appendpath_option = normal
87
 
[/b/]
88
 
check_signatures=require
89
 
# test trailing / matching with no children
90
 
[/a/]
91
 
check_signatures=check-available
92
 
gpg_signing_command=false
93
 
user_local_option=local
94
 
# test trailing / matching
95
 
[/a/*]
96
 
#subdirs will match but not the parent
97
 
[/a/c]
98
 
check_signatures=ignore
99
 
post_commit=bzrlib.tests.test_config.post_commit
100
 
#testing explicit beats globs
101
 
"""
102
 
 
103
 
 
104
 
class InstrumentedConfigObj(object):
105
 
    """A config obj look-enough-alike to record calls made to it."""
106
 
 
107
 
    def __contains__(self, thing):
108
 
        self._calls.append(('__contains__', thing))
109
 
        return False
110
 
 
111
 
    def __getitem__(self, key):
112
 
        self._calls.append(('__getitem__', key))
113
 
        return self
114
 
 
115
 
    def __init__(self, input, encoding=None):
116
 
        self._calls = [('__init__', input, encoding)]
117
 
 
118
 
    def __setitem__(self, key, value):
119
 
        self._calls.append(('__setitem__', key, value))
120
 
 
121
 
    def __delitem__(self, key):
122
 
        self._calls.append(('__delitem__', key))
123
 
 
124
 
    def keys(self):
125
 
        self._calls.append(('keys',))
126
 
        return []
127
 
 
128
 
    def write(self, arg):
129
 
        self._calls.append(('write',))
130
 
 
131
 
    def as_bool(self, value):
132
 
        self._calls.append(('as_bool', value))
133
 
        return False
134
 
 
135
 
    def get_value(self, section, name):
136
 
        self._calls.append(('get_value', section, name))
137
 
        return None
 
26
import bzrlib.config as config
 
27
import bzrlib.errors as errors
 
28
from bzrlib.selftest import TestCase, TestCaseInTempDir
 
29
 
 
30
 
 
31
sample_config_text = ("[DEFAULT]\n"
 
32
                      "email=Robert Collins <robertc@example.com>\n"
 
33
                      "editor=vim\n"
 
34
                      "gpg_signing_command=gnome-gpg\n")
 
35
 
 
36
 
 
37
sample_always_signatures = ("[DEFAULT]\n"
 
38
                            "check_signatures=require\n")
 
39
 
 
40
 
 
41
sample_ignore_signatures = ("[DEFAULT]\n"
 
42
                            "check_signatures=ignore\n")
 
43
 
 
44
 
 
45
sample_maybe_signatures = ("[DEFAULT]\n"
 
46
                            "check_signatures=check-available\n")
 
47
 
 
48
 
 
49
sample_branches_text = ("[http://www.example.com]\n"
 
50
                        "# Top level policy\n"
 
51
                        "email=Robert Collins <robertc@example.org>\n"
 
52
                        "[http://www.example.com/useglobal]\n"
 
53
                        "# different project, forces global lookup\n"
 
54
                        "recurse=false\n"
 
55
                        "[/b/]\n"
 
56
                        "check_signatures=require\n"
 
57
                        "# test trailing / matching with no children\n"
 
58
                        "[/a/]\n"
 
59
                        "check_signatures=check-available\n"
 
60
                        "gpg_signing_command=false\n"
 
61
                        "# test trailing / matching\n"
 
62
                        "[/a/*]\n"
 
63
                        "#subdirs will match but not the parent\n"
 
64
                        "recurse=False\n"
 
65
                        "[/a/c]\n"
 
66
                        "check_signatures=ignore\n"
 
67
                        "#testing explicit beats globs\n")
 
68
 
 
69
 
 
70
class InstrumentedConfigParser(object):
 
71
    """A config parser look-enough-alike to record calls made to it."""
 
72
 
 
73
    def __init__(self):
 
74
        self._calls = []
 
75
 
 
76
    def read(self, filenames):
 
77
        self._calls.append(('read', filenames))
138
78
 
139
79
 
140
80
class FakeBranch(object):
141
81
 
142
 
    def __init__(self, base=None, user_id=None):
143
 
        if base is None:
144
 
            self.base = "http://example.com/branches/demo"
145
 
        else:
146
 
            self.base = base
147
 
        self.control_files = FakeControlFiles(user_id=user_id)
148
 
 
149
 
    def lock_write(self):
150
 
        pass
151
 
 
152
 
    def unlock(self):
153
 
        pass
154
 
 
155
 
 
156
 
class FakeControlFiles(object):
157
 
 
158
 
    def __init__(self, user_id=None):
159
 
        self.email = user_id
160
 
        self.files = {}
161
 
 
162
 
    def get_utf8(self, filename):
 
82
    def __init__(self):
 
83
        self.base = "http://example.com/branches/demo"
 
84
        self.email = 'Robert Collins <robertc@example.net>\n'
 
85
 
 
86
    def controlfile(self, filename, mode):
163
87
        if filename != 'email':
164
88
            raise NotImplementedError
165
89
        if self.email is not None:
166
90
            return StringIO(self.email)
167
 
        raise errors.NoSuchFile(filename)
168
 
 
169
 
    def get(self, filename):
170
 
        try:
171
 
            return StringIO(self.files[filename])
172
 
        except KeyError:
173
 
            raise errors.NoSuchFile(filename)
174
 
 
175
 
    def put(self, filename, fileobj):
176
 
        self.files[filename] = fileobj.read()
 
91
        raise errors.NoSuchFile
177
92
 
178
93
 
179
94
class InstrumentedConfig(config.Config):
193
108
        return self._signatures
194
109
 
195
110
 
196
 
bool_config = """[DEFAULT]
197
 
active = true
198
 
inactive = false
199
 
[UPPERCASE]
200
 
active = True
201
 
nonactive = False
202
 
"""
203
 
class TestConfigObj(TestCase):
204
 
    def test_get_bool(self):
205
 
        from bzrlib.config import ConfigObj
206
 
        co = ConfigObj(StringIO(bool_config))
207
 
        self.assertIs(co.get_bool('DEFAULT', 'active'), True)
208
 
        self.assertIs(co.get_bool('DEFAULT', 'inactive'), False)
209
 
        self.assertIs(co.get_bool('UPPERCASE', 'active'), True)
210
 
        self.assertIs(co.get_bool('UPPERCASE', 'nonactive'), False)
211
 
 
212
 
 
213
111
class TestConfig(TestCase):
214
112
 
215
113
    def test_constructs(self):
231
129
 
232
130
    def test_signatures_default(self):
233
131
        my_config = config.Config()
234
 
        self.assertFalse(my_config.signature_needed())
235
132
        self.assertEqual(config.CHECK_IF_POSSIBLE,
236
133
                         my_config.signature_checking())
237
 
        self.assertEqual(config.SIGN_WHEN_REQUIRED,
238
 
                         my_config.signing_policy())
239
134
 
240
135
    def test_signatures_template_method(self):
241
136
        my_config = InstrumentedConfig()
253
148
        my_config = config.Config()
254
149
        self.assertEqual('gpg', my_config.gpg_signing_command())
255
150
 
256
 
    def test_get_user_option_default(self):
257
 
        my_config = config.Config()
258
 
        self.assertEqual(None, my_config.get_user_option('no_option'))
259
 
 
260
 
    def test_post_commit_default(self):
261
 
        my_config = config.Config()
262
 
        self.assertEqual(None, my_config.post_commit())
263
 
 
264
 
    def test_log_format_default(self):
265
 
        my_config = config.Config()
266
 
        self.assertEqual('long', my_config.log_format())
267
 
 
268
151
 
269
152
class TestConfigPath(TestCase):
270
153
 
271
154
    def setUp(self):
272
155
        super(TestConfigPath, self).setUp()
 
156
        self.oldenv = os.environ.get('HOME', None)
273
157
        os.environ['HOME'] = '/home/bogus'
274
 
        if sys.platform == 'win32':
275
 
            os.environ['BZR_HOME'] = \
276
 
                r'C:\Documents and Settings\bogus\Application Data'
277
158
 
 
159
    def tearDown(self):
 
160
        os.environ['HOME'] = self.oldenv
 
161
        super(TestConfigPath, self).tearDown()
 
162
    
278
163
    def test_config_dir(self):
279
 
        if sys.platform == 'win32':
280
 
            self.assertEqual(config.config_dir(), 
281
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0')
282
 
        else:
283
 
            self.assertEqual(config.config_dir(), '/home/bogus/.bazaar')
 
164
        self.assertEqual(config.config_dir(), '/home/bogus/.bazaar')
284
165
 
285
166
    def test_config_filename(self):
286
 
        if sys.platform == 'win32':
287
 
            self.assertEqual(config.config_filename(), 
288
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/bazaar.conf')
289
 
        else:
290
 
            self.assertEqual(config.config_filename(),
291
 
                             '/home/bogus/.bazaar/bazaar.conf')
 
167
        self.assertEqual(config.config_filename(),
 
168
                         '/home/bogus/.bazaar/bazaar.conf')
292
169
 
293
170
    def test_branches_config_filename(self):
294
 
        if sys.platform == 'win32':
295
 
            self.assertEqual(config.branches_config_filename(), 
296
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/branches.conf')
297
 
        else:
298
 
            self.assertEqual(config.branches_config_filename(),
299
 
                             '/home/bogus/.bazaar/branches.conf')
300
 
 
301
 
    def test_locations_config_filename(self):
302
 
        if sys.platform == 'win32':
303
 
            self.assertEqual(config.locations_config_filename(), 
304
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/locations.conf')
305
 
        else:
306
 
            self.assertEqual(config.locations_config_filename(),
307
 
                             '/home/bogus/.bazaar/locations.conf')
 
171
        self.assertEqual(config.branches_config_filename(),
 
172
                         '/home/bogus/.bazaar/branches.conf')
308
173
 
309
174
class TestIniConfig(TestCase):
310
175
 
312
177
        my_config = config.IniBasedConfig("nothing")
313
178
 
314
179
    def test_from_fp(self):
315
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
 
180
        config_file = StringIO(sample_config_text)
316
181
        my_config = config.IniBasedConfig(None)
317
182
        self.failUnless(
318
183
            isinstance(my_config._get_parser(file=config_file),
319
 
                        ConfigObj))
 
184
                        ConfigParser))
320
185
 
321
186
    def test_cached(self):
322
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
 
187
        config_file = StringIO(sample_config_text)
323
188
        my_config = config.IniBasedConfig(None)
324
189
        parser = my_config._get_parser(file=config_file)
325
190
        self.failUnless(my_config._get_parser() is parser)
332
197
 
333
198
    def test_calls_read_filenames(self):
334
199
        # replace the class that is constructured, to check its parameters
335
 
        oldparserclass = config.ConfigObj
336
 
        config.ConfigObj = InstrumentedConfigObj
 
200
        oldparserclass = config.ConfigParser
 
201
        config.ConfigParser = InstrumentedConfigParser
337
202
        my_config = config.GlobalConfig()
338
203
        try:
339
204
            parser = my_config._get_parser()
340
205
        finally:
341
 
            config.ConfigObj = oldparserclass
342
 
        self.failUnless(isinstance(parser, InstrumentedConfigObj))
343
 
        self.assertEqual(parser._calls, [('__init__', config.config_filename(),
344
 
                                          'utf-8')])
345
 
 
346
 
 
347
 
class TestBranchConfig(TestCaseWithTransport):
 
206
            config.ConfigParser = oldparserclass
 
207
        self.failUnless(isinstance(parser, InstrumentedConfigParser))
 
208
        self.assertEqual(parser._calls, [('read', [config.config_filename()])])
 
209
 
 
210
 
 
211
class TestBranchConfig(TestCaseInTempDir):
348
212
 
349
213
    def test_constructs(self):
350
214
        branch = FakeBranch()
358
222
        self.assertEqual(branch.base, location_config.location)
359
223
        self.failUnless(location_config is my_config._get_location_config())
360
224
 
361
 
    def test_get_config(self):
362
 
        """The Branch.get_config method works properly"""
363
 
        b = BzrDir.create_standalone_workingtree('.').branch
364
 
        my_config = b.get_config()
365
 
        self.assertIs(my_config.get_user_option('wacky'), None)
366
 
        my_config.set_user_option('wacky', 'unlikely')
367
 
        self.assertEqual(my_config.get_user_option('wacky'), 'unlikely')
368
 
 
369
 
        # Ensure we get the same thing if we start again
370
 
        b2 = Branch.open('.')
371
 
        my_config2 = b2.get_config()
372
 
        self.assertEqual(my_config2.get_user_option('wacky'), 'unlikely')
373
 
 
374
 
    def test_has_explicit_nickname(self):
375
 
        b = self.make_branch('.')
376
 
        self.assertFalse(b.get_config().has_explicit_nickname())
377
 
        b.nick = 'foo'
378
 
        self.assertTrue(b.get_config().has_explicit_nickname())
379
 
 
380
 
    def test_config_url(self):
381
 
        """The Branch.get_config will use section that uses a local url"""
382
 
        branch = self.make_branch('branch')
383
 
        self.assertEqual('branch', branch.nick)
384
 
 
385
 
        locations = config.locations_config_filename()
386
 
        config.ensure_config_dir_exists()
387
 
        local_url = urlutils.local_path_to_url('branch')
388
 
        open(locations, 'wb').write('[%s]\nnickname = foobar' 
389
 
                                    % (local_url,))
390
 
        self.assertEqual('foobar', branch.nick)
391
 
 
392
 
    def test_config_local_path(self):
393
 
        """The Branch.get_config will use a local system path"""
394
 
        branch = self.make_branch('branch')
395
 
        self.assertEqual('branch', branch.nick)
396
 
 
397
 
        locations = config.locations_config_filename()
398
 
        config.ensure_config_dir_exists()
399
 
        open(locations, 'wb').write('[%s/branch]\nnickname = barry' 
400
 
                                    % (osutils.getcwd().encode('utf8'),))
401
 
        self.assertEqual('barry', branch.nick)
402
 
 
403
 
    def test_config_creates_local(self):
404
 
        """Creating a new entry in config uses a local path."""
405
 
        branch = self.make_branch('branch', format='knit')
406
 
        branch.set_push_location('http://foobar')
407
 
        locations = config.locations_config_filename()
408
 
        local_path = osutils.getcwd().encode('utf8')
409
 
        # Surprisingly ConfigObj doesn't create a trailing newline
410
 
        self.check_file_contents(locations,
411
 
            '[%s/branch]\npush_location = http://foobar\npush_location:policy = norecurse' % (local_path,))
412
 
 
413
 
    def test_autonick_urlencoded(self):
414
 
        b = self.make_branch('!repo')
415
 
        self.assertEqual('!repo', b.get_config().get_nickname())
416
 
 
417
 
    def test_warn_if_masked(self):
418
 
        _warning = trace.warning
419
 
        warnings = []
420
 
        def warning(*args):
421
 
            warnings.append(args[0] % args[1:])
422
 
 
423
 
        def set_option(store, warn_masked=True):
424
 
            warnings[:] = []
425
 
            conf.set_user_option('example_option', repr(store), store=store,
426
 
                                 warn_masked=warn_masked)
427
 
        def assertWarning(warning):
428
 
            if warning is None:
429
 
                self.assertEqual(0, len(warnings))
430
 
            else:
431
 
                self.assertEqual(1, len(warnings))
432
 
                self.assertEqual(warning, warnings[0])
433
 
        trace.warning = warning
434
 
        try:
435
 
            branch = self.make_branch('.')
436
 
            conf = branch.get_config()
437
 
            set_option(config.STORE_GLOBAL)
438
 
            assertWarning(None)
439
 
            set_option(config.STORE_BRANCH)
440
 
            assertWarning(None)
441
 
            set_option(config.STORE_GLOBAL)
442
 
            assertWarning('Value "4" is masked by "3" from branch.conf')
443
 
            set_option(config.STORE_GLOBAL, warn_masked=False)
444
 
            assertWarning(None)
445
 
            set_option(config.STORE_LOCATION)
446
 
            assertWarning(None)
447
 
            set_option(config.STORE_BRANCH)
448
 
            assertWarning('Value "3" is masked by "0" from locations.conf')
449
 
            set_option(config.STORE_BRANCH, warn_masked=False)
450
 
            assertWarning(None)
451
 
        finally:
452
 
            trace.warning = _warning
453
 
 
454
225
 
455
226
class TestGlobalConfigItems(TestCase):
456
227
 
457
228
    def test_user_id(self):
458
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
 
229
        config_file = StringIO(sample_config_text)
459
230
        my_config = config.GlobalConfig()
460
231
        my_config._parser = my_config._get_parser(file=config_file)
461
 
        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
 
232
        self.assertEqual("Robert Collins <robertc@example.com>",
462
233
                         my_config._get_user_id())
463
234
 
464
235
    def test_absent_user_id(self):
468
239
        self.assertEqual(None, my_config._get_user_id())
469
240
 
470
241
    def test_configured_editor(self):
471
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
 
242
        config_file = StringIO(sample_config_text)
472
243
        my_config = config.GlobalConfig()
473
244
        my_config._parser = my_config._get_parser(file=config_file)
474
245
        self.assertEqual("vim", my_config.get_editor())
477
248
        config_file = StringIO(sample_always_signatures)
478
249
        my_config = config.GlobalConfig()
479
250
        my_config._parser = my_config._get_parser(file=config_file)
480
 
        self.assertEqual(config.CHECK_NEVER,
 
251
        self.assertEqual(config.CHECK_ALWAYS,
481
252
                         my_config.signature_checking())
482
 
        self.assertEqual(config.SIGN_ALWAYS,
483
 
                         my_config.signing_policy())
484
253
        self.assertEqual(True, my_config.signature_needed())
485
254
 
486
255
    def test_signatures_if_possible(self):
487
256
        config_file = StringIO(sample_maybe_signatures)
488
257
        my_config = config.GlobalConfig()
489
258
        my_config._parser = my_config._get_parser(file=config_file)
490
 
        self.assertEqual(config.CHECK_NEVER,
 
259
        self.assertEqual(config.CHECK_IF_POSSIBLE,
491
260
                         my_config.signature_checking())
492
 
        self.assertEqual(config.SIGN_WHEN_REQUIRED,
493
 
                         my_config.signing_policy())
494
261
        self.assertEqual(False, my_config.signature_needed())
495
262
 
496
263
    def test_signatures_ignore(self):
497
264
        config_file = StringIO(sample_ignore_signatures)
498
265
        my_config = config.GlobalConfig()
499
266
        my_config._parser = my_config._get_parser(file=config_file)
500
 
        self.assertEqual(config.CHECK_ALWAYS,
 
267
        self.assertEqual(config.CHECK_NEVER,
501
268
                         my_config.signature_checking())
502
 
        self.assertEqual(config.SIGN_NEVER,
503
 
                         my_config.signing_policy())
504
269
        self.assertEqual(False, my_config.signature_needed())
505
270
 
506
 
    def _get_sample_config(self):
507
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
508
 
        my_config = config.GlobalConfig()
509
 
        my_config._parser = my_config._get_parser(file=config_file)
510
 
        return my_config
511
 
 
512
271
    def test_gpg_signing_command(self):
513
 
        my_config = self._get_sample_config()
 
272
        config_file = StringIO(sample_config_text)
 
273
        my_config = config.GlobalConfig()
 
274
        my_config._parser = my_config._get_parser(file=config_file)
514
275
        self.assertEqual("gnome-gpg", my_config.gpg_signing_command())
515
276
        self.assertEqual(False, my_config.signature_needed())
516
277
 
517
 
    def _get_empty_config(self):
518
 
        config_file = StringIO("")
519
 
        my_config = config.GlobalConfig()
520
 
        my_config._parser = my_config._get_parser(file=config_file)
521
 
        return my_config
522
 
 
523
278
    def test_gpg_signing_command_unset(self):
524
 
        my_config = self._get_empty_config()
 
279
        config_file = StringIO("")
 
280
        my_config = config.GlobalConfig()
 
281
        my_config._parser = my_config._get_parser(file=config_file)
525
282
        self.assertEqual("gpg", my_config.gpg_signing_command())
526
283
 
527
 
    def test_get_user_option_default(self):
528
 
        my_config = self._get_empty_config()
529
 
        self.assertEqual(None, my_config.get_user_option('no_option'))
530
 
 
531
 
    def test_get_user_option_global(self):
532
 
        my_config = self._get_sample_config()
533
 
        self.assertEqual("something",
534
 
                         my_config.get_user_option('user_global_option'))
535
 
        
536
 
    def test_post_commit_default(self):
537
 
        my_config = self._get_sample_config()
538
 
        self.assertEqual(None, my_config.post_commit())
539
 
 
540
 
    def test_configured_logformat(self):
541
 
        my_config = self._get_sample_config()
542
 
        self.assertEqual("short", my_config.log_format())
543
 
 
544
 
    def test_get_alias(self):
545
 
        my_config = self._get_sample_config()
546
 
        self.assertEqual('help', my_config.get_alias('h'))
547
 
 
548
 
    def test_get_no_alias(self):
549
 
        my_config = self._get_sample_config()
550
 
        self.assertEqual(None, my_config.get_alias('foo'))
551
 
 
552
 
    def test_get_long_alias(self):
553
 
        my_config = self._get_sample_config()
554
 
        self.assertEqual(sample_long_alias, my_config.get_alias('ll'))
555
 
 
556
 
 
557
 
class TestLocationConfig(TestCaseInTempDir):
 
284
 
 
285
class TestLocationConfig(TestCase):
558
286
 
559
287
    def test_constructs(self):
560
288
        my_config = config.LocationConfig('http://example.com')
561
289
        self.assertRaises(TypeError, config.LocationConfig)
562
290
 
563
291
    def test_branch_calls_read_filenames(self):
564
 
        # This is testing the correct file names are provided.
565
 
        # TODO: consolidate with the test for GlobalConfigs filename checks.
566
 
        #
567
292
        # replace the class that is constructured, to check its parameters
568
 
        oldparserclass = config.ConfigObj
569
 
        config.ConfigObj = InstrumentedConfigObj
570
 
        try:
571
 
            my_config = config.LocationConfig('http://www.example.com')
572
 
            parser = my_config._get_parser()
573
 
        finally:
574
 
            config.ConfigObj = oldparserclass
575
 
        self.failUnless(isinstance(parser, InstrumentedConfigObj))
576
 
        self.assertEqual(parser._calls,
577
 
                         [('__init__', config.locations_config_filename(),
578
 
                           'utf-8')])
579
 
        config.ensure_config_dir_exists()
580
 
        #os.mkdir(config.config_dir())
581
 
        f = file(config.branches_config_filename(), 'wb')
582
 
        f.write('')
583
 
        f.close()
584
 
        oldparserclass = config.ConfigObj
585
 
        config.ConfigObj = InstrumentedConfigObj
586
 
        try:
587
 
            my_config = config.LocationConfig('http://www.example.com')
588
 
            parser = my_config._get_parser()
589
 
        finally:
590
 
            config.ConfigObj = oldparserclass
 
293
        oldparserclass = config.ConfigParser
 
294
        config.ConfigParser = InstrumentedConfigParser
 
295
        my_config = config.LocationConfig('http://www.example.com')
 
296
        try:
 
297
            parser = my_config._get_parser()
 
298
        finally:
 
299
            config.ConfigParser = oldparserclass
 
300
        self.failUnless(isinstance(parser, InstrumentedConfigParser))
 
301
        self.assertEqual(parser._calls, [('read', [config.branches_config_filename()])])
591
302
 
592
303
    def test_get_global_config(self):
593
 
        my_config = config.BranchConfig(FakeBranch('http://example.com'))
 
304
        my_config = config.LocationConfig('http://example.com')
594
305
        global_config = my_config._get_global_config()
595
306
        self.failUnless(isinstance(global_config, config.GlobalConfig))
596
307
        self.failUnless(global_config is my_config._get_global_config())
597
308
 
598
 
    def test__get_matching_sections_no_match(self):
599
 
        self.get_branch_config('/')
600
 
        self.assertEqual([], self.my_location_config._get_matching_sections())
 
309
    def test__get_section_no_match(self):
 
310
        self.get_location_config('/')
 
311
        self.assertEqual(None, self.my_config._get_section())
601
312
        
602
 
    def test__get_matching_sections_exact(self):
603
 
        self.get_branch_config('http://www.example.com')
604
 
        self.assertEqual([('http://www.example.com', '')],
605
 
                         self.my_location_config._get_matching_sections())
 
313
    def test__get_section_exact(self):
 
314
        self.get_location_config('http://www.example.com')
 
315
        self.assertEqual('http://www.example.com',
 
316
                         self.my_config._get_section())
606
317
   
607
 
    def test__get_matching_sections_suffix_does_not(self):
608
 
        self.get_branch_config('http://www.example.com-com')
609
 
        self.assertEqual([], self.my_location_config._get_matching_sections())
610
 
 
611
 
    def test__get_matching_sections_subdir_recursive(self):
612
 
        self.get_branch_config('http://www.example.com/com')
613
 
        self.assertEqual([('http://www.example.com', 'com')],
614
 
                         self.my_location_config._get_matching_sections())
615
 
 
616
 
    def test__get_matching_sections_ignoreparent(self):
617
 
        self.get_branch_config('http://www.example.com/ignoreparent')
618
 
        self.assertEqual([('http://www.example.com/ignoreparent', '')],
619
 
                         self.my_location_config._get_matching_sections())
620
 
 
621
 
    def test__get_matching_sections_ignoreparent_subdir(self):
622
 
        self.get_branch_config(
623
 
            'http://www.example.com/ignoreparent/childbranch')
624
 
        self.assertEqual([('http://www.example.com/ignoreparent', 'childbranch')],
625
 
                         self.my_location_config._get_matching_sections())
626
 
 
627
 
    def test__get_matching_sections_subdir_trailing_slash(self):
628
 
        self.get_branch_config('/b')
629
 
        self.assertEqual([('/b/', '')],
630
 
                         self.my_location_config._get_matching_sections())
631
 
 
632
 
    def test__get_matching_sections_subdir_child(self):
633
 
        self.get_branch_config('/a/foo')
634
 
        self.assertEqual([('/a/*', ''), ('/a/', 'foo')],
635
 
                         self.my_location_config._get_matching_sections())
636
 
 
637
 
    def test__get_matching_sections_subdir_child_child(self):
638
 
        self.get_branch_config('/a/foo/bar')
639
 
        self.assertEqual([('/a/*', 'bar'), ('/a/', 'foo/bar')],
640
 
                         self.my_location_config._get_matching_sections())
641
 
 
642
 
    def test__get_matching_sections_trailing_slash_with_children(self):
643
 
        self.get_branch_config('/a/')
644
 
        self.assertEqual([('/a/', '')],
645
 
                         self.my_location_config._get_matching_sections())
646
 
 
647
 
    def test__get_matching_sections_explicit_over_glob(self):
648
 
        # XXX: 2006-09-08 jamesh
649
 
        # This test only passes because ord('c') > ord('*').  If there
650
 
        # was a config section for '/a/?', it would get precedence
651
 
        # over '/a/c'.
652
 
        self.get_branch_config('/a/c')
653
 
        self.assertEqual([('/a/c', ''), ('/a/*', ''), ('/a/', 'c')],
654
 
                         self.my_location_config._get_matching_sections())
655
 
 
656
 
    def test__get_option_policy_normal(self):
657
 
        self.get_branch_config('http://www.example.com')
658
 
        self.assertEqual(
659
 
            self.my_location_config._get_config_policy(
660
 
            'http://www.example.com', 'normal_option'),
661
 
            config.POLICY_NONE)
662
 
 
663
 
    def test__get_option_policy_norecurse(self):
664
 
        self.get_branch_config('http://www.example.com')
665
 
        self.assertEqual(
666
 
            self.my_location_config._get_option_policy(
667
 
            'http://www.example.com', 'norecurse_option'),
668
 
            config.POLICY_NORECURSE)
669
 
        # Test old recurse=False setting:
670
 
        self.assertEqual(
671
 
            self.my_location_config._get_option_policy(
672
 
            'http://www.example.com/norecurse', 'normal_option'),
673
 
            config.POLICY_NORECURSE)
674
 
 
675
 
    def test__get_option_policy_normal(self):
676
 
        self.get_branch_config('http://www.example.com')
677
 
        self.assertEqual(
678
 
            self.my_location_config._get_option_policy(
679
 
            'http://www.example.com', 'appendpath_option'),
680
 
            config.POLICY_APPENDPATH)
 
318
    def test__get_section_suffix_does_not(self):
 
319
        self.get_location_config('http://www.example.com-com')
 
320
        self.assertEqual(None, self.my_config._get_section())
 
321
 
 
322
    def test__get_section_subdir_recursive(self):
 
323
        self.get_location_config('http://www.example.com/com')
 
324
        self.assertEqual('http://www.example.com',
 
325
                         self.my_config._get_section())
 
326
 
 
327
    def test__get_section_subdir_matches(self):
 
328
        self.get_location_config('http://www.example.com/useglobal')
 
329
        self.assertEqual('http://www.example.com/useglobal',
 
330
                         self.my_config._get_section())
 
331
 
 
332
    def test__get_section_subdir_nonrecursive(self):
 
333
        self.get_location_config(
 
334
            'http://www.example.com/useglobal/childbranch')
 
335
        self.assertEqual('http://www.example.com',
 
336
                         self.my_config._get_section())
 
337
 
 
338
    def test__get_section_subdir_trailing_slash(self):
 
339
        self.get_location_config('/b')
 
340
        self.assertEqual('/b/', self.my_config._get_section())
 
341
 
 
342
    def test__get_section_subdir_child(self):
 
343
        self.get_location_config('/a/foo')
 
344
        self.assertEqual('/a/*', self.my_config._get_section())
 
345
 
 
346
    def test__get_section_subdir_child_child(self):
 
347
        self.get_location_config('/a/foo/bar')
 
348
        self.assertEqual('/a/', self.my_config._get_section())
 
349
 
 
350
    def test__get_section_trailing_slash_with_children(self):
 
351
        self.get_location_config('/a/')
 
352
        self.assertEqual('/a/', self.my_config._get_section())
 
353
 
 
354
    def test__get_section_explicit_over_glob(self):
 
355
        self.get_location_config('/a/c')
 
356
        self.assertEqual('/a/c', self.my_config._get_section())
 
357
 
 
358
    def get_location_config(self, location, global_config=None):
 
359
        if global_config is None:
 
360
            global_file = StringIO(sample_config_text)
 
361
        else:
 
362
            global_file = StringIO(global_config)
 
363
        branches_file = StringIO(sample_branches_text)
 
364
        self.my_config = config.LocationConfig(location)
 
365
        self.my_config._get_parser(branches_file)
 
366
        self.my_config._get_global_config()._get_parser(global_file)
681
367
 
682
368
    def test_location_without_username(self):
683
 
        self.get_branch_config('http://www.example.com/ignoreparent')
684
 
        self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
 
369
        self.get_location_config('http://www.example.com/useglobal')
 
370
        self.assertEqual('Robert Collins <robertc@example.com>',
685
371
                         self.my_config.username())
686
372
 
687
373
    def test_location_not_listed(self):
688
 
        """Test that the global username is used when no location matches"""
689
 
        self.get_branch_config('/home/robertc/sources')
690
 
        self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
 
374
        self.get_location_config('/home/robertc/sources')
 
375
        self.assertEqual('Robert Collins <robertc@example.com>',
691
376
                         self.my_config.username())
692
377
 
693
378
    def test_overriding_location(self):
694
 
        self.get_branch_config('http://www.example.com/foo')
 
379
        self.get_location_config('http://www.example.com/foo')
695
380
        self.assertEqual('Robert Collins <robertc@example.org>',
696
381
                         self.my_config.username())
697
382
 
698
383
    def test_signatures_not_set(self):
699
 
        self.get_branch_config('http://www.example.com',
 
384
        self.get_location_config('http://www.example.com',
700
385
                                 global_config=sample_ignore_signatures)
701
 
        self.assertEqual(config.CHECK_ALWAYS,
 
386
        self.assertEqual(config.CHECK_NEVER,
702
387
                         self.my_config.signature_checking())
703
 
        self.assertEqual(config.SIGN_NEVER,
704
 
                         self.my_config.signing_policy())
705
388
 
706
389
    def test_signatures_never(self):
707
 
        self.get_branch_config('/a/c')
 
390
        self.get_location_config('/a/c')
708
391
        self.assertEqual(config.CHECK_NEVER,
709
392
                         self.my_config.signature_checking())
710
393
        
711
394
    def test_signatures_when_available(self):
712
 
        self.get_branch_config('/a/', global_config=sample_ignore_signatures)
 
395
        self.get_location_config('/a/', global_config=sample_ignore_signatures)
713
396
        self.assertEqual(config.CHECK_IF_POSSIBLE,
714
397
                         self.my_config.signature_checking())
715
398
        
716
399
    def test_signatures_always(self):
717
 
        self.get_branch_config('/b')
 
400
        self.get_location_config('/b')
718
401
        self.assertEqual(config.CHECK_ALWAYS,
719
402
                         self.my_config.signature_checking())
720
403
        
721
404
    def test_gpg_signing_command(self):
722
 
        self.get_branch_config('/b')
 
405
        self.get_location_config('/b')
723
406
        self.assertEqual("gnome-gpg", self.my_config.gpg_signing_command())
724
407
 
725
408
    def test_gpg_signing_command_missing(self):
726
 
        self.get_branch_config('/a')
 
409
        self.get_location_config('/a')
727
410
        self.assertEqual("false", self.my_config.gpg_signing_command())
728
411
 
729
 
    def test_get_user_option_global(self):
730
 
        self.get_branch_config('/a')
731
 
        self.assertEqual('something',
732
 
                         self.my_config.get_user_option('user_global_option'))
733
 
 
734
 
    def test_get_user_option_local(self):
735
 
        self.get_branch_config('/a')
736
 
        self.assertEqual('local',
737
 
                         self.my_config.get_user_option('user_local_option'))
738
 
 
739
 
    def test_get_user_option_appendpath(self):
740
 
        # returned as is for the base path:
741
 
        self.get_branch_config('http://www.example.com')
742
 
        self.assertEqual('append',
743
 
                         self.my_config.get_user_option('appendpath_option'))
744
 
        # Extra path components get appended:
745
 
        self.get_branch_config('http://www.example.com/a/b/c')
746
 
        self.assertEqual('append/a/b/c',
747
 
                         self.my_config.get_user_option('appendpath_option'))
748
 
        # Overriden for http://www.example.com/dir, where it is a
749
 
        # normal option:
750
 
        self.get_branch_config('http://www.example.com/dir/a/b/c')
751
 
        self.assertEqual('normal',
752
 
                         self.my_config.get_user_option('appendpath_option'))
753
 
 
754
 
    def test_get_user_option_norecurse(self):
755
 
        self.get_branch_config('http://www.example.com')
756
 
        self.assertEqual('norecurse',
757
 
                         self.my_config.get_user_option('norecurse_option'))
758
 
        self.get_branch_config('http://www.example.com/dir')
759
 
        self.assertEqual(None,
760
 
                         self.my_config.get_user_option('norecurse_option'))
761
 
        # http://www.example.com/norecurse is a recurse=False section
762
 
        # that redefines normal_option.  Subdirectories do not pick up
763
 
        # this redefinition.
764
 
        self.get_branch_config('http://www.example.com/norecurse')
765
 
        self.assertEqual('norecurse',
766
 
                         self.my_config.get_user_option('normal_option'))
767
 
        self.get_branch_config('http://www.example.com/norecurse/subdir')
768
 
        self.assertEqual('normal',
769
 
                         self.my_config.get_user_option('normal_option'))
770
 
 
771
 
    def test_set_user_option_norecurse(self):
772
 
        self.get_branch_config('http://www.example.com')
773
 
        self.my_config.set_user_option('foo', 'bar',
774
 
                                       store=config.STORE_LOCATION_NORECURSE)
775
 
        self.assertEqual(
776
 
            self.my_location_config._get_option_policy(
777
 
            'http://www.example.com', 'foo'),
778
 
            config.POLICY_NORECURSE)
779
 
 
780
 
    def test_set_user_option_appendpath(self):
781
 
        self.get_branch_config('http://www.example.com')
782
 
        self.my_config.set_user_option('foo', 'bar',
783
 
                                       store=config.STORE_LOCATION_APPENDPATH)
784
 
        self.assertEqual(
785
 
            self.my_location_config._get_option_policy(
786
 
            'http://www.example.com', 'foo'),
787
 
            config.POLICY_APPENDPATH)
788
 
 
789
 
    def test_set_user_option_change_policy(self):
790
 
        self.get_branch_config('http://www.example.com')
791
 
        self.my_config.set_user_option('norecurse_option', 'normal',
792
 
                                       store=config.STORE_LOCATION)
793
 
        self.assertEqual(
794
 
            self.my_location_config._get_option_policy(
795
 
            'http://www.example.com', 'norecurse_option'),
796
 
            config.POLICY_NONE)
797
 
 
798
 
    def test_set_user_option_recurse_false_section(self):
799
 
        # The following section has recurse=False set.  The test is to
800
 
        # make sure that a normal option can be added to the section,
801
 
        # converting recurse=False to the norecurse policy.
802
 
        self.get_branch_config('http://www.example.com/norecurse')
803
 
        self.callDeprecated(['The recurse option is deprecated as of 0.14.  '
804
 
                             'The section "http://www.example.com/norecurse" '
805
 
                             'has been converted to use policies.'],
806
 
                            self.my_config.set_user_option,
807
 
                            'foo', 'bar', store=config.STORE_LOCATION)
808
 
        self.assertEqual(
809
 
            self.my_location_config._get_option_policy(
810
 
            'http://www.example.com/norecurse', 'foo'),
811
 
            config.POLICY_NONE)
812
 
        # The previously existing option is still norecurse:
813
 
        self.assertEqual(
814
 
            self.my_location_config._get_option_policy(
815
 
            'http://www.example.com/norecurse', 'normal_option'),
816
 
            config.POLICY_NORECURSE)
817
 
 
818
 
    def test_post_commit_default(self):
819
 
        self.get_branch_config('/a/c')
820
 
        self.assertEqual('bzrlib.tests.test_config.post_commit',
821
 
                         self.my_config.post_commit())
822
 
 
823
 
    def get_branch_config(self, location, global_config=None):
824
 
        if global_config is None:
825
 
            global_file = StringIO(sample_config_text.encode('utf-8'))
826
 
        else:
827
 
            global_file = StringIO(global_config.encode('utf-8'))
828
 
        branches_file = StringIO(sample_branches_text.encode('utf-8'))
829
 
        self.my_config = config.BranchConfig(FakeBranch(location))
830
 
        # Force location config to use specified file
831
 
        self.my_location_config = self.my_config._get_location_config()
832
 
        self.my_location_config._get_parser(branches_file)
833
 
        # Force global config to use specified file
834
 
        self.my_config._get_global_config()._get_parser(global_file)
835
 
 
836
 
    def test_set_user_setting_sets_and_saves(self):
837
 
        self.get_branch_config('/a/c')
838
 
        record = InstrumentedConfigObj("foo")
839
 
        self.my_location_config._parser = record
840
 
 
841
 
        real_mkdir = os.mkdir
842
 
        self.created = False
843
 
        def checked_mkdir(path, mode=0777):
844
 
            self.log('making directory: %s', path)
845
 
            real_mkdir(path, mode)
846
 
            self.created = True
847
 
 
848
 
        os.mkdir = checked_mkdir
849
 
        try:
850
 
            self.callDeprecated(['The recurse option is deprecated as of '
851
 
                                 '0.14.  The section "/a/c" has been '
852
 
                                 'converted to use policies.'],
853
 
                                self.my_config.set_user_option,
854
 
                                'foo', 'bar', store=config.STORE_LOCATION)
855
 
        finally:
856
 
            os.mkdir = real_mkdir
857
 
 
858
 
        self.failUnless(self.created, 'Failed to create ~/.bazaar')
859
 
        self.assertEqual([('__contains__', '/a/c'),
860
 
                          ('__contains__', '/a/c/'),
861
 
                          ('__setitem__', '/a/c', {}),
862
 
                          ('__getitem__', '/a/c'),
863
 
                          ('__setitem__', 'foo', 'bar'),
864
 
                          ('__getitem__', '/a/c'),
865
 
                          ('as_bool', 'recurse'),
866
 
                          ('__getitem__', '/a/c'),
867
 
                          ('__delitem__', 'recurse'),
868
 
                          ('__getitem__', '/a/c'),
869
 
                          ('keys',),
870
 
                          ('__getitem__', '/a/c'),
871
 
                          ('__contains__', 'foo:policy'),
872
 
                          ('write',)],
873
 
                         record._calls[1:])
874
 
 
875
 
    def test_set_user_setting_sets_and_saves2(self):
876
 
        self.get_branch_config('/a/c')
877
 
        self.assertIs(self.my_config.get_user_option('foo'), None)
878
 
        self.my_config.set_user_option('foo', 'bar')
879
 
        self.assertEqual(
880
 
            self.my_config.branch.control_files.files['branch.conf'], 
881
 
            'foo = bar')
882
 
        self.assertEqual(self.my_config.get_user_option('foo'), 'bar')
883
 
        self.my_config.set_user_option('foo', 'baz',
884
 
                                       store=config.STORE_LOCATION)
885
 
        self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
886
 
        self.my_config.set_user_option('foo', 'qux')
887
 
        self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
888
 
        
889
 
 
890
 
precedence_global = 'option = global'
891
 
precedence_branch = 'option = branch'
892
 
precedence_location = """
893
 
[http://]
894
 
recurse = true
895
 
option = recurse
896
 
[http://example.com/specific]
897
 
option = exact
898
 
"""
899
 
 
900
 
 
901
 
class TestBranchConfigItems(TestCaseInTempDir):
902
 
 
903
 
    def get_branch_config(self, global_config=None, location=None, 
904
 
                          location_config=None, branch_data_config=None):
905
 
        my_config = config.BranchConfig(FakeBranch(location))
906
 
        if global_config is not None:
907
 
            global_file = StringIO(global_config.encode('utf-8'))
908
 
            my_config._get_global_config()._get_parser(global_file)
909
 
        self.my_location_config = my_config._get_location_config()
910
 
        if location_config is not None:
911
 
            location_file = StringIO(location_config.encode('utf-8'))
912
 
            self.my_location_config._get_parser(location_file)
913
 
        if branch_data_config is not None:
914
 
            my_config.branch.control_files.files['branch.conf'] = \
915
 
                branch_data_config
916
 
        return my_config
 
412
 
 
413
class TestBranchConfigItems(TestCase):
917
414
 
918
415
    def test_user_id(self):
919
 
        branch = FakeBranch(user_id='Robert Collins <robertc@example.net>')
 
416
        branch = FakeBranch()
920
417
        my_config = config.BranchConfig(branch)
921
418
        self.assertEqual("Robert Collins <robertc@example.net>",
922
 
                         my_config.username())
923
 
        branch.control_files.email = "John"
924
 
        my_config.set_user_option('email', 
925
 
                                  "Robert Collins <robertc@example.org>")
926
 
        self.assertEqual("John", my_config.username())
927
 
        branch.control_files.email = None
928
 
        self.assertEqual("Robert Collins <robertc@example.org>",
929
 
                         my_config.username())
 
419
                         my_config._get_user_id())
 
420
        branch.email = "John"
 
421
        self.assertEqual("John", my_config._get_user_id())
930
422
 
931
423
    def test_not_set_in_branch(self):
932
 
        my_config = self.get_branch_config(sample_config_text)
933
 
        my_config.branch.control_files.email = None
934
 
        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
 
424
        branch = FakeBranch()
 
425
        my_config = config.BranchConfig(branch)
 
426
        branch.email = None
 
427
        config_file = StringIO(sample_config_text)
 
428
        (my_config._get_location_config().
 
429
            _get_global_config()._get_parser(config_file))
 
430
        self.assertEqual("Robert Collins <robertc@example.com>",
935
431
                         my_config._get_user_id())
936
 
        my_config.branch.control_files.email = "John"
 
432
        branch.email = "John"
937
433
        self.assertEqual("John", my_config._get_user_id())
938
434
 
939
 
    def test_BZR_EMAIL_OVERRIDES(self):
940
 
        os.environ['BZR_EMAIL'] = "Robert Collins <robertc@example.org>"
 
435
    def test_BZREMAIL_OVERRIDES(self):
 
436
        os.environ['BZREMAIL'] = "Robert Collins <robertc@example.org>"
941
437
        branch = FakeBranch()
942
438
        my_config = config.BranchConfig(branch)
943
439
        self.assertEqual("Robert Collins <robertc@example.org>",
944
440
                         my_config.username())
945
441
    
946
442
    def test_signatures_forced(self):
947
 
        my_config = self.get_branch_config(
948
 
            global_config=sample_always_signatures)
949
 
        self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
950
 
        self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
951
 
        self.assertTrue(my_config.signature_needed())
952
 
 
953
 
    def test_signatures_forced_branch(self):
954
 
        my_config = self.get_branch_config(
955
 
            global_config=sample_ignore_signatures,
956
 
            branch_data_config=sample_always_signatures)
957
 
        self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
958
 
        self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
959
 
        self.assertTrue(my_config.signature_needed())
 
443
        branch = FakeBranch()
 
444
        my_config = config.BranchConfig(branch)
 
445
        config_file = StringIO(sample_always_signatures)
 
446
        (my_config._get_location_config().
 
447
            _get_global_config()._get_parser(config_file))
 
448
        self.assertEqual(config.CHECK_ALWAYS, my_config.signature_checking())
960
449
 
961
450
    def test_gpg_signing_command(self):
962
 
        my_config = self.get_branch_config(
963
 
            # branch data cannot set gpg_signing_command
964
 
            branch_data_config="gpg_signing_command=pgp")
965
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
966
 
        my_config._get_global_config()._get_parser(config_file)
 
451
        branch = FakeBranch()
 
452
        my_config = config.BranchConfig(branch)
 
453
        config_file = StringIO(sample_config_text)
 
454
        (my_config._get_location_config().
 
455
            _get_global_config()._get_parser(config_file))
967
456
        self.assertEqual('gnome-gpg', my_config.gpg_signing_command())
968
 
 
969
 
    def test_get_user_option_global(self):
970
 
        branch = FakeBranch()
971
 
        my_config = config.BranchConfig(branch)
972
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
973
 
        (my_config._get_global_config()._get_parser(config_file))
974
 
        self.assertEqual('something',
975
 
                         my_config.get_user_option('user_global_option'))
976
 
 
977
 
    def test_post_commit_default(self):
978
 
        branch = FakeBranch()
979
 
        my_config = self.get_branch_config(sample_config_text, '/a/c',
980
 
                                           sample_branches_text)
981
 
        self.assertEqual(my_config.branch.base, '/a/c')
982
 
        self.assertEqual('bzrlib.tests.test_config.post_commit',
983
 
                         my_config.post_commit())
984
 
        my_config.set_user_option('post_commit', 'rmtree_root')
985
 
        # post-commit is ignored when bresent in branch data
986
 
        self.assertEqual('bzrlib.tests.test_config.post_commit',
987
 
                         my_config.post_commit())
988
 
        my_config.set_user_option('post_commit', 'rmtree_root',
989
 
                                  store=config.STORE_LOCATION)
990
 
        self.assertEqual('rmtree_root', my_config.post_commit())
991
 
 
992
 
    def test_config_precedence(self):
993
 
        my_config = self.get_branch_config(global_config=precedence_global)
994
 
        self.assertEqual(my_config.get_user_option('option'), 'global')
995
 
        my_config = self.get_branch_config(global_config=precedence_global, 
996
 
                                      branch_data_config=precedence_branch)
997
 
        self.assertEqual(my_config.get_user_option('option'), 'branch')
998
 
        my_config = self.get_branch_config(global_config=precedence_global, 
999
 
                                      branch_data_config=precedence_branch,
1000
 
                                      location_config=precedence_location)
1001
 
        self.assertEqual(my_config.get_user_option('option'), 'recurse')
1002
 
        my_config = self.get_branch_config(global_config=precedence_global, 
1003
 
                                      branch_data_config=precedence_branch,
1004
 
                                      location_config=precedence_location,
1005
 
                                      location='http://example.com/specific')
1006
 
        self.assertEqual(my_config.get_user_option('option'), 'exact')
1007
 
 
1008
 
 
1009
 
class TestMailAddressExtraction(TestCase):
1010
 
 
1011
 
    def test_extract_email_address(self):
1012
 
        self.assertEqual('jane@test.com',
1013
 
                         config.extract_email_address('Jane <jane@test.com>'))
1014
 
        self.assertRaises(errors.NoEmailInUsername,
1015
 
                          config.extract_email_address, 'Jane Tester')
1016
 
 
1017
 
 
1018
 
class TestTreeConfig(TestCaseWithTransport):
1019
 
 
1020
 
    def test_get_value(self):
1021
 
        """Test that retreiving a value from a section is possible"""
1022
 
        branch = self.make_branch('.')
1023
 
        tree_config = config.TreeConfig(branch)
1024
 
        tree_config.set_option('value', 'key', 'SECTION')
1025
 
        tree_config.set_option('value2', 'key2')
1026
 
        tree_config.set_option('value3-top', 'key3')
1027
 
        tree_config.set_option('value3-section', 'key3', 'SECTION')
1028
 
        value = tree_config.get_option('key', 'SECTION')
1029
 
        self.assertEqual(value, 'value')
1030
 
        value = tree_config.get_option('key2')
1031
 
        self.assertEqual(value, 'value2')
1032
 
        self.assertEqual(tree_config.get_option('non-existant'), None)
1033
 
        value = tree_config.get_option('non-existant', 'SECTION')
1034
 
        self.assertEqual(value, None)
1035
 
        value = tree_config.get_option('non-existant', default='default')
1036
 
        self.assertEqual(value, 'default')
1037
 
        self.assertEqual(tree_config.get_option('key2', 'NOSECTION'), None)
1038
 
        value = tree_config.get_option('key2', 'NOSECTION', default='default')
1039
 
        self.assertEqual(value, 'default')
1040
 
        value = tree_config.get_option('key3')
1041
 
        self.assertEqual(value, 'value3-top')
1042
 
        value = tree_config.get_option('key3', 'SECTION')
1043
 
        self.assertEqual(value, 'value3-section')