2120 lines
76 KiB
Python
2120 lines
76 KiB
Python
# vim: tabstop=4 shiftwidth=4 softtabstop=4
|
|
|
|
# Copyright 2012 Red Hat, Inc.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
import os
|
|
import StringIO
|
|
import sys
|
|
import tempfile
|
|
|
|
import fixtures
|
|
|
|
from oslo.config.cfg import *
|
|
from tests import utils
|
|
|
|
|
|
class ExceptionsTestCase(utils.BaseTestCase):
|
|
|
|
def test_error(self):
|
|
msg = str(Error('foobar'))
|
|
self.assertEquals(msg, 'foobar')
|
|
|
|
def test_args_already_parsed_error(self):
|
|
msg = str(ArgsAlreadyParsedError('foobar'))
|
|
self.assertEquals(msg, 'arguments already parsed: foobar')
|
|
|
|
def test_no_such_opt_error(self):
|
|
msg = str(NoSuchOptError('foo'))
|
|
self.assertEquals(msg, 'no such option: foo')
|
|
|
|
def test_no_such_opt_error_with_group(self):
|
|
msg = str(NoSuchOptError('foo', OptGroup('bar')))
|
|
self.assertEquals(msg, 'no such option in group bar: foo')
|
|
|
|
def test_no_such_group_error(self):
|
|
msg = str(NoSuchGroupError('bar'))
|
|
self.assertEquals(msg, 'no such group: bar')
|
|
|
|
def test_duplicate_opt_error(self):
|
|
msg = str(DuplicateOptError('foo'))
|
|
self.assertEquals(msg, 'duplicate option: foo')
|
|
|
|
def test_required_opt_error(self):
|
|
msg = str(RequiredOptError('foo'))
|
|
self.assertEquals(msg, 'value required for option: foo')
|
|
|
|
def test_required_opt_error_with_group(self):
|
|
msg = str(RequiredOptError('foo', OptGroup('bar')))
|
|
self.assertEquals(msg, 'value required for option: bar.foo')
|
|
|
|
def test_template_substitution_error(self):
|
|
msg = str(TemplateSubstitutionError('foobar'))
|
|
self.assertEquals(msg, 'template substitution error: foobar')
|
|
|
|
def test_config_files_not_found_error(self):
|
|
msg = str(ConfigFilesNotFoundError(['foo', 'bar']))
|
|
self.assertEquals(msg, 'Failed to read some config files: foo,bar')
|
|
|
|
def test_config_file_parse_error(self):
|
|
msg = str(ConfigFileParseError('foo', 'foobar'))
|
|
self.assertEquals(msg, 'Failed to parse foo: foobar')
|
|
|
|
|
|
class BaseTestCase(utils.BaseTestCase):
|
|
|
|
class TestConfigOpts(ConfigOpts):
|
|
def __call__(self, args=None):
|
|
return ConfigOpts.__call__(self,
|
|
args=args,
|
|
prog='test',
|
|
version='1.0',
|
|
usage='%(prog)s FOO BAR',
|
|
default_config_files=[])
|
|
|
|
def setUp(self):
|
|
super(BaseTestCase, self).setUp()
|
|
self.useFixture(fixtures.NestedTempfile())
|
|
self.conf = self.TestConfigOpts()
|
|
|
|
self.tempdirs = []
|
|
|
|
def create_tempfiles(self, files, ext='.conf'):
|
|
tempfiles = []
|
|
for (basename, contents) in files:
|
|
if not os.path.isabs(basename):
|
|
(fd, path) = tempfile.mkstemp(prefix=basename, suffix=ext)
|
|
else:
|
|
path = basename + ext
|
|
fd = os.open(path, os.O_CREAT | os.O_WRONLY)
|
|
tempfiles.append(path)
|
|
try:
|
|
os.write(fd, contents)
|
|
finally:
|
|
os.close(fd)
|
|
return tempfiles
|
|
|
|
|
|
class UsageTestCase(BaseTestCase):
|
|
|
|
def test_print_usage(self):
|
|
f = StringIO.StringIO()
|
|
self.conf([])
|
|
self.conf.print_usage(file=f)
|
|
self.assertTrue('usage: test FOO BAR' in f.getvalue())
|
|
self.assertTrue('optional:' not in f.getvalue())
|
|
|
|
|
|
class HelpTestCase(BaseTestCase):
|
|
|
|
def test_print_help(self):
|
|
f = StringIO.StringIO()
|
|
self.conf([])
|
|
self.conf.print_help(file=f)
|
|
self.assertTrue('usage: test FOO BAR' in f.getvalue())
|
|
self.assertTrue('optional' in f.getvalue())
|
|
self.assertTrue('-h, --help' in f.getvalue())
|
|
|
|
|
|
class FindConfigFilesTestCase(BaseTestCase):
|
|
|
|
def test_find_config_files(self):
|
|
config_files = [os.path.expanduser('~/.blaa/blaa.conf'),
|
|
'/etc/foo.conf']
|
|
|
|
self.stubs.Set(sys, 'argv', ['foo'])
|
|
self.stubs.Set(os.path, 'exists', lambda p: p in config_files)
|
|
|
|
self.assertEquals(find_config_files(project='blaa'), config_files)
|
|
|
|
def test_find_config_files_with_extension(self):
|
|
config_files = ['/etc/foo.json']
|
|
|
|
self.stubs.Set(sys, 'argv', ['foo'])
|
|
self.stubs.Set(os.path, 'exists', lambda p: p in config_files)
|
|
|
|
self.assertEquals(find_config_files(project='blaa'), [])
|
|
self.assertEquals(find_config_files(project='blaa', extension='.json'),
|
|
config_files)
|
|
|
|
|
|
class CliOptsTestCase(BaseTestCase):
|
|
|
|
def _do_cli_test(self, opt_class, default, cli_args, value,
|
|
deps=(None, None)):
|
|
self.conf.register_cli_opt(opt_class('foo', default=default,
|
|
deprecated_name=deps[0],
|
|
deprecated_group=deps[1]))
|
|
|
|
self.conf(cli_args)
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, value)
|
|
|
|
def test_str_default(self):
|
|
self._do_cli_test(StrOpt, None, [], None)
|
|
|
|
def test_str_arg(self):
|
|
self._do_cli_test(StrOpt, None, ['--foo', 'bar'], 'bar')
|
|
|
|
def test_str_arg_deprecated_name(self):
|
|
self._do_cli_test(StrOpt, None, ['--oldfoo', 'bar'], 'bar',
|
|
deps=('oldfoo', None))
|
|
|
|
def test_str_arg_deprecated_group(self):
|
|
self._do_cli_test(StrOpt, None, ['--old-foo', 'bar'], 'bar',
|
|
deps=(None, 'old'))
|
|
|
|
def test_str_arg_deprecated_group_default(self):
|
|
self._do_cli_test(StrOpt, None, ['--foo', 'bar'], 'bar',
|
|
deps=(None, 'DEFAULT'))
|
|
|
|
def test_str_arg_deprecated_group_and_name(self):
|
|
self._do_cli_test(StrOpt, None, ['--old-oof', 'bar'], 'bar',
|
|
deps=('oof', 'old'))
|
|
|
|
def test_bool_default(self):
|
|
self._do_cli_test(BoolOpt, False, [], False)
|
|
|
|
def test_bool_arg(self):
|
|
self._do_cli_test(BoolOpt, None, ['--foo'], True)
|
|
|
|
def test_bool_arg_deprecated_name(self):
|
|
self._do_cli_test(BoolOpt, None, ['--oldfoo'], True,
|
|
deps=('oldfoo', None))
|
|
|
|
def test_bool_arg_deprecated_group(self):
|
|
self._do_cli_test(BoolOpt, None, ['--old-foo'], True,
|
|
deps=(None, 'old'))
|
|
|
|
def test_bool_arg_deprecated_group_default(self):
|
|
self._do_cli_test(BoolOpt, None, ['--foo'], True,
|
|
deps=(None, 'DEFAULT'))
|
|
|
|
def test_bool_arg_deprecated_group_and_name(self):
|
|
self._do_cli_test(BoolOpt, None, ['--old-oof'], True,
|
|
deps=('oof', 'old'))
|
|
|
|
def test_bool_arg_inverse(self):
|
|
self._do_cli_test(BoolOpt, None, ['--foo', '--nofoo'], False)
|
|
|
|
def test_bool_arg_inverse_deprecated_name(self):
|
|
self._do_cli_test(BoolOpt, None, ['--oldfoo', '--nooldfoo'], False,
|
|
deps=('oldfoo', None))
|
|
|
|
def test_bool_arg_inverse_deprecated_group(self):
|
|
self._do_cli_test(BoolOpt, None, ['--old-foo', '--old-nofoo'], False,
|
|
deps=(None, 'old'))
|
|
|
|
def test_bool_arg_inverse_deprecated_group_default(self):
|
|
self._do_cli_test(BoolOpt, None, ['--foo', '--nofoo'], False,
|
|
deps=(None, 'DEFAULT'))
|
|
|
|
def test_bool_arg_inverse_deprecated_group_and_name(self):
|
|
self._do_cli_test(BoolOpt, None, ['--old-oof', '--old-nooof'], False,
|
|
deps=('oof', 'old'))
|
|
|
|
def test_int_default(self):
|
|
self._do_cli_test(IntOpt, 10, [], 10)
|
|
|
|
def test_int_arg(self):
|
|
self._do_cli_test(IntOpt, None, ['--foo=20'], 20)
|
|
|
|
def test_int_arg_deprecated_name(self):
|
|
self._do_cli_test(IntOpt, None, ['--oldfoo=20'], 20,
|
|
deps=('oldfoo', None))
|
|
|
|
def test_int_arg_deprecated_group(self):
|
|
self._do_cli_test(IntOpt, None, ['--old-foo=20'], 20,
|
|
deps=(None, 'old'))
|
|
|
|
def test_int_arg_deprecated_group_default(self):
|
|
self._do_cli_test(IntOpt, None, ['--foo=20'], 20,
|
|
deps=(None, 'DEFAULT'))
|
|
|
|
def test_int_arg_deprecated_group_and_name(self):
|
|
self._do_cli_test(IntOpt, None, ['--old-oof=20'], 20,
|
|
deps=('oof', 'old'))
|
|
|
|
def test_float_default(self):
|
|
self._do_cli_test(FloatOpt, 1.0, [], 1.0)
|
|
|
|
def test_float_arg(self):
|
|
self._do_cli_test(FloatOpt, None, ['--foo', '2.0'], 2.0)
|
|
|
|
def test_float_arg_deprecated_name(self):
|
|
self._do_cli_test(FloatOpt, None, ['--oldfoo', '2.0'], 2.0,
|
|
deps=('oldfoo', None))
|
|
|
|
def test_float_arg_deprecated_group(self):
|
|
self._do_cli_test(FloatOpt, None, ['--old-foo', '2.0'], 2.0,
|
|
deps=(None, 'old'))
|
|
|
|
def test_float_arg_deprecated_group_default(self):
|
|
self._do_cli_test(FloatOpt, None, ['--foo', '2.0'], 2.0,
|
|
deps=(None, 'DEFAULT'))
|
|
|
|
def test_float_arg_deprecated_group_and_name(self):
|
|
self._do_cli_test(FloatOpt, None, ['--old-oof', '2.0'], 2.0,
|
|
deps=('oof', 'old'))
|
|
|
|
def test_list_default(self):
|
|
self._do_cli_test(ListOpt, ['bar'], [], ['bar'])
|
|
|
|
def test_list_arg(self):
|
|
self._do_cli_test(ListOpt, None,
|
|
['--foo', 'blaa,bar'], ['blaa', 'bar'])
|
|
|
|
def test_list_arg_with_spaces(self):
|
|
self._do_cli_test(ListOpt, None,
|
|
['--foo', 'blaa ,bar'], ['blaa', 'bar'])
|
|
|
|
def test_list_arg_deprecated_name(self):
|
|
self._do_cli_test(ListOpt, None,
|
|
['--oldfoo', 'blaa,bar'], ['blaa', 'bar'],
|
|
deps=('oldfoo', None))
|
|
|
|
def test_list_arg_deprecated_group(self):
|
|
self._do_cli_test(ListOpt, None,
|
|
['--old-foo', 'blaa,bar'], ['blaa', 'bar'],
|
|
deps=(None, 'old'))
|
|
|
|
def test_list_arg_deprecated_group_default(self):
|
|
self._do_cli_test(ListOpt, None,
|
|
['--foo', 'blaa,bar'], ['blaa', 'bar'],
|
|
deps=(None, 'DEFAULT'))
|
|
|
|
def test_list_arg_deprecated_group_and_name(self):
|
|
self._do_cli_test(ListOpt, None,
|
|
['--old-oof', 'blaa,bar'], ['blaa', 'bar'],
|
|
deps=('oof', 'old'))
|
|
|
|
def test_multistr_default(self):
|
|
self._do_cli_test(MultiStrOpt, ['bar'], [], ['bar'])
|
|
|
|
def test_multistr_arg(self):
|
|
self._do_cli_test(MultiStrOpt, None,
|
|
['--foo', 'blaa', '--foo', 'bar'], ['blaa', 'bar'])
|
|
|
|
def test_multistr_arg_deprecated_name(self):
|
|
self._do_cli_test(MultiStrOpt, None,
|
|
['--oldfoo', 'blaa', '--oldfoo', 'bar'],
|
|
['blaa', 'bar'],
|
|
deps=('oldfoo', None))
|
|
|
|
def test_multistr_arg_deprecated_group(self):
|
|
self._do_cli_test(MultiStrOpt, None,
|
|
['--old-foo', 'blaa', '--old-foo', 'bar'],
|
|
['blaa', 'bar'],
|
|
deps=(None, 'old'))
|
|
|
|
def test_multistr_arg_deprecated_group_default(self):
|
|
self._do_cli_test(MultiStrOpt, None,
|
|
['--foo', 'blaa', '--foo', 'bar'],
|
|
['blaa', 'bar'],
|
|
deps=(None, 'DEFAULT'))
|
|
|
|
def test_multistr_arg_deprecated_group_and_name(self):
|
|
self._do_cli_test(MultiStrOpt, None,
|
|
['--old-oof', 'blaa', '--old-oof', 'bar'],
|
|
['blaa', 'bar'],
|
|
deps=('oof', 'old'))
|
|
|
|
def test_help(self):
|
|
self.stubs.Set(sys, 'stdout', StringIO.StringIO())
|
|
self.assertRaises(SystemExit, self.conf, ['--help'])
|
|
self.assertTrue('FOO BAR' in sys.stdout.getvalue())
|
|
self.assertTrue('--version' in sys.stdout.getvalue())
|
|
self.assertTrue('--help' in sys.stdout.getvalue())
|
|
self.assertTrue('--config-file' in sys.stdout.getvalue())
|
|
|
|
def test_version(self):
|
|
self.stubs.Set(sys, 'stderr', StringIO.StringIO())
|
|
self.assertRaises(SystemExit, self.conf, ['--version'])
|
|
self.assertTrue('1.0' in sys.stderr.getvalue())
|
|
|
|
def test_config_file(self):
|
|
paths = self.create_tempfiles([('1', '[DEFAULT]'),
|
|
('2', '[DEFAULT]')])
|
|
|
|
self.conf(['--config-file', paths[0], '--config-file', paths[1]])
|
|
|
|
self.assertEquals(self.conf.config_file, paths)
|
|
|
|
|
|
class PositionalTestCase(BaseTestCase):
|
|
|
|
def _do_pos_test(self, opt_class, default, cli_args, value):
|
|
self.conf.register_cli_opt(opt_class('foo',
|
|
default=default,
|
|
positional=True))
|
|
|
|
self.conf(cli_args)
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, value)
|
|
|
|
def test_positional_str_default(self):
|
|
self._do_pos_test(StrOpt, None, [], None)
|
|
|
|
def test_positional_str_arg(self):
|
|
self._do_pos_test(StrOpt, None, ['bar'], 'bar')
|
|
|
|
def test_positional_int_default(self):
|
|
self._do_pos_test(IntOpt, 10, [], 10)
|
|
|
|
def test_positional_int_arg(self):
|
|
self._do_pos_test(IntOpt, None, ['20'], 20)
|
|
|
|
def test_positional_float_default(self):
|
|
self._do_pos_test(FloatOpt, 1.0, [], 1.0)
|
|
|
|
def test_positional_float_arg(self):
|
|
self._do_pos_test(FloatOpt, None, ['2.0'], 2.0)
|
|
|
|
def test_positional_list_default(self):
|
|
self._do_pos_test(ListOpt, ['bar'], [], ['bar'])
|
|
|
|
def test_positional_list_arg(self):
|
|
self._do_pos_test(ListOpt, None,
|
|
['blaa,bar'], ['blaa', 'bar'])
|
|
|
|
def test_positional_multistr_default(self):
|
|
self._do_pos_test(MultiStrOpt, ['bar'], [], ['bar'])
|
|
|
|
def test_positional_multistr_arg(self):
|
|
self._do_pos_test(MultiStrOpt, None,
|
|
['blaa', 'bar'], ['blaa', 'bar'])
|
|
|
|
def test_positional_bool(self):
|
|
self.assertRaises(ValueError, BoolOpt, 'foo', positional=True)
|
|
|
|
def test_required_positional_opt(self):
|
|
self.conf.register_cli_opt(StrOpt('foo',
|
|
required=True,
|
|
positional=True))
|
|
|
|
self.conf(['bar'])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, 'bar')
|
|
|
|
def test_missing_required_cli_opt(self):
|
|
self.conf.register_cli_opt(StrOpt('foo',
|
|
required=True,
|
|
positional=True))
|
|
self.assertRaises(RequiredOptError, self.conf, [])
|
|
|
|
|
|
class ConfigFileOptsTestCase(BaseTestCase):
|
|
|
|
def _do_deprecated_test(self, opt_class, value, result, key,
|
|
section='DEFAULT',
|
|
dname=None, dgroup=None):
|
|
self.conf.register_opt(opt_class('newfoo',
|
|
deprecated_name=dname,
|
|
deprecated_group=dgroup))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[' + section + ']\n' +
|
|
key + ' = ' + value + '\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
self.assertTrue(hasattr(self.conf, 'newfoo'))
|
|
self.assertEquals(self.conf.newfoo, result)
|
|
|
|
def _do_dname_test_use(self, opt_class, value, result):
|
|
self._do_deprecated_test(opt_class, value, result, 'oldfoo',
|
|
dname='oldfoo')
|
|
|
|
def _do_dgroup_test_use(self, opt_class, value, result):
|
|
self._do_deprecated_test(opt_class, value, result, 'newfoo',
|
|
section='old', dgroup='old')
|
|
|
|
def _do_default_dgroup_test_use(self, opt_class, value, result):
|
|
self._do_deprecated_test(opt_class, value, result, 'newfoo',
|
|
section='DEFAULT', dgroup='DEFAULT')
|
|
|
|
def _do_dgroup_and_dname_test_use(self, opt_class, value, result):
|
|
self._do_deprecated_test(opt_class, value, result, 'oof',
|
|
section='old', dgroup='old', dname='oof')
|
|
|
|
def _do_dname_test_ignore(self, opt_class, value, result):
|
|
self._do_deprecated_test(opt_class, value, result, 'newfoo',
|
|
dname='oldfoo')
|
|
|
|
def _do_dgroup_test_ignore(self, opt_class, value, result):
|
|
self._do_deprecated_test(opt_class, value, result, 'newfoo',
|
|
section='DEFAULT', dgroup='old')
|
|
|
|
def _do_dgroup_and_dname_test_ignore(self, opt_class, value, result):
|
|
self._do_deprecated_test(opt_class, value, result, 'oof',
|
|
section='old', dgroup='old', dname='oof')
|
|
|
|
def test_conf_file_str_default(self):
|
|
self.conf.register_opt(StrOpt('foo', default='bar'))
|
|
|
|
paths = self.create_tempfiles([('test', '[DEFAULT]\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, 'bar')
|
|
|
|
def test_conf_file_str_value(self):
|
|
self.conf.register_opt(StrOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('test', '[DEFAULT]\n''foo = bar\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, 'bar')
|
|
|
|
def test_conf_file_str_value_override(self):
|
|
self.conf.register_cli_opt(StrOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('1',
|
|
'[DEFAULT]\n'
|
|
'foo = baar\n'),
|
|
('2',
|
|
'[DEFAULT]\n'
|
|
'foo = baaar\n')])
|
|
|
|
self.conf(['--foo', 'bar',
|
|
'--config-file', paths[0],
|
|
'--config-file', paths[1]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, 'baaar')
|
|
|
|
def test_conf_file_str_value_override_use_deprecated(self):
|
|
"""last option should always win, even if last uses deprecated"""
|
|
self.conf.register_cli_opt(StrOpt('newfoo', deprecated_name='oldfoo'))
|
|
|
|
paths = self.create_tempfiles([('0',
|
|
'[DEFAULT]\n'
|
|
'newfoo = middle\n'),
|
|
('1',
|
|
'[DEFAULT]\n'
|
|
'oldfoo = last\n')])
|
|
|
|
self.conf(['--newfoo', 'first',
|
|
'--config-file', paths[0],
|
|
'--config-file', paths[1]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'newfoo'))
|
|
self.assertFalse(hasattr(self.conf, 'oldfoo'))
|
|
self.assertEquals(self.conf.newfoo, 'last')
|
|
|
|
def test_conf_file_str_use_dname(self):
|
|
self._do_dname_test_use(StrOpt, 'value1', 'value1')
|
|
|
|
def test_conf_file_str_use_dgroup(self):
|
|
self._do_dgroup_test_use(StrOpt, 'value1', 'value1')
|
|
|
|
def test_conf_file_str_use_default_dgroup(self):
|
|
self._do_default_dgroup_test_use(StrOpt, 'value1', 'value1')
|
|
|
|
def test_conf_file_str_use_dgroup_and_dname(self):
|
|
self._do_dgroup_and_dname_test_use(StrOpt, 'value1', 'value1')
|
|
|
|
def test_conf_file_str_ignore_dname(self):
|
|
self._do_dname_test_ignore(StrOpt, 'value2', 'value2')
|
|
|
|
def test_conf_file_str_ignore_dgroup(self):
|
|
self._do_dgroup_test_ignore(StrOpt, 'value2', 'value2')
|
|
|
|
def test_conf_file_str_ignore_dgroup_and_dname(self):
|
|
self._do_dgroup_and_dname_test_ignore(StrOpt, 'value2', 'value2')
|
|
|
|
def test_conf_file_bool_default(self):
|
|
self.conf.register_opt(BoolOpt('foo', default=False))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, False)
|
|
|
|
def test_conf_file_bool_value(self):
|
|
self.conf.register_opt(BoolOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = true\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, True)
|
|
|
|
def test_conf_file_bool_cli_value_override(self):
|
|
self.conf.register_cli_opt(BoolOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('1',
|
|
'[DEFAULT]\n'
|
|
'foo = 0\n')])
|
|
|
|
self.conf(['--foo',
|
|
'--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, False)
|
|
|
|
def test_conf_file_bool_cli_inverse_override(self):
|
|
self.conf.register_cli_opt(BoolOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('1',
|
|
'[DEFAULT]\n'
|
|
'foo = true\n')])
|
|
|
|
self.conf(['--nofoo',
|
|
'--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, True)
|
|
|
|
def test_conf_file_bool_file_value_override(self):
|
|
self.conf.register_cli_opt(BoolOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('1',
|
|
'[DEFAULT]\n'
|
|
'foo = 0\n'),
|
|
('2',
|
|
'[DEFAULT]\n'
|
|
'foo = yes\n')])
|
|
|
|
self.conf(['--config-file', paths[0],
|
|
'--config-file', paths[1]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, True)
|
|
|
|
def test_conf_file_bool_use_dname(self):
|
|
self._do_dname_test_use(BoolOpt, 'yes', True)
|
|
|
|
def test_conf_file_bool_use_dgroup(self):
|
|
self._do_dgroup_test_use(BoolOpt, 'yes', True)
|
|
|
|
def test_conf_file_bool_use_default_dgroup(self):
|
|
self._do_default_dgroup_test_use(BoolOpt, 'yes', True)
|
|
|
|
def test_conf_file_bool_use_dgroup_and_dname(self):
|
|
self._do_dgroup_and_dname_test_use(BoolOpt, 'yes', True)
|
|
|
|
def test_conf_file_bool_ignore_dname(self):
|
|
self._do_dname_test_ignore(BoolOpt, 'no', False)
|
|
|
|
def test_conf_file_bool_ignore_dgroup(self):
|
|
self._do_dgroup_test_ignore(BoolOpt, 'no', False)
|
|
|
|
def test_conf_file_bool_ignore_group_and_dname(self):
|
|
self._do_dgroup_and_dname_test_ignore(BoolOpt, 'no', False)
|
|
|
|
def test_conf_file_int_default(self):
|
|
self.conf.register_opt(IntOpt('foo', default=666))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, 666)
|
|
|
|
def test_conf_file_int_value(self):
|
|
self.conf.register_opt(IntOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = 666\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, 666)
|
|
|
|
def test_conf_file_int_value_override(self):
|
|
self.conf.register_cli_opt(IntOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('1',
|
|
'[DEFAULT]\n'
|
|
'foo = 66\n'),
|
|
('2',
|
|
'[DEFAULT]\n'
|
|
'foo = 666\n')])
|
|
|
|
self.conf(['--foo', '6',
|
|
'--config-file', paths[0],
|
|
'--config-file', paths[1]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, 666)
|
|
|
|
def test_conf_file_int_use_dname(self):
|
|
self._do_dname_test_use(IntOpt, '66', 66)
|
|
|
|
def test_conf_file_int_use_dgroup(self):
|
|
self._do_dgroup_test_use(IntOpt, '66', 66)
|
|
|
|
def test_conf_file_int_use_default_dgroup(self):
|
|
self._do_default_dgroup_test_use(IntOpt, '66', 66)
|
|
|
|
def test_conf_file_int_use_dgroup_and_dname(self):
|
|
self._do_dgroup_and_dname_test_use(IntOpt, '66', 66)
|
|
|
|
def test_conf_file_int_ignore_dname(self):
|
|
self._do_dname_test_ignore(IntOpt, '64', 64)
|
|
|
|
def test_conf_file_int_ignore_dgroup(self):
|
|
self._do_dgroup_test_ignore(IntOpt, '64', 64)
|
|
|
|
def test_conf_file_int_ignore_dgroup_and_dname(self):
|
|
self._do_dgroup_and_dname_test_ignore(IntOpt, '64', 64)
|
|
|
|
def test_conf_file_float_default(self):
|
|
self.conf.register_opt(FloatOpt('foo', default=6.66))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, 6.66)
|
|
|
|
def test_conf_file_float_value(self):
|
|
self.conf.register_opt(FloatOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = 6.66\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, 6.66)
|
|
|
|
def test_conf_file_float_value_override(self):
|
|
self.conf.register_cli_opt(FloatOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('1',
|
|
'[DEFAULT]\n'
|
|
'foo = 6.6\n'),
|
|
('2',
|
|
'[DEFAULT]\n'
|
|
'foo = 6.66\n')])
|
|
|
|
self.conf(['--foo', '6',
|
|
'--config-file', paths[0],
|
|
'--config-file', paths[1]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, 6.66)
|
|
|
|
def test_conf_file_float_use_dname(self):
|
|
self._do_dname_test_use(FloatOpt, '66.54', 66.54)
|
|
|
|
def test_conf_file_float_use_dgroup(self):
|
|
self._do_dgroup_test_use(FloatOpt, '66.54', 66.54)
|
|
|
|
def test_conf_file_float_use_default_dgroup(self):
|
|
self._do_default_dgroup_test_use(FloatOpt, '66.54', 66.54)
|
|
|
|
def test_conf_file_float_use_dgroup_and_dname(self):
|
|
self._do_dgroup_and_dname_test_use(FloatOpt, '66.54', 66.54)
|
|
|
|
def test_conf_file_float_ignore_dname(self):
|
|
self._do_dname_test_ignore(FloatOpt, '64.54', 64.54)
|
|
|
|
def test_conf_file_float_ignore_dgroup(self):
|
|
self._do_dgroup_test_ignore(FloatOpt, '64.54', 64.54)
|
|
|
|
def test_conf_file_float_ignore_dgroup_and_dname(self):
|
|
self._do_dgroup_and_dname_test_ignore(FloatOpt, '64.54', 64.54)
|
|
|
|
def test_conf_file_list_default(self):
|
|
self.conf.register_opt(ListOpt('foo', default=['bar']))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, ['bar'])
|
|
|
|
def test_conf_file_list_value(self):
|
|
self.conf.register_opt(ListOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = bar\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, ['bar'])
|
|
|
|
def test_conf_file_list_value_override(self):
|
|
self.conf.register_cli_opt(ListOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('1',
|
|
'[DEFAULT]\n'
|
|
'foo = bar,bar\n'),
|
|
('2',
|
|
'[DEFAULT]\n'
|
|
'foo = b,a,r\n')])
|
|
|
|
self.conf(['--foo', 'bar',
|
|
'--config-file', paths[0],
|
|
'--config-file', paths[1]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, ['b', 'a', 'r'])
|
|
|
|
def test_conf_file_list_use_dname(self):
|
|
self._do_dname_test_use(ListOpt, 'a,b,c', ['a', 'b', 'c'])
|
|
|
|
def test_conf_file_list_use_dgroup(self):
|
|
self._do_dgroup_test_use(ListOpt, 'a,b,c', ['a', 'b', 'c'])
|
|
|
|
def test_conf_file_list_use_default_dgroup(self):
|
|
self._do_default_dgroup_test_use(ListOpt, 'a,b,c', ['a', 'b', 'c'])
|
|
|
|
def test_conf_file_list_use_dgroup_and_dname(self):
|
|
self._do_dgroup_and_dname_test_use(ListOpt, 'a,b,c', ['a', 'b', 'c'])
|
|
|
|
def test_conf_file_list_ignore_dname(self):
|
|
self._do_dname_test_ignore(ListOpt, 'd,e,f', ['d', 'e', 'f'])
|
|
|
|
def test_conf_file_list_ignore_dgroup(self):
|
|
self._do_dgroup_test_ignore(ListOpt, 'd,e,f', ['d', 'e', 'f'])
|
|
|
|
def test_conf_file_list_ignore_dgroup_and_dname(self):
|
|
self._do_dgroup_and_dname_test_ignore(ListOpt, 'd,e,f',
|
|
['d', 'e', 'f'])
|
|
|
|
def test_conf_file_list_spaces_use_dname(self):
|
|
self._do_dname_test_use(ListOpt, 'a, b, c', ['a', 'b', 'c'])
|
|
|
|
def test_conf_file_list_spaces_use_dgroup(self):
|
|
self._do_dgroup_test_use(ListOpt, 'a, b, c', ['a', 'b', 'c'])
|
|
|
|
def test_conf_file_list_spaces_use_default_dgroup(self):
|
|
self._do_default_dgroup_test_use(ListOpt, 'a, b, c', ['a', 'b', 'c'])
|
|
|
|
def test_conf_file_list_spaces_use_dgroup_and_dname(self):
|
|
self._do_dgroup_and_dname_test_use(ListOpt, 'a, b, c', ['a', 'b', 'c'])
|
|
|
|
def test_conf_file_list_spaces_ignore_dname(self):
|
|
self._do_dname_test_ignore(ListOpt, 'd, e, f', ['d', 'e', 'f'])
|
|
|
|
def test_conf_file_list_spaces_ignore_dgroup(self):
|
|
self._do_dgroup_test_ignore(ListOpt, 'd, e, f', ['d', 'e', 'f'])
|
|
|
|
def test_conf_file_list_spaces_ignore_dgroup_and_dname(self):
|
|
self._do_dgroup_and_dname_test_ignore(ListOpt, 'd, e, f',
|
|
['d', 'e', 'f'])
|
|
|
|
def test_conf_file_multistr_default(self):
|
|
self.conf.register_opt(MultiStrOpt('foo', default=['bar']))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, ['bar'])
|
|
|
|
def test_conf_file_multistr_value(self):
|
|
self.conf.register_opt(MultiStrOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = bar\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, ['bar'])
|
|
|
|
def test_conf_file_multistr_values_append_deprecated(self):
|
|
self.conf.register_cli_opt(MultiStrOpt('foo',
|
|
deprecated_name='oldfoo'))
|
|
|
|
paths = self.create_tempfiles([('1',
|
|
'[DEFAULT]\n'
|
|
'foo = bar1\n'),
|
|
('2',
|
|
'[DEFAULT]\n'
|
|
'oldfoo = bar2\n'
|
|
'oldfoo = bar3\n')])
|
|
|
|
self.conf(['--foo', 'bar0',
|
|
'--config-file', paths[0],
|
|
'--config-file', paths[1]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
|
|
self.assertEquals(self.conf.foo, ['bar0', 'bar1', 'bar2', 'bar3'])
|
|
|
|
def test_conf_file_multistr_values_append(self):
|
|
self.conf.register_cli_opt(MultiStrOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('1',
|
|
'[DEFAULT]\n'
|
|
'foo = bar1\n'),
|
|
('2',
|
|
'[DEFAULT]\n'
|
|
'foo = bar2\n'
|
|
'foo = bar3\n')])
|
|
|
|
self.conf(['--foo', 'bar0',
|
|
'--config-file', paths[0],
|
|
'--config-file', paths[1]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
|
|
self.assertEquals(self.conf.foo, ['bar0', 'bar1', 'bar2', 'bar3'])
|
|
|
|
def test_conf_file_multistr_deprecated(self):
|
|
self.conf.register_opt(MultiStrOpt('newfoo', deprecated_name='oldfoo'))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'oldfoo= bar1\n'
|
|
'oldfoo = bar2\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
self.assertTrue(hasattr(self.conf, 'newfoo'))
|
|
self.assertEquals(self.conf.newfoo, ['bar1', 'bar2'])
|
|
|
|
def test_conf_file_multiple_opts(self):
|
|
self.conf.register_opts([StrOpt('foo'), StrOpt('bar')])
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = bar\n'
|
|
'bar = foo\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, 'bar')
|
|
self.assertTrue(hasattr(self.conf, 'bar'))
|
|
self.assertEquals(self.conf.bar, 'foo')
|
|
|
|
def test_conf_file_raw_value(self):
|
|
self.conf.register_opt(StrOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = bar-%08x\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, 'bar-%08x')
|
|
|
|
|
|
class OptGroupsTestCase(BaseTestCase):
|
|
|
|
def test_arg_group(self):
|
|
blaa_group = OptGroup('blaa', 'blaa options')
|
|
self.conf.register_group(blaa_group)
|
|
self.conf.register_cli_opt(StrOpt('foo'), group=blaa_group)
|
|
|
|
self.conf(['--blaa-foo', 'bar'])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'blaa'))
|
|
self.assertTrue(hasattr(self.conf.blaa, 'foo'))
|
|
self.assertEquals(self.conf.blaa.foo, 'bar')
|
|
|
|
def test_autocreate_group(self):
|
|
self.conf.register_cli_opt(StrOpt('foo'), group='blaa')
|
|
|
|
self.conf(['--blaa-foo', 'bar'])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'blaa'))
|
|
self.assertTrue(hasattr(self.conf.blaa, 'foo'))
|
|
self.assertEquals(self.conf.blaa.foo, 'bar')
|
|
|
|
def test_arg_group_by_name(self):
|
|
self.conf.register_group(OptGroup('blaa'))
|
|
self.conf.register_cli_opt(StrOpt('foo'), group='blaa')
|
|
|
|
self.conf(['--blaa-foo', 'bar'])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'blaa'))
|
|
self.assertTrue(hasattr(self.conf.blaa, 'foo'))
|
|
self.assertEquals(self.conf.blaa.foo, 'bar')
|
|
|
|
def test_arg_group_with_default(self):
|
|
self.conf.register_group(OptGroup('blaa'))
|
|
self.conf.register_cli_opt(StrOpt('foo', default='bar'), group='blaa')
|
|
|
|
self.conf([])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'blaa'))
|
|
self.assertTrue(hasattr(self.conf.blaa, 'foo'))
|
|
self.assertEquals(self.conf.blaa.foo, 'bar')
|
|
|
|
def test_arg_group_with_conf_and_group_opts(self):
|
|
self.conf.register_cli_opt(StrOpt('conf'), group='blaa')
|
|
self.conf.register_cli_opt(StrOpt('group'), group='blaa')
|
|
|
|
self.conf(['--blaa-conf', 'foo', '--blaa-group', 'bar'])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'blaa'))
|
|
self.assertTrue(hasattr(self.conf.blaa, 'conf'))
|
|
self.assertEquals(self.conf.blaa.conf, 'foo')
|
|
self.assertTrue(hasattr(self.conf.blaa, 'group'))
|
|
self.assertEquals(self.conf.blaa.group, 'bar')
|
|
|
|
def test_arg_group_in_config_file(self):
|
|
self.conf.register_group(OptGroup('blaa'))
|
|
self.conf.register_opt(StrOpt('foo'), group='blaa')
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[blaa]\n'
|
|
'foo = bar\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'blaa'))
|
|
self.assertTrue(hasattr(self.conf.blaa, 'foo'))
|
|
self.assertEquals(self.conf.blaa.foo, 'bar')
|
|
|
|
def test_arg_group_in_config_file_with_deprecated_name(self):
|
|
self.conf.register_group(OptGroup('blaa'))
|
|
self.conf.register_opt(StrOpt('foo', deprecated_name='oldfoo'),
|
|
group='blaa')
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[blaa]\n'
|
|
'oldfoo = bar\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'blaa'))
|
|
self.assertTrue(hasattr(self.conf.blaa, 'foo'))
|
|
self.assertEquals(self.conf.blaa.foo, 'bar')
|
|
|
|
def test_arg_group_in_config_file_with_deprecated_group(self):
|
|
self.conf.register_group(OptGroup('blaa'))
|
|
self.conf.register_opt(StrOpt('foo', deprecated_group='DEFAULT'),
|
|
group='blaa')
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = bar\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'blaa'))
|
|
self.assertTrue(hasattr(self.conf.blaa, 'foo'))
|
|
self.assertEquals(self.conf.blaa.foo, 'bar')
|
|
|
|
def test_arg_group_in_config_file_with_deprecated_group_and_name(self):
|
|
self.conf.register_group(OptGroup('blaa'))
|
|
self.conf.register_opt(StrOpt('foo',
|
|
deprecated_group='DEFAULT',
|
|
deprecated_name='oldfoo'),
|
|
group='blaa')
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'oldfoo = bar\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'blaa'))
|
|
self.assertTrue(hasattr(self.conf.blaa, 'foo'))
|
|
self.assertEquals(self.conf.blaa.foo, 'bar')
|
|
|
|
def test_arg_group_in_config_file_override_deprecated_name(self):
|
|
self.conf.register_group(OptGroup('blaa'))
|
|
self.conf.register_opt(StrOpt('foo', deprecated_name='oldfoo'),
|
|
group='blaa')
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[blaa]\n'
|
|
'foo = bar\n'
|
|
'oldfoo = blabla\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'blaa'))
|
|
self.assertTrue(hasattr(self.conf.blaa, 'foo'))
|
|
self.assertEquals(self.conf.blaa.foo, 'bar')
|
|
|
|
def test_arg_group_in_config_file_override_deprecated_group(self):
|
|
self.conf.register_group(OptGroup('blaa'))
|
|
self.conf.register_opt(StrOpt('foo', deprecated_group='DEFAULT'),
|
|
group='blaa')
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = blabla\n'
|
|
'[blaa]\n'
|
|
'foo = bar\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'blaa'))
|
|
self.assertTrue(hasattr(self.conf.blaa, 'foo'))
|
|
self.assertEquals(self.conf.blaa.foo, 'bar')
|
|
|
|
def test_arg_group_in_config_file_override_deprecated_group_and_name(self):
|
|
self.conf.register_group(OptGroup('blaa'))
|
|
self.conf.register_opt(StrOpt('foo',
|
|
deprecated_group='DEFAULT',
|
|
deprecated_name='oldfoo'),
|
|
group='blaa')
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'oldfoo = blabla\n'
|
|
'[blaa]\n'
|
|
'foo = bar\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'blaa'))
|
|
self.assertTrue(hasattr(self.conf.blaa, 'foo'))
|
|
self.assertEquals(self.conf.blaa.foo, 'bar')
|
|
|
|
|
|
class MappingInterfaceTestCase(BaseTestCase):
|
|
|
|
def test_mapping_interface(self):
|
|
self.conf.register_cli_opt(StrOpt('foo'))
|
|
|
|
self.conf(['--foo', 'bar'])
|
|
|
|
self.assertTrue('foo' in self.conf)
|
|
self.assertTrue('config_file' in self.conf)
|
|
self.assertEquals(len(self.conf), 3)
|
|
self.assertEquals(self.conf['foo'], 'bar')
|
|
self.assertEquals(self.conf.get('foo'), 'bar')
|
|
self.assertTrue('bar' in self.conf.values())
|
|
|
|
def test_mapping_interface_with_group(self):
|
|
self.conf.register_group(OptGroup('blaa'))
|
|
self.conf.register_cli_opt(StrOpt('foo'), group='blaa')
|
|
|
|
self.conf(['--blaa-foo', 'bar'])
|
|
|
|
self.assertTrue('blaa' in self.conf)
|
|
self.assertTrue('foo' in self.conf['blaa'])
|
|
self.assertEquals(len(self.conf['blaa']), 1)
|
|
self.assertEquals(self.conf['blaa']['foo'], 'bar')
|
|
self.assertEquals(self.conf['blaa'].get('foo'), 'bar')
|
|
self.assertTrue('bar' in self.conf['blaa'].values())
|
|
self.assertEquals(self.conf.blaa, self.conf['blaa'])
|
|
|
|
|
|
class ReRegisterOptTestCase(BaseTestCase):
|
|
|
|
def test_conf_file_re_register_opt(self):
|
|
opt = StrOpt('foo')
|
|
self.assertTrue(self.conf.register_opt(opt))
|
|
self.assertFalse(self.conf.register_opt(opt))
|
|
|
|
def test_conf_file_re_register_opt_in_group(self):
|
|
group = OptGroup('blaa')
|
|
self.conf.register_group(group)
|
|
self.conf.register_group(group) # not an error
|
|
opt = StrOpt('foo')
|
|
self.assertTrue(self.conf.register_opt(opt, group=group))
|
|
self.assertFalse(self.conf.register_opt(opt, group='blaa'))
|
|
|
|
|
|
class TemplateSubstitutionTestCase(BaseTestCase):
|
|
|
|
def _prep_test_str_sub(self, foo_default=None, bar_default=None):
|
|
self.conf.register_cli_opt(StrOpt('foo', default=foo_default))
|
|
self.conf.register_cli_opt(StrOpt('bar', default=bar_default))
|
|
|
|
def _assert_str_sub(self):
|
|
self.assertTrue(hasattr(self.conf, 'bar'))
|
|
self.assertEquals(self.conf.bar, 'blaa')
|
|
|
|
def test_str_sub_default_from_default(self):
|
|
self._prep_test_str_sub(foo_default='blaa', bar_default='$foo')
|
|
|
|
self.conf([])
|
|
|
|
self._assert_str_sub()
|
|
|
|
def test_str_sub_default_from_default_recurse(self):
|
|
self.conf.register_cli_opt(StrOpt('blaa', default='blaa'))
|
|
self._prep_test_str_sub(foo_default='$blaa', bar_default='$foo')
|
|
|
|
self.conf([])
|
|
|
|
self._assert_str_sub()
|
|
|
|
def test_str_sub_default_from_arg(self):
|
|
self._prep_test_str_sub(bar_default='$foo')
|
|
|
|
self.conf(['--foo', 'blaa'])
|
|
|
|
self._assert_str_sub()
|
|
|
|
def test_str_sub_default_from_config_file(self):
|
|
self._prep_test_str_sub(bar_default='$foo')
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = blaa\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self._assert_str_sub()
|
|
|
|
def test_str_sub_arg_from_default(self):
|
|
self._prep_test_str_sub(foo_default='blaa')
|
|
|
|
self.conf(['--bar', '$foo'])
|
|
|
|
self._assert_str_sub()
|
|
|
|
def test_str_sub_arg_from_arg(self):
|
|
self._prep_test_str_sub()
|
|
|
|
self.conf(['--foo', 'blaa', '--bar', '$foo'])
|
|
|
|
self._assert_str_sub()
|
|
|
|
def test_str_sub_arg_from_config_file(self):
|
|
self._prep_test_str_sub()
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = blaa\n')])
|
|
|
|
self.conf(['--config-file', paths[0], '--bar=$foo'])
|
|
|
|
self._assert_str_sub()
|
|
|
|
def test_str_sub_config_file_from_default(self):
|
|
self._prep_test_str_sub(foo_default='blaa')
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'bar = $foo\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self._assert_str_sub()
|
|
|
|
def test_str_sub_config_file_from_arg(self):
|
|
self._prep_test_str_sub()
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'bar = $foo\n')])
|
|
|
|
self.conf(['--config-file', paths[0], '--foo=blaa'])
|
|
|
|
self._assert_str_sub()
|
|
|
|
def test_str_sub_config_file_from_config_file(self):
|
|
self._prep_test_str_sub()
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'bar = $foo\n'
|
|
'foo = blaa\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self._assert_str_sub()
|
|
|
|
def test_str_sub_group_from_default(self):
|
|
self.conf.register_cli_opt(StrOpt('foo', default='blaa'))
|
|
self.conf.register_group(OptGroup('ba'))
|
|
self.conf.register_cli_opt(StrOpt('r', default='$foo'), group='ba')
|
|
|
|
self.conf([])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'ba'))
|
|
self.assertTrue(hasattr(self.conf.ba, 'r'))
|
|
self.assertEquals(self.conf.ba.r, 'blaa')
|
|
|
|
def test_config_dir(self):
|
|
snafu_group = OptGroup('snafu')
|
|
self.conf.register_group(snafu_group)
|
|
self.conf.register_cli_opt(StrOpt('foo'))
|
|
self.conf.register_cli_opt(StrOpt('bell'), group=snafu_group)
|
|
|
|
dir = tempfile.mkdtemp()
|
|
self.tempdirs.append(dir)
|
|
|
|
paths = self.create_tempfiles([(os.path.join(dir, '00-test'),
|
|
'[DEFAULT]\n'
|
|
'foo = bar-00\n'
|
|
'[snafu]\n'
|
|
'bell = whistle-00\n'),
|
|
(os.path.join(dir, '02-test'),
|
|
'[snafu]\n'
|
|
'bell = whistle-02\n'
|
|
'[DEFAULT]\n'
|
|
'foo = bar-02\n'),
|
|
(os.path.join(dir, '01-test'),
|
|
'[DEFAULT]\n'
|
|
'foo = bar-01\n')])
|
|
|
|
self.conf(['--foo', 'bar',
|
|
'--config-dir', os.path.dirname(paths[0])])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, 'bar-02')
|
|
self.assertTrue(hasattr(self.conf, 'snafu'))
|
|
self.assertTrue(hasattr(self.conf.snafu, 'bell'))
|
|
self.assertEquals(self.conf.snafu.bell, 'whistle-02')
|
|
|
|
def test_config_dir_file_precedence(self):
|
|
snafu_group = OptGroup('snafu')
|
|
self.conf.register_group(snafu_group)
|
|
self.conf.register_cli_opt(StrOpt('foo'))
|
|
self.conf.register_cli_opt(StrOpt('bell'), group=snafu_group)
|
|
|
|
dir = tempfile.mkdtemp()
|
|
self.tempdirs.append(dir)
|
|
|
|
paths = self.create_tempfiles([(os.path.join(dir, '00-test'),
|
|
'[DEFAULT]\n'
|
|
'foo = bar-00\n'),
|
|
('01-test',
|
|
'[snafu]\n'
|
|
'bell = whistle-01\n'
|
|
'[DEFAULT]\n'
|
|
'foo = bar-01\n'),
|
|
('03-test',
|
|
'[snafu]\n'
|
|
'bell = whistle-03\n'
|
|
'[DEFAULT]\n'
|
|
'foo = bar-03\n'),
|
|
(os.path.join(dir, '02-test'),
|
|
'[DEFAULT]\n'
|
|
'foo = bar-02\n')])
|
|
|
|
self.conf(['--foo', 'bar',
|
|
'--config-file', paths[1],
|
|
'--config-dir', os.path.dirname(paths[0]),
|
|
'--config-file', paths[2], ])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, 'bar-02')
|
|
self.assertTrue(hasattr(self.conf, 'snafu'))
|
|
self.assertTrue(hasattr(self.conf.snafu, 'bell'))
|
|
self.assertEquals(self.conf.snafu.bell, 'whistle-03')
|
|
|
|
|
|
class ReparseTestCase(BaseTestCase):
|
|
|
|
def test_reparse(self):
|
|
self.conf.register_group(OptGroup('blaa'))
|
|
self.conf.register_cli_opt(StrOpt('foo', default='r'), group='blaa')
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[blaa]\n'
|
|
'foo = b\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'blaa'))
|
|
self.assertTrue(hasattr(self.conf.blaa, 'foo'))
|
|
self.assertEquals(self.conf.blaa.foo, 'b')
|
|
|
|
self.conf(['--blaa-foo', 'a'])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'blaa'))
|
|
self.assertTrue(hasattr(self.conf.blaa, 'foo'))
|
|
self.assertEquals(self.conf.blaa.foo, 'a')
|
|
|
|
self.conf([])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'blaa'))
|
|
self.assertTrue(hasattr(self.conf.blaa, 'foo'))
|
|
self.assertEquals(self.conf.blaa.foo, 'r')
|
|
|
|
|
|
class OverridesTestCase(BaseTestCase):
|
|
|
|
def test_default_none(self):
|
|
self.conf.register_opt(StrOpt('foo', default='foo'))
|
|
self.conf([])
|
|
self.assertEquals(self.conf.foo, 'foo')
|
|
self.conf.set_default('foo', None)
|
|
self.assertEquals(self.conf.foo, None)
|
|
self.conf.clear_default('foo')
|
|
self.assertEquals(self.conf.foo, 'foo')
|
|
|
|
def test_override_none(self):
|
|
self.conf.register_opt(StrOpt('foo', default='foo'))
|
|
self.conf([])
|
|
self.assertEquals(self.conf.foo, 'foo')
|
|
self.conf.set_override('foo', None)
|
|
self.assertEquals(self.conf.foo, None)
|
|
self.conf.clear_override('foo')
|
|
self.assertEquals(self.conf.foo, 'foo')
|
|
|
|
def test_no_default_override(self):
|
|
self.conf.register_opt(StrOpt('foo'))
|
|
self.conf([])
|
|
self.assertEquals(self.conf.foo, None)
|
|
self.conf.set_default('foo', 'bar')
|
|
self.assertEquals(self.conf.foo, 'bar')
|
|
self.conf.clear_default('foo')
|
|
self.assertEquals(self.conf.foo, None)
|
|
|
|
def test_default_override(self):
|
|
self.conf.register_opt(StrOpt('foo', default='foo'))
|
|
self.conf([])
|
|
self.assertEquals(self.conf.foo, 'foo')
|
|
self.conf.set_default('foo', 'bar')
|
|
self.assertEquals(self.conf.foo, 'bar')
|
|
self.conf.clear_default('foo')
|
|
self.assertEquals(self.conf.foo, 'foo')
|
|
|
|
def test_override(self):
|
|
self.conf.register_opt(StrOpt('foo'))
|
|
self.conf.set_override('foo', 'bar')
|
|
self.conf([])
|
|
self.assertEquals(self.conf.foo, 'bar')
|
|
self.conf.clear_override('foo')
|
|
self.assertEquals(self.conf.foo, None)
|
|
|
|
def test_group_no_default_override(self):
|
|
self.conf.register_group(OptGroup('blaa'))
|
|
self.conf.register_opt(StrOpt('foo'), group='blaa')
|
|
self.conf([])
|
|
self.assertEquals(self.conf.blaa.foo, None)
|
|
self.conf.set_default('foo', 'bar', group='blaa')
|
|
self.assertEquals(self.conf.blaa.foo, 'bar')
|
|
self.conf.clear_default('foo', group='blaa')
|
|
self.assertEquals(self.conf.blaa.foo, None)
|
|
|
|
def test_group_default_override(self):
|
|
self.conf.register_group(OptGroup('blaa'))
|
|
self.conf.register_opt(StrOpt('foo', default='foo'), group='blaa')
|
|
self.conf([])
|
|
self.assertEquals(self.conf.blaa.foo, 'foo')
|
|
self.conf.set_default('foo', 'bar', group='blaa')
|
|
self.assertEquals(self.conf.blaa.foo, 'bar')
|
|
self.conf.clear_default('foo', group='blaa')
|
|
self.assertEquals(self.conf.blaa.foo, 'foo')
|
|
|
|
def test_group_override(self):
|
|
self.conf.register_group(OptGroup('blaa'))
|
|
self.conf.register_opt(StrOpt('foo'), group='blaa')
|
|
self.assertEquals(self.conf.blaa.foo, None)
|
|
self.conf.set_override('foo', 'bar', group='blaa')
|
|
self.conf([])
|
|
self.assertEquals(self.conf.blaa.foo, 'bar')
|
|
self.conf.clear_override('foo', group='blaa')
|
|
self.assertEquals(self.conf.blaa.foo, None)
|
|
|
|
def test_cli_bool_default(self):
|
|
self.conf.register_cli_opt(BoolOpt('foo'))
|
|
self.conf.set_default('foo', True)
|
|
self.assertTrue(self.conf.foo)
|
|
self.conf([])
|
|
self.assertTrue(self.conf.foo)
|
|
self.conf.set_default('foo', False)
|
|
self.assertFalse(self.conf.foo)
|
|
self.conf.clear_default('foo')
|
|
self.assertTrue(self.conf.foo is None)
|
|
|
|
def test_cli_bool_override(self):
|
|
self.conf.register_cli_opt(BoolOpt('foo'))
|
|
self.conf.set_override('foo', True)
|
|
self.assertTrue(self.conf.foo)
|
|
self.conf([])
|
|
self.assertTrue(self.conf.foo)
|
|
self.conf.set_override('foo', False)
|
|
self.assertFalse(self.conf.foo)
|
|
self.conf.clear_override('foo')
|
|
self.assertTrue(self.conf.foo is None)
|
|
|
|
|
|
class ResetAndClearTestCase(BaseTestCase):
|
|
|
|
def test_clear(self):
|
|
self.conf.register_cli_opt(StrOpt('foo'))
|
|
self.conf.register_cli_opt(StrOpt('bar'), group='blaa')
|
|
|
|
self.assertEquals(self.conf.foo, None)
|
|
self.assertEquals(self.conf.blaa.bar, None)
|
|
|
|
self.conf(['--foo', 'foo', '--blaa-bar', 'bar'])
|
|
|
|
self.assertEquals(self.conf.foo, 'foo')
|
|
self.assertEquals(self.conf.blaa.bar, 'bar')
|
|
|
|
self.conf.clear()
|
|
|
|
self.assertEquals(self.conf.foo, None)
|
|
self.assertEquals(self.conf.blaa.bar, None)
|
|
|
|
def test_reset_and_clear_with_defaults_and_overrides(self):
|
|
self.conf.register_cli_opt(StrOpt('foo'))
|
|
self.conf.register_cli_opt(StrOpt('bar'), group='blaa')
|
|
|
|
self.conf.set_default('foo', 'foo')
|
|
self.conf.set_override('bar', 'bar', group='blaa')
|
|
|
|
self.conf(['--foo', 'foofoo'])
|
|
|
|
self.assertEquals(self.conf.foo, 'foofoo')
|
|
self.assertEquals(self.conf.blaa.bar, 'bar')
|
|
|
|
self.conf.clear()
|
|
|
|
self.assertEquals(self.conf.foo, 'foo')
|
|
self.assertEquals(self.conf.blaa.bar, 'bar')
|
|
|
|
self.conf.reset()
|
|
|
|
self.assertEquals(self.conf.foo, None)
|
|
self.assertEquals(self.conf.blaa.bar, None)
|
|
|
|
|
|
class UnregisterOptTestCase(BaseTestCase):
|
|
|
|
def test_unregister_opt(self):
|
|
opts = [StrOpt('foo'), StrOpt('bar')]
|
|
|
|
self.conf.register_opts(opts)
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertTrue(hasattr(self.conf, 'bar'))
|
|
|
|
self.conf.unregister_opt(opts[0])
|
|
|
|
self.assertFalse(hasattr(self.conf, 'foo'))
|
|
self.assertTrue(hasattr(self.conf, 'bar'))
|
|
|
|
self.conf([])
|
|
|
|
self.assertRaises(ArgsAlreadyParsedError,
|
|
self.conf.unregister_opt, opts[1])
|
|
|
|
self.conf.clear()
|
|
|
|
self.assertTrue(hasattr(self.conf, 'bar'))
|
|
|
|
self.conf.unregister_opts(opts)
|
|
|
|
def test_unregister_opt_from_group(self):
|
|
opt = StrOpt('foo')
|
|
|
|
self.conf.register_opt(opt, group='blaa')
|
|
|
|
self.assertTrue(hasattr(self.conf, 'blaa'))
|
|
self.assertTrue(hasattr(self.conf.blaa, 'foo'))
|
|
|
|
self.conf.unregister_opt(opt, group='blaa')
|
|
|
|
self.assertFalse(hasattr(self.conf.blaa, 'foo'))
|
|
|
|
|
|
class ImportOptTestCase(BaseTestCase):
|
|
|
|
def test_import_opt(self):
|
|
self.assertFalse(hasattr(CONF, 'blaa'))
|
|
CONF.import_opt('blaa', 'tests.testmods.blaa_opt')
|
|
self.assertTrue(hasattr(CONF, 'blaa'))
|
|
|
|
def test_import_opt_in_group(self):
|
|
self.assertFalse(hasattr(CONF, 'bar'))
|
|
CONF.import_opt('foo', 'tests.testmods.bar_foo_opt', group='bar')
|
|
self.assertTrue(hasattr(CONF, 'bar'))
|
|
self.assertTrue(hasattr(CONF.bar, 'foo'))
|
|
|
|
def test_import_opt_import_errror(self):
|
|
self.assertRaises(ImportError, CONF.import_opt,
|
|
'blaa', 'tests.testmods.blaablaa_opt')
|
|
|
|
def test_import_opt_no_such_opt(self):
|
|
self.assertRaises(NoSuchOptError, CONF.import_opt,
|
|
'blaablaa', 'tests.testmods.blaa_opt')
|
|
|
|
def test_import_opt_no_such_group(self):
|
|
self.assertRaises(NoSuchGroupError, CONF.import_opt,
|
|
'blaa', 'tests.testmods.blaa_opt', group='blaa')
|
|
|
|
|
|
class ImportGroupTestCase(BaseTestCase):
|
|
|
|
def test_import_group(self):
|
|
self.assertFalse(hasattr(CONF, 'qux'))
|
|
CONF.import_group('qux', 'tests.testmods.baz_qux_opt')
|
|
self.assertTrue(hasattr(CONF, 'qux'))
|
|
self.assertTrue(hasattr(CONF.qux, 'baz'))
|
|
|
|
def test_import_group_import_error(self):
|
|
self.assertRaises(ImportError, CONF.import_group,
|
|
'qux', 'tests.testmods.bazzz_quxxx_opt')
|
|
|
|
def test_import_group_no_such_group(self):
|
|
self.assertRaises(NoSuchGroupError, CONF.import_group,
|
|
'quxxx', 'tests.testmods.baz_qux_opt')
|
|
|
|
|
|
class RequiredOptsTestCase(BaseTestCase):
|
|
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
self.conf.register_opt(StrOpt('boo', required=False))
|
|
|
|
def test_required_opt(self):
|
|
self.conf.register_opt(StrOpt('foo', required=True))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = bar')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, 'bar')
|
|
|
|
def test_required_cli_opt(self):
|
|
self.conf.register_cli_opt(StrOpt('foo', required=True))
|
|
|
|
self.conf(['--foo', 'bar'])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, 'bar')
|
|
|
|
def test_required_cli_opt_with_dash(self):
|
|
self.conf.register_cli_opt(StrOpt('foo-bar', required=True))
|
|
|
|
self.conf(['--foo-bar', 'baz'])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo_bar'))
|
|
self.assertEquals(self.conf.foo_bar, 'baz')
|
|
|
|
def test_missing_required_opt(self):
|
|
self.conf.register_opt(StrOpt('foo', required=True))
|
|
self.assertRaises(RequiredOptError, self.conf, [])
|
|
|
|
def test_missing_required_cli_opt(self):
|
|
self.conf.register_cli_opt(StrOpt('foo', required=True))
|
|
self.assertRaises(RequiredOptError, self.conf, [])
|
|
|
|
def test_required_group_opt(self):
|
|
self.conf.register_group(OptGroup('blaa'))
|
|
self.conf.register_opt(StrOpt('foo', required=True), group='blaa')
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[blaa]\n'
|
|
'foo = bar')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
self.assertTrue(hasattr(self.conf, 'blaa'))
|
|
self.assertTrue(hasattr(self.conf.blaa, 'foo'))
|
|
self.assertEquals(self.conf.blaa.foo, 'bar')
|
|
|
|
def test_required_cli_group_opt(self):
|
|
self.conf.register_group(OptGroup('blaa'))
|
|
self.conf.register_cli_opt(StrOpt('foo', required=True), group='blaa')
|
|
|
|
self.conf(['--blaa-foo', 'bar'])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'blaa'))
|
|
self.assertTrue(hasattr(self.conf.blaa, 'foo'))
|
|
self.assertEquals(self.conf.blaa.foo, 'bar')
|
|
|
|
def test_missing_required_group_opt(self):
|
|
self.conf.register_group(OptGroup('blaa'))
|
|
self.conf.register_opt(StrOpt('foo', required=True), group='blaa')
|
|
self.assertRaises(RequiredOptError, self.conf, [])
|
|
|
|
def test_missing_required_cli_group_opt(self):
|
|
self.conf.register_group(OptGroup('blaa'))
|
|
self.conf.register_cli_opt(StrOpt('foo', required=True), group='blaa')
|
|
self.assertRaises(RequiredOptError, self.conf, [])
|
|
|
|
def test_required_opt_with_default(self):
|
|
self.conf.register_cli_opt(StrOpt('foo', required=True))
|
|
self.conf.set_default('foo', 'bar')
|
|
|
|
self.conf([])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, 'bar')
|
|
|
|
def test_required_opt_with_override(self):
|
|
self.conf.register_cli_opt(StrOpt('foo', required=True))
|
|
self.conf.set_override('foo', 'bar')
|
|
|
|
self.conf([])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, 'bar')
|
|
|
|
|
|
class SadPathTestCase(BaseTestCase):
|
|
|
|
def test_unknown_attr(self):
|
|
self.conf([])
|
|
self.assertFalse(hasattr(self.conf, 'foo'))
|
|
self.assertRaises(NoSuchOptError, getattr, self.conf, 'foo')
|
|
|
|
def test_unknown_attr_is_attr_error(self):
|
|
self.conf([])
|
|
self.assertFalse(hasattr(self.conf, 'foo'))
|
|
self.assertRaises(AttributeError, getattr, self.conf, 'foo')
|
|
|
|
def test_unknown_group_attr(self):
|
|
self.conf.register_group(OptGroup('blaa'))
|
|
|
|
self.conf([])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'blaa'))
|
|
self.assertFalse(hasattr(self.conf.blaa, 'foo'))
|
|
self.assertRaises(NoSuchOptError, getattr, self.conf.blaa, 'foo')
|
|
|
|
def test_ok_duplicate(self):
|
|
opt = StrOpt('foo')
|
|
self.conf.register_cli_opt(opt)
|
|
opt2 = StrOpt('foo')
|
|
self.conf.register_cli_opt(opt2)
|
|
|
|
self.conf([])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, None)
|
|
|
|
def test_error_duplicate(self):
|
|
self.conf.register_cli_opt(StrOpt('foo', help='bar'))
|
|
self.assertRaises(DuplicateOptError,
|
|
self.conf.register_cli_opt, StrOpt('foo'))
|
|
|
|
def test_error_duplicate_with_different_dest(self):
|
|
self.conf.register_cli_opt(StrOpt('foo', dest='f'))
|
|
self.conf.register_cli_opt(StrOpt('foo'))
|
|
self.assertRaises(DuplicateOptError, self.conf, [])
|
|
|
|
def test_error_duplicate_short(self):
|
|
self.conf.register_cli_opt(StrOpt('foo', short='f'))
|
|
self.conf.register_cli_opt(StrOpt('bar', short='f'))
|
|
self.assertRaises(DuplicateOptError, self.conf, [])
|
|
|
|
def test_no_such_group(self):
|
|
group = OptGroup('blaa')
|
|
self.assertRaises(NoSuchGroupError, self.conf.register_cli_opt,
|
|
StrOpt('foo'), group=group)
|
|
|
|
def test_already_parsed(self):
|
|
self.conf([])
|
|
|
|
self.assertRaises(ArgsAlreadyParsedError,
|
|
self.conf.register_cli_opt, StrOpt('foo'))
|
|
|
|
def test_bad_cli_arg(self):
|
|
self.conf.register_opt(BoolOpt('foo'))
|
|
|
|
self.stubs.Set(sys, 'stderr', StringIO.StringIO())
|
|
|
|
self.assertRaises(SystemExit, self.conf, ['--foo'])
|
|
|
|
self.assertTrue('error' in sys.stderr.getvalue())
|
|
self.assertTrue('--foo' in sys.stderr.getvalue())
|
|
|
|
def _do_test_bad_cli_value(self, opt_class):
|
|
self.conf.register_cli_opt(opt_class('foo'))
|
|
|
|
self.stubs.Set(sys, 'stderr', StringIO.StringIO())
|
|
|
|
self.assertRaises(SystemExit, self.conf, ['--foo', 'bar'])
|
|
|
|
self.assertTrue('foo' in sys.stderr.getvalue())
|
|
self.assertTrue('bar' in sys.stderr.getvalue())
|
|
|
|
def test_bad_int_arg(self):
|
|
self._do_test_bad_cli_value(IntOpt)
|
|
|
|
def test_bad_float_arg(self):
|
|
self._do_test_bad_cli_value(FloatOpt)
|
|
|
|
def test_conf_file_not_found(self):
|
|
(fd, path) = tempfile.mkstemp()
|
|
|
|
os.remove(path)
|
|
|
|
self.assertRaises(ConfigFilesNotFoundError,
|
|
self.conf, ['--config-file', path])
|
|
|
|
def test_conf_file_broken(self):
|
|
paths = self.create_tempfiles([('test', 'foo')])
|
|
|
|
self.assertRaises(ConfigFileParseError,
|
|
self.conf, ['--config-file', paths[0]])
|
|
|
|
def _do_test_conf_file_bad_value(self, opt_class):
|
|
self.conf.register_opt(opt_class('foo'))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = bar\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertRaises(ConfigFileValueError, getattr, self.conf, 'foo')
|
|
|
|
def test_conf_file_bad_bool(self):
|
|
self._do_test_conf_file_bad_value(BoolOpt)
|
|
|
|
def test_conf_file_bad_int(self):
|
|
self._do_test_conf_file_bad_value(IntOpt)
|
|
|
|
def test_conf_file_bad_float(self):
|
|
self._do_test_conf_file_bad_value(FloatOpt)
|
|
|
|
def test_str_sub_from_group(self):
|
|
self.conf.register_group(OptGroup('f'))
|
|
self.conf.register_cli_opt(StrOpt('oo', default='blaa'), group='f')
|
|
self.conf.register_cli_opt(StrOpt('bar', default='$f.oo'))
|
|
|
|
self.conf([])
|
|
|
|
self.assertFalse(hasattr(self.conf, 'bar'))
|
|
self.assertRaises(TemplateSubstitutionError, getattr, self.conf, 'bar')
|
|
|
|
def test_set_default_unknown_attr(self):
|
|
self.conf([])
|
|
self.assertRaises(NoSuchOptError, self.conf.set_default, 'foo', 'bar')
|
|
|
|
def test_set_default_unknown_group(self):
|
|
self.conf([])
|
|
self.assertRaises(NoSuchGroupError,
|
|
self.conf.set_default, 'foo', 'bar', group='blaa')
|
|
|
|
def test_set_override_unknown_attr(self):
|
|
self.conf([])
|
|
self.assertRaises(NoSuchOptError, self.conf.set_override, 'foo', 'bar')
|
|
|
|
def test_set_override_unknown_group(self):
|
|
self.conf([])
|
|
self.assertRaises(NoSuchGroupError,
|
|
self.conf.set_override, 'foo', 'bar', group='blaa')
|
|
|
|
|
|
class FindFileTestCase(BaseTestCase):
|
|
|
|
def test_find_policy_file(self):
|
|
policy_file = '/etc/policy.json'
|
|
|
|
self.stubs.Set(os.path, 'exists', lambda p: p == policy_file)
|
|
|
|
self.conf([])
|
|
|
|
self.assertEquals(self.conf.find_file('foo.json'), None)
|
|
self.assertEquals(self.conf.find_file('policy.json'), policy_file)
|
|
|
|
def test_find_policy_file_with_config_file(self):
|
|
dir = tempfile.mkdtemp()
|
|
self.tempdirs.append(dir)
|
|
|
|
paths = self.create_tempfiles([(os.path.join(dir, 'test.conf'),
|
|
'[DEFAULT]'),
|
|
(os.path.join(dir, 'policy.json'),
|
|
'{}')],
|
|
ext='')
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertEquals(self.conf.find_file('policy.json'), paths[1])
|
|
|
|
def test_find_policy_file_with_config_dir(self):
|
|
dir = tempfile.mkdtemp()
|
|
self.tempdirs.append(dir)
|
|
|
|
path = self.create_tempfiles([(os.path.join(dir, 'policy.json'),
|
|
'{}')],
|
|
ext='')[0]
|
|
|
|
self.conf(['--config-dir', dir])
|
|
|
|
self.assertEquals(self.conf.find_file('policy.json'), path)
|
|
|
|
|
|
class OptDumpingTestCase(BaseTestCase):
|
|
|
|
class FakeLogger:
|
|
|
|
def __init__(self, test_case, expected_lvl):
|
|
self.test_case = test_case
|
|
self.expected_lvl = expected_lvl
|
|
self.logged = []
|
|
|
|
def log(self, lvl, fmt, *args):
|
|
self.test_case.assertEquals(lvl, self.expected_lvl)
|
|
self.logged.append(fmt % args)
|
|
|
|
def setUp(self):
|
|
super(OptDumpingTestCase, self).setUp()
|
|
self._args = ['--foo', 'this', '--blaa-bar', 'that',
|
|
'--blaa-key', 'admin', '--passwd', 'hush']
|
|
|
|
def _do_test_log_opt_values(self, args):
|
|
self.conf.register_cli_opt(StrOpt('foo'))
|
|
self.conf.register_cli_opt(StrOpt('passwd', secret=True))
|
|
self.conf.register_group(OptGroup('blaa'))
|
|
self.conf.register_cli_opt(StrOpt('bar'), 'blaa')
|
|
self.conf.register_cli_opt(StrOpt('key', secret=True), 'blaa')
|
|
|
|
self.conf(args)
|
|
|
|
logger = self.FakeLogger(self, 666)
|
|
|
|
self.conf.log_opt_values(logger, 666)
|
|
|
|
self.assertEquals(logger.logged, [
|
|
"*" * 80,
|
|
"Configuration options gathered from:",
|
|
"command line args: ['--foo', 'this', '--blaa-bar', "
|
|
"'that', '--blaa-key', 'admin', '--passwd', 'hush']",
|
|
"config files: []",
|
|
"=" * 80,
|
|
"config_dir = None",
|
|
"config_file = []",
|
|
"foo = this",
|
|
"passwd = ****",
|
|
"blaa.bar = that",
|
|
"blaa.key = *****",
|
|
"*" * 80,
|
|
])
|
|
|
|
def test_log_opt_values(self):
|
|
self._do_test_log_opt_values(self._args)
|
|
|
|
def test_log_opt_values_from_sys_argv(self):
|
|
self.stubs.Set(sys, 'argv', ['foo'] + self._args)
|
|
self._do_test_log_opt_values(None)
|
|
|
|
|
|
class ConfigParserTestCase(utils.BaseTestCase):
|
|
def test_no_section(self):
|
|
with tempfile.NamedTemporaryFile() as tmpfile:
|
|
tmpfile.write('foo = bar')
|
|
tmpfile.flush()
|
|
|
|
parser = ConfigParser(tmpfile.name, {})
|
|
self.assertRaises(ParseError, parser.parse)
|
|
|
|
|
|
class TildeExpansionTestCase(BaseTestCase):
|
|
|
|
def test_config_file_tilde(self):
|
|
homedir = os.path.expanduser('~')
|
|
tmpfile = tempfile.mktemp(dir=homedir, prefix='cfg-', suffix='.conf')
|
|
tmpbase = os.path.basename(tmpfile)
|
|
|
|
try:
|
|
self.conf(['--config-file', os.path.join('~', tmpbase)])
|
|
except ConfigFilesNotFoundError, cfnfe:
|
|
print cfnfe
|
|
self.assertTrue(homedir in str(cfnfe))
|
|
|
|
self.stubs.Set(os.path, 'exists', lambda p: p == tmpfile)
|
|
|
|
self.assertEquals(self.conf.find_file(tmpbase), tmpfile)
|
|
|
|
def test_config_dir_tilde(self):
|
|
homedir = os.path.expanduser('~')
|
|
tmpdir = tempfile.mktemp(dir=homedir,
|
|
prefix='cfg-',
|
|
suffix='.d')
|
|
tmpfile = os.path.join(tmpdir, 'foo.conf')
|
|
tmpbase = os.path.basename(tmpfile)
|
|
|
|
self.stubs.Set(glob, 'glob', lambda p: [tmpfile])
|
|
|
|
try:
|
|
print ['--config-dir', os.path.join('~', os.path.basename(tmpdir))]
|
|
self.conf(['--config-dir',
|
|
os.path.join('~', os.path.basename(tmpdir))])
|
|
except ConfigFilesNotFoundError, cfnfe:
|
|
print cfnfe
|
|
self.assertTrue(os.path.expanduser('~') in str(cfnfe))
|
|
|
|
self.stubs.Set(os.path, 'exists', lambda p: p == tmpfile)
|
|
|
|
self.assertEquals(self.conf.find_file(tmpbase), tmpfile)
|
|
|
|
|
|
class SubCommandTestCase(BaseTestCase):
|
|
|
|
def test_sub_command(self):
|
|
def add_parsers(subparsers):
|
|
sub = subparsers.add_parser('a')
|
|
sub.add_argument('bar', type=int)
|
|
|
|
self.conf.register_cli_opt(SubCommandOpt('cmd', handler=add_parsers))
|
|
self.assertTrue(hasattr(self.conf, 'cmd'))
|
|
self.conf(['a', '10'])
|
|
self.assertTrue(hasattr(self.conf.cmd, 'name'))
|
|
self.assertTrue(hasattr(self.conf.cmd, 'bar'))
|
|
self.assertEquals(self.conf.cmd.name, 'a')
|
|
self.assertEquals(self.conf.cmd.bar, 10)
|
|
|
|
def test_sub_command_with_dest(self):
|
|
def add_parsers(subparsers):
|
|
sub = subparsers.add_parser('a')
|
|
|
|
self.conf.register_cli_opt(SubCommandOpt('cmd', dest='command',
|
|
handler=add_parsers))
|
|
self.assertTrue(hasattr(self.conf, 'command'))
|
|
self.conf(['a'])
|
|
self.assertEquals(self.conf.command.name, 'a')
|
|
|
|
def test_sub_command_with_group(self):
|
|
def add_parsers(subparsers):
|
|
sub = subparsers.add_parser('a')
|
|
sub.add_argument('--bar', choices='XYZ')
|
|
|
|
self.conf.register_cli_opt(SubCommandOpt('cmd', handler=add_parsers),
|
|
group='blaa')
|
|
self.assertTrue(hasattr(self.conf, 'blaa'))
|
|
self.assertTrue(hasattr(self.conf.blaa, 'cmd'))
|
|
self.conf(['a', '--bar', 'Z'])
|
|
self.assertTrue(hasattr(self.conf.blaa.cmd, 'name'))
|
|
self.assertTrue(hasattr(self.conf.blaa.cmd, 'bar'))
|
|
self.assertEquals(self.conf.blaa.cmd.name, 'a')
|
|
self.assertEquals(self.conf.blaa.cmd.bar, 'Z')
|
|
|
|
def test_sub_command_not_cli(self):
|
|
self.conf.register_opt(SubCommandOpt('cmd'))
|
|
self.conf([])
|
|
|
|
def test_sub_command_resparse(self):
|
|
def add_parsers(subparsers):
|
|
sub = subparsers.add_parser('a')
|
|
|
|
self.conf.register_cli_opt(SubCommandOpt('cmd',
|
|
handler=add_parsers))
|
|
|
|
foo_opt = StrOpt('foo')
|
|
self.conf.register_cli_opt(foo_opt)
|
|
|
|
self.conf(['--foo=bar', 'a'])
|
|
|
|
self.assertTrue(hasattr(self.conf.cmd, 'name'))
|
|
self.assertEquals(self.conf.cmd.name, 'a')
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEquals(self.conf.foo, 'bar')
|
|
|
|
self.conf.clear()
|
|
self.conf.unregister_opt(foo_opt)
|
|
self.conf(['a'])
|
|
|
|
self.assertTrue(hasattr(self.conf.cmd, 'name'))
|
|
self.assertEquals(self.conf.cmd.name, 'a')
|
|
self.assertFalse(hasattr(self.conf, 'foo'))
|
|
|
|
def test_sub_command_no_handler(self):
|
|
self.conf.register_cli_opt(SubCommandOpt('cmd'))
|
|
self.stubs.Set(sys, 'stderr', StringIO.StringIO())
|
|
self.assertRaises(SystemExit, self.conf, [])
|
|
self.assertTrue('error' in sys.stderr.getvalue())
|
|
|
|
def test_sub_command_with_help(self):
|
|
def add_parsers(subparsers):
|
|
sub = subparsers.add_parser('a')
|
|
|
|
self.conf.register_cli_opt(SubCommandOpt('cmd',
|
|
title='foo foo',
|
|
description='bar bar',
|
|
help='blaa blaa',
|
|
handler=add_parsers))
|
|
self.stubs.Set(sys, 'stdout', StringIO.StringIO())
|
|
self.assertRaises(SystemExit, self.conf, ['--help'])
|
|
self.assertTrue('foo foo' in sys.stdout.getvalue())
|
|
self.assertTrue('bar bar' in sys.stdout.getvalue())
|
|
self.assertTrue('blaa blaa' in sys.stdout.getvalue())
|
|
|
|
def test_sub_command_errors(self):
|
|
def add_parsers(subparsers):
|
|
sub = subparsers.add_parser('a')
|
|
sub.add_argument('--bar')
|
|
|
|
self.conf.register_cli_opt(BoolOpt('bar'))
|
|
self.conf.register_cli_opt(SubCommandOpt('cmd', handler=add_parsers))
|
|
self.conf(['a'])
|
|
self.assertRaises(DuplicateOptError, getattr, self.conf.cmd, 'bar')
|
|
self.assertRaises(NoSuchOptError, getattr, self.conf.cmd, 'foo')
|
|
|
|
def test_sub_command_multiple(self):
|
|
self.conf.register_cli_opt(SubCommandOpt('cmd1'))
|
|
self.conf.register_cli_opt(SubCommandOpt('cmd2'))
|
|
self.stubs.Set(sys, 'stderr', StringIO.StringIO())
|
|
self.assertRaises(SystemExit, self.conf, [])
|
|
self.assertTrue('multiple' in sys.stderr.getvalue())
|
|
|
|
|
|
class SetDefaultsTestCase(BaseTestCase):
|
|
|
|
def test_default_to_none(self):
|
|
opts = [StrOpt('foo', default='foo')]
|
|
self.conf.register_opts(opts)
|
|
set_defaults(opts, foo=None)
|
|
self.conf([])
|
|
self.assertEquals(self.conf.foo, None)
|
|
|
|
def test_default_from_none(self):
|
|
opts = [StrOpt('foo')]
|
|
self.conf.register_opts(opts)
|
|
set_defaults(opts, foo='bar')
|
|
self.conf([])
|
|
self.assertEquals(self.conf.foo, 'bar')
|
|
|
|
def test_change_default(self):
|
|
opts = [StrOpt('foo', default='foo')]
|
|
self.conf.register_opts(opts)
|
|
set_defaults(opts, foo='bar')
|
|
self.conf([])
|
|
self.assertEquals(self.conf.foo, 'bar')
|
|
|
|
def test_group_default_to_none(self):
|
|
opts = [StrOpt('foo', default='foo')]
|
|
self.conf.register_opts(opts, group='blaa')
|
|
set_defaults(opts, foo=None)
|
|
self.conf([])
|
|
self.assertEquals(self.conf.blaa.foo, None)
|
|
|
|
def test_group_default_from_none(self):
|
|
opts = [StrOpt('foo')]
|
|
self.conf.register_opts(opts, group='blaa')
|
|
set_defaults(opts, foo='bar')
|
|
self.conf([])
|
|
self.assertEquals(self.conf.blaa.foo, 'bar')
|
|
|
|
def test_group_change_default(self):
|
|
opts = [StrOpt('foo', default='foo')]
|
|
self.conf.register_opts(opts, group='blaa')
|
|
set_defaults(opts, foo='bar')
|
|
self.conf([])
|
|
self.assertEquals(self.conf.blaa.foo, 'bar')
|