1
# Copyright (C) 2005-2012 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
"""Tests for finding and reading the bzr config file[s]."""
18
# import system imports here
19
from cStringIO import StringIO
25
from testtools import matchers
27
#import bzrlib specific imports here
38
registry as _mod_registry,
43
from bzrlib.symbol_versioning import (
46
from bzrlib.transport import remote as transport_remote
47
from bzrlib.tests import (
52
from bzrlib.util.configobj import configobj
55
def lockable_config_scenarios():
58
{'config_class': config.GlobalConfig,
60
'config_section': 'DEFAULT'}),
62
{'config_class': config.LocationConfig,
64
'config_section': '.'}),]
67
load_tests = scenarios.load_tests_apply_scenarios
69
# Register helpers to build stores
70
config.test_store_builder_registry.register(
71
'configobj', lambda test: config.TransportIniFileStore(
72
test.get_transport(), 'configobj.conf'))
73
config.test_store_builder_registry.register(
74
'bazaar', lambda test: config.GlobalStore())
75
config.test_store_builder_registry.register(
76
'location', lambda test: config.LocationStore())
79
def build_backing_branch(test, relpath,
80
transport_class=None, server_class=None):
81
"""Test helper to create a backing branch only once.
83
Some tests needs multiple stores/stacks to check concurrent update
84
behaviours. As such, they need to build different branch *objects* even if
85
they share the branch on disk.
87
:param relpath: The relative path to the branch. (Note that the helper
88
should always specify the same relpath).
90
:param transport_class: The Transport class the test needs to use.
92
:param server_class: The server associated with the ``transport_class``
95
Either both or neither of ``transport_class`` and ``server_class`` should
98
if transport_class is not None and server_class is not None:
99
test.transport_class = transport_class
100
test.transport_server = server_class
101
elif not (transport_class is None and server_class is None):
102
raise AssertionError('Specify both ``transport_class`` and '
103
'``server_class`` or neither of them')
104
if getattr(test, 'backing_branch', None) is None:
105
# First call, let's build the branch on disk
106
test.backing_branch = test.make_branch(relpath)
109
def build_branch_store(test):
110
build_backing_branch(test, 'branch')
111
b = branch.Branch.open('branch')
112
return config.BranchStore(b)
113
config.test_store_builder_registry.register('branch', build_branch_store)
116
def build_control_store(test):
117
build_backing_branch(test, 'branch')
118
b = controldir.ControlDir.open('branch')
119
return config.ControlStore(b)
120
config.test_store_builder_registry.register('control', build_control_store)
123
def build_remote_branch_store(test):
124
# There is only one permutation (but we won't be able to handle more with
125
# this design anyway)
127
server_class) = transport_remote.get_test_permutations()[0]
128
build_backing_branch(test, 'branch', transport_class, server_class)
129
b = branch.Branch.open(test.get_url('branch'))
130
return config.BranchStore(b)
131
config.test_store_builder_registry.register('remote_branch',
132
build_remote_branch_store)
135
config.test_stack_builder_registry.register(
136
'bazaar', lambda test: config.GlobalStack())
137
config.test_stack_builder_registry.register(
138
'location', lambda test: config.LocationStack('.'))
141
def build_branch_stack(test):
142
build_backing_branch(test, 'branch')
143
b = branch.Branch.open('branch')
144
return config.BranchStack(b)
145
config.test_stack_builder_registry.register('branch', build_branch_stack)
148
def build_branch_only_stack(test):
149
# There is only one permutation (but we won't be able to handle more with
150
# this design anyway)
152
server_class) = transport_remote.get_test_permutations()[0]
153
build_backing_branch(test, 'branch', transport_class, server_class)
154
b = branch.Branch.open(test.get_url('branch'))
155
return config.BranchOnlyStack(b)
156
config.test_stack_builder_registry.register('branch_only',
157
build_branch_only_stack)
159
def build_remote_control_stack(test):
160
# There is only one permutation (but we won't be able to handle more with
161
# this design anyway)
163
server_class) = transport_remote.get_test_permutations()[0]
164
# We need only a bzrdir for this, not a full branch, but it's not worth
165
# creating a dedicated helper to create only the bzrdir
166
build_backing_branch(test, 'branch', transport_class, server_class)
167
b = branch.Branch.open(test.get_url('branch'))
168
return config.RemoteControlStack(b.bzrdir)
169
config.test_stack_builder_registry.register('remote_control',
170
build_remote_control_stack)
173
sample_long_alias="log -r-15..-1 --line"
174
sample_config_text = u"""
176
email=Erik B\u00e5gfors <erik@bagfors.nu>
178
change_editor=vimdiff -of @new_path @old_path
179
gpg_signing_command=gnome-gpg
180
gpg_signing_key=DD4D5088
182
validate_signatures_in_log=true
184
user_global_option=something
185
bzr.mergetool.sometool=sometool {base} {this} {other} -o {result}
186
bzr.mergetool.funkytool=funkytool "arg with spaces" {this_temp}
187
bzr.mergetool.newtool='"newtool with spaces" {this_temp}'
188
bzr.default_mergetool=sometool
191
ll=""" + sample_long_alias + "\n"
194
sample_always_signatures = """
196
check_signatures=ignore
197
create_signatures=always
200
sample_ignore_signatures = """
202
check_signatures=require
203
create_signatures=never
206
sample_maybe_signatures = """
208
check_signatures=ignore
209
create_signatures=when-required
212
sample_branches_text = """
213
[http://www.example.com]
215
email=Robert Collins <robertc@example.org>
216
normal_option = normal
217
appendpath_option = append
218
appendpath_option:policy = appendpath
219
norecurse_option = norecurse
220
norecurse_option:policy = norecurse
221
[http://www.example.com/ignoreparent]
222
# different project: ignore parent dir config
224
[http://www.example.com/norecurse]
225
# configuration items that only apply to this dir
227
normal_option = norecurse
228
[http://www.example.com/dir]
229
appendpath_option = normal
231
check_signatures=require
232
# test trailing / matching with no children
234
check_signatures=check-available
235
gpg_signing_command=false
236
gpg_signing_key=default
237
user_local_option=local
238
# test trailing / matching
240
#subdirs will match but not the parent
242
check_signatures=ignore
243
post_commit=bzrlib.tests.test_config.post_commit
244
#testing explicit beats globs
248
def create_configs(test):
249
"""Create configuration files for a given test.
251
This requires creating a tree (and populate the ``test.tree`` attribute)
252
and its associated branch and will populate the following attributes:
254
- branch_config: A BranchConfig for the associated branch.
256
- locations_config : A LocationConfig for the associated branch
258
- bazaar_config: A GlobalConfig.
260
The tree and branch are created in a 'tree' subdirectory so the tests can
261
still use the test directory to stay outside of the branch.
263
tree = test.make_branch_and_tree('tree')
265
test.branch_config = config.BranchConfig(tree.branch)
266
test.locations_config = config.LocationConfig(tree.basedir)
267
test.bazaar_config = config.GlobalConfig()
270
def create_configs_with_file_option(test):
271
"""Create configuration files with a ``file`` option set in each.
273
This builds on ``create_configs`` and add one ``file`` option in each
274
configuration with a value which allows identifying the configuration file.
277
test.bazaar_config.set_user_option('file', 'bazaar')
278
test.locations_config.set_user_option('file', 'locations')
279
test.branch_config.set_user_option('file', 'branch')
282
class TestOptionsMixin:
284
def assertOptions(self, expected, conf):
285
# We don't care about the parser (as it will make tests hard to write
286
# and error-prone anyway)
287
self.assertThat([opt[:4] for opt in conf._get_options()],
288
matchers.Equals(expected))
291
class InstrumentedConfigObj(object):
292
"""A config obj look-enough-alike to record calls made to it."""
294
def __contains__(self, thing):
295
self._calls.append(('__contains__', thing))
298
def __getitem__(self, key):
299
self._calls.append(('__getitem__', key))
302
def __init__(self, input, encoding=None):
303
self._calls = [('__init__', input, encoding)]
305
def __setitem__(self, key, value):
306
self._calls.append(('__setitem__', key, value))
308
def __delitem__(self, key):
309
self._calls.append(('__delitem__', key))
312
self._calls.append(('keys',))
316
self._calls.append(('reload',))
318
def write(self, arg):
319
self._calls.append(('write',))
321
def as_bool(self, value):
322
self._calls.append(('as_bool', value))
325
def get_value(self, section, name):
326
self._calls.append(('get_value', section, name))
330
class FakeBranch(object):
332
def __init__(self, base=None):
334
self.base = "http://example.com/branches/demo"
337
self._transport = self.control_files = \
338
FakeControlFilesAndTransport()
340
def _get_config(self):
341
return config.TransportConfig(self._transport, 'branch.conf')
343
def lock_write(self):
350
class FakeControlFilesAndTransport(object):
354
self._transport = self
356
def get(self, filename):
359
return StringIO(self.files[filename])
361
raise errors.NoSuchFile(filename)
363
def get_bytes(self, filename):
366
return self.files[filename]
368
raise errors.NoSuchFile(filename)
370
def put(self, filename, fileobj):
371
self.files[filename] = fileobj.read()
373
def put_file(self, filename, fileobj):
374
return self.put(filename, fileobj)
377
class InstrumentedConfig(config.Config):
378
"""An instrumented config that supplies stubs for template methods."""
381
super(InstrumentedConfig, self).__init__()
383
self._signatures = config.CHECK_NEVER
385
def _get_user_id(self):
386
self._calls.append('_get_user_id')
387
return "Robert Collins <robert.collins@example.org>"
389
def _get_signature_checking(self):
390
self._calls.append('_get_signature_checking')
391
return self._signatures
393
def _get_change_editor(self):
394
self._calls.append('_get_change_editor')
395
return 'vimdiff -fo @new_path @old_path'
398
bool_config = """[DEFAULT]
407
class TestConfigObj(tests.TestCase):
409
def test_get_bool(self):
410
co = config.ConfigObj(StringIO(bool_config))
411
self.assertIs(co.get_bool('DEFAULT', 'active'), True)
412
self.assertIs(co.get_bool('DEFAULT', 'inactive'), False)
413
self.assertIs(co.get_bool('UPPERCASE', 'active'), True)
414
self.assertIs(co.get_bool('UPPERCASE', 'nonactive'), False)
416
def test_hash_sign_in_value(self):
418
Before 4.5.0, ConfigObj did not quote # signs in values, so they'd be
419
treated as comments when read in again. (#86838)
421
co = config.ConfigObj()
422
co['test'] = 'foo#bar'
424
co.write(outfile=outfile)
425
lines = outfile.getvalue().splitlines()
426
self.assertEqual(lines, ['test = "foo#bar"'])
427
co2 = config.ConfigObj(lines)
428
self.assertEqual(co2['test'], 'foo#bar')
430
def test_triple_quotes(self):
431
# Bug #710410: if the value string has triple quotes
432
# then ConfigObj versions up to 4.7.2 will quote them wrong
433
# and won't able to read them back
434
triple_quotes_value = '''spam
435
""" that's my spam """
437
co = config.ConfigObj()
438
co['test'] = triple_quotes_value
439
# While writing this test another bug in ConfigObj has been found:
440
# method co.write() without arguments produces list of lines
441
# one option per line, and multiline values are not split
442
# across multiple lines,
443
# and that breaks the parsing these lines back by ConfigObj.
444
# This issue only affects test, but it's better to avoid
445
# `co.write()` construct at all.
446
# [bialix 20110222] bug report sent to ConfigObj's author
448
co.write(outfile=outfile)
449
output = outfile.getvalue()
450
# now we're trying to read it back
451
co2 = config.ConfigObj(StringIO(output))
452
self.assertEquals(triple_quotes_value, co2['test'])
455
erroneous_config = """[section] # line 1
458
whocares=notme # line 4
462
class TestConfigObjErrors(tests.TestCase):
464
def test_duplicate_section_name_error_line(self):
466
co = configobj.ConfigObj(StringIO(erroneous_config),
468
except config.configobj.DuplicateError, e:
469
self.assertEqual(3, e.line_number)
471
self.fail('Error in config file not detected')
474
class TestConfig(tests.TestCase):
476
def test_constructs(self):
479
def test_user_email(self):
480
my_config = InstrumentedConfig()
481
self.assertEqual('robert.collins@example.org', my_config.user_email())
482
self.assertEqual(['_get_user_id'], my_config._calls)
484
def test_username(self):
485
my_config = InstrumentedConfig()
486
self.assertEqual('Robert Collins <robert.collins@example.org>',
487
my_config.username())
488
self.assertEqual(['_get_user_id'], my_config._calls)
490
def test_signatures_default(self):
491
my_config = config.Config()
493
self.applyDeprecated(deprecated_in((2, 5, 0)),
494
my_config.signature_needed))
495
self.assertEqual(config.CHECK_IF_POSSIBLE,
496
self.applyDeprecated(deprecated_in((2, 5, 0)),
497
my_config.signature_checking))
498
self.assertEqual(config.SIGN_WHEN_REQUIRED,
499
self.applyDeprecated(deprecated_in((2, 5, 0)),
500
my_config.signing_policy))
502
def test_signatures_template_method(self):
503
my_config = InstrumentedConfig()
504
self.assertEqual(config.CHECK_NEVER,
505
self.applyDeprecated(deprecated_in((2, 5, 0)),
506
my_config.signature_checking))
507
self.assertEqual(['_get_signature_checking'], my_config._calls)
509
def test_signatures_template_method_none(self):
510
my_config = InstrumentedConfig()
511
my_config._signatures = None
512
self.assertEqual(config.CHECK_IF_POSSIBLE,
513
self.applyDeprecated(deprecated_in((2, 5, 0)),
514
my_config.signature_checking))
515
self.assertEqual(['_get_signature_checking'], my_config._calls)
517
def test_gpg_signing_command_default(self):
518
my_config = config.Config()
519
self.assertEqual('gpg',
520
self.applyDeprecated(deprecated_in((2, 5, 0)),
521
my_config.gpg_signing_command))
523
def test_get_user_option_default(self):
524
my_config = config.Config()
525
self.assertEqual(None, my_config.get_user_option('no_option'))
527
def test_post_commit_default(self):
528
my_config = config.Config()
529
self.assertEqual(None, self.applyDeprecated(deprecated_in((2, 5, 0)),
530
my_config.post_commit))
533
def test_log_format_default(self):
534
my_config = config.Config()
535
self.assertEqual('long',
536
self.applyDeprecated(deprecated_in((2, 5, 0)),
537
my_config.log_format))
539
def test_acceptable_keys_default(self):
540
my_config = config.Config()
541
self.assertEqual(None, self.applyDeprecated(deprecated_in((2, 5, 0)),
542
my_config.acceptable_keys))
544
def test_validate_signatures_in_log_default(self):
545
my_config = config.Config()
546
self.assertEqual(False, my_config.validate_signatures_in_log())
548
def test_get_change_editor(self):
549
my_config = InstrumentedConfig()
550
change_editor = my_config.get_change_editor('old_tree', 'new_tree')
551
self.assertEqual(['_get_change_editor'], my_config._calls)
552
self.assertIs(diff.DiffFromTool, change_editor.__class__)
553
self.assertEqual(['vimdiff', '-fo', '@new_path', '@old_path'],
554
change_editor.command_template)
557
class TestConfigPath(tests.TestCase):
560
super(TestConfigPath, self).setUp()
561
self.overrideEnv('HOME', '/home/bogus')
562
self.overrideEnv('XDG_CACHE_DIR', '')
563
if sys.platform == 'win32':
565
'BZR_HOME', r'C:\Documents and Settings\bogus\Application Data')
567
'C:/Documents and Settings/bogus/Application Data/bazaar/2.0'
569
self.bzr_home = '/home/bogus/.bazaar'
571
def test_config_dir(self):
572
self.assertEqual(config.config_dir(), self.bzr_home)
574
def test_config_dir_is_unicode(self):
575
self.assertIsInstance(config.config_dir(), unicode)
577
def test_config_filename(self):
578
self.assertEqual(config.config_filename(),
579
self.bzr_home + '/bazaar.conf')
581
def test_locations_config_filename(self):
582
self.assertEqual(config.locations_config_filename(),
583
self.bzr_home + '/locations.conf')
585
def test_authentication_config_filename(self):
586
self.assertEqual(config.authentication_config_filename(),
587
self.bzr_home + '/authentication.conf')
589
def test_xdg_cache_dir(self):
590
self.assertEqual(config.xdg_cache_dir(),
591
'/home/bogus/.cache')
594
class TestXDGConfigDir(tests.TestCaseInTempDir):
595
# must be in temp dir because config tests for the existence of the bazaar
596
# subdirectory of $XDG_CONFIG_HOME
599
if sys.platform in ('darwin', 'win32'):
600
raise tests.TestNotApplicable(
601
'XDG config dir not used on this platform')
602
super(TestXDGConfigDir, self).setUp()
603
self.overrideEnv('HOME', self.test_home_dir)
604
# BZR_HOME overrides everything we want to test so unset it.
605
self.overrideEnv('BZR_HOME', None)
607
def test_xdg_config_dir_exists(self):
608
"""When ~/.config/bazaar exists, use it as the config dir."""
609
newdir = osutils.pathjoin(self.test_home_dir, '.config', 'bazaar')
611
self.assertEqual(config.config_dir(), newdir)
613
def test_xdg_config_home(self):
614
"""When XDG_CONFIG_HOME is set, use it."""
615
xdgconfigdir = osutils.pathjoin(self.test_home_dir, 'xdgconfig')
616
self.overrideEnv('XDG_CONFIG_HOME', xdgconfigdir)
617
newdir = osutils.pathjoin(xdgconfigdir, 'bazaar')
619
self.assertEqual(config.config_dir(), newdir)
622
class TestIniConfig(tests.TestCaseInTempDir):
624
def make_config_parser(self, s):
625
conf = config.IniBasedConfig.from_string(s)
626
return conf, conf._get_parser()
629
class TestIniConfigBuilding(TestIniConfig):
631
def test_contructs(self):
632
my_config = config.IniBasedConfig()
634
def test_from_fp(self):
635
my_config = config.IniBasedConfig.from_string(sample_config_text)
636
self.assertIsInstance(my_config._get_parser(), configobj.ConfigObj)
638
def test_cached(self):
639
my_config = config.IniBasedConfig.from_string(sample_config_text)
640
parser = my_config._get_parser()
641
self.assertTrue(my_config._get_parser() is parser)
643
def _dummy_chown(self, path, uid, gid):
644
self.path, self.uid, self.gid = path, uid, gid
646
def test_ini_config_ownership(self):
647
"""Ensure that chown is happening during _write_config_file"""
648
self.requireFeature(features.chown_feature)
649
self.overrideAttr(os, 'chown', self._dummy_chown)
650
self.path = self.uid = self.gid = None
651
conf = config.IniBasedConfig(file_name='./foo.conf')
652
conf._write_config_file()
653
self.assertEquals(self.path, './foo.conf')
654
self.assertTrue(isinstance(self.uid, int))
655
self.assertTrue(isinstance(self.gid, int))
657
def test_get_filename_parameter_is_deprecated_(self):
658
conf = self.callDeprecated([
659
'IniBasedConfig.__init__(get_filename) was deprecated in 2.3.'
660
' Use file_name instead.'],
661
config.IniBasedConfig, lambda: 'ini.conf')
662
self.assertEqual('ini.conf', conf.file_name)
664
def test_get_parser_file_parameter_is_deprecated_(self):
665
config_file = StringIO(sample_config_text.encode('utf-8'))
666
conf = config.IniBasedConfig.from_string(sample_config_text)
667
conf = self.callDeprecated([
668
'IniBasedConfig._get_parser(file=xxx) was deprecated in 2.3.'
669
' Use IniBasedConfig(_content=xxx) instead.'],
670
conf._get_parser, file=config_file)
673
class TestIniConfigSaving(tests.TestCaseInTempDir):
675
def test_cant_save_without_a_file_name(self):
676
conf = config.IniBasedConfig()
677
self.assertRaises(AssertionError, conf._write_config_file)
679
def test_saved_with_content(self):
680
content = 'foo = bar\n'
681
conf = config.IniBasedConfig.from_string(
682
content, file_name='./test.conf', save=True)
683
self.assertFileEqual(content, 'test.conf')
686
class TestIniConfigOptionExpansion(tests.TestCase):
687
"""Test option expansion from the IniConfig level.
689
What we really want here is to test the Config level, but the class being
690
abstract as far as storing values is concerned, this can't be done
693
# FIXME: This should be rewritten when all configs share a storage
694
# implementation -- vila 2011-02-18
696
def get_config(self, string=None):
699
c = config.IniBasedConfig.from_string(string)
702
def assertExpansion(self, expected, conf, string, env=None):
703
self.assertEquals(expected, conf.expand_options(string, env))
705
def test_no_expansion(self):
706
c = self.get_config('')
707
self.assertExpansion('foo', c, 'foo')
709
def test_env_adding_options(self):
710
c = self.get_config('')
711
self.assertExpansion('bar', c, '{foo}', {'foo': 'bar'})
713
def test_env_overriding_options(self):
714
c = self.get_config('foo=baz')
715
self.assertExpansion('bar', c, '{foo}', {'foo': 'bar'})
717
def test_simple_ref(self):
718
c = self.get_config('foo=xxx')
719
self.assertExpansion('xxx', c, '{foo}')
721
def test_unknown_ref(self):
722
c = self.get_config('')
723
self.assertRaises(errors.ExpandingUnknownOption,
724
c.expand_options, '{foo}')
726
def test_indirect_ref(self):
727
c = self.get_config('''
731
self.assertExpansion('xxx', c, '{bar}')
733
def test_embedded_ref(self):
734
c = self.get_config('''
738
self.assertExpansion('xxx', c, '{{bar}}')
740
def test_simple_loop(self):
741
c = self.get_config('foo={foo}')
742
self.assertRaises(errors.OptionExpansionLoop, c.expand_options, '{foo}')
744
def test_indirect_loop(self):
745
c = self.get_config('''
749
e = self.assertRaises(errors.OptionExpansionLoop,
750
c.expand_options, '{foo}')
751
self.assertEquals('foo->bar->baz', e.refs)
752
self.assertEquals('{foo}', e.string)
755
conf = self.get_config('''
759
list={foo},{bar},{baz}
761
self.assertEquals(['start', 'middle', 'end'],
762
conf.get_user_option('list', expand=True))
764
def test_cascading_list(self):
765
conf = self.get_config('''
771
self.assertEquals(['start', 'middle', 'end'],
772
conf.get_user_option('list', expand=True))
774
def test_pathological_hidden_list(self):
775
conf = self.get_config('''
781
hidden={start}{middle}{end}
783
# Nope, it's either a string or a list, and the list wins as soon as a
784
# ',' appears, so the string concatenation never occur.
785
self.assertEquals(['{foo', '}', '{', 'bar}'],
786
conf.get_user_option('hidden', expand=True))
789
class TestLocationConfigOptionExpansion(tests.TestCaseInTempDir):
791
def get_config(self, location, string=None):
794
# Since we don't save the config we won't strictly require to inherit
795
# from TestCaseInTempDir, but an error occurs so quickly...
796
c = config.LocationConfig.from_string(string, location)
799
def test_dont_cross_unrelated_section(self):
800
c = self.get_config('/another/branch/path','''
805
[/another/branch/path]
808
self.assertRaises(errors.ExpandingUnknownOption,
809
c.get_user_option, 'bar', expand=True)
811
def test_cross_related_sections(self):
812
c = self.get_config('/project/branch/path','''
816
[/project/branch/path]
819
self.assertEquals('quux', c.get_user_option('bar', expand=True))
822
class TestIniBaseConfigOnDisk(tests.TestCaseInTempDir):
824
def test_cannot_reload_without_name(self):
825
conf = config.IniBasedConfig.from_string(sample_config_text)
826
self.assertRaises(AssertionError, conf.reload)
828
def test_reload_see_new_value(self):
829
c1 = config.IniBasedConfig.from_string('editor=vim\n',
830
file_name='./test/conf')
831
c1._write_config_file()
832
c2 = config.IniBasedConfig.from_string('editor=emacs\n',
833
file_name='./test/conf')
834
c2._write_config_file()
835
self.assertEqual('vim', c1.get_user_option('editor'))
836
self.assertEqual('emacs', c2.get_user_option('editor'))
837
# Make sure we get the Right value
839
self.assertEqual('emacs', c1.get_user_option('editor'))
842
class TestLockableConfig(tests.TestCaseInTempDir):
844
scenarios = lockable_config_scenarios()
849
config_section = None
852
super(TestLockableConfig, self).setUp()
853
self._content = '[%s]\none=1\ntwo=2\n' % (self.config_section,)
854
self.config = self.create_config(self._content)
856
def get_existing_config(self):
857
return self.config_class(*self.config_args)
859
def create_config(self, content):
860
kwargs = dict(save=True)
861
c = self.config_class.from_string(content, *self.config_args, **kwargs)
864
def test_simple_read_access(self):
865
self.assertEquals('1', self.config.get_user_option('one'))
867
def test_simple_write_access(self):
868
self.config.set_user_option('one', 'one')
869
self.assertEquals('one', self.config.get_user_option('one'))
871
def test_listen_to_the_last_speaker(self):
873
c2 = self.get_existing_config()
874
c1.set_user_option('one', 'ONE')
875
c2.set_user_option('two', 'TWO')
876
self.assertEquals('ONE', c1.get_user_option('one'))
877
self.assertEquals('TWO', c2.get_user_option('two'))
878
# The second update respect the first one
879
self.assertEquals('ONE', c2.get_user_option('one'))
881
def test_last_speaker_wins(self):
882
# If the same config is not shared, the same variable modified twice
883
# can only see a single result.
885
c2 = self.get_existing_config()
886
c1.set_user_option('one', 'c1')
887
c2.set_user_option('one', 'c2')
888
self.assertEquals('c2', c2._get_user_option('one'))
889
# The first modification is still available until another refresh
891
self.assertEquals('c1', c1._get_user_option('one'))
892
c1.set_user_option('two', 'done')
893
self.assertEquals('c2', c1._get_user_option('one'))
895
def test_writes_are_serialized(self):
897
c2 = self.get_existing_config()
899
# We spawn a thread that will pause *during* the write
900
before_writing = threading.Event()
901
after_writing = threading.Event()
902
writing_done = threading.Event()
903
c1_orig = c1._write_config_file
904
def c1_write_config_file():
907
# The lock is held. We wait for the main thread to decide when to
910
c1._write_config_file = c1_write_config_file
912
c1.set_user_option('one', 'c1')
914
t1 = threading.Thread(target=c1_set_option)
915
# Collect the thread after the test
916
self.addCleanup(t1.join)
917
# Be ready to unblock the thread if the test goes wrong
918
self.addCleanup(after_writing.set)
920
before_writing.wait()
921
self.assertTrue(c1._lock.is_held)
922
self.assertRaises(errors.LockContention,
923
c2.set_user_option, 'one', 'c2')
924
self.assertEquals('c1', c1.get_user_option('one'))
925
# Let the lock be released
928
c2.set_user_option('one', 'c2')
929
self.assertEquals('c2', c2.get_user_option('one'))
931
def test_read_while_writing(self):
933
# We spawn a thread that will pause *during* the write
934
ready_to_write = threading.Event()
935
do_writing = threading.Event()
936
writing_done = threading.Event()
937
c1_orig = c1._write_config_file
938
def c1_write_config_file():
940
# The lock is held. We wait for the main thread to decide when to
945
c1._write_config_file = c1_write_config_file
947
c1.set_user_option('one', 'c1')
948
t1 = threading.Thread(target=c1_set_option)
949
# Collect the thread after the test
950
self.addCleanup(t1.join)
951
# Be ready to unblock the thread if the test goes wrong
952
self.addCleanup(do_writing.set)
954
# Ensure the thread is ready to write
955
ready_to_write.wait()
956
self.assertTrue(c1._lock.is_held)
957
self.assertEquals('c1', c1.get_user_option('one'))
958
# If we read during the write, we get the old value
959
c2 = self.get_existing_config()
960
self.assertEquals('1', c2.get_user_option('one'))
961
# Let the writing occur and ensure it occurred
964
# Now we get the updated value
965
c3 = self.get_existing_config()
966
self.assertEquals('c1', c3.get_user_option('one'))
969
class TestGetUserOptionAs(TestIniConfig):
971
def test_get_user_option_as_bool(self):
972
conf, parser = self.make_config_parser("""
975
an_invalid_bool = maybe
976
a_list = hmm, who knows ? # This is interpreted as a list !
978
get_bool = conf.get_user_option_as_bool
979
self.assertEqual(True, get_bool('a_true_bool'))
980
self.assertEqual(False, get_bool('a_false_bool'))
983
warnings.append(args[0] % args[1:])
984
self.overrideAttr(trace, 'warning', warning)
985
msg = 'Value "%s" is not a boolean for "%s"'
986
self.assertIs(None, get_bool('an_invalid_bool'))
987
self.assertEquals(msg % ('maybe', 'an_invalid_bool'), warnings[0])
989
self.assertIs(None, get_bool('not_defined_in_this_config'))
990
self.assertEquals([], warnings)
992
def test_get_user_option_as_list(self):
993
conf, parser = self.make_config_parser("""
998
get_list = conf.get_user_option_as_list
999
self.assertEqual(['a', 'b', 'c'], get_list('a_list'))
1000
self.assertEqual(['1'], get_list('length_1'))
1001
self.assertEqual('x', conf.get_user_option('one_item'))
1002
# automatically cast to list
1003
self.assertEqual(['x'], get_list('one_item'))
1005
def test_get_user_option_as_int_from_SI(self):
1006
conf, parser = self.make_config_parser("""
1015
def get_si(s, default=None):
1016
return self.applyDeprecated(
1017
deprecated_in((2, 5, 0)),
1018
conf.get_user_option_as_int_from_SI, s, default)
1019
self.assertEqual(100, get_si('plain'))
1020
self.assertEqual(5000, get_si('si_k'))
1021
self.assertEqual(5000, get_si('si_kb'))
1022
self.assertEqual(5000000, get_si('si_m'))
1023
self.assertEqual(5000000, get_si('si_mb'))
1024
self.assertEqual(5000000000, get_si('si_g'))
1025
self.assertEqual(5000000000, get_si('si_gb'))
1026
self.assertEqual(None, get_si('non-exist'))
1027
self.assertEqual(42, get_si('non-exist-with-default', 42))
1030
class TestSupressWarning(TestIniConfig):
1032
def make_warnings_config(self, s):
1033
conf, parser = self.make_config_parser(s)
1034
return conf.suppress_warning
1036
def test_suppress_warning_unknown(self):
1037
suppress_warning = self.make_warnings_config('')
1038
self.assertEqual(False, suppress_warning('unknown_warning'))
1040
def test_suppress_warning_known(self):
1041
suppress_warning = self.make_warnings_config('suppress_warnings=a,b')
1042
self.assertEqual(False, suppress_warning('c'))
1043
self.assertEqual(True, suppress_warning('a'))
1044
self.assertEqual(True, suppress_warning('b'))
1047
class TestGetConfig(tests.TestCase):
1049
def test_constructs(self):
1050
my_config = config.GlobalConfig()
1052
def test_calls_read_filenames(self):
1053
# replace the class that is constructed, to check its parameters
1054
oldparserclass = config.ConfigObj
1055
config.ConfigObj = InstrumentedConfigObj
1056
my_config = config.GlobalConfig()
1058
parser = my_config._get_parser()
1060
config.ConfigObj = oldparserclass
1061
self.assertIsInstance(parser, InstrumentedConfigObj)
1062
self.assertEqual(parser._calls, [('__init__', config.config_filename(),
1066
class TestBranchConfig(tests.TestCaseWithTransport):
1068
def test_constructs(self):
1069
branch = FakeBranch()
1070
my_config = config.BranchConfig(branch)
1071
self.assertRaises(TypeError, config.BranchConfig)
1073
def test_get_location_config(self):
1074
branch = FakeBranch()
1075
my_config = config.BranchConfig(branch)
1076
location_config = my_config._get_location_config()
1077
self.assertEqual(branch.base, location_config.location)
1078
self.assertIs(location_config, my_config._get_location_config())
1080
def test_get_config(self):
1081
"""The Branch.get_config method works properly"""
1082
b = controldir.ControlDir.create_standalone_workingtree('.').branch
1083
my_config = b.get_config()
1084
self.assertIs(my_config.get_user_option('wacky'), None)
1085
my_config.set_user_option('wacky', 'unlikely')
1086
self.assertEqual(my_config.get_user_option('wacky'), 'unlikely')
1088
# Ensure we get the same thing if we start again
1089
b2 = branch.Branch.open('.')
1090
my_config2 = b2.get_config()
1091
self.assertEqual(my_config2.get_user_option('wacky'), 'unlikely')
1093
def test_has_explicit_nickname(self):
1094
b = self.make_branch('.')
1095
self.assertFalse(b.get_config().has_explicit_nickname())
1097
self.assertTrue(b.get_config().has_explicit_nickname())
1099
def test_config_url(self):
1100
"""The Branch.get_config will use section that uses a local url"""
1101
branch = self.make_branch('branch')
1102
self.assertEqual('branch', branch.nick)
1104
local_url = urlutils.local_path_to_url('branch')
1105
conf = config.LocationConfig.from_string(
1106
'[%s]\nnickname = foobar' % (local_url,),
1107
local_url, save=True)
1108
self.assertEqual('foobar', branch.nick)
1110
def test_config_local_path(self):
1111
"""The Branch.get_config will use a local system path"""
1112
branch = self.make_branch('branch')
1113
self.assertEqual('branch', branch.nick)
1115
local_path = osutils.getcwd().encode('utf8')
1116
conf = config.LocationConfig.from_string(
1117
'[%s/branch]\nnickname = barry' % (local_path,),
1118
'branch', save=True)
1119
self.assertEqual('barry', branch.nick)
1121
def test_config_creates_local(self):
1122
"""Creating a new entry in config uses a local path."""
1123
branch = self.make_branch('branch', format='knit')
1124
branch.set_push_location('http://foobar')
1125
local_path = osutils.getcwd().encode('utf8')
1126
# Surprisingly ConfigObj doesn't create a trailing newline
1127
self.check_file_contents(config.locations_config_filename(),
1129
'push_location = http://foobar\n'
1130
'push_location:policy = norecurse\n'
1133
def test_autonick_urlencoded(self):
1134
b = self.make_branch('!repo')
1135
self.assertEqual('!repo', b.get_config().get_nickname())
1137
def test_autonick_uses_branch_name(self):
1138
b = self.make_branch('foo', name='bar')
1139
self.assertEqual('bar', b.get_config().get_nickname())
1141
def test_warn_if_masked(self):
1144
warnings.append(args[0] % args[1:])
1145
self.overrideAttr(trace, 'warning', warning)
1147
def set_option(store, warn_masked=True):
1149
conf.set_user_option('example_option', repr(store), store=store,
1150
warn_masked=warn_masked)
1151
def assertWarning(warning):
1153
self.assertEqual(0, len(warnings))
1155
self.assertEqual(1, len(warnings))
1156
self.assertEqual(warning, warnings[0])
1157
branch = self.make_branch('.')
1158
conf = branch.get_config()
1159
set_option(config.STORE_GLOBAL)
1161
set_option(config.STORE_BRANCH)
1163
set_option(config.STORE_GLOBAL)
1164
assertWarning('Value "4" is masked by "3" from branch.conf')
1165
set_option(config.STORE_GLOBAL, warn_masked=False)
1167
set_option(config.STORE_LOCATION)
1169
set_option(config.STORE_BRANCH)
1170
assertWarning('Value "3" is masked by "0" from locations.conf')
1171
set_option(config.STORE_BRANCH, warn_masked=False)
1175
class TestGlobalConfigItems(tests.TestCaseInTempDir):
1177
def test_user_id(self):
1178
my_config = config.GlobalConfig.from_string(sample_config_text)
1179
self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
1180
my_config._get_user_id())
1182
def test_absent_user_id(self):
1183
my_config = config.GlobalConfig()
1184
self.assertEqual(None, my_config._get_user_id())
1186
def test_signatures_always(self):
1187
my_config = config.GlobalConfig.from_string(sample_always_signatures)
1188
self.assertEqual(config.CHECK_NEVER,
1189
self.applyDeprecated(deprecated_in((2, 5, 0)),
1190
my_config.signature_checking))
1191
self.assertEqual(config.SIGN_ALWAYS,
1192
self.applyDeprecated(deprecated_in((2, 5, 0)),
1193
my_config.signing_policy))
1194
self.assertEqual(True,
1195
self.applyDeprecated(deprecated_in((2, 5, 0)),
1196
my_config.signature_needed))
1198
def test_signatures_if_possible(self):
1199
my_config = config.GlobalConfig.from_string(sample_maybe_signatures)
1200
self.assertEqual(config.CHECK_NEVER,
1201
self.applyDeprecated(deprecated_in((2, 5, 0)),
1202
my_config.signature_checking))
1203
self.assertEqual(config.SIGN_WHEN_REQUIRED,
1204
self.applyDeprecated(deprecated_in((2, 5, 0)),
1205
my_config.signing_policy))
1206
self.assertEqual(False, self.applyDeprecated(deprecated_in((2, 5, 0)),
1207
my_config.signature_needed))
1209
def test_signatures_ignore(self):
1210
my_config = config.GlobalConfig.from_string(sample_ignore_signatures)
1211
self.assertEqual(config.CHECK_ALWAYS,
1212
self.applyDeprecated(deprecated_in((2, 5, 0)),
1213
my_config.signature_checking))
1214
self.assertEqual(config.SIGN_NEVER,
1215
self.applyDeprecated(deprecated_in((2, 5, 0)),
1216
my_config.signing_policy))
1217
self.assertEqual(False, self.applyDeprecated(deprecated_in((2, 5, 0)),
1218
my_config.signature_needed))
1220
def _get_sample_config(self):
1221
my_config = config.GlobalConfig.from_string(sample_config_text)
1224
def test_gpg_signing_command(self):
1225
my_config = self._get_sample_config()
1226
self.assertEqual("gnome-gpg",
1227
self.applyDeprecated(
1228
deprecated_in((2, 5, 0)), my_config.gpg_signing_command))
1229
self.assertEqual(False, self.applyDeprecated(deprecated_in((2, 5, 0)),
1230
my_config.signature_needed))
1232
def test_gpg_signing_key(self):
1233
my_config = self._get_sample_config()
1234
self.assertEqual("DD4D5088",
1235
self.applyDeprecated(deprecated_in((2, 5, 0)),
1236
my_config.gpg_signing_key))
1238
def _get_empty_config(self):
1239
my_config = config.GlobalConfig()
1242
def test_gpg_signing_command_unset(self):
1243
my_config = self._get_empty_config()
1244
self.assertEqual("gpg",
1245
self.applyDeprecated(
1246
deprecated_in((2, 5, 0)), my_config.gpg_signing_command))
1248
def test_get_user_option_default(self):
1249
my_config = self._get_empty_config()
1250
self.assertEqual(None, my_config.get_user_option('no_option'))
1252
def test_get_user_option_global(self):
1253
my_config = self._get_sample_config()
1254
self.assertEqual("something",
1255
my_config.get_user_option('user_global_option'))
1257
def test_post_commit_default(self):
1258
my_config = self._get_sample_config()
1259
self.assertEqual(None,
1260
self.applyDeprecated(deprecated_in((2, 5, 0)),
1261
my_config.post_commit))
1263
def test_configured_logformat(self):
1264
my_config = self._get_sample_config()
1265
self.assertEqual("short",
1266
self.applyDeprecated(deprecated_in((2, 5, 0)),
1267
my_config.log_format))
1269
def test_configured_acceptable_keys(self):
1270
my_config = self._get_sample_config()
1271
self.assertEqual("amy",
1272
self.applyDeprecated(deprecated_in((2, 5, 0)),
1273
my_config.acceptable_keys))
1275
def test_configured_validate_signatures_in_log(self):
1276
my_config = self._get_sample_config()
1277
self.assertEqual(True, my_config.validate_signatures_in_log())
1279
def test_get_alias(self):
1280
my_config = self._get_sample_config()
1281
self.assertEqual('help', my_config.get_alias('h'))
1283
def test_get_aliases(self):
1284
my_config = self._get_sample_config()
1285
aliases = my_config.get_aliases()
1286
self.assertEqual(2, len(aliases))
1287
sorted_keys = sorted(aliases)
1288
self.assertEqual('help', aliases[sorted_keys[0]])
1289
self.assertEqual(sample_long_alias, aliases[sorted_keys[1]])
1291
def test_get_no_alias(self):
1292
my_config = self._get_sample_config()
1293
self.assertEqual(None, my_config.get_alias('foo'))
1295
def test_get_long_alias(self):
1296
my_config = self._get_sample_config()
1297
self.assertEqual(sample_long_alias, my_config.get_alias('ll'))
1299
def test_get_change_editor(self):
1300
my_config = self._get_sample_config()
1301
change_editor = my_config.get_change_editor('old', 'new')
1302
self.assertIs(diff.DiffFromTool, change_editor.__class__)
1303
self.assertEqual('vimdiff -of @new_path @old_path',
1304
' '.join(change_editor.command_template))
1306
def test_get_no_change_editor(self):
1307
my_config = self._get_empty_config()
1308
change_editor = my_config.get_change_editor('old', 'new')
1309
self.assertIs(None, change_editor)
1311
def test_get_merge_tools(self):
1312
conf = self._get_sample_config()
1313
tools = conf.get_merge_tools()
1314
self.log(repr(tools))
1316
{u'funkytool' : u'funkytool "arg with spaces" {this_temp}',
1317
u'sometool' : u'sometool {base} {this} {other} -o {result}',
1318
u'newtool' : u'"newtool with spaces" {this_temp}'},
1321
def test_get_merge_tools_empty(self):
1322
conf = self._get_empty_config()
1323
tools = conf.get_merge_tools()
1324
self.assertEqual({}, tools)
1326
def test_find_merge_tool(self):
1327
conf = self._get_sample_config()
1328
cmdline = conf.find_merge_tool('sometool')
1329
self.assertEqual('sometool {base} {this} {other} -o {result}', cmdline)
1331
def test_find_merge_tool_not_found(self):
1332
conf = self._get_sample_config()
1333
cmdline = conf.find_merge_tool('DOES NOT EXIST')
1334
self.assertIs(cmdline, None)
1336
def test_find_merge_tool_known(self):
1337
conf = self._get_empty_config()
1338
cmdline = conf.find_merge_tool('kdiff3')
1339
self.assertEquals('kdiff3 {base} {this} {other} -o {result}', cmdline)
1341
def test_find_merge_tool_override_known(self):
1342
conf = self._get_empty_config()
1343
conf.set_user_option('bzr.mergetool.kdiff3', 'kdiff3 blah')
1344
cmdline = conf.find_merge_tool('kdiff3')
1345
self.assertEqual('kdiff3 blah', cmdline)
1348
class TestGlobalConfigSavingOptions(tests.TestCaseInTempDir):
1350
def test_empty(self):
1351
my_config = config.GlobalConfig()
1352
self.assertEqual(0, len(my_config.get_aliases()))
1354
def test_set_alias(self):
1355
my_config = config.GlobalConfig()
1356
alias_value = 'commit --strict'
1357
my_config.set_alias('commit', alias_value)
1358
new_config = config.GlobalConfig()
1359
self.assertEqual(alias_value, new_config.get_alias('commit'))
1361
def test_remove_alias(self):
1362
my_config = config.GlobalConfig()
1363
my_config.set_alias('commit', 'commit --strict')
1364
# Now remove the alias again.
1365
my_config.unset_alias('commit')
1366
new_config = config.GlobalConfig()
1367
self.assertIs(None, new_config.get_alias('commit'))
1370
class TestLocationConfig(tests.TestCaseInTempDir, TestOptionsMixin):
1372
def test_constructs(self):
1373
my_config = config.LocationConfig('http://example.com')
1374
self.assertRaises(TypeError, config.LocationConfig)
1376
def test_branch_calls_read_filenames(self):
1377
# This is testing the correct file names are provided.
1378
# TODO: consolidate with the test for GlobalConfigs filename checks.
1380
# replace the class that is constructed, to check its parameters
1381
oldparserclass = config.ConfigObj
1382
config.ConfigObj = InstrumentedConfigObj
1384
my_config = config.LocationConfig('http://www.example.com')
1385
parser = my_config._get_parser()
1387
config.ConfigObj = oldparserclass
1388
self.assertIsInstance(parser, InstrumentedConfigObj)
1389
self.assertEqual(parser._calls,
1390
[('__init__', config.locations_config_filename(),
1393
def test_get_global_config(self):
1394
my_config = config.BranchConfig(FakeBranch('http://example.com'))
1395
global_config = my_config._get_global_config()
1396
self.assertIsInstance(global_config, config.GlobalConfig)
1397
self.assertIs(global_config, my_config._get_global_config())
1399
def assertLocationMatching(self, expected):
1400
self.assertEqual(expected,
1401
list(self.my_location_config._get_matching_sections()))
1403
def test__get_matching_sections_no_match(self):
1404
self.get_branch_config('/')
1405
self.assertLocationMatching([])
1407
def test__get_matching_sections_exact(self):
1408
self.get_branch_config('http://www.example.com')
1409
self.assertLocationMatching([('http://www.example.com', '')])
1411
def test__get_matching_sections_suffix_does_not(self):
1412
self.get_branch_config('http://www.example.com-com')
1413
self.assertLocationMatching([])
1415
def test__get_matching_sections_subdir_recursive(self):
1416
self.get_branch_config('http://www.example.com/com')
1417
self.assertLocationMatching([('http://www.example.com', 'com')])
1419
def test__get_matching_sections_ignoreparent(self):
1420
self.get_branch_config('http://www.example.com/ignoreparent')
1421
self.assertLocationMatching([('http://www.example.com/ignoreparent',
1424
def test__get_matching_sections_ignoreparent_subdir(self):
1425
self.get_branch_config(
1426
'http://www.example.com/ignoreparent/childbranch')
1427
self.assertLocationMatching([('http://www.example.com/ignoreparent',
1430
def test__get_matching_sections_subdir_trailing_slash(self):
1431
self.get_branch_config('/b')
1432
self.assertLocationMatching([('/b/', '')])
1434
def test__get_matching_sections_subdir_child(self):
1435
self.get_branch_config('/a/foo')
1436
self.assertLocationMatching([('/a/*', ''), ('/a/', 'foo')])
1438
def test__get_matching_sections_subdir_child_child(self):
1439
self.get_branch_config('/a/foo/bar')
1440
self.assertLocationMatching([('/a/*', 'bar'), ('/a/', 'foo/bar')])
1442
def test__get_matching_sections_trailing_slash_with_children(self):
1443
self.get_branch_config('/a/')
1444
self.assertLocationMatching([('/a/', '')])
1446
def test__get_matching_sections_explicit_over_glob(self):
1447
# XXX: 2006-09-08 jamesh
1448
# This test only passes because ord('c') > ord('*'). If there
1449
# was a config section for '/a/?', it would get precedence
1451
self.get_branch_config('/a/c')
1452
self.assertLocationMatching([('/a/c', ''), ('/a/*', ''), ('/a/', 'c')])
1454
def test__get_option_policy_normal(self):
1455
self.get_branch_config('http://www.example.com')
1457
self.my_location_config._get_config_policy(
1458
'http://www.example.com', 'normal_option'),
1461
def test__get_option_policy_norecurse(self):
1462
self.get_branch_config('http://www.example.com')
1464
self.my_location_config._get_option_policy(
1465
'http://www.example.com', 'norecurse_option'),
1466
config.POLICY_NORECURSE)
1467
# Test old recurse=False setting:
1469
self.my_location_config._get_option_policy(
1470
'http://www.example.com/norecurse', 'normal_option'),
1471
config.POLICY_NORECURSE)
1473
def test__get_option_policy_normal(self):
1474
self.get_branch_config('http://www.example.com')
1476
self.my_location_config._get_option_policy(
1477
'http://www.example.com', 'appendpath_option'),
1478
config.POLICY_APPENDPATH)
1480
def test__get_options_with_policy(self):
1481
self.get_branch_config('/dir/subdir',
1482
location_config="""\
1484
other_url = /other-dir
1485
other_url:policy = appendpath
1487
other_url = /other-subdir
1490
[(u'other_url', u'/other-subdir', u'/dir/subdir', 'locations'),
1491
(u'other_url', u'/other-dir', u'/dir', 'locations'),
1492
(u'other_url:policy', u'appendpath', u'/dir', 'locations')],
1493
self.my_location_config)
1495
def test_location_without_username(self):
1496
self.get_branch_config('http://www.example.com/ignoreparent')
1497
self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
1498
self.my_config.username())
1500
def test_location_not_listed(self):
1501
"""Test that the global username is used when no location matches"""
1502
self.get_branch_config('/home/robertc/sources')
1503
self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
1504
self.my_config.username())
1506
def test_overriding_location(self):
1507
self.get_branch_config('http://www.example.com/foo')
1508
self.assertEqual('Robert Collins <robertc@example.org>',
1509
self.my_config.username())
1511
def test_signatures_not_set(self):
1512
self.get_branch_config('http://www.example.com',
1513
global_config=sample_ignore_signatures)
1514
self.assertEqual(config.CHECK_ALWAYS,
1515
self.applyDeprecated(deprecated_in((2, 5, 0)),
1516
self.my_config.signature_checking))
1517
self.assertEqual(config.SIGN_NEVER,
1518
self.applyDeprecated(deprecated_in((2, 5, 0)),
1519
self.my_config.signing_policy))
1521
def test_signatures_never(self):
1522
self.get_branch_config('/a/c')
1523
self.assertEqual(config.CHECK_NEVER,
1524
self.applyDeprecated(deprecated_in((2, 5, 0)),
1525
self.my_config.signature_checking))
1527
def test_signatures_when_available(self):
1528
self.get_branch_config('/a/', global_config=sample_ignore_signatures)
1529
self.assertEqual(config.CHECK_IF_POSSIBLE,
1530
self.applyDeprecated(deprecated_in((2, 5, 0)),
1531
self.my_config.signature_checking))
1533
def test_signatures_always(self):
1534
self.get_branch_config('/b')
1535
self.assertEqual(config.CHECK_ALWAYS,
1536
self.applyDeprecated(deprecated_in((2, 5, 0)),
1537
self.my_config.signature_checking))
1539
def test_gpg_signing_command(self):
1540
self.get_branch_config('/b')
1541
self.assertEqual("gnome-gpg",
1542
self.applyDeprecated(deprecated_in((2, 5, 0)),
1543
self.my_config.gpg_signing_command))
1545
def test_gpg_signing_command_missing(self):
1546
self.get_branch_config('/a')
1547
self.assertEqual("false",
1548
self.applyDeprecated(deprecated_in((2, 5, 0)),
1549
self.my_config.gpg_signing_command))
1551
def test_gpg_signing_key(self):
1552
self.get_branch_config('/b')
1553
self.assertEqual("DD4D5088", self.applyDeprecated(deprecated_in((2, 5, 0)),
1554
self.my_config.gpg_signing_key))
1556
def test_gpg_signing_key_default(self):
1557
self.get_branch_config('/a')
1558
self.assertEqual("erik@bagfors.nu",
1559
self.applyDeprecated(deprecated_in((2, 5, 0)),
1560
self.my_config.gpg_signing_key))
1562
def test_get_user_option_global(self):
1563
self.get_branch_config('/a')
1564
self.assertEqual('something',
1565
self.my_config.get_user_option('user_global_option'))
1567
def test_get_user_option_local(self):
1568
self.get_branch_config('/a')
1569
self.assertEqual('local',
1570
self.my_config.get_user_option('user_local_option'))
1572
def test_get_user_option_appendpath(self):
1573
# returned as is for the base path:
1574
self.get_branch_config('http://www.example.com')
1575
self.assertEqual('append',
1576
self.my_config.get_user_option('appendpath_option'))
1577
# Extra path components get appended:
1578
self.get_branch_config('http://www.example.com/a/b/c')
1579
self.assertEqual('append/a/b/c',
1580
self.my_config.get_user_option('appendpath_option'))
1581
# Overriden for http://www.example.com/dir, where it is a
1583
self.get_branch_config('http://www.example.com/dir/a/b/c')
1584
self.assertEqual('normal',
1585
self.my_config.get_user_option('appendpath_option'))
1587
def test_get_user_option_norecurse(self):
1588
self.get_branch_config('http://www.example.com')
1589
self.assertEqual('norecurse',
1590
self.my_config.get_user_option('norecurse_option'))
1591
self.get_branch_config('http://www.example.com/dir')
1592
self.assertEqual(None,
1593
self.my_config.get_user_option('norecurse_option'))
1594
# http://www.example.com/norecurse is a recurse=False section
1595
# that redefines normal_option. Subdirectories do not pick up
1596
# this redefinition.
1597
self.get_branch_config('http://www.example.com/norecurse')
1598
self.assertEqual('norecurse',
1599
self.my_config.get_user_option('normal_option'))
1600
self.get_branch_config('http://www.example.com/norecurse/subdir')
1601
self.assertEqual('normal',
1602
self.my_config.get_user_option('normal_option'))
1604
def test_set_user_option_norecurse(self):
1605
self.get_branch_config('http://www.example.com')
1606
self.my_config.set_user_option('foo', 'bar',
1607
store=config.STORE_LOCATION_NORECURSE)
1609
self.my_location_config._get_option_policy(
1610
'http://www.example.com', 'foo'),
1611
config.POLICY_NORECURSE)
1613
def test_set_user_option_appendpath(self):
1614
self.get_branch_config('http://www.example.com')
1615
self.my_config.set_user_option('foo', 'bar',
1616
store=config.STORE_LOCATION_APPENDPATH)
1618
self.my_location_config._get_option_policy(
1619
'http://www.example.com', 'foo'),
1620
config.POLICY_APPENDPATH)
1622
def test_set_user_option_change_policy(self):
1623
self.get_branch_config('http://www.example.com')
1624
self.my_config.set_user_option('norecurse_option', 'normal',
1625
store=config.STORE_LOCATION)
1627
self.my_location_config._get_option_policy(
1628
'http://www.example.com', 'norecurse_option'),
1631
def test_set_user_option_recurse_false_section(self):
1632
# The following section has recurse=False set. The test is to
1633
# make sure that a normal option can be added to the section,
1634
# converting recurse=False to the norecurse policy.
1635
self.get_branch_config('http://www.example.com/norecurse')
1636
self.callDeprecated(['The recurse option is deprecated as of 0.14. '
1637
'The section "http://www.example.com/norecurse" '
1638
'has been converted to use policies.'],
1639
self.my_config.set_user_option,
1640
'foo', 'bar', store=config.STORE_LOCATION)
1642
self.my_location_config._get_option_policy(
1643
'http://www.example.com/norecurse', 'foo'),
1645
# The previously existing option is still norecurse:
1647
self.my_location_config._get_option_policy(
1648
'http://www.example.com/norecurse', 'normal_option'),
1649
config.POLICY_NORECURSE)
1651
def test_post_commit_default(self):
1652
self.get_branch_config('/a/c')
1653
self.assertEqual('bzrlib.tests.test_config.post_commit',
1654
self.applyDeprecated(deprecated_in((2, 5, 0)),
1655
self.my_config.post_commit))
1657
def get_branch_config(self, location, global_config=None,
1658
location_config=None):
1659
my_branch = FakeBranch(location)
1660
if global_config is None:
1661
global_config = sample_config_text
1662
if location_config is None:
1663
location_config = sample_branches_text
1665
my_global_config = config.GlobalConfig.from_string(global_config,
1667
my_location_config = config.LocationConfig.from_string(
1668
location_config, my_branch.base, save=True)
1669
my_config = config.BranchConfig(my_branch)
1670
self.my_config = my_config
1671
self.my_location_config = my_config._get_location_config()
1673
def test_set_user_setting_sets_and_saves(self):
1674
self.get_branch_config('/a/c')
1675
record = InstrumentedConfigObj("foo")
1676
self.my_location_config._parser = record
1678
self.callDeprecated(['The recurse option is deprecated as of '
1679
'0.14. The section "/a/c" has been '
1680
'converted to use policies.'],
1681
self.my_config.set_user_option,
1682
'foo', 'bar', store=config.STORE_LOCATION)
1683
self.assertEqual([('reload',),
1684
('__contains__', '/a/c'),
1685
('__contains__', '/a/c/'),
1686
('__setitem__', '/a/c', {}),
1687
('__getitem__', '/a/c'),
1688
('__setitem__', 'foo', 'bar'),
1689
('__getitem__', '/a/c'),
1690
('as_bool', 'recurse'),
1691
('__getitem__', '/a/c'),
1692
('__delitem__', 'recurse'),
1693
('__getitem__', '/a/c'),
1695
('__getitem__', '/a/c'),
1696
('__contains__', 'foo:policy'),
1700
def test_set_user_setting_sets_and_saves2(self):
1701
self.get_branch_config('/a/c')
1702
self.assertIs(self.my_config.get_user_option('foo'), None)
1703
self.my_config.set_user_option('foo', 'bar')
1705
self.my_config.branch.control_files.files['branch.conf'].strip(),
1707
self.assertEqual(self.my_config.get_user_option('foo'), 'bar')
1708
self.my_config.set_user_option('foo', 'baz',
1709
store=config.STORE_LOCATION)
1710
self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
1711
self.my_config.set_user_option('foo', 'qux')
1712
self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
1714
def test_get_bzr_remote_path(self):
1715
my_config = config.LocationConfig('/a/c')
1716
self.assertEqual('bzr', my_config.get_bzr_remote_path())
1717
my_config.set_user_option('bzr_remote_path', '/path-bzr')
1718
self.assertEqual('/path-bzr', my_config.get_bzr_remote_path())
1719
self.overrideEnv('BZR_REMOTE_PATH', '/environ-bzr')
1720
self.assertEqual('/environ-bzr', my_config.get_bzr_remote_path())
1723
precedence_global = 'option = global'
1724
precedence_branch = 'option = branch'
1725
precedence_location = """
1729
[http://example.com/specific]
1733
class TestBranchConfigItems(tests.TestCaseInTempDir):
1735
def get_branch_config(self, global_config=None, location=None,
1736
location_config=None, branch_data_config=None):
1737
my_branch = FakeBranch(location)
1738
if global_config is not None:
1739
my_global_config = config.GlobalConfig.from_string(global_config,
1741
if location_config is not None:
1742
my_location_config = config.LocationConfig.from_string(
1743
location_config, my_branch.base, save=True)
1744
my_config = config.BranchConfig(my_branch)
1745
if branch_data_config is not None:
1746
my_config.branch.control_files.files['branch.conf'] = \
1750
def test_user_id(self):
1751
branch = FakeBranch()
1752
my_config = config.BranchConfig(branch)
1753
self.assertIsNot(None, my_config.username())
1754
my_config.branch.control_files.files['email'] = "John"
1755
my_config.set_user_option('email',
1756
"Robert Collins <robertc@example.org>")
1757
self.assertEqual("Robert Collins <robertc@example.org>",
1758
my_config.username())
1760
def test_BZR_EMAIL_OVERRIDES(self):
1761
self.overrideEnv('BZR_EMAIL', "Robert Collins <robertc@example.org>")
1762
branch = FakeBranch()
1763
my_config = config.BranchConfig(branch)
1764
self.assertEqual("Robert Collins <robertc@example.org>",
1765
my_config.username())
1767
def test_signatures_forced(self):
1768
my_config = self.get_branch_config(
1769
global_config=sample_always_signatures)
1770
self.assertEqual(config.CHECK_NEVER,
1771
self.applyDeprecated(deprecated_in((2, 5, 0)),
1772
my_config.signature_checking))
1773
self.assertEqual(config.SIGN_ALWAYS,
1774
self.applyDeprecated(deprecated_in((2, 5, 0)),
1775
my_config.signing_policy))
1776
self.assertTrue(self.applyDeprecated(deprecated_in((2, 5, 0)),
1777
my_config.signature_needed))
1779
def test_signatures_forced_branch(self):
1780
my_config = self.get_branch_config(
1781
global_config=sample_ignore_signatures,
1782
branch_data_config=sample_always_signatures)
1783
self.assertEqual(config.CHECK_NEVER,
1784
self.applyDeprecated(deprecated_in((2, 5, 0)),
1785
my_config.signature_checking))
1786
self.assertEqual(config.SIGN_ALWAYS,
1787
self.applyDeprecated(deprecated_in((2, 5, 0)),
1788
my_config.signing_policy))
1789
self.assertTrue(self.applyDeprecated(deprecated_in((2, 5, 0)),
1790
my_config.signature_needed))
1792
def test_gpg_signing_command(self):
1793
my_config = self.get_branch_config(
1794
global_config=sample_config_text,
1795
# branch data cannot set gpg_signing_command
1796
branch_data_config="gpg_signing_command=pgp")
1797
self.assertEqual('gnome-gpg',
1798
self.applyDeprecated(deprecated_in((2, 5, 0)),
1799
my_config.gpg_signing_command))
1801
def test_get_user_option_global(self):
1802
my_config = self.get_branch_config(global_config=sample_config_text)
1803
self.assertEqual('something',
1804
my_config.get_user_option('user_global_option'))
1806
def test_post_commit_default(self):
1807
my_config = self.get_branch_config(global_config=sample_config_text,
1809
location_config=sample_branches_text)
1810
self.assertEqual(my_config.branch.base, '/a/c')
1811
self.assertEqual('bzrlib.tests.test_config.post_commit',
1812
self.applyDeprecated(deprecated_in((2, 5, 0)),
1813
my_config.post_commit))
1814
my_config.set_user_option('post_commit', 'rmtree_root')
1815
# post-commit is ignored when present in branch data
1816
self.assertEqual('bzrlib.tests.test_config.post_commit',
1817
self.applyDeprecated(deprecated_in((2, 5, 0)),
1818
my_config.post_commit))
1819
my_config.set_user_option('post_commit', 'rmtree_root',
1820
store=config.STORE_LOCATION)
1821
self.assertEqual('rmtree_root',
1822
self.applyDeprecated(deprecated_in((2, 5, 0)),
1823
my_config.post_commit))
1825
def test_config_precedence(self):
1826
# FIXME: eager test, luckily no persitent config file makes it fail
1828
my_config = self.get_branch_config(global_config=precedence_global)
1829
self.assertEqual(my_config.get_user_option('option'), 'global')
1830
my_config = self.get_branch_config(global_config=precedence_global,
1831
branch_data_config=precedence_branch)
1832
self.assertEqual(my_config.get_user_option('option'), 'branch')
1833
my_config = self.get_branch_config(
1834
global_config=precedence_global,
1835
branch_data_config=precedence_branch,
1836
location_config=precedence_location)
1837
self.assertEqual(my_config.get_user_option('option'), 'recurse')
1838
my_config = self.get_branch_config(
1839
global_config=precedence_global,
1840
branch_data_config=precedence_branch,
1841
location_config=precedence_location,
1842
location='http://example.com/specific')
1843
self.assertEqual(my_config.get_user_option('option'), 'exact')
1846
class TestMailAddressExtraction(tests.TestCase):
1848
def test_extract_email_address(self):
1849
self.assertEqual('jane@test.com',
1850
config.extract_email_address('Jane <jane@test.com>'))
1851
self.assertRaises(errors.NoEmailInUsername,
1852
config.extract_email_address, 'Jane Tester')
1854
def test_parse_username(self):
1855
self.assertEqual(('', 'jdoe@example.com'),
1856
config.parse_username('jdoe@example.com'))
1857
self.assertEqual(('', 'jdoe@example.com'),
1858
config.parse_username('<jdoe@example.com>'))
1859
self.assertEqual(('John Doe', 'jdoe@example.com'),
1860
config.parse_username('John Doe <jdoe@example.com>'))
1861
self.assertEqual(('John Doe', ''),
1862
config.parse_username('John Doe'))
1863
self.assertEqual(('John Doe', 'jdoe@example.com'),
1864
config.parse_username('John Doe jdoe@example.com'))
1866
class TestTreeConfig(tests.TestCaseWithTransport):
1868
def test_get_value(self):
1869
"""Test that retreiving a value from a section is possible"""
1870
branch = self.make_branch('.')
1871
tree_config = config.TreeConfig(branch)
1872
tree_config.set_option('value', 'key', 'SECTION')
1873
tree_config.set_option('value2', 'key2')
1874
tree_config.set_option('value3-top', 'key3')
1875
tree_config.set_option('value3-section', 'key3', 'SECTION')
1876
value = tree_config.get_option('key', 'SECTION')
1877
self.assertEqual(value, 'value')
1878
value = tree_config.get_option('key2')
1879
self.assertEqual(value, 'value2')
1880
self.assertEqual(tree_config.get_option('non-existant'), None)
1881
value = tree_config.get_option('non-existant', 'SECTION')
1882
self.assertEqual(value, None)
1883
value = tree_config.get_option('non-existant', default='default')
1884
self.assertEqual(value, 'default')
1885
self.assertEqual(tree_config.get_option('key2', 'NOSECTION'), None)
1886
value = tree_config.get_option('key2', 'NOSECTION', default='default')
1887
self.assertEqual(value, 'default')
1888
value = tree_config.get_option('key3')
1889
self.assertEqual(value, 'value3-top')
1890
value = tree_config.get_option('key3', 'SECTION')
1891
self.assertEqual(value, 'value3-section')
1894
class TestTransportConfig(tests.TestCaseWithTransport):
1896
def test_load_utf8(self):
1897
"""Ensure we can load an utf8-encoded file."""
1898
t = self.get_transport()
1899
unicode_user = u'b\N{Euro Sign}ar'
1900
unicode_content = u'user=%s' % (unicode_user,)
1901
utf8_content = unicode_content.encode('utf8')
1902
# Store the raw content in the config file
1903
t.put_bytes('foo.conf', utf8_content)
1904
conf = config.TransportConfig(t, 'foo.conf')
1905
self.assertEquals(unicode_user, conf.get_option('user'))
1907
def test_load_non_ascii(self):
1908
"""Ensure we display a proper error on non-ascii, non utf-8 content."""
1909
t = self.get_transport()
1910
t.put_bytes('foo.conf', 'user=foo\n#\xff\n')
1911
conf = config.TransportConfig(t, 'foo.conf')
1912
self.assertRaises(errors.ConfigContentError, conf._get_configobj)
1914
def test_load_erroneous_content(self):
1915
"""Ensure we display a proper error on content that can't be parsed."""
1916
t = self.get_transport()
1917
t.put_bytes('foo.conf', '[open_section\n')
1918
conf = config.TransportConfig(t, 'foo.conf')
1919
self.assertRaises(errors.ParseConfigError, conf._get_configobj)
1921
def test_load_permission_denied(self):
1922
"""Ensure we get an empty config file if the file is inaccessible."""
1925
warnings.append(args[0] % args[1:])
1926
self.overrideAttr(trace, 'warning', warning)
1928
class DenyingTransport(object):
1930
def __init__(self, base):
1933
def get_bytes(self, relpath):
1934
raise errors.PermissionDenied(relpath, "")
1936
cfg = config.TransportConfig(
1937
DenyingTransport("nonexisting://"), 'control.conf')
1938
self.assertIs(None, cfg.get_option('non-existant', 'SECTION'))
1941
[u'Permission denied while trying to open configuration file '
1942
u'nonexisting:///control.conf.'])
1944
def test_get_value(self):
1945
"""Test that retreiving a value from a section is possible"""
1946
bzrdir_config = config.TransportConfig(self.get_transport('.'),
1948
bzrdir_config.set_option('value', 'key', 'SECTION')
1949
bzrdir_config.set_option('value2', 'key2')
1950
bzrdir_config.set_option('value3-top', 'key3')
1951
bzrdir_config.set_option('value3-section', 'key3', 'SECTION')
1952
value = bzrdir_config.get_option('key', 'SECTION')
1953
self.assertEqual(value, 'value')
1954
value = bzrdir_config.get_option('key2')
1955
self.assertEqual(value, 'value2')
1956
self.assertEqual(bzrdir_config.get_option('non-existant'), None)
1957
value = bzrdir_config.get_option('non-existant', 'SECTION')
1958
self.assertEqual(value, None)
1959
value = bzrdir_config.get_option('non-existant', default='default')
1960
self.assertEqual(value, 'default')
1961
self.assertEqual(bzrdir_config.get_option('key2', 'NOSECTION'), None)
1962
value = bzrdir_config.get_option('key2', 'NOSECTION',
1964
self.assertEqual(value, 'default')
1965
value = bzrdir_config.get_option('key3')
1966
self.assertEqual(value, 'value3-top')
1967
value = bzrdir_config.get_option('key3', 'SECTION')
1968
self.assertEqual(value, 'value3-section')
1970
def test_set_unset_default_stack_on(self):
1971
my_dir = self.make_bzrdir('.')
1972
bzrdir_config = config.BzrDirConfig(my_dir)
1973
self.assertIs(None, bzrdir_config.get_default_stack_on())
1974
bzrdir_config.set_default_stack_on('Foo')
1975
self.assertEqual('Foo', bzrdir_config._config.get_option(
1976
'default_stack_on'))
1977
self.assertEqual('Foo', bzrdir_config.get_default_stack_on())
1978
bzrdir_config.set_default_stack_on(None)
1979
self.assertIs(None, bzrdir_config.get_default_stack_on())
1982
class TestOldConfigHooks(tests.TestCaseWithTransport):
1985
super(TestOldConfigHooks, self).setUp()
1986
create_configs_with_file_option(self)
1988
def assertGetHook(self, conf, name, value):
1992
config.OldConfigHooks.install_named_hook('get', hook, None)
1994
config.OldConfigHooks.uninstall_named_hook, 'get', None)
1995
self.assertLength(0, calls)
1996
actual_value = conf.get_user_option(name)
1997
self.assertEquals(value, actual_value)
1998
self.assertLength(1, calls)
1999
self.assertEquals((conf, name, value), calls[0])
2001
def test_get_hook_bazaar(self):
2002
self.assertGetHook(self.bazaar_config, 'file', 'bazaar')
2004
def test_get_hook_locations(self):
2005
self.assertGetHook(self.locations_config, 'file', 'locations')
2007
def test_get_hook_branch(self):
2008
# Since locations masks branch, we define a different option
2009
self.branch_config.set_user_option('file2', 'branch')
2010
self.assertGetHook(self.branch_config, 'file2', 'branch')
2012
def assertSetHook(self, conf, name, value):
2016
config.OldConfigHooks.install_named_hook('set', hook, None)
2018
config.OldConfigHooks.uninstall_named_hook, 'set', None)
2019
self.assertLength(0, calls)
2020
conf.set_user_option(name, value)
2021
self.assertLength(1, calls)
2022
# We can't assert the conf object below as different configs use
2023
# different means to implement set_user_option and we care only about
2025
self.assertEquals((name, value), calls[0][1:])
2027
def test_set_hook_bazaar(self):
2028
self.assertSetHook(self.bazaar_config, 'foo', 'bazaar')
2030
def test_set_hook_locations(self):
2031
self.assertSetHook(self.locations_config, 'foo', 'locations')
2033
def test_set_hook_branch(self):
2034
self.assertSetHook(self.branch_config, 'foo', 'branch')
2036
def assertRemoveHook(self, conf, name, section_name=None):
2040
config.OldConfigHooks.install_named_hook('remove', hook, None)
2042
config.OldConfigHooks.uninstall_named_hook, 'remove', None)
2043
self.assertLength(0, calls)
2044
conf.remove_user_option(name, section_name)
2045
self.assertLength(1, calls)
2046
# We can't assert the conf object below as different configs use
2047
# different means to implement remove_user_option and we care only about
2049
self.assertEquals((name,), calls[0][1:])
2051
def test_remove_hook_bazaar(self):
2052
self.assertRemoveHook(self.bazaar_config, 'file')
2054
def test_remove_hook_locations(self):
2055
self.assertRemoveHook(self.locations_config, 'file',
2056
self.locations_config.location)
2058
def test_remove_hook_branch(self):
2059
self.assertRemoveHook(self.branch_config, 'file')
2061
def assertLoadHook(self, name, conf_class, *conf_args):
2065
config.OldConfigHooks.install_named_hook('load', hook, None)
2067
config.OldConfigHooks.uninstall_named_hook, 'load', None)
2068
self.assertLength(0, calls)
2070
conf = conf_class(*conf_args)
2071
# Access an option to trigger a load
2072
conf.get_user_option(name)
2073
self.assertLength(1, calls)
2074
# Since we can't assert about conf, we just use the number of calls ;-/
2076
def test_load_hook_bazaar(self):
2077
self.assertLoadHook('file', config.GlobalConfig)
2079
def test_load_hook_locations(self):
2080
self.assertLoadHook('file', config.LocationConfig, self.tree.basedir)
2082
def test_load_hook_branch(self):
2083
self.assertLoadHook('file', config.BranchConfig, self.tree.branch)
2085
def assertSaveHook(self, conf):
2089
config.OldConfigHooks.install_named_hook('save', hook, None)
2091
config.OldConfigHooks.uninstall_named_hook, 'save', None)
2092
self.assertLength(0, calls)
2093
# Setting an option triggers a save
2094
conf.set_user_option('foo', 'bar')
2095
self.assertLength(1, calls)
2096
# Since we can't assert about conf, we just use the number of calls ;-/
2098
def test_save_hook_bazaar(self):
2099
self.assertSaveHook(self.bazaar_config)
2101
def test_save_hook_locations(self):
2102
self.assertSaveHook(self.locations_config)
2104
def test_save_hook_branch(self):
2105
self.assertSaveHook(self.branch_config)
2108
class TestOldConfigHooksForRemote(tests.TestCaseWithTransport):
2109
"""Tests config hooks for remote configs.
2111
No tests for the remove hook as this is not implemented there.
2115
super(TestOldConfigHooksForRemote, self).setUp()
2116
self.transport_server = test_server.SmartTCPServer_for_testing
2117
create_configs_with_file_option(self)
2119
def assertGetHook(self, conf, name, value):
2123
config.OldConfigHooks.install_named_hook('get', hook, None)
2125
config.OldConfigHooks.uninstall_named_hook, 'get', None)
2126
self.assertLength(0, calls)
2127
actual_value = conf.get_option(name)
2128
self.assertEquals(value, actual_value)
2129
self.assertLength(1, calls)
2130
self.assertEquals((conf, name, value), calls[0])
2132
def test_get_hook_remote_branch(self):
2133
remote_branch = branch.Branch.open(self.get_url('tree'))
2134
self.assertGetHook(remote_branch._get_config(), 'file', 'branch')
2136
def test_get_hook_remote_bzrdir(self):
2137
remote_bzrdir = controldir.ControlDir.open(self.get_url('tree'))
2138
conf = remote_bzrdir._get_config()
2139
conf.set_option('remotedir', 'file')
2140
self.assertGetHook(conf, 'file', 'remotedir')
2142
def assertSetHook(self, conf, name, value):
2146
config.OldConfigHooks.install_named_hook('set', hook, None)
2148
config.OldConfigHooks.uninstall_named_hook, 'set', None)
2149
self.assertLength(0, calls)
2150
conf.set_option(value, name)
2151
self.assertLength(1, calls)
2152
# We can't assert the conf object below as different configs use
2153
# different means to implement set_user_option and we care only about
2155
self.assertEquals((name, value), calls[0][1:])
2157
def test_set_hook_remote_branch(self):
2158
remote_branch = branch.Branch.open(self.get_url('tree'))
2159
self.addCleanup(remote_branch.lock_write().unlock)
2160
self.assertSetHook(remote_branch._get_config(), 'file', 'remote')
2162
def test_set_hook_remote_bzrdir(self):
2163
remote_branch = branch.Branch.open(self.get_url('tree'))
2164
self.addCleanup(remote_branch.lock_write().unlock)
2165
remote_bzrdir = controldir.ControlDir.open(self.get_url('tree'))
2166
self.assertSetHook(remote_bzrdir._get_config(), 'file', 'remotedir')
2168
def assertLoadHook(self, expected_nb_calls, name, conf_class, *conf_args):
2172
config.OldConfigHooks.install_named_hook('load', hook, None)
2174
config.OldConfigHooks.uninstall_named_hook, 'load', None)
2175
self.assertLength(0, calls)
2177
conf = conf_class(*conf_args)
2178
# Access an option to trigger a load
2179
conf.get_option(name)
2180
self.assertLength(expected_nb_calls, calls)
2181
# Since we can't assert about conf, we just use the number of calls ;-/
2183
def test_load_hook_remote_branch(self):
2184
remote_branch = branch.Branch.open(self.get_url('tree'))
2185
self.assertLoadHook(1, 'file', remote.RemoteBranchConfig, remote_branch)
2187
def test_load_hook_remote_bzrdir(self):
2188
remote_bzrdir = controldir.ControlDir.open(self.get_url('tree'))
2189
# The config file doesn't exist, set an option to force its creation
2190
conf = remote_bzrdir._get_config()
2191
conf.set_option('remotedir', 'file')
2192
# We get one call for the server and one call for the client, this is
2193
# caused by the differences in implementations betwen
2194
# SmartServerBzrDirRequestConfigFile (in smart/bzrdir.py) and
2195
# SmartServerBranchGetConfigFile (in smart/branch.py)
2196
self.assertLoadHook(2 ,'file', remote.RemoteBzrDirConfig, remote_bzrdir)
2198
def assertSaveHook(self, conf):
2202
config.OldConfigHooks.install_named_hook('save', hook, None)
2204
config.OldConfigHooks.uninstall_named_hook, 'save', None)
2205
self.assertLength(0, calls)
2206
# Setting an option triggers a save
2207
conf.set_option('foo', 'bar')
2208
self.assertLength(1, calls)
2209
# Since we can't assert about conf, we just use the number of calls ;-/
2211
def test_save_hook_remote_branch(self):
2212
remote_branch = branch.Branch.open(self.get_url('tree'))
2213
self.addCleanup(remote_branch.lock_write().unlock)
2214
self.assertSaveHook(remote_branch._get_config())
2216
def test_save_hook_remote_bzrdir(self):
2217
remote_branch = branch.Branch.open(self.get_url('tree'))
2218
self.addCleanup(remote_branch.lock_write().unlock)
2219
remote_bzrdir = controldir.ControlDir.open(self.get_url('tree'))
2220
self.assertSaveHook(remote_bzrdir._get_config())
2223
class TestOption(tests.TestCase):
2225
def test_default_value(self):
2226
opt = config.Option('foo', default='bar')
2227
self.assertEquals('bar', opt.get_default())
2229
def test_callable_default_value(self):
2230
def bar_as_unicode():
2232
opt = config.Option('foo', default=bar_as_unicode)
2233
self.assertEquals('bar', opt.get_default())
2235
def test_default_value_from_env(self):
2236
opt = config.Option('foo', default='bar', default_from_env=['FOO'])
2237
self.overrideEnv('FOO', 'quux')
2238
# Env variable provides a default taking over the option one
2239
self.assertEquals('quux', opt.get_default())
2241
def test_first_default_value_from_env_wins(self):
2242
opt = config.Option('foo', default='bar',
2243
default_from_env=['NO_VALUE', 'FOO', 'BAZ'])
2244
self.overrideEnv('FOO', 'foo')
2245
self.overrideEnv('BAZ', 'baz')
2246
# The first env var set wins
2247
self.assertEquals('foo', opt.get_default())
2249
def test_not_supported_list_default_value(self):
2250
self.assertRaises(AssertionError, config.Option, 'foo', default=[1])
2252
def test_not_supported_object_default_value(self):
2253
self.assertRaises(AssertionError, config.Option, 'foo',
2256
def test_not_supported_callable_default_value_not_unicode(self):
2257
def bar_not_unicode():
2259
opt = config.Option('foo', default=bar_not_unicode)
2260
self.assertRaises(AssertionError, opt.get_default)
2262
def test_get_help_topic(self):
2263
opt = config.Option('foo')
2264
self.assertEquals('foo', opt.get_help_topic())
2267
class TestOptionConverterMixin(object):
2269
def assertConverted(self, expected, opt, value):
2270
self.assertEquals(expected, opt.convert_from_unicode(None, value))
2272
def assertWarns(self, opt, value):
2275
warnings.append(args[0] % args[1:])
2276
self.overrideAttr(trace, 'warning', warning)
2277
self.assertEquals(None, opt.convert_from_unicode(None, value))
2278
self.assertLength(1, warnings)
2280
'Value "%s" is not valid for "%s"' % (value, opt.name),
2283
def assertErrors(self, opt, value):
2284
self.assertRaises(errors.ConfigOptionValueError,
2285
opt.convert_from_unicode, None, value)
2287
def assertConvertInvalid(self, opt, invalid_value):
2289
self.assertEquals(None, opt.convert_from_unicode(None, invalid_value))
2290
opt.invalid = 'warning'
2291
self.assertWarns(opt, invalid_value)
2292
opt.invalid = 'error'
2293
self.assertErrors(opt, invalid_value)
2296
class TestOptionWithBooleanConverter(tests.TestCase, TestOptionConverterMixin):
2298
def get_option(self):
2299
return config.Option('foo', help='A boolean.',
2300
from_unicode=config.bool_from_store)
2302
def test_convert_invalid(self):
2303
opt = self.get_option()
2304
# A string that is not recognized as a boolean
2305
self.assertConvertInvalid(opt, u'invalid-boolean')
2306
# A list of strings is never recognized as a boolean
2307
self.assertConvertInvalid(opt, [u'not', u'a', u'boolean'])
2309
def test_convert_valid(self):
2310
opt = self.get_option()
2311
self.assertConverted(True, opt, u'True')
2312
self.assertConverted(True, opt, u'1')
2313
self.assertConverted(False, opt, u'False')
2316
class TestOptionWithIntegerConverter(tests.TestCase, TestOptionConverterMixin):
2318
def get_option(self):
2319
return config.Option('foo', help='An integer.',
2320
from_unicode=config.int_from_store)
2322
def test_convert_invalid(self):
2323
opt = self.get_option()
2324
# A string that is not recognized as an integer
2325
self.assertConvertInvalid(opt, u'forty-two')
2326
# A list of strings is never recognized as an integer
2327
self.assertConvertInvalid(opt, [u'a', u'list'])
2329
def test_convert_valid(self):
2330
opt = self.get_option()
2331
self.assertConverted(16, opt, u'16')
2334
class TestOptionWithSIUnitConverter(tests.TestCase, TestOptionConverterMixin):
2336
def get_option(self):
2337
return config.Option('foo', help='An integer in SI units.',
2338
from_unicode=config.int_SI_from_store)
2340
def test_convert_invalid(self):
2341
opt = self.get_option()
2342
self.assertConvertInvalid(opt, u'not-a-unit')
2343
self.assertConvertInvalid(opt, u'Gb') # Forgot the int
2344
self.assertConvertInvalid(opt, u'1b') # Forgot the unit
2345
self.assertConvertInvalid(opt, u'1GG')
2346
self.assertConvertInvalid(opt, u'1Mbb')
2347
self.assertConvertInvalid(opt, u'1MM')
2349
def test_convert_valid(self):
2350
opt = self.get_option()
2351
self.assertConverted(int(5e3), opt, u'5kb')
2352
self.assertConverted(int(5e6), opt, u'5M')
2353
self.assertConverted(int(5e6), opt, u'5MB')
2354
self.assertConverted(int(5e9), opt, u'5g')
2355
self.assertConverted(int(5e9), opt, u'5gB')
2356
self.assertConverted(100, opt, u'100')
2359
class TestListOption(tests.TestCase, TestOptionConverterMixin):
2361
def get_option(self):
2362
return config.ListOption('foo', help='A list.')
2364
def test_convert_invalid(self):
2365
opt = self.get_option()
2366
# We don't even try to convert a list into a list, we only expect
2368
self.assertConvertInvalid(opt, [1])
2369
# No string is invalid as all forms can be converted to a list
2371
def test_convert_valid(self):
2372
opt = self.get_option()
2373
# An empty string is an empty list
2374
self.assertConverted([], opt, '') # Using a bare str() just in case
2375
self.assertConverted([], opt, u'')
2377
self.assertConverted([u'True'], opt, u'True')
2379
self.assertConverted([u'42'], opt, u'42')
2381
self.assertConverted([u'bar'], opt, u'bar')
2384
class TestRegistryOption(tests.TestCase, TestOptionConverterMixin):
2386
def get_option(self, registry):
2387
return config.RegistryOption('foo', registry,
2388
help='A registry option.')
2390
def test_convert_invalid(self):
2391
registry = _mod_registry.Registry()
2392
opt = self.get_option(registry)
2393
self.assertConvertInvalid(opt, [1])
2394
self.assertConvertInvalid(opt, u"notregistered")
2396
def test_convert_valid(self):
2397
registry = _mod_registry.Registry()
2398
registry.register("someval", 1234)
2399
opt = self.get_option(registry)
2400
# Using a bare str() just in case
2401
self.assertConverted(1234, opt, "someval")
2402
self.assertConverted(1234, opt, u'someval')
2403
self.assertConverted(None, opt, None)
2405
def test_help(self):
2406
registry = _mod_registry.Registry()
2407
registry.register("someval", 1234, help="some option")
2408
registry.register("dunno", 1234, help="some other option")
2409
opt = self.get_option(registry)
2411
'A registry option.\n'
2413
'The following values are supported:\n'
2414
' dunno - some other option\n'
2415
' someval - some option\n',
2418
def test_get_help_text(self):
2419
registry = _mod_registry.Registry()
2420
registry.register("someval", 1234, help="some option")
2421
registry.register("dunno", 1234, help="some other option")
2422
opt = self.get_option(registry)
2424
'A registry option.\n'
2426
'The following values are supported:\n'
2427
' dunno - some other option\n'
2428
' someval - some option\n',
2429
opt.get_help_text())
2432
class TestOptionRegistry(tests.TestCase):
2435
super(TestOptionRegistry, self).setUp()
2436
# Always start with an empty registry
2437
self.overrideAttr(config, 'option_registry', config.OptionRegistry())
2438
self.registry = config.option_registry
2440
def test_register(self):
2441
opt = config.Option('foo')
2442
self.registry.register(opt)
2443
self.assertIs(opt, self.registry.get('foo'))
2445
def test_registered_help(self):
2446
opt = config.Option('foo', help='A simple option')
2447
self.registry.register(opt)
2448
self.assertEquals('A simple option', self.registry.get_help('foo'))
2450
lazy_option = config.Option('lazy_foo', help='Lazy help')
2452
def test_register_lazy(self):
2453
self.registry.register_lazy('lazy_foo', self.__module__,
2454
'TestOptionRegistry.lazy_option')
2455
self.assertIs(self.lazy_option, self.registry.get('lazy_foo'))
2457
def test_registered_lazy_help(self):
2458
self.registry.register_lazy('lazy_foo', self.__module__,
2459
'TestOptionRegistry.lazy_option')
2460
self.assertEquals('Lazy help', self.registry.get_help('lazy_foo'))
2463
class TestRegisteredOptions(tests.TestCase):
2464
"""All registered options should verify some constraints."""
2466
scenarios = [(key, {'option_name': key, 'option': option}) for key, option
2467
in config.option_registry.iteritems()]
2470
super(TestRegisteredOptions, self).setUp()
2471
self.registry = config.option_registry
2473
def test_proper_name(self):
2474
# An option should be registered under its own name, this can't be
2475
# checked at registration time for the lazy ones.
2476
self.assertEquals(self.option_name, self.option.name)
2478
def test_help_is_set(self):
2479
option_help = self.registry.get_help(self.option_name)
2480
self.assertNotEquals(None, option_help)
2481
# Come on, think about the user, he really wants to know what the
2483
self.assertIsNot(None, option_help)
2484
self.assertNotEquals('', option_help)
2487
class TestSection(tests.TestCase):
2489
# FIXME: Parametrize so that all sections produced by Stores run these
2490
# tests -- vila 2011-04-01
2492
def test_get_a_value(self):
2493
a_dict = dict(foo='bar')
2494
section = config.Section('myID', a_dict)
2495
self.assertEquals('bar', section.get('foo'))
2497
def test_get_unknown_option(self):
2499
section = config.Section(None, a_dict)
2500
self.assertEquals('out of thin air',
2501
section.get('foo', 'out of thin air'))
2503
def test_options_is_shared(self):
2505
section = config.Section(None, a_dict)
2506
self.assertIs(a_dict, section.options)
2509
class TestMutableSection(tests.TestCase):
2511
scenarios = [('mutable',
2513
lambda opts: config.MutableSection('myID', opts)},),
2517
a_dict = dict(foo='bar')
2518
section = self.get_section(a_dict)
2519
section.set('foo', 'new_value')
2520
self.assertEquals('new_value', section.get('foo'))
2521
# The change appears in the shared section
2522
self.assertEquals('new_value', a_dict.get('foo'))
2523
# We keep track of the change
2524
self.assertTrue('foo' in section.orig)
2525
self.assertEquals('bar', section.orig.get('foo'))
2527
def test_set_preserve_original_once(self):
2528
a_dict = dict(foo='bar')
2529
section = self.get_section(a_dict)
2530
section.set('foo', 'first_value')
2531
section.set('foo', 'second_value')
2532
# We keep track of the original value
2533
self.assertTrue('foo' in section.orig)
2534
self.assertEquals('bar', section.orig.get('foo'))
2536
def test_remove(self):
2537
a_dict = dict(foo='bar')
2538
section = self.get_section(a_dict)
2539
section.remove('foo')
2540
# We get None for unknown options via the default value
2541
self.assertEquals(None, section.get('foo'))
2542
# Or we just get the default value
2543
self.assertEquals('unknown', section.get('foo', 'unknown'))
2544
self.assertFalse('foo' in section.options)
2545
# We keep track of the deletion
2546
self.assertTrue('foo' in section.orig)
2547
self.assertEquals('bar', section.orig.get('foo'))
2549
def test_remove_new_option(self):
2551
section = self.get_section(a_dict)
2552
section.set('foo', 'bar')
2553
section.remove('foo')
2554
self.assertFalse('foo' in section.options)
2555
# The option didn't exist initially so it we need to keep track of it
2556
# with a special value
2557
self.assertTrue('foo' in section.orig)
2558
self.assertEquals(config._NewlyCreatedOption, section.orig['foo'])
2561
class TestCommandLineStore(tests.TestCase):
2564
super(TestCommandLineStore, self).setUp()
2565
self.store = config.CommandLineStore()
2566
self.overrideAttr(config, 'option_registry', config.OptionRegistry())
2568
def get_section(self):
2569
"""Get the unique section for the command line overrides."""
2570
sections = list(self.store.get_sections())
2571
self.assertLength(1, sections)
2572
store, section = sections[0]
2573
self.assertEquals(self.store, store)
2576
def test_no_override(self):
2577
self.store._from_cmdline([])
2578
section = self.get_section()
2579
self.assertLength(0, list(section.iter_option_names()))
2581
def test_simple_override(self):
2582
self.store._from_cmdline(['a=b'])
2583
section = self.get_section()
2584
self.assertEqual('b', section.get('a'))
2586
def test_list_override(self):
2587
opt = config.ListOption('l')
2588
config.option_registry.register(opt)
2589
self.store._from_cmdline(['l=1,2,3'])
2590
val = self.get_section().get('l')
2591
self.assertEqual('1,2,3', val)
2592
# Reminder: lists should be registered as such explicitely, otherwise
2593
# the conversion needs to be done afterwards.
2594
self.assertEqual(['1', '2', '3'],
2595
opt.convert_from_unicode(self.store, val))
2597
def test_multiple_overrides(self):
2598
self.store._from_cmdline(['a=b', 'x=y'])
2599
section = self.get_section()
2600
self.assertEquals('b', section.get('a'))
2601
self.assertEquals('y', section.get('x'))
2603
def test_wrong_syntax(self):
2604
self.assertRaises(errors.BzrCommandError,
2605
self.store._from_cmdline, ['a=b', 'c'])
2607
class TestStoreMinimalAPI(tests.TestCaseWithTransport):
2609
scenarios = [(key, {'get_store': builder}) for key, builder
2610
in config.test_store_builder_registry.iteritems()] + [
2611
('cmdline', {'get_store': lambda test: config.CommandLineStore()})]
2614
store = self.get_store(self)
2615
if type(store) == config.TransportIniFileStore:
2616
raise tests.TestNotApplicable(
2617
"%s is not a concrete Store implementation"
2618
" so it doesn't need an id" % (store.__class__.__name__,))
2619
self.assertIsNot(None, store.id)
2622
class TestStore(tests.TestCaseWithTransport):
2624
def assertSectionContent(self, expected, (store, section)):
2625
"""Assert that some options have the proper values in a section."""
2626
expected_name, expected_options = expected
2627
self.assertEquals(expected_name, section.id)
2630
dict([(k, section.get(k)) for k in expected_options.keys()]))
2633
class TestReadonlyStore(TestStore):
2635
scenarios = [(key, {'get_store': builder}) for key, builder
2636
in config.test_store_builder_registry.iteritems()]
2638
def test_building_delays_load(self):
2639
store = self.get_store(self)
2640
self.assertEquals(False, store.is_loaded())
2641
store._load_from_string('')
2642
self.assertEquals(True, store.is_loaded())
2644
def test_get_no_sections_for_empty(self):
2645
store = self.get_store(self)
2646
store._load_from_string('')
2647
self.assertEquals([], list(store.get_sections()))
2649
def test_get_default_section(self):
2650
store = self.get_store(self)
2651
store._load_from_string('foo=bar')
2652
sections = list(store.get_sections())
2653
self.assertLength(1, sections)
2654
self.assertSectionContent((None, {'foo': 'bar'}), sections[0])
2656
def test_get_named_section(self):
2657
store = self.get_store(self)
2658
store._load_from_string('[baz]\nfoo=bar')
2659
sections = list(store.get_sections())
2660
self.assertLength(1, sections)
2661
self.assertSectionContent(('baz', {'foo': 'bar'}), sections[0])
2663
def test_load_from_string_fails_for_non_empty_store(self):
2664
store = self.get_store(self)
2665
store._load_from_string('foo=bar')
2666
self.assertRaises(AssertionError, store._load_from_string, 'bar=baz')
2669
class TestStoreQuoting(TestStore):
2671
scenarios = [(key, {'get_store': builder}) for key, builder
2672
in config.test_store_builder_registry.iteritems()]
2675
super(TestStoreQuoting, self).setUp()
2676
self.store = self.get_store(self)
2677
# We need a loaded store but any content will do
2678
self.store._load_from_string('')
2680
def assertIdempotent(self, s):
2681
"""Assert that quoting an unquoted string is a no-op and vice-versa.
2683
What matters here is that option values, as they appear in a store, can
2684
be safely round-tripped out of the store and back.
2686
:param s: A string, quoted if required.
2688
self.assertEquals(s, self.store.quote(self.store.unquote(s)))
2689
self.assertEquals(s, self.store.unquote(self.store.quote(s)))
2691
def test_empty_string(self):
2692
if isinstance(self.store, config.IniFileStore):
2693
# configobj._quote doesn't handle empty values
2694
self.assertRaises(AssertionError,
2695
self.assertIdempotent, '')
2697
self.assertIdempotent('')
2698
# But quoted empty strings are ok
2699
self.assertIdempotent('""')
2701
def test_embedded_spaces(self):
2702
self.assertIdempotent('" a b c "')
2704
def test_embedded_commas(self):
2705
self.assertIdempotent('" a , b c "')
2707
def test_simple_comma(self):
2708
if isinstance(self.store, config.IniFileStore):
2709
# configobj requires that lists are special-cased
2710
self.assertRaises(AssertionError,
2711
self.assertIdempotent, ',')
2713
self.assertIdempotent(',')
2714
# When a single comma is required, quoting is also required
2715
self.assertIdempotent('","')
2717
def test_list(self):
2718
if isinstance(self.store, config.IniFileStore):
2719
# configobj requires that lists are special-cased
2720
self.assertRaises(AssertionError,
2721
self.assertIdempotent, 'a,b')
2723
self.assertIdempotent('a,b')
2726
class TestDictFromStore(tests.TestCase):
2728
def test_unquote_not_string(self):
2729
conf = config.MemoryStack('x=2\n[a_section]\na=1\n')
2730
value = conf.get('a_section')
2731
# Urgh, despite 'conf' asking for the no-name section, we get the
2732
# content of another section as a dict o_O
2733
self.assertEquals({'a': '1'}, value)
2734
unquoted = conf.store.unquote(value)
2735
# Which cannot be unquoted but shouldn't crash either (the use cases
2736
# are getting the value or displaying it. In the later case, '%s' will
2738
self.assertEquals({'a': '1'}, unquoted)
2739
self.assertEquals("{u'a': u'1'}", '%s' % (unquoted,))
2742
class TestIniFileStoreContent(tests.TestCaseWithTransport):
2743
"""Simulate loading a config store with content of various encodings.
2745
All files produced by bzr are in utf8 content.
2747
Users may modify them manually and end up with a file that can't be
2748
loaded. We need to issue proper error messages in this case.
2751
invalid_utf8_char = '\xff'
2753
def test_load_utf8(self):
2754
"""Ensure we can load an utf8-encoded file."""
2755
t = self.get_transport()
2756
# From http://pad.lv/799212
2757
unicode_user = u'b\N{Euro Sign}ar'
2758
unicode_content = u'user=%s' % (unicode_user,)
2759
utf8_content = unicode_content.encode('utf8')
2760
# Store the raw content in the config file
2761
t.put_bytes('foo.conf', utf8_content)
2762
store = config.TransportIniFileStore(t, 'foo.conf')
2764
stack = config.Stack([store.get_sections], store)
2765
self.assertEquals(unicode_user, stack.get('user'))
2767
def test_load_non_ascii(self):
2768
"""Ensure we display a proper error on non-ascii, non utf-8 content."""
2769
t = self.get_transport()
2770
t.put_bytes('foo.conf', 'user=foo\n#%s\n' % (self.invalid_utf8_char,))
2771
store = config.TransportIniFileStore(t, 'foo.conf')
2772
self.assertRaises(errors.ConfigContentError, store.load)
2774
def test_load_erroneous_content(self):
2775
"""Ensure we display a proper error on content that can't be parsed."""
2776
t = self.get_transport()
2777
t.put_bytes('foo.conf', '[open_section\n')
2778
store = config.TransportIniFileStore(t, 'foo.conf')
2779
self.assertRaises(errors.ParseConfigError, store.load)
2781
def test_load_permission_denied(self):
2782
"""Ensure we get warned when trying to load an inaccessible file."""
2785
warnings.append(args[0] % args[1:])
2786
self.overrideAttr(trace, 'warning', warning)
2788
t = self.get_transport()
2790
def get_bytes(relpath):
2791
raise errors.PermissionDenied(relpath, "")
2792
t.get_bytes = get_bytes
2793
store = config.TransportIniFileStore(t, 'foo.conf')
2794
self.assertRaises(errors.PermissionDenied, store.load)
2797
[u'Permission denied while trying to load configuration store %s.'
2798
% store.external_url()])
2801
class TestIniConfigContent(tests.TestCaseWithTransport):
2802
"""Simulate loading a IniBasedConfig with content of various encodings.
2804
All files produced by bzr are in utf8 content.
2806
Users may modify them manually and end up with a file that can't be
2807
loaded. We need to issue proper error messages in this case.
2810
invalid_utf8_char = '\xff'
2812
def test_load_utf8(self):
2813
"""Ensure we can load an utf8-encoded file."""
2814
# From http://pad.lv/799212
2815
unicode_user = u'b\N{Euro Sign}ar'
2816
unicode_content = u'user=%s' % (unicode_user,)
2817
utf8_content = unicode_content.encode('utf8')
2818
# Store the raw content in the config file
2819
with open('foo.conf', 'wb') as f:
2820
f.write(utf8_content)
2821
conf = config.IniBasedConfig(file_name='foo.conf')
2822
self.assertEquals(unicode_user, conf.get_user_option('user'))
2824
def test_load_badly_encoded_content(self):
2825
"""Ensure we display a proper error on non-ascii, non utf-8 content."""
2826
with open('foo.conf', 'wb') as f:
2827
f.write('user=foo\n#%s\n' % (self.invalid_utf8_char,))
2828
conf = config.IniBasedConfig(file_name='foo.conf')
2829
self.assertRaises(errors.ConfigContentError, conf._get_parser)
2831
def test_load_erroneous_content(self):
2832
"""Ensure we display a proper error on content that can't be parsed."""
2833
with open('foo.conf', 'wb') as f:
2834
f.write('[open_section\n')
2835
conf = config.IniBasedConfig(file_name='foo.conf')
2836
self.assertRaises(errors.ParseConfigError, conf._get_parser)
2839
class TestMutableStore(TestStore):
2841
scenarios = [(key, {'store_id': key, 'get_store': builder}) for key, builder
2842
in config.test_store_builder_registry.iteritems()]
2845
super(TestMutableStore, self).setUp()
2846
self.transport = self.get_transport()
2848
def has_store(self, store):
2849
store_basename = urlutils.relative_url(self.transport.external_url(),
2850
store.external_url())
2851
return self.transport.has(store_basename)
2853
def test_save_empty_creates_no_file(self):
2854
# FIXME: There should be a better way than relying on the test
2855
# parametrization to identify branch.conf -- vila 2011-0526
2856
if self.store_id in ('branch', 'remote_branch'):
2857
raise tests.TestNotApplicable(
2858
'branch.conf is *always* created when a branch is initialized')
2859
store = self.get_store(self)
2861
self.assertEquals(False, self.has_store(store))
2863
def test_save_emptied_succeeds(self):
2864
store = self.get_store(self)
2865
store._load_from_string('foo=bar\n')
2866
# FIXME: There should be a better way than relying on the test
2867
# parametrization to identify branch.conf -- vila 2011-0526
2868
if self.store_id in ('branch', 'remote_branch'):
2869
# branch stores requires write locked branches
2870
self.addCleanup(store.branch.lock_write().unlock)
2871
section = store.get_mutable_section(None)
2872
section.remove('foo')
2874
self.assertEquals(True, self.has_store(store))
2875
modified_store = self.get_store(self)
2876
sections = list(modified_store.get_sections())
2877
self.assertLength(0, sections)
2879
def test_save_with_content_succeeds(self):
2880
# FIXME: There should be a better way than relying on the test
2881
# parametrization to identify branch.conf -- vila 2011-0526
2882
if self.store_id in ('branch', 'remote_branch'):
2883
raise tests.TestNotApplicable(
2884
'branch.conf is *always* created when a branch is initialized')
2885
store = self.get_store(self)
2886
store._load_from_string('foo=bar\n')
2887
self.assertEquals(False, self.has_store(store))
2889
self.assertEquals(True, self.has_store(store))
2890
modified_store = self.get_store(self)
2891
sections = list(modified_store.get_sections())
2892
self.assertLength(1, sections)
2893
self.assertSectionContent((None, {'foo': 'bar'}), sections[0])
2895
def test_set_option_in_empty_store(self):
2896
store = self.get_store(self)
2897
# FIXME: There should be a better way than relying on the test
2898
# parametrization to identify branch.conf -- vila 2011-0526
2899
if self.store_id in ('branch', 'remote_branch'):
2900
# branch stores requires write locked branches
2901
self.addCleanup(store.branch.lock_write().unlock)
2902
section = store.get_mutable_section(None)
2903
section.set('foo', 'bar')
2905
modified_store = self.get_store(self)
2906
sections = list(modified_store.get_sections())
2907
self.assertLength(1, sections)
2908
self.assertSectionContent((None, {'foo': 'bar'}), sections[0])
2910
def test_set_option_in_default_section(self):
2911
store = self.get_store(self)
2912
store._load_from_string('')
2913
# FIXME: There should be a better way than relying on the test
2914
# parametrization to identify branch.conf -- vila 2011-0526
2915
if self.store_id in ('branch', 'remote_branch'):
2916
# branch stores requires write locked branches
2917
self.addCleanup(store.branch.lock_write().unlock)
2918
section = store.get_mutable_section(None)
2919
section.set('foo', 'bar')
2921
modified_store = self.get_store(self)
2922
sections = list(modified_store.get_sections())
2923
self.assertLength(1, sections)
2924
self.assertSectionContent((None, {'foo': 'bar'}), sections[0])
2926
def test_set_option_in_named_section(self):
2927
store = self.get_store(self)
2928
store._load_from_string('')
2929
# FIXME: There should be a better way than relying on the test
2930
# parametrization to identify branch.conf -- vila 2011-0526
2931
if self.store_id in ('branch', 'remote_branch'):
2932
# branch stores requires write locked branches
2933
self.addCleanup(store.branch.lock_write().unlock)
2934
section = store.get_mutable_section('baz')
2935
section.set('foo', 'bar')
2937
modified_store = self.get_store(self)
2938
sections = list(modified_store.get_sections())
2939
self.assertLength(1, sections)
2940
self.assertSectionContent(('baz', {'foo': 'bar'}), sections[0])
2942
def test_load_hook(self):
2943
# First, we need to ensure that the store exists
2944
store = self.get_store(self)
2945
# FIXME: There should be a better way than relying on the test
2946
# parametrization to identify branch.conf -- vila 2011-0526
2947
if self.store_id in ('branch', 'remote_branch'):
2948
# branch stores requires write locked branches
2949
self.addCleanup(store.branch.lock_write().unlock)
2950
section = store.get_mutable_section('baz')
2951
section.set('foo', 'bar')
2953
# Now we can try to load it
2954
store = self.get_store(self)
2958
config.ConfigHooks.install_named_hook('load', hook, None)
2959
self.assertLength(0, calls)
2961
self.assertLength(1, calls)
2962
self.assertEquals((store,), calls[0])
2964
def test_save_hook(self):
2968
config.ConfigHooks.install_named_hook('save', hook, None)
2969
self.assertLength(0, calls)
2970
store = self.get_store(self)
2971
# FIXME: There should be a better way than relying on the test
2972
# parametrization to identify branch.conf -- vila 2011-0526
2973
if self.store_id in ('branch', 'remote_branch'):
2974
# branch stores requires write locked branches
2975
self.addCleanup(store.branch.lock_write().unlock)
2976
section = store.get_mutable_section('baz')
2977
section.set('foo', 'bar')
2979
self.assertLength(1, calls)
2980
self.assertEquals((store,), calls[0])
2982
def test_set_mark_dirty(self):
2983
stack = config.MemoryStack('')
2984
self.assertLength(0, stack.store.dirty_sections)
2985
stack.set('foo', 'baz')
2986
self.assertLength(1, stack.store.dirty_sections)
2987
self.assertTrue(stack.store._need_saving())
2989
def test_remove_mark_dirty(self):
2990
stack = config.MemoryStack('foo=bar')
2991
self.assertLength(0, stack.store.dirty_sections)
2993
self.assertLength(1, stack.store.dirty_sections)
2994
self.assertTrue(stack.store._need_saving())
2997
class TestStoreSaveChanges(tests.TestCaseWithTransport):
2998
"""Tests that config changes are kept in memory and saved on-demand."""
3001
super(TestStoreSaveChanges, self).setUp()
3002
self.transport = self.get_transport()
3003
# Most of the tests involve two stores pointing to the same persistent
3004
# storage to observe the effects of concurrent changes
3005
self.st1 = config.TransportIniFileStore(self.transport, 'foo.conf')
3006
self.st2 = config.TransportIniFileStore(self.transport, 'foo.conf')
3009
self.warnings.append(args[0] % args[1:])
3010
self.overrideAttr(trace, 'warning', warning)
3012
def has_store(self, store):
3013
store_basename = urlutils.relative_url(self.transport.external_url(),
3014
store.external_url())
3015
return self.transport.has(store_basename)
3017
def get_stack(self, store):
3018
# Any stack will do as long as it uses the right store, just a single
3019
# no-name section is enough
3020
return config.Stack([store.get_sections], store)
3022
def test_no_changes_no_save(self):
3023
s = self.get_stack(self.st1)
3024
s.store.save_changes()
3025
self.assertEquals(False, self.has_store(self.st1))
3027
def test_unrelated_concurrent_update(self):
3028
s1 = self.get_stack(self.st1)
3029
s2 = self.get_stack(self.st2)
3030
s1.set('foo', 'bar')
3031
s2.set('baz', 'quux')
3033
# Changes don't propagate magically
3034
self.assertEquals(None, s1.get('baz'))
3035
s2.store.save_changes()
3036
self.assertEquals('quux', s2.get('baz'))
3037
# Changes are acquired when saving
3038
self.assertEquals('bar', s2.get('foo'))
3039
# Since there is no overlap, no warnings are emitted
3040
self.assertLength(0, self.warnings)
3042
def test_concurrent_update_modified(self):
3043
s1 = self.get_stack(self.st1)
3044
s2 = self.get_stack(self.st2)
3045
s1.set('foo', 'bar')
3046
s2.set('foo', 'baz')
3049
s2.store.save_changes()
3050
self.assertEquals('baz', s2.get('foo'))
3051
# But the user get a warning
3052
self.assertLength(1, self.warnings)
3053
warning = self.warnings[0]
3054
self.assertStartsWith(warning, 'Option foo in section None')
3055
self.assertEndsWith(warning, 'was changed from <CREATED> to bar.'
3056
' The baz value will be saved.')
3058
def test_concurrent_deletion(self):
3059
self.st1._load_from_string('foo=bar')
3061
s1 = self.get_stack(self.st1)
3062
s2 = self.get_stack(self.st2)
3065
s1.store.save_changes()
3067
self.assertLength(0, self.warnings)
3068
s2.store.save_changes()
3070
self.assertLength(1, self.warnings)
3071
warning = self.warnings[0]
3072
self.assertStartsWith(warning, 'Option foo in section None')
3073
self.assertEndsWith(warning, 'was changed from bar to <CREATED>.'
3074
' The <DELETED> value will be saved.')
3077
class TestQuotingIniFileStore(tests.TestCaseWithTransport):
3079
def get_store(self):
3080
return config.TransportIniFileStore(self.get_transport(), 'foo.conf')
3082
def test_get_quoted_string(self):
3083
store = self.get_store()
3084
store._load_from_string('foo= " abc "')
3085
stack = config.Stack([store.get_sections])
3086
self.assertEquals(' abc ', stack.get('foo'))
3088
def test_set_quoted_string(self):
3089
store = self.get_store()
3090
stack = config.Stack([store.get_sections], store)
3091
stack.set('foo', ' a b c ')
3093
self.assertFileEqual('foo = " a b c "' + os.linesep, 'foo.conf')
3096
class TestTransportIniFileStore(TestStore):
3098
def test_loading_unknown_file_fails(self):
3099
store = config.TransportIniFileStore(self.get_transport(),
3101
self.assertRaises(errors.NoSuchFile, store.load)
3103
def test_invalid_content(self):
3104
store = config.TransportIniFileStore(self.get_transport(), 'foo.conf')
3105
self.assertEquals(False, store.is_loaded())
3106
exc = self.assertRaises(
3107
errors.ParseConfigError, store._load_from_string,
3108
'this is invalid !')
3109
self.assertEndsWith(exc.filename, 'foo.conf')
3110
# And the load failed
3111
self.assertEquals(False, store.is_loaded())
3113
def test_get_embedded_sections(self):
3114
# A more complicated example (which also shows that section names and
3115
# option names share the same name space...)
3116
# FIXME: This should be fixed by forbidding dicts as values ?
3117
# -- vila 2011-04-05
3118
store = config.TransportIniFileStore(self.get_transport(), 'foo.conf')
3119
store._load_from_string('''
3123
foo_in_DEFAULT=foo_DEFAULT
3131
sections = list(store.get_sections())
3132
self.assertLength(4, sections)
3133
# The default section has no name.
3134
# List values are provided as strings and need to be explicitly
3135
# converted by specifying from_unicode=list_from_store at option
3137
self.assertSectionContent((None, {'foo': 'bar', 'l': u'1,2'}),
3139
self.assertSectionContent(
3140
('DEFAULT', {'foo_in_DEFAULT': 'foo_DEFAULT'}), sections[1])
3141
self.assertSectionContent(
3142
('bar', {'foo_in_bar': 'barbar'}), sections[2])
3143
# sub sections are provided as embedded dicts.
3144
self.assertSectionContent(
3145
('baz', {'foo_in_baz': 'barbaz', 'qux': {'foo_in_qux': 'quux'}}),
3149
class TestLockableIniFileStore(TestStore):
3151
def test_create_store_in_created_dir(self):
3152
self.assertPathDoesNotExist('dir')
3153
t = self.get_transport('dir/subdir')
3154
store = config.LockableIniFileStore(t, 'foo.conf')
3155
store.get_mutable_section(None).set('foo', 'bar')
3157
self.assertPathExists('dir/subdir')
3160
class TestConcurrentStoreUpdates(TestStore):
3161
"""Test that Stores properly handle conccurent updates.
3163
New Store implementation may fail some of these tests but until such
3164
implementations exist it's hard to properly filter them from the scenarios
3165
applied here. If you encounter such a case, contact the bzr devs.
3168
scenarios = [(key, {'get_stack': builder}) for key, builder
3169
in config.test_stack_builder_registry.iteritems()]
3172
super(TestConcurrentStoreUpdates, self).setUp()
3173
self.stack = self.get_stack(self)
3174
if not isinstance(self.stack, config._CompatibleStack):
3175
raise tests.TestNotApplicable(
3176
'%s is not meant to be compatible with the old config design'
3178
self.stack.set('one', '1')
3179
self.stack.set('two', '2')
3181
self.stack.store.save()
3183
def test_simple_read_access(self):
3184
self.assertEquals('1', self.stack.get('one'))
3186
def test_simple_write_access(self):
3187
self.stack.set('one', 'one')
3188
self.assertEquals('one', self.stack.get('one'))
3190
def test_listen_to_the_last_speaker(self):
3192
c2 = self.get_stack(self)
3193
c1.set('one', 'ONE')
3194
c2.set('two', 'TWO')
3195
self.assertEquals('ONE', c1.get('one'))
3196
self.assertEquals('TWO', c2.get('two'))
3197
# The second update respect the first one
3198
self.assertEquals('ONE', c2.get('one'))
3200
def test_last_speaker_wins(self):
3201
# If the same config is not shared, the same variable modified twice
3202
# can only see a single result.
3204
c2 = self.get_stack(self)
3207
self.assertEquals('c2', c2.get('one'))
3208
# The first modification is still available until another refresh
3210
self.assertEquals('c1', c1.get('one'))
3211
c1.set('two', 'done')
3212
self.assertEquals('c2', c1.get('one'))
3214
def test_writes_are_serialized(self):
3216
c2 = self.get_stack(self)
3218
# We spawn a thread that will pause *during* the config saving.
3219
before_writing = threading.Event()
3220
after_writing = threading.Event()
3221
writing_done = threading.Event()
3222
c1_save_without_locking_orig = c1.store.save_without_locking
3223
def c1_save_without_locking():
3224
before_writing.set()
3225
c1_save_without_locking_orig()
3226
# The lock is held. We wait for the main thread to decide when to
3228
after_writing.wait()
3229
c1.store.save_without_locking = c1_save_without_locking
3233
t1 = threading.Thread(target=c1_set)
3234
# Collect the thread after the test
3235
self.addCleanup(t1.join)
3236
# Be ready to unblock the thread if the test goes wrong
3237
self.addCleanup(after_writing.set)
3239
before_writing.wait()
3240
self.assertRaises(errors.LockContention,
3241
c2.set, 'one', 'c2')
3242
self.assertEquals('c1', c1.get('one'))
3243
# Let the lock be released
3247
self.assertEquals('c2', c2.get('one'))
3249
def test_read_while_writing(self):
3251
# We spawn a thread that will pause *during* the write
3252
ready_to_write = threading.Event()
3253
do_writing = threading.Event()
3254
writing_done = threading.Event()
3255
# We override the _save implementation so we know the store is locked
3256
c1_save_without_locking_orig = c1.store.save_without_locking
3257
def c1_save_without_locking():
3258
ready_to_write.set()
3259
# The lock is held. We wait for the main thread to decide when to
3262
c1_save_without_locking_orig()
3264
c1.store.save_without_locking = c1_save_without_locking
3267
t1 = threading.Thread(target=c1_set)
3268
# Collect the thread after the test
3269
self.addCleanup(t1.join)
3270
# Be ready to unblock the thread if the test goes wrong
3271
self.addCleanup(do_writing.set)
3273
# Ensure the thread is ready to write
3274
ready_to_write.wait()
3275
self.assertEquals('c1', c1.get('one'))
3276
# If we read during the write, we get the old value
3277
c2 = self.get_stack(self)
3278
self.assertEquals('1', c2.get('one'))
3279
# Let the writing occur and ensure it occurred
3282
# Now we get the updated value
3283
c3 = self.get_stack(self)
3284
self.assertEquals('c1', c3.get('one'))
3286
# FIXME: It may be worth looking into removing the lock dir when it's not
3287
# needed anymore and look at possible fallouts for concurrent lockers. This
3288
# will matter if/when we use config files outside of bazaar directories
3289
# (.bazaar or .bzr) -- vila 20110-04-111
3292
class TestSectionMatcher(TestStore):
3294
scenarios = [('location', {'matcher': config.LocationMatcher}),
3295
('id', {'matcher': config.NameMatcher}),]
3298
super(TestSectionMatcher, self).setUp()
3299
# Any simple store is good enough
3300
self.get_store = config.test_store_builder_registry.get('configobj')
3302
def test_no_matches_for_empty_stores(self):
3303
store = self.get_store(self)
3304
store._load_from_string('')
3305
matcher = self.matcher(store, '/bar')
3306
self.assertEquals([], list(matcher.get_sections()))
3308
def test_build_doesnt_load_store(self):
3309
store = self.get_store(self)
3310
matcher = self.matcher(store, '/bar')
3311
self.assertFalse(store.is_loaded())
3314
class TestLocationSection(tests.TestCase):
3316
def get_section(self, options, extra_path):
3317
section = config.Section('foo', options)
3318
return config.LocationSection(section, extra_path)
3320
def test_simple_option(self):
3321
section = self.get_section({'foo': 'bar'}, '')
3322
self.assertEquals('bar', section.get('foo'))
3324
def test_option_with_extra_path(self):
3325
section = self.get_section({'foo': 'bar', 'foo:policy': 'appendpath'},
3327
self.assertEquals('bar/baz', section.get('foo'))
3329
def test_invalid_policy(self):
3330
section = self.get_section({'foo': 'bar', 'foo:policy': 'die'},
3332
# invalid policies are ignored
3333
self.assertEquals('bar', section.get('foo'))
3336
class TestLocationMatcher(TestStore):
3339
super(TestLocationMatcher, self).setUp()
3340
# Any simple store is good enough
3341
self.get_store = config.test_store_builder_registry.get('configobj')
3343
def test_unrelated_section_excluded(self):
3344
store = self.get_store(self)
3345
store._load_from_string('''
3353
section=/foo/bar/baz
3357
self.assertEquals(['/foo', '/foo/baz', '/foo/bar', '/foo/bar/baz',
3359
[section.id for _, section in store.get_sections()])
3360
matcher = config.LocationMatcher(store, '/foo/bar/quux')
3361
sections = [section for _, section in matcher.get_sections()]
3362
self.assertEquals(['/foo/bar', '/foo'],
3363
[section.id for section in sections])
3364
self.assertEquals(['quux', 'bar/quux'],
3365
[section.extra_path for section in sections])
3367
def test_more_specific_sections_first(self):
3368
store = self.get_store(self)
3369
store._load_from_string('''
3375
self.assertEquals(['/foo', '/foo/bar'],
3376
[section.id for _, section in store.get_sections()])
3377
matcher = config.LocationMatcher(store, '/foo/bar/baz')
3378
sections = [section for _, section in matcher.get_sections()]
3379
self.assertEquals(['/foo/bar', '/foo'],
3380
[section.id for section in sections])
3381
self.assertEquals(['baz', 'bar/baz'],
3382
[section.extra_path for section in sections])
3384
def test_appendpath_in_no_name_section(self):
3385
# It's a bit weird to allow appendpath in a no-name section, but
3386
# someone may found a use for it
3387
store = self.get_store(self)
3388
store._load_from_string('''
3390
foo:policy = appendpath
3392
matcher = config.LocationMatcher(store, 'dir/subdir')
3393
sections = list(matcher.get_sections())
3394
self.assertLength(1, sections)
3395
self.assertEquals('bar/dir/subdir', sections[0][1].get('foo'))
3397
def test_file_urls_are_normalized(self):
3398
store = self.get_store(self)
3399
if sys.platform == 'win32':
3400
expected_url = 'file:///C:/dir/subdir'
3401
expected_location = 'C:/dir/subdir'
3403
expected_url = 'file:///dir/subdir'
3404
expected_location = '/dir/subdir'
3405
matcher = config.LocationMatcher(store, expected_url)
3406
self.assertEquals(expected_location, matcher.location)
3409
class TestStartingPathMatcher(TestStore):
3412
super(TestStartingPathMatcher, self).setUp()
3413
# Any simple store is good enough
3414
self.store = config.IniFileStore()
3416
def assertSectionIDs(self, expected, location, content):
3417
self.store._load_from_string(content)
3418
matcher = config.StartingPathMatcher(self.store, location)
3419
sections = list(matcher.get_sections())
3420
self.assertLength(len(expected), sections)
3421
self.assertEqual(expected, [section.id for _, section in sections])
3424
def test_empty(self):
3425
self.assertSectionIDs([], self.get_url(), '')
3427
def test_url_vs_local_paths(self):
3428
# The matcher location is an url and the section names are local paths
3429
sections = self.assertSectionIDs(['/foo/bar', '/foo'],
3430
'file:///foo/bar/baz', '''\
3435
def test_local_path_vs_url(self):
3436
# The matcher location is a local path and the section names are urls
3437
sections = self.assertSectionIDs(['file:///foo/bar', 'file:///foo'],
3438
'/foo/bar/baz', '''\
3444
def test_no_name_section_included_when_present(self):
3445
# Note that other tests will cover the case where the no-name section
3446
# is empty and as such, not included.
3447
sections = self.assertSectionIDs(['/foo/bar', '/foo', None],
3448
'/foo/bar/baz', '''\
3449
option = defined so the no-name section exists
3453
self.assertEquals(['baz', 'bar/baz', '/foo/bar/baz'],
3454
[s.locals['relpath'] for _, s in sections])
3456
def test_order_reversed(self):
3457
self.assertSectionIDs(['/foo/bar', '/foo'], '/foo/bar/baz', '''\
3462
def test_unrelated_section_excluded(self):
3463
self.assertSectionIDs(['/foo/bar', '/foo'], '/foo/bar/baz', '''\
3469
def test_glob_included(self):
3470
sections = self.assertSectionIDs(['/foo/*/baz', '/foo/b*', '/foo'],
3471
'/foo/bar/baz', '''\
3477
# Note that 'baz' as a relpath for /foo/b* is not fully correct, but
3478
# nothing really is... as far using {relpath} to append it to something
3479
# else, this seems good enough though.
3480
self.assertEquals(['', 'baz', 'bar/baz'],
3481
[s.locals['relpath'] for _, s in sections])
3483
def test_respect_order(self):
3484
self.assertSectionIDs(['/foo', '/foo/b*', '/foo/*/baz'],
3485
'/foo/bar/baz', '''\
3493
class TestNameMatcher(TestStore):
3496
super(TestNameMatcher, self).setUp()
3497
self.matcher = config.NameMatcher
3498
# Any simple store is good enough
3499
self.get_store = config.test_store_builder_registry.get('configobj')
3501
def get_matching_sections(self, name):
3502
store = self.get_store(self)
3503
store._load_from_string('''
3511
matcher = self.matcher(store, name)
3512
return list(matcher.get_sections())
3514
def test_matching(self):
3515
sections = self.get_matching_sections('foo')
3516
self.assertLength(1, sections)
3517
self.assertSectionContent(('foo', {'option': 'foo'}), sections[0])
3519
def test_not_matching(self):
3520
sections = self.get_matching_sections('baz')
3521
self.assertLength(0, sections)
3524
class TestBaseStackGet(tests.TestCase):
3527
super(TestBaseStackGet, self).setUp()
3528
self.overrideAttr(config, 'option_registry', config.OptionRegistry())
3530
def test_get_first_definition(self):
3531
store1 = config.IniFileStore()
3532
store1._load_from_string('foo=bar')
3533
store2 = config.IniFileStore()
3534
store2._load_from_string('foo=baz')
3535
conf = config.Stack([store1.get_sections, store2.get_sections])
3536
self.assertEquals('bar', conf.get('foo'))
3538
def test_get_with_registered_default_value(self):
3539
config.option_registry.register(config.Option('foo', default='bar'))
3540
conf_stack = config.Stack([])
3541
self.assertEquals('bar', conf_stack.get('foo'))
3543
def test_get_without_registered_default_value(self):
3544
config.option_registry.register(config.Option('foo'))
3545
conf_stack = config.Stack([])
3546
self.assertEquals(None, conf_stack.get('foo'))
3548
def test_get_without_default_value_for_not_registered(self):
3549
conf_stack = config.Stack([])
3550
self.assertEquals(None, conf_stack.get('foo'))
3552
def test_get_for_empty_section_callable(self):
3553
conf_stack = config.Stack([lambda : []])
3554
self.assertEquals(None, conf_stack.get('foo'))
3556
def test_get_for_broken_callable(self):
3557
# Trying to use and invalid callable raises an exception on first use
3558
conf_stack = config.Stack([object])
3559
self.assertRaises(TypeError, conf_stack.get, 'foo')
3562
class TestStackWithSimpleStore(tests.TestCase):
3565
super(TestStackWithSimpleStore, self).setUp()
3566
self.overrideAttr(config, 'option_registry', config.OptionRegistry())
3567
self.registry = config.option_registry
3569
def get_conf(self, content=None):
3570
return config.MemoryStack(content)
3572
def test_override_value_from_env(self):
3573
self.registry.register(
3574
config.Option('foo', default='bar', override_from_env=['FOO']))
3575
self.overrideEnv('FOO', 'quux')
3576
# Env variable provides a default taking over the option one
3577
conf = self.get_conf('foo=store')
3578
self.assertEquals('quux', conf.get('foo'))
3580
def test_first_override_value_from_env_wins(self):
3581
self.registry.register(
3582
config.Option('foo', default='bar',
3583
override_from_env=['NO_VALUE', 'FOO', 'BAZ']))
3584
self.overrideEnv('FOO', 'foo')
3585
self.overrideEnv('BAZ', 'baz')
3586
# The first env var set wins
3587
conf = self.get_conf('foo=store')
3588
self.assertEquals('foo', conf.get('foo'))
3591
class TestMemoryStack(tests.TestCase):
3594
conf = config.MemoryStack('foo=bar')
3595
self.assertEquals('bar', conf.get('foo'))
3598
conf = config.MemoryStack('foo=bar')
3599
conf.set('foo', 'baz')
3600
self.assertEquals('baz', conf.get('foo'))
3602
def test_no_content(self):
3603
conf = config.MemoryStack()
3604
# No content means no loading
3605
self.assertFalse(conf.store.is_loaded())
3606
self.assertRaises(NotImplementedError, conf.get, 'foo')
3607
# But a content can still be provided
3608
conf.store._load_from_string('foo=bar')
3609
self.assertEquals('bar', conf.get('foo'))
3612
class TestStackIterSections(tests.TestCase):
3614
def test_empty_stack(self):
3615
conf = config.Stack([])
3616
sections = list(conf.iter_sections())
3617
self.assertLength(0, sections)
3619
def test_empty_store(self):
3620
store = config.IniFileStore()
3621
store._load_from_string('')
3622
conf = config.Stack([store.get_sections])
3623
sections = list(conf.iter_sections())
3624
self.assertLength(0, sections)
3626
def test_simple_store(self):
3627
store = config.IniFileStore()
3628
store._load_from_string('foo=bar')
3629
conf = config.Stack([store.get_sections])
3630
tuples = list(conf.iter_sections())
3631
self.assertLength(1, tuples)
3632
(found_store, found_section) = tuples[0]
3633
self.assertIs(store, found_store)
3635
def test_two_stores(self):
3636
store1 = config.IniFileStore()
3637
store1._load_from_string('foo=bar')
3638
store2 = config.IniFileStore()
3639
store2._load_from_string('bar=qux')
3640
conf = config.Stack([store1.get_sections, store2.get_sections])
3641
tuples = list(conf.iter_sections())
3642
self.assertLength(2, tuples)
3643
self.assertIs(store1, tuples[0][0])
3644
self.assertIs(store2, tuples[1][0])
3647
class TestStackWithTransport(tests.TestCaseWithTransport):
3649
scenarios = [(key, {'get_stack': builder}) for key, builder
3650
in config.test_stack_builder_registry.iteritems()]
3653
class TestConcreteStacks(TestStackWithTransport):
3655
def test_build_stack(self):
3656
# Just a smoke test to help debug builders
3657
stack = self.get_stack(self)
3660
class TestStackGet(TestStackWithTransport):
3663
super(TestStackGet, self).setUp()
3664
self.conf = self.get_stack(self)
3666
def test_get_for_empty_stack(self):
3667
self.assertEquals(None, self.conf.get('foo'))
3669
def test_get_hook(self):
3670
self.conf.set('foo', 'bar')
3674
config.ConfigHooks.install_named_hook('get', hook, None)
3675
self.assertLength(0, calls)
3676
value = self.conf.get('foo')
3677
self.assertEquals('bar', value)
3678
self.assertLength(1, calls)
3679
self.assertEquals((self.conf, 'foo', 'bar'), calls[0])
3682
class TestStackGetWithConverter(tests.TestCase):
3685
super(TestStackGetWithConverter, self).setUp()
3686
self.overrideAttr(config, 'option_registry', config.OptionRegistry())
3687
self.registry = config.option_registry
3689
def get_conf(self, content=None):
3690
return config.MemoryStack(content)
3692
def register_bool_option(self, name, default=None, default_from_env=None):
3693
b = config.Option(name, help='A boolean.',
3694
default=default, default_from_env=default_from_env,
3695
from_unicode=config.bool_from_store)
3696
self.registry.register(b)
3698
def test_get_default_bool_None(self):
3699
self.register_bool_option('foo')
3700
conf = self.get_conf('')
3701
self.assertEquals(None, conf.get('foo'))
3703
def test_get_default_bool_True(self):
3704
self.register_bool_option('foo', u'True')
3705
conf = self.get_conf('')
3706
self.assertEquals(True, conf.get('foo'))
3708
def test_get_default_bool_False(self):
3709
self.register_bool_option('foo', False)
3710
conf = self.get_conf('')
3711
self.assertEquals(False, conf.get('foo'))
3713
def test_get_default_bool_False_as_string(self):
3714
self.register_bool_option('foo', u'False')
3715
conf = self.get_conf('')
3716
self.assertEquals(False, conf.get('foo'))
3718
def test_get_default_bool_from_env_converted(self):
3719
self.register_bool_option('foo', u'True', default_from_env=['FOO'])
3720
self.overrideEnv('FOO', 'False')
3721
conf = self.get_conf('')
3722
self.assertEquals(False, conf.get('foo'))
3724
def test_get_default_bool_when_conversion_fails(self):
3725
self.register_bool_option('foo', default='True')
3726
conf = self.get_conf('foo=invalid boolean')
3727
self.assertEquals(True, conf.get('foo'))
3729
def register_integer_option(self, name,
3730
default=None, default_from_env=None):
3731
i = config.Option(name, help='An integer.',
3732
default=default, default_from_env=default_from_env,
3733
from_unicode=config.int_from_store)
3734
self.registry.register(i)
3736
def test_get_default_integer_None(self):
3737
self.register_integer_option('foo')
3738
conf = self.get_conf('')
3739
self.assertEquals(None, conf.get('foo'))
3741
def test_get_default_integer(self):
3742
self.register_integer_option('foo', 42)
3743
conf = self.get_conf('')
3744
self.assertEquals(42, conf.get('foo'))
3746
def test_get_default_integer_as_string(self):
3747
self.register_integer_option('foo', u'42')
3748
conf = self.get_conf('')
3749
self.assertEquals(42, conf.get('foo'))
3751
def test_get_default_integer_from_env(self):
3752
self.register_integer_option('foo', default_from_env=['FOO'])
3753
self.overrideEnv('FOO', '18')
3754
conf = self.get_conf('')
3755
self.assertEquals(18, conf.get('foo'))
3757
def test_get_default_integer_when_conversion_fails(self):
3758
self.register_integer_option('foo', default='12')
3759
conf = self.get_conf('foo=invalid integer')
3760
self.assertEquals(12, conf.get('foo'))
3762
def register_list_option(self, name, default=None, default_from_env=None):
3763
l = config.ListOption(name, help='A list.', default=default,
3764
default_from_env=default_from_env)
3765
self.registry.register(l)
3767
def test_get_default_list_None(self):
3768
self.register_list_option('foo')
3769
conf = self.get_conf('')
3770
self.assertEquals(None, conf.get('foo'))
3772
def test_get_default_list_empty(self):
3773
self.register_list_option('foo', '')
3774
conf = self.get_conf('')
3775
self.assertEquals([], conf.get('foo'))
3777
def test_get_default_list_from_env(self):
3778
self.register_list_option('foo', default_from_env=['FOO'])
3779
self.overrideEnv('FOO', '')
3780
conf = self.get_conf('')
3781
self.assertEquals([], conf.get('foo'))
3783
def test_get_with_list_converter_no_item(self):
3784
self.register_list_option('foo', None)
3785
conf = self.get_conf('foo=,')
3786
self.assertEquals([], conf.get('foo'))
3788
def test_get_with_list_converter_many_items(self):
3789
self.register_list_option('foo', None)
3790
conf = self.get_conf('foo=m,o,r,e')
3791
self.assertEquals(['m', 'o', 'r', 'e'], conf.get('foo'))
3793
def test_get_with_list_converter_embedded_spaces_many_items(self):
3794
self.register_list_option('foo', None)
3795
conf = self.get_conf('foo=" bar", "baz "')
3796
self.assertEquals([' bar', 'baz '], conf.get('foo'))
3798
def test_get_with_list_converter_stripped_spaces_many_items(self):
3799
self.register_list_option('foo', None)
3800
conf = self.get_conf('foo= bar , baz ')
3801
self.assertEquals(['bar', 'baz'], conf.get('foo'))
3804
class TestIterOptionRefs(tests.TestCase):
3805
"""iter_option_refs is a bit unusual, document some cases."""
3807
def assertRefs(self, expected, string):
3808
self.assertEquals(expected, list(config.iter_option_refs(string)))
3810
def test_empty(self):
3811
self.assertRefs([(False, '')], '')
3813
def test_no_refs(self):
3814
self.assertRefs([(False, 'foo bar')], 'foo bar')
3816
def test_single_ref(self):
3817
self.assertRefs([(False, ''), (True, '{foo}'), (False, '')], '{foo}')
3819
def test_broken_ref(self):
3820
self.assertRefs([(False, '{foo')], '{foo')
3822
def test_embedded_ref(self):
3823
self.assertRefs([(False, '{'), (True, '{foo}'), (False, '}')],
3826
def test_two_refs(self):
3827
self.assertRefs([(False, ''), (True, '{foo}'),
3828
(False, ''), (True, '{bar}'),
3832
def test_newline_in_refs_are_not_matched(self):
3833
self.assertRefs([(False, '{\nxx}{xx\n}{{\n}}')], '{\nxx}{xx\n}{{\n}}')
3836
class TestStackExpandOptions(tests.TestCaseWithTransport):
3839
super(TestStackExpandOptions, self).setUp()
3840
self.overrideAttr(config, 'option_registry', config.OptionRegistry())
3841
self.registry = config.option_registry
3842
store = config.TransportIniFileStore(self.get_transport(), 'foo.conf')
3843
self.conf = config.Stack([store.get_sections], store)
3845
def assertExpansion(self, expected, string, env=None):
3846
self.assertEquals(expected, self.conf.expand_options(string, env))
3848
def test_no_expansion(self):
3849
self.assertExpansion('foo', 'foo')
3851
def test_expand_default_value(self):
3852
self.conf.store._load_from_string('bar=baz')
3853
self.registry.register(config.Option('foo', default=u'{bar}'))
3854
self.assertEquals('baz', self.conf.get('foo', expand=True))
3856
def test_expand_default_from_env(self):
3857
self.conf.store._load_from_string('bar=baz')
3858
self.registry.register(config.Option('foo', default_from_env=['FOO']))
3859
self.overrideEnv('FOO', '{bar}')
3860
self.assertEquals('baz', self.conf.get('foo', expand=True))
3862
def test_expand_default_on_failed_conversion(self):
3863
self.conf.store._load_from_string('baz=bogus\nbar=42\nfoo={baz}')
3864
self.registry.register(
3865
config.Option('foo', default=u'{bar}',
3866
from_unicode=config.int_from_store))
3867
self.assertEquals(42, self.conf.get('foo', expand=True))
3869
def test_env_adding_options(self):
3870
self.assertExpansion('bar', '{foo}', {'foo': 'bar'})
3872
def test_env_overriding_options(self):
3873
self.conf.store._load_from_string('foo=baz')
3874
self.assertExpansion('bar', '{foo}', {'foo': 'bar'})
3876
def test_simple_ref(self):
3877
self.conf.store._load_from_string('foo=xxx')
3878
self.assertExpansion('xxx', '{foo}')
3880
def test_unknown_ref(self):
3881
self.assertRaises(errors.ExpandingUnknownOption,
3882
self.conf.expand_options, '{foo}')
3884
def test_indirect_ref(self):
3885
self.conf.store._load_from_string('''
3889
self.assertExpansion('xxx', '{bar}')
3891
def test_embedded_ref(self):
3892
self.conf.store._load_from_string('''
3896
self.assertExpansion('xxx', '{{bar}}')
3898
def test_simple_loop(self):
3899
self.conf.store._load_from_string('foo={foo}')
3900
self.assertRaises(errors.OptionExpansionLoop,
3901
self.conf.expand_options, '{foo}')
3903
def test_indirect_loop(self):
3904
self.conf.store._load_from_string('''
3908
e = self.assertRaises(errors.OptionExpansionLoop,
3909
self.conf.expand_options, '{foo}')
3910
self.assertEquals('foo->bar->baz', e.refs)
3911
self.assertEquals('{foo}', e.string)
3913
def test_list(self):
3914
self.conf.store._load_from_string('''
3918
list={foo},{bar},{baz}
3920
self.registry.register(
3921
config.ListOption('list'))
3922
self.assertEquals(['start', 'middle', 'end'],
3923
self.conf.get('list', expand=True))
3925
def test_cascading_list(self):
3926
self.conf.store._load_from_string('''
3932
self.registry.register(config.ListOption('list'))
3933
# Register an intermediate option as a list to ensure no conversion
3934
# happen while expanding. Conversion should only occur for the original
3935
# option ('list' here).
3936
self.registry.register(config.ListOption('baz'))
3937
self.assertEquals(['start', 'middle', 'end'],
3938
self.conf.get('list', expand=True))
3940
def test_pathologically_hidden_list(self):
3941
self.conf.store._load_from_string('''
3947
hidden={start}{middle}{end}
3949
# What matters is what the registration says, the conversion happens
3950
# only after all expansions have been performed
3951
self.registry.register(config.ListOption('hidden'))
3952
self.assertEquals(['bin', 'go'],
3953
self.conf.get('hidden', expand=True))
3956
class TestStackCrossSectionsExpand(tests.TestCaseWithTransport):
3959
super(TestStackCrossSectionsExpand, self).setUp()
3961
def get_config(self, location, string):
3964
# Since we don't save the config we won't strictly require to inherit
3965
# from TestCaseInTempDir, but an error occurs so quickly...
3966
c = config.LocationStack(location)
3967
c.store._load_from_string(string)
3970
def test_dont_cross_unrelated_section(self):
3971
c = self.get_config('/another/branch/path','''
3976
[/another/branch/path]
3979
self.assertRaises(errors.ExpandingUnknownOption,
3980
c.get, 'bar', expand=True)
3982
def test_cross_related_sections(self):
3983
c = self.get_config('/project/branch/path','''
3987
[/project/branch/path]
3990
self.assertEquals('quux', c.get('bar', expand=True))
3993
class TestStackCrossStoresExpand(tests.TestCaseWithTransport):
3995
def test_cross_global_locations(self):
3996
l_store = config.LocationStore()
3997
l_store._load_from_string('''
4003
g_store = config.GlobalStore()
4004
g_store._load_from_string('''
4010
stack = config.LocationStack('/branch')
4011
self.assertEquals('glob-bar', stack.get('lbar', expand=True))
4012
self.assertEquals('loc-foo', stack.get('gfoo', expand=True))
4015
class TestStackExpandSectionLocals(tests.TestCaseWithTransport):
4017
def test_expand_locals_empty(self):
4018
l_store = config.LocationStore()
4019
l_store._load_from_string('''
4020
[/home/user/project]
4025
stack = config.LocationStack('/home/user/project/')
4026
self.assertEquals('', stack.get('base', expand=True))
4027
self.assertEquals('', stack.get('rel', expand=True))
4029
def test_expand_basename_locally(self):
4030
l_store = config.LocationStore()
4031
l_store._load_from_string('''
4032
[/home/user/project]
4036
stack = config.LocationStack('/home/user/project/branch')
4037
self.assertEquals('branch', stack.get('bfoo', expand=True))
4039
def test_expand_basename_locally_longer_path(self):
4040
l_store = config.LocationStore()
4041
l_store._load_from_string('''
4046
stack = config.LocationStack('/home/user/project/dir/branch')
4047
self.assertEquals('branch', stack.get('bfoo', expand=True))
4049
def test_expand_relpath_locally(self):
4050
l_store = config.LocationStore()
4051
l_store._load_from_string('''
4052
[/home/user/project]
4053
lfoo = loc-foo/{relpath}
4056
stack = config.LocationStack('/home/user/project/branch')
4057
self.assertEquals('loc-foo/branch', stack.get('lfoo', expand=True))
4059
def test_expand_relpath_unknonw_in_global(self):
4060
g_store = config.GlobalStore()
4061
g_store._load_from_string('''
4066
stack = config.LocationStack('/home/user/project/branch')
4067
self.assertRaises(errors.ExpandingUnknownOption,
4068
stack.get, 'gfoo', expand=True)
4070
def test_expand_local_option_locally(self):
4071
l_store = config.LocationStore()
4072
l_store._load_from_string('''
4073
[/home/user/project]
4074
lfoo = loc-foo/{relpath}
4078
g_store = config.GlobalStore()
4079
g_store._load_from_string('''
4085
stack = config.LocationStack('/home/user/project/branch')
4086
self.assertEquals('glob-bar', stack.get('lbar', expand=True))
4087
self.assertEquals('loc-foo/branch', stack.get('gfoo', expand=True))
4089
def test_locals_dont_leak(self):
4090
"""Make sure we chose the right local in presence of several sections.
4092
l_store = config.LocationStore()
4093
l_store._load_from_string('''
4095
lfoo = loc-foo/{relpath}
4096
[/home/user/project]
4097
lfoo = loc-foo/{relpath}
4100
stack = config.LocationStack('/home/user/project/branch')
4101
self.assertEquals('loc-foo/branch', stack.get('lfoo', expand=True))
4102
stack = config.LocationStack('/home/user/bar/baz')
4103
self.assertEquals('loc-foo/bar/baz', stack.get('lfoo', expand=True))
4107
class TestStackSet(TestStackWithTransport):
4109
def test_simple_set(self):
4110
conf = self.get_stack(self)
4111
self.assertEquals(None, conf.get('foo'))
4112
conf.set('foo', 'baz')
4113
# Did we get it back ?
4114
self.assertEquals('baz', conf.get('foo'))
4116
def test_set_creates_a_new_section(self):
4117
conf = self.get_stack(self)
4118
conf.set('foo', 'baz')
4119
self.assertEquals, 'baz', conf.get('foo')
4121
def test_set_hook(self):
4125
config.ConfigHooks.install_named_hook('set', hook, None)
4126
self.assertLength(0, calls)
4127
conf = self.get_stack(self)
4128
conf.set('foo', 'bar')
4129
self.assertLength(1, calls)
4130
self.assertEquals((conf, 'foo', 'bar'), calls[0])
4133
class TestStackRemove(TestStackWithTransport):
4135
def test_remove_existing(self):
4136
conf = self.get_stack(self)
4137
conf.set('foo', 'bar')
4138
self.assertEquals('bar', conf.get('foo'))
4140
# Did we get it back ?
4141
self.assertEquals(None, conf.get('foo'))
4143
def test_remove_unknown(self):
4144
conf = self.get_stack(self)
4145
self.assertRaises(KeyError, conf.remove, 'I_do_not_exist')
4147
def test_remove_hook(self):
4151
config.ConfigHooks.install_named_hook('remove', hook, None)
4152
self.assertLength(0, calls)
4153
conf = self.get_stack(self)
4154
conf.set('foo', 'bar')
4156
self.assertLength(1, calls)
4157
self.assertEquals((conf, 'foo'), calls[0])
4160
class TestConfigGetOptions(tests.TestCaseWithTransport, TestOptionsMixin):
4163
super(TestConfigGetOptions, self).setUp()
4164
create_configs(self)
4166
def test_no_variable(self):
4167
# Using branch should query branch, locations and bazaar
4168
self.assertOptions([], self.branch_config)
4170
def test_option_in_bazaar(self):
4171
self.bazaar_config.set_user_option('file', 'bazaar')
4172
self.assertOptions([('file', 'bazaar', 'DEFAULT', 'bazaar')],
4175
def test_option_in_locations(self):
4176
self.locations_config.set_user_option('file', 'locations')
4178
[('file', 'locations', self.tree.basedir, 'locations')],
4179
self.locations_config)
4181
def test_option_in_branch(self):
4182
self.branch_config.set_user_option('file', 'branch')
4183
self.assertOptions([('file', 'branch', 'DEFAULT', 'branch')],
4186
def test_option_in_bazaar_and_branch(self):
4187
self.bazaar_config.set_user_option('file', 'bazaar')
4188
self.branch_config.set_user_option('file', 'branch')
4189
self.assertOptions([('file', 'branch', 'DEFAULT', 'branch'),
4190
('file', 'bazaar', 'DEFAULT', 'bazaar'),],
4193
def test_option_in_branch_and_locations(self):
4194
# Hmm, locations override branch :-/
4195
self.locations_config.set_user_option('file', 'locations')
4196
self.branch_config.set_user_option('file', 'branch')
4198
[('file', 'locations', self.tree.basedir, 'locations'),
4199
('file', 'branch', 'DEFAULT', 'branch'),],
4202
def test_option_in_bazaar_locations_and_branch(self):
4203
self.bazaar_config.set_user_option('file', 'bazaar')
4204
self.locations_config.set_user_option('file', 'locations')
4205
self.branch_config.set_user_option('file', 'branch')
4207
[('file', 'locations', self.tree.basedir, 'locations'),
4208
('file', 'branch', 'DEFAULT', 'branch'),
4209
('file', 'bazaar', 'DEFAULT', 'bazaar'),],
4213
class TestConfigRemoveOption(tests.TestCaseWithTransport, TestOptionsMixin):
4216
super(TestConfigRemoveOption, self).setUp()
4217
create_configs_with_file_option(self)
4219
def test_remove_in_locations(self):
4220
self.locations_config.remove_user_option('file', self.tree.basedir)
4222
[('file', 'branch', 'DEFAULT', 'branch'),
4223
('file', 'bazaar', 'DEFAULT', 'bazaar'),],
4226
def test_remove_in_branch(self):
4227
self.branch_config.remove_user_option('file')
4229
[('file', 'locations', self.tree.basedir, 'locations'),
4230
('file', 'bazaar', 'DEFAULT', 'bazaar'),],
4233
def test_remove_in_bazaar(self):
4234
self.bazaar_config.remove_user_option('file')
4236
[('file', 'locations', self.tree.basedir, 'locations'),
4237
('file', 'branch', 'DEFAULT', 'branch'),],
4241
class TestConfigGetSections(tests.TestCaseWithTransport):
4244
super(TestConfigGetSections, self).setUp()
4245
create_configs(self)
4247
def assertSectionNames(self, expected, conf, name=None):
4248
"""Check which sections are returned for a given config.
4250
If fallback configurations exist their sections can be included.
4252
:param expected: A list of section names.
4254
:param conf: The configuration that will be queried.
4256
:param name: An optional section name that will be passed to
4259
sections = list(conf._get_sections(name))
4260
self.assertLength(len(expected), sections)
4261
self.assertEqual(expected, [name for name, _, _ in sections])
4263
def test_bazaar_default_section(self):
4264
self.assertSectionNames(['DEFAULT'], self.bazaar_config)
4266
def test_locations_default_section(self):
4267
# No sections are defined in an empty file
4268
self.assertSectionNames([], self.locations_config)
4270
def test_locations_named_section(self):
4271
self.locations_config.set_user_option('file', 'locations')
4272
self.assertSectionNames([self.tree.basedir], self.locations_config)
4274
def test_locations_matching_sections(self):
4275
loc_config = self.locations_config
4276
loc_config.set_user_option('file', 'locations')
4277
# We need to cheat a bit here to create an option in sections above and
4278
# below the 'location' one.
4279
parser = loc_config._get_parser()
4280
# locations.cong deals with '/' ignoring native os.sep
4281
location_names = self.tree.basedir.split('/')
4282
parent = '/'.join(location_names[:-1])
4283
child = '/'.join(location_names + ['child'])
4285
parser[parent]['file'] = 'parent'
4287
parser[child]['file'] = 'child'
4288
self.assertSectionNames([self.tree.basedir, parent], loc_config)
4290
def test_branch_data_default_section(self):
4291
self.assertSectionNames([None],
4292
self.branch_config._get_branch_data_config())
4294
def test_branch_default_sections(self):
4295
# No sections are defined in an empty locations file
4296
self.assertSectionNames([None, 'DEFAULT'],
4298
# Unless we define an option
4299
self.branch_config._get_location_config().set_user_option(
4300
'file', 'locations')
4301
self.assertSectionNames([self.tree.basedir, None, 'DEFAULT'],
4304
def test_bazaar_named_section(self):
4305
# We need to cheat as the API doesn't give direct access to sections
4306
# other than DEFAULT.
4307
self.bazaar_config.set_alias('bazaar', 'bzr')
4308
self.assertSectionNames(['ALIASES'], self.bazaar_config, 'ALIASES')
4311
class TestAuthenticationConfigFile(tests.TestCase):
4312
"""Test the authentication.conf file matching"""
4314
def _got_user_passwd(self, expected_user, expected_password,
4315
config, *args, **kwargs):
4316
credentials = config.get_credentials(*args, **kwargs)
4317
if credentials is None:
4321
user = credentials['user']
4322
password = credentials['password']
4323
self.assertEquals(expected_user, user)
4324
self.assertEquals(expected_password, password)
4326
def test_empty_config(self):
4327
conf = config.AuthenticationConfig(_file=StringIO())
4328
self.assertEquals({}, conf._get_config())
4329
self._got_user_passwd(None, None, conf, 'http', 'foo.net')
4331
def test_non_utf8_config(self):
4332
conf = config.AuthenticationConfig(_file=StringIO(
4334
self.assertRaises(errors.ConfigContentError, conf._get_config)
4336
def test_missing_auth_section_header(self):
4337
conf = config.AuthenticationConfig(_file=StringIO('foo = bar'))
4338
self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
4340
def test_auth_section_header_not_closed(self):
4341
conf = config.AuthenticationConfig(_file=StringIO('[DEF'))
4342
self.assertRaises(errors.ParseConfigError, conf._get_config)
4344
def test_auth_value_not_boolean(self):
4345
conf = config.AuthenticationConfig(_file=StringIO(
4349
verify_certificates=askme # Error: Not a boolean
4351
self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
4353
def test_auth_value_not_int(self):
4354
conf = config.AuthenticationConfig(_file=StringIO(
4358
port=port # Error: Not an int
4360
self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
4362
def test_unknown_password_encoding(self):
4363
conf = config.AuthenticationConfig(_file=StringIO(
4367
password_encoding=unknown
4369
self.assertRaises(ValueError, conf.get_password,
4370
'ftp', 'foo.net', 'joe')
4372
def test_credentials_for_scheme_host(self):
4373
conf = config.AuthenticationConfig(_file=StringIO(
4374
"""# Identity on foo.net
4379
password=secret-pass
4382
self._got_user_passwd('joe', 'secret-pass', conf, 'ftp', 'foo.net')
4384
self._got_user_passwd(None, None, conf, 'http', 'foo.net')
4386
self._got_user_passwd(None, None, conf, 'ftp', 'bar.net')
4388
def test_credentials_for_host_port(self):
4389
conf = config.AuthenticationConfig(_file=StringIO(
4390
"""# Identity on foo.net
4396
password=secret-pass
4399
self._got_user_passwd('joe', 'secret-pass',
4400
conf, 'ftp', 'foo.net', port=10021)
4402
self._got_user_passwd(None, None, conf, 'ftp', 'foo.net')
4404
def test_for_matching_host(self):
4405
conf = config.AuthenticationConfig(_file=StringIO(
4406
"""# Identity on foo.net
4412
[sourceforge domain]
4419
self._got_user_passwd('georges', 'bendover',
4420
conf, 'bzr', 'foo.bzr.sf.net')
4422
self._got_user_passwd(None, None,
4423
conf, 'bzr', 'bbzr.sf.net')
4425
def test_for_matching_host_None(self):
4426
conf = config.AuthenticationConfig(_file=StringIO(
4427
"""# Identity on foo.net
4437
self._got_user_passwd('joe', 'joepass',
4438
conf, 'bzr', 'quux.net')
4439
# no host but different scheme
4440
self._got_user_passwd('georges', 'bendover',
4441
conf, 'ftp', 'quux.net')
4443
def test_credentials_for_path(self):
4444
conf = config.AuthenticationConfig(_file=StringIO(
4460
self._got_user_passwd(None, None,
4461
conf, 'http', host='bar.org', path='/dir3')
4463
self._got_user_passwd('georges', 'bendover',
4464
conf, 'http', host='bar.org', path='/dir2')
4466
self._got_user_passwd('jim', 'jimpass',
4467
conf, 'http', host='bar.org',path='/dir1/subdir')
4469
def test_credentials_for_user(self):
4470
conf = config.AuthenticationConfig(_file=StringIO(
4479
self._got_user_passwd('jim', 'jimpass',
4480
conf, 'http', 'bar.org')
4482
self._got_user_passwd('jim', 'jimpass',
4483
conf, 'http', 'bar.org', user='jim')
4484
# Don't get a different user if one is specified
4485
self._got_user_passwd(None, None,
4486
conf, 'http', 'bar.org', user='georges')
4488
def test_credentials_for_user_without_password(self):
4489
conf = config.AuthenticationConfig(_file=StringIO(
4496
# Get user but no password
4497
self._got_user_passwd('jim', None,
4498
conf, 'http', 'bar.org')
4500
def test_verify_certificates(self):
4501
conf = config.AuthenticationConfig(_file=StringIO(
4508
verify_certificates=False
4515
credentials = conf.get_credentials('https', 'bar.org')
4516
self.assertEquals(False, credentials.get('verify_certificates'))
4517
credentials = conf.get_credentials('https', 'foo.net')
4518
self.assertEquals(True, credentials.get('verify_certificates'))
4521
class TestAuthenticationStorage(tests.TestCaseInTempDir):
4523
def test_set_credentials(self):
4524
conf = config.AuthenticationConfig()
4525
conf.set_credentials('name', 'host', 'user', 'scheme', 'password',
4526
99, path='/foo', verify_certificates=False, realm='realm')
4527
credentials = conf.get_credentials(host='host', scheme='scheme',
4528
port=99, path='/foo',
4530
CREDENTIALS = {'name': 'name', 'user': 'user', 'password': 'password',
4531
'verify_certificates': False, 'scheme': 'scheme',
4532
'host': 'host', 'port': 99, 'path': '/foo',
4534
self.assertEqual(CREDENTIALS, credentials)
4535
credentials_from_disk = config.AuthenticationConfig().get_credentials(
4536
host='host', scheme='scheme', port=99, path='/foo', realm='realm')
4537
self.assertEqual(CREDENTIALS, credentials_from_disk)
4539
def test_reset_credentials_different_name(self):
4540
conf = config.AuthenticationConfig()
4541
conf.set_credentials('name', 'host', 'user', 'scheme', 'password'),
4542
conf.set_credentials('name2', 'host', 'user2', 'scheme', 'password'),
4543
self.assertIs(None, conf._get_config().get('name'))
4544
credentials = conf.get_credentials(host='host', scheme='scheme')
4545
CREDENTIALS = {'name': 'name2', 'user': 'user2', 'password':
4546
'password', 'verify_certificates': True,
4547
'scheme': 'scheme', 'host': 'host', 'port': None,
4548
'path': None, 'realm': None}
4549
self.assertEqual(CREDENTIALS, credentials)
4552
class TestAuthenticationConfig(tests.TestCase):
4553
"""Test AuthenticationConfig behaviour"""
4555
def _check_default_password_prompt(self, expected_prompt_format, scheme,
4556
host=None, port=None, realm=None,
4560
user, password = 'jim', 'precious'
4561
expected_prompt = expected_prompt_format % {
4562
'scheme': scheme, 'host': host, 'port': port,
4563
'user': user, 'realm': realm}
4565
stdout = tests.StringIOWrapper()
4566
stderr = tests.StringIOWrapper()
4567
ui.ui_factory = tests.TestUIFactory(stdin=password + '\n',
4568
stdout=stdout, stderr=stderr)
4569
# We use an empty conf so that the user is always prompted
4570
conf = config.AuthenticationConfig()
4571
self.assertEquals(password,
4572
conf.get_password(scheme, host, user, port=port,
4573
realm=realm, path=path))
4574
self.assertEquals(expected_prompt, stderr.getvalue())
4575
self.assertEquals('', stdout.getvalue())
4577
def _check_default_username_prompt(self, expected_prompt_format, scheme,
4578
host=None, port=None, realm=None,
4583
expected_prompt = expected_prompt_format % {
4584
'scheme': scheme, 'host': host, 'port': port,
4586
stdout = tests.StringIOWrapper()
4587
stderr = tests.StringIOWrapper()
4588
ui.ui_factory = tests.TestUIFactory(stdin=username+ '\n',
4589
stdout=stdout, stderr=stderr)
4590
# We use an empty conf so that the user is always prompted
4591
conf = config.AuthenticationConfig()
4592
self.assertEquals(username, conf.get_user(scheme, host, port=port,
4593
realm=realm, path=path, ask=True))
4594
self.assertEquals(expected_prompt, stderr.getvalue())
4595
self.assertEquals('', stdout.getvalue())
4597
def test_username_defaults_prompts(self):
4598
# HTTP prompts can't be tested here, see test_http.py
4599
self._check_default_username_prompt(u'FTP %(host)s username: ', 'ftp')
4600
self._check_default_username_prompt(
4601
u'FTP %(host)s:%(port)d username: ', 'ftp', port=10020)
4602
self._check_default_username_prompt(
4603
u'SSH %(host)s:%(port)d username: ', 'ssh', port=12345)
4605
def test_username_default_no_prompt(self):
4606
conf = config.AuthenticationConfig()
4607
self.assertEquals(None,
4608
conf.get_user('ftp', 'example.com'))
4609
self.assertEquals("explicitdefault",
4610
conf.get_user('ftp', 'example.com', default="explicitdefault"))
4612
def test_password_default_prompts(self):
4613
# HTTP prompts can't be tested here, see test_http.py
4614
self._check_default_password_prompt(
4615
u'FTP %(user)s@%(host)s password: ', 'ftp')
4616
self._check_default_password_prompt(
4617
u'FTP %(user)s@%(host)s:%(port)d password: ', 'ftp', port=10020)
4618
self._check_default_password_prompt(
4619
u'SSH %(user)s@%(host)s:%(port)d password: ', 'ssh', port=12345)
4620
# SMTP port handling is a bit special (it's handled if embedded in the
4622
# FIXME: should we: forbid that, extend it to other schemes, leave
4623
# things as they are that's fine thank you ?
4624
self._check_default_password_prompt(
4625
u'SMTP %(user)s@%(host)s password: ', 'smtp')
4626
self._check_default_password_prompt(
4627
u'SMTP %(user)s@%(host)s password: ', 'smtp', host='bar.org:10025')
4628
self._check_default_password_prompt(
4629
u'SMTP %(user)s@%(host)s:%(port)d password: ', 'smtp', port=10025)
4631
def test_ssh_password_emits_warning(self):
4632
conf = config.AuthenticationConfig(_file=StringIO(
4640
entered_password = 'typed-by-hand'
4641
stdout = tests.StringIOWrapper()
4642
stderr = tests.StringIOWrapper()
4643
ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
4644
stdout=stdout, stderr=stderr)
4646
# Since the password defined in the authentication config is ignored,
4647
# the user is prompted
4648
self.assertEquals(entered_password,
4649
conf.get_password('ssh', 'bar.org', user='jim'))
4650
self.assertContainsRe(
4652
'password ignored in section \[ssh with password\]')
4654
def test_ssh_without_password_doesnt_emit_warning(self):
4655
conf = config.AuthenticationConfig(_file=StringIO(
4662
entered_password = 'typed-by-hand'
4663
stdout = tests.StringIOWrapper()
4664
stderr = tests.StringIOWrapper()
4665
ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
4669
# Since the password defined in the authentication config is ignored,
4670
# the user is prompted
4671
self.assertEquals(entered_password,
4672
conf.get_password('ssh', 'bar.org', user='jim'))
4673
# No warning shoud be emitted since there is no password. We are only
4675
self.assertNotContainsRe(
4677
'password ignored in section \[ssh with password\]')
4679
def test_uses_fallback_stores(self):
4680
self.overrideAttr(config, 'credential_store_registry',
4681
config.CredentialStoreRegistry())
4682
store = StubCredentialStore()
4683
store.add_credentials("http", "example.com", "joe", "secret")
4684
config.credential_store_registry.register("stub", store, fallback=True)
4685
conf = config.AuthenticationConfig(_file=StringIO())
4686
creds = conf.get_credentials("http", "example.com")
4687
self.assertEquals("joe", creds["user"])
4688
self.assertEquals("secret", creds["password"])
4691
class StubCredentialStore(config.CredentialStore):
4697
def add_credentials(self, scheme, host, user, password=None):
4698
self._username[(scheme, host)] = user
4699
self._password[(scheme, host)] = password
4701
def get_credentials(self, scheme, host, port=None, user=None,
4702
path=None, realm=None):
4703
key = (scheme, host)
4704
if not key in self._username:
4706
return { "scheme": scheme, "host": host, "port": port,
4707
"user": self._username[key], "password": self._password[key]}
4710
class CountingCredentialStore(config.CredentialStore):
4715
def get_credentials(self, scheme, host, port=None, user=None,
4716
path=None, realm=None):
4721
class TestCredentialStoreRegistry(tests.TestCase):
4723
def _get_cs_registry(self):
4724
return config.credential_store_registry
4726
def test_default_credential_store(self):
4727
r = self._get_cs_registry()
4728
default = r.get_credential_store(None)
4729
self.assertIsInstance(default, config.PlainTextCredentialStore)
4731
def test_unknown_credential_store(self):
4732
r = self._get_cs_registry()
4733
# It's hard to imagine someone creating a credential store named
4734
# 'unknown' so we use that as an never registered key.
4735
self.assertRaises(KeyError, r.get_credential_store, 'unknown')
4737
def test_fallback_none_registered(self):
4738
r = config.CredentialStoreRegistry()
4739
self.assertEquals(None,
4740
r.get_fallback_credentials("http", "example.com"))
4742
def test_register(self):
4743
r = config.CredentialStoreRegistry()
4744
r.register("stub", StubCredentialStore(), fallback=False)
4745
r.register("another", StubCredentialStore(), fallback=True)
4746
self.assertEquals(["another", "stub"], r.keys())
4748
def test_register_lazy(self):
4749
r = config.CredentialStoreRegistry()
4750
r.register_lazy("stub", "bzrlib.tests.test_config",
4751
"StubCredentialStore", fallback=False)
4752
self.assertEquals(["stub"], r.keys())
4753
self.assertIsInstance(r.get_credential_store("stub"),
4754
StubCredentialStore)
4756
def test_is_fallback(self):
4757
r = config.CredentialStoreRegistry()
4758
r.register("stub1", None, fallback=False)
4759
r.register("stub2", None, fallback=True)
4760
self.assertEquals(False, r.is_fallback("stub1"))
4761
self.assertEquals(True, r.is_fallback("stub2"))
4763
def test_no_fallback(self):
4764
r = config.CredentialStoreRegistry()
4765
store = CountingCredentialStore()
4766
r.register("count", store, fallback=False)
4767
self.assertEquals(None,
4768
r.get_fallback_credentials("http", "example.com"))
4769
self.assertEquals(0, store._calls)
4771
def test_fallback_credentials(self):
4772
r = config.CredentialStoreRegistry()
4773
store = StubCredentialStore()
4774
store.add_credentials("http", "example.com",
4775
"somebody", "geheim")
4776
r.register("stub", store, fallback=True)
4777
creds = r.get_fallback_credentials("http", "example.com")
4778
self.assertEquals("somebody", creds["user"])
4779
self.assertEquals("geheim", creds["password"])
4781
def test_fallback_first_wins(self):
4782
r = config.CredentialStoreRegistry()
4783
stub1 = StubCredentialStore()
4784
stub1.add_credentials("http", "example.com",
4785
"somebody", "stub1")
4786
r.register("stub1", stub1, fallback=True)
4787
stub2 = StubCredentialStore()
4788
stub2.add_credentials("http", "example.com",
4789
"somebody", "stub2")
4790
r.register("stub2", stub1, fallback=True)
4791
creds = r.get_fallback_credentials("http", "example.com")
4792
self.assertEquals("somebody", creds["user"])
4793
self.assertEquals("stub1", creds["password"])
4796
class TestPlainTextCredentialStore(tests.TestCase):
4798
def test_decode_password(self):
4799
r = config.credential_store_registry
4800
plain_text = r.get_credential_store()
4801
decoded = plain_text.decode_password(dict(password='secret'))
4802
self.assertEquals('secret', decoded)
4805
# FIXME: Once we have a way to declare authentication to all test servers, we
4806
# can implement generic tests.
4807
# test_user_password_in_url
4808
# test_user_in_url_password_from_config
4809
# test_user_in_url_password_prompted
4810
# test_user_in_config
4811
# test_user_getpass.getuser
4812
# test_user_prompted ?
4813
class TestAuthenticationRing(tests.TestCaseWithTransport):
4817
class TestAutoUserId(tests.TestCase):
4818
"""Test inferring an automatic user name."""
4820
def test_auto_user_id(self):
4821
"""Automatic inference of user name.
4823
This is a bit hard to test in an isolated way, because it depends on
4824
system functions that go direct to /etc or perhaps somewhere else.
4825
But it's reasonable to say that on Unix, with an /etc/mailname, we ought
4826
to be able to choose a user name with no configuration.
4828
if sys.platform == 'win32':
4829
raise tests.TestSkipped(
4830
"User name inference not implemented on win32")
4831
realname, address = config._auto_user_id()
4832
if os.path.exists('/etc/mailname'):
4833
self.assertIsNot(None, realname)
4834
self.assertIsNot(None, address)
4836
self.assertEquals((None, None), (realname, address))
4839
class EmailOptionTests(tests.TestCase):
4841
def test_default_email_uses_BZR_EMAIL(self):
4842
conf = config.MemoryStack('email=jelmer@debian.org')
4843
# BZR_EMAIL takes precedence over EMAIL
4844
self.overrideEnv('BZR_EMAIL', 'jelmer@samba.org')
4845
self.overrideEnv('EMAIL', 'jelmer@apache.org')
4846
self.assertEquals('jelmer@samba.org', conf.get('email'))
4848
def test_default_email_uses_EMAIL(self):
4849
conf = config.MemoryStack('')
4850
self.overrideEnv('BZR_EMAIL', None)
4851
self.overrideEnv('EMAIL', 'jelmer@apache.org')
4852
self.assertEquals('jelmer@apache.org', conf.get('email'))
4854
def test_BZR_EMAIL_overrides(self):
4855
conf = config.MemoryStack('email=jelmer@debian.org')
4856
self.overrideEnv('BZR_EMAIL', 'jelmer@apache.org')
4857
self.assertEquals('jelmer@apache.org', conf.get('email'))
4858
self.overrideEnv('BZR_EMAIL', None)
4859
self.overrideEnv('EMAIL', 'jelmer@samba.org')
4860
self.assertEquals('jelmer@debian.org', conf.get('email'))
4863
class MailClientOptionTests(tests.TestCase):
4865
def test_default(self):
4866
conf = config.MemoryStack('')
4867
client = conf.get('mail_client')
4868
self.assertIs(client, mail_client.DefaultMail)
4870
def test_evolution(self):
4871
conf = config.MemoryStack('mail_client=evolution')
4872
client = conf.get('mail_client')
4873
self.assertIs(client, mail_client.Evolution)
4875
def test_kmail(self):
4876
conf = config.MemoryStack('mail_client=kmail')
4877
client = conf.get('mail_client')
4878
self.assertIs(client, mail_client.KMail)
4880
def test_mutt(self):
4881
conf = config.MemoryStack('mail_client=mutt')
4882
client = conf.get('mail_client')
4883
self.assertIs(client, mail_client.Mutt)
4885
def test_thunderbird(self):
4886
conf = config.MemoryStack('mail_client=thunderbird')
4887
client = conf.get('mail_client')
4888
self.assertIs(client, mail_client.Thunderbird)
4890
def test_explicit_default(self):
4891
conf = config.MemoryStack('mail_client=default')
4892
client = conf.get('mail_client')
4893
self.assertIs(client, mail_client.DefaultMail)
4895
def test_editor(self):
4896
conf = config.MemoryStack('mail_client=editor')
4897
client = conf.get('mail_client')
4898
self.assertIs(client, mail_client.Editor)
4900
def test_mapi(self):
4901
conf = config.MemoryStack('mail_client=mapi')
4902
client = conf.get('mail_client')
4903
self.assertIs(client, mail_client.MAPIClient)
4905
def test_xdg_email(self):
4906
conf = config.MemoryStack('mail_client=xdg-email')
4907
client = conf.get('mail_client')
4908
self.assertIs(client, mail_client.XDGEmail)
4910
def test_unknown(self):
4911
conf = config.MemoryStack('mail_client=firebird')
4912
self.assertRaises(errors.ConfigOptionValueError, conf.get,
added
removed
bzrlib/tests/test_config.py
