5165 lines
197 KiB
Python
5165 lines
197 KiB
Python
# Copyright 2014 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 argparse
|
|
import errno
|
|
import functools
|
|
import io
|
|
import logging
|
|
import os
|
|
import shutil
|
|
import sys
|
|
import tempfile
|
|
import unittest
|
|
from unittest import mock
|
|
|
|
import fixtures
|
|
from oslotest import base
|
|
import testscenarios
|
|
|
|
from oslo_config import cfg
|
|
from oslo_config import types
|
|
|
|
load_tests = testscenarios.load_tests_apply_scenarios
|
|
|
|
|
|
class ExceptionsTestCase(base.BaseTestCase):
|
|
|
|
def test_error(self):
|
|
msg = str(cfg.Error('foobar'))
|
|
self.assertEqual('foobar', msg)
|
|
|
|
def test_args_already_parsed_error(self):
|
|
msg = str(cfg.ArgsAlreadyParsedError('foobar'))
|
|
self.assertEqual('arguments already parsed: foobar', msg)
|
|
|
|
def test_no_such_opt_error(self):
|
|
msg = str(cfg.NoSuchOptError('foo'))
|
|
self.assertEqual('no such option foo in group [DEFAULT]', msg)
|
|
|
|
def test_no_such_opt_error_with_group(self):
|
|
msg = str(cfg.NoSuchOptError('foo', cfg.OptGroup('bar')))
|
|
self.assertEqual('no such option foo in group [bar]', msg)
|
|
|
|
def test_no_such_group_error(self):
|
|
msg = str(cfg.NoSuchGroupError('bar'))
|
|
self.assertEqual('no such group [bar]', msg)
|
|
|
|
def test_duplicate_opt_error(self):
|
|
msg = str(cfg.DuplicateOptError('foo'))
|
|
self.assertEqual('duplicate option: foo', msg)
|
|
|
|
def test_required_opt_error(self):
|
|
msg = str(cfg.RequiredOptError('foo'))
|
|
self.assertEqual('value required for option foo in group [DEFAULT]',
|
|
msg)
|
|
|
|
def test_required_opt_error_with_group(self):
|
|
msg = str(cfg.RequiredOptError('foo', cfg.OptGroup('bar')))
|
|
self.assertEqual('value required for option foo in group [bar]', msg)
|
|
|
|
def test_template_substitution_error(self):
|
|
msg = str(cfg.TemplateSubstitutionError('foobar'))
|
|
self.assertEqual('template substitution error: foobar', msg)
|
|
|
|
def test_config_files_not_found_error(self):
|
|
msg = str(cfg.ConfigFilesNotFoundError(['foo', 'bar']))
|
|
self.assertEqual('Failed to find some config files: foo,bar', msg)
|
|
|
|
def test_config_files_permission_denied_error(self):
|
|
msg = str(cfg.ConfigFilesPermissionDeniedError(['foo', 'bar']))
|
|
self.assertEqual('Failed to open some config files: foo,bar', msg)
|
|
|
|
def test_config_dir_not_found_error(self):
|
|
msg = str(cfg.ConfigDirNotFoundError('foobar'))
|
|
self.assertEqual('Failed to read config file directory: foobar', msg)
|
|
|
|
def test_config_file_parse_error(self):
|
|
msg = str(cfg.ConfigFileParseError('foo', 'foobar'))
|
|
self.assertEqual('Failed to parse foo: foobar', msg)
|
|
|
|
|
|
class BaseTestCase(base.BaseTestCase):
|
|
|
|
class TestConfigOpts(cfg.ConfigOpts):
|
|
def __call__(self, args=None, default_config_files=[],
|
|
default_config_dirs=[], usage=None):
|
|
return cfg.ConfigOpts.__call__(
|
|
self,
|
|
args=args,
|
|
prog='test',
|
|
version='1.0',
|
|
usage=usage,
|
|
description='somedesc',
|
|
epilog='tepilog',
|
|
default_config_files=default_config_files,
|
|
default_config_dirs=default_config_dirs,
|
|
validate_default_values=True)
|
|
|
|
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):
|
|
# create all the tempfiles in a tempdir
|
|
tmpdir = tempfile.mkdtemp()
|
|
path = os.path.join(tmpdir, basename + ext)
|
|
# the path can start with a subdirectory so create
|
|
# it if it doesn't exist yet
|
|
if not os.path.exists(os.path.dirname(path)):
|
|
os.makedirs(os.path.dirname(path))
|
|
else:
|
|
path = basename + ext
|
|
fd = os.open(path, os.O_CREAT | os.O_WRONLY)
|
|
tempfiles.append(path)
|
|
try:
|
|
os.write(fd, contents.encode('utf-8'))
|
|
finally:
|
|
os.close(fd)
|
|
return tempfiles
|
|
|
|
|
|
class UsageTestCase(BaseTestCase):
|
|
|
|
def test_print_usage(self):
|
|
f = io.StringIO()
|
|
self.conf([])
|
|
self.conf.print_usage(file=f)
|
|
self.assertIn(
|
|
'usage: test [-h] [--config-dir DIR] [--config-file PATH]\n\
|
|
[--shell_completion SHELL_COMPLETION] [--version]',
|
|
f.getvalue())
|
|
self.assertNotIn('somedesc', f.getvalue())
|
|
self.assertNotIn('tepilog', f.getvalue())
|
|
self.assertNotIn('optional:', f.getvalue())
|
|
|
|
def test_print_custom_usage(self):
|
|
conf = self.TestConfigOpts()
|
|
|
|
self.tempdirs = []
|
|
f = io.StringIO()
|
|
conf([], usage='%(prog)s FOO BAR')
|
|
conf.print_usage(file=f)
|
|
self.assertIn('usage: test FOO BAR', f.getvalue())
|
|
self.assertNotIn('somedesc', f.getvalue())
|
|
self.assertNotIn('tepilog', f.getvalue())
|
|
self.assertNotIn('optional:', f.getvalue())
|
|
|
|
def test_print_help(self):
|
|
f = io.StringIO()
|
|
self.conf([])
|
|
self.conf.print_help(file=f)
|
|
self.assertIn(
|
|
'usage: test [-h] [--config-dir DIR] [--config-file PATH]\n\
|
|
[--shell_completion SHELL_COMPLETION] [--version]',
|
|
f.getvalue())
|
|
self.assertIn('somedesc', f.getvalue())
|
|
self.assertIn('tepilog', f.getvalue())
|
|
self.assertNotIn('optional:', f.getvalue())
|
|
|
|
|
|
class HelpTestCase(BaseTestCase):
|
|
|
|
def test_print_help(self):
|
|
f = io.StringIO()
|
|
self.conf([])
|
|
self.conf.print_help(file=f)
|
|
self.assertIn(
|
|
'usage: test [-h] [--config-dir DIR] [--config-file PATH]\n\
|
|
[--shell_completion SHELL_COMPLETION] [--version]',
|
|
f.getvalue())
|
|
# argparse may generate two different help messages:
|
|
# - In Python >=3.10: "options:\n --version"
|
|
# - In Python <3.10: "optional arguments:"
|
|
self.assertRegex(f.getvalue(), 'option(s|al arguments):')
|
|
self.assertIn('-h, --help', f.getvalue())
|
|
|
|
def test_print_strOpt_with_choices_help(self):
|
|
f = io.StringIO()
|
|
cli_opts = [
|
|
cfg.StrOpt('aa', short='a', default='xx',
|
|
choices=['xx', 'yy', 'zz'],
|
|
help='StrOpt with choices.'),
|
|
cfg.StrOpt('bb', short='b', default='yy',
|
|
choices=[None, 'yy', 'zz'],
|
|
help='StrOpt with choices.'),
|
|
cfg.StrOpt('cc', short='c', default='zz',
|
|
choices=['', 'yy', 'zz'],
|
|
help='StrOpt with choices.'),
|
|
]
|
|
self.conf.register_cli_opts(cli_opts)
|
|
self.conf([])
|
|
self.conf.print_help(file=f)
|
|
self.assertIn(
|
|
'usage: test [-h] [--aa AA] [--bb BB] [--cc CC] '
|
|
'[--config-dir DIR]',
|
|
f.getvalue())
|
|
# argparse may generate two different help messages:
|
|
# - In Python >=3.10: "options:\n --version"
|
|
# - In Python <3.10: "optional arguments:"
|
|
self.assertRegex(f.getvalue(), 'option(s|al arguments):')
|
|
self.assertIn('-h, --help', f.getvalue())
|
|
self.assertIn('StrOpt with choices. Allowed values: xx, yy, zz',
|
|
f.getvalue())
|
|
self.assertIn('StrOpt with choices. Allowed values: <None>, yy, zz',
|
|
f.getvalue())
|
|
self.assertIn("StrOpt with choices. Allowed values: '', yy, zz",
|
|
f.getvalue())
|
|
|
|
def test_print_sorted_help(self):
|
|
f = io.StringIO()
|
|
self.conf.register_cli_opt(cfg.StrOpt('abc'))
|
|
self.conf.register_cli_opt(cfg.StrOpt('zba'))
|
|
self.conf.register_cli_opt(cfg.StrOpt('ghi'))
|
|
self.conf.register_cli_opt(cfg.StrOpt('deb'))
|
|
self.conf([])
|
|
self.conf.print_help(file=f)
|
|
zba = f.getvalue().find('--zba')
|
|
abc = f.getvalue().find('--abc')
|
|
ghi = f.getvalue().find('--ghi')
|
|
deb = f.getvalue().find('--deb')
|
|
list = [abc, deb, ghi, zba]
|
|
self.assertEqual(sorted(list), list)
|
|
|
|
def test_print_sorted_help_with_positionals(self):
|
|
f = io.StringIO()
|
|
self.conf.register_cli_opt(
|
|
cfg.StrOpt('pst', positional=True, required=False))
|
|
self.conf.register_cli_opt(cfg.StrOpt('abc'))
|
|
self.conf.register_cli_opt(cfg.StrOpt('zba'))
|
|
self.conf.register_cli_opt(cfg.StrOpt('ghi'))
|
|
self.conf([])
|
|
self.conf.print_help(file=f)
|
|
zba = f.getvalue().find('--zba')
|
|
abc = f.getvalue().find('--abc')
|
|
ghi = f.getvalue().find('--ghi')
|
|
list = [abc, ghi, zba]
|
|
self.assertEqual(sorted(list), list)
|
|
|
|
def test_print_help_with_deprecated(self):
|
|
f = io.StringIO()
|
|
abc = cfg.StrOpt('a-bc',
|
|
deprecated_opts=[cfg.DeprecatedOpt('d-ef')])
|
|
uvw = cfg.StrOpt('u-vw',
|
|
deprecated_name='x-yz')
|
|
|
|
self.conf.register_cli_opt(abc)
|
|
self.conf.register_cli_opt(uvw)
|
|
self.conf([])
|
|
self.conf.print_help(file=f)
|
|
if sys.version_info >= (3, 13):
|
|
self.assertIn('--a-bc, --d-ef, --d_ef A_BC', f.getvalue())
|
|
self.assertIn('--u-vw, --x-yz, --x_yz U_VW', f.getvalue())
|
|
else:
|
|
self.assertIn('--a-bc A_BC, --d-ef A_BC, --d_ef A_BC',
|
|
f.getvalue())
|
|
self.assertIn('--u-vw U_VW, --x-yz U_VW, --x_yz U_VW',
|
|
f.getvalue())
|
|
|
|
|
|
class FindConfigFilesTestCase(BaseTestCase):
|
|
|
|
def test_find_config_files(self):
|
|
config_files = [
|
|
os.path.expanduser('~/.blaa/blaa.conf'),
|
|
'/etc/foo.conf',
|
|
]
|
|
|
|
self.useFixture(fixtures.MonkeyPatch('sys.argv', ['foo']))
|
|
self.useFixture(fixtures.MonkeyPatch('os.path.exists',
|
|
lambda p: p in config_files))
|
|
|
|
self.assertEqual(cfg.find_config_files(project='blaa'), config_files)
|
|
|
|
def test_find_config_files_overrides(self):
|
|
"""Ensure priority of directories is enforced.
|
|
|
|
Ensure we will only ever return two files: $project.conf and
|
|
$prog.conf.
|
|
"""
|
|
config_files = [
|
|
os.path.expanduser('~/.foo/foo.conf'),
|
|
# no '~/.foo/bar.conf' to make sure we fall through
|
|
os.path.expanduser('~/foo.conf'),
|
|
os.path.expanduser('~/bar.conf'),
|
|
'/etc/foo/foo.conf',
|
|
'/etc/foo/bar.conf',
|
|
'/etc/foo.conf',
|
|
'/etc/bar.conf',
|
|
]
|
|
|
|
self.useFixture(fixtures.MonkeyPatch(
|
|
'os.path.exists', lambda p: p in config_files))
|
|
|
|
expected = [
|
|
os.path.expanduser('~/.foo/foo.conf'),
|
|
os.path.expanduser('~/bar.conf'),
|
|
]
|
|
actual = cfg.find_config_files(project='foo', prog='bar')
|
|
self.assertEqual(expected, actual)
|
|
|
|
def test_find_config_files_snap(self):
|
|
config_files = [
|
|
'/snap/nova/current/etc/blaa/blaa.conf',
|
|
'/var/snap/nova/common/etc/blaa/blaa.conf',
|
|
]
|
|
fake_env = {
|
|
'SNAP': '/snap/nova/current/',
|
|
'SNAP_COMMON': '/var/snap/nova/common/',
|
|
}
|
|
|
|
self.useFixture(fixtures.MonkeyPatch('sys.argv', ['foo']))
|
|
self.useFixture(fixtures.MonkeyPatch('os.path.exists',
|
|
lambda p: p in config_files))
|
|
self.useFixture(fixtures.MonkeyPatch('os.environ', fake_env))
|
|
|
|
self.assertEqual(cfg.find_config_files(project='blaa'),
|
|
['/var/snap/nova/common/etc/blaa/blaa.conf'])
|
|
|
|
def test_find_config_files_with_extension(self):
|
|
config_files = ['/etc/foo.json']
|
|
|
|
self.useFixture(fixtures.MonkeyPatch('sys.argv', ['foo']))
|
|
self.useFixture(fixtures.MonkeyPatch('os.path.exists',
|
|
lambda p: p in config_files))
|
|
|
|
self.assertEqual(cfg.find_config_files(project='blaa'), [])
|
|
self.assertEqual(cfg.find_config_files(project='blaa',
|
|
extension='.json'),
|
|
config_files)
|
|
|
|
|
|
class FindConfigDirsTestCase(BaseTestCase):
|
|
|
|
def test_find_config_dirs(self):
|
|
config_dirs = [os.path.expanduser('~/.blaa/blaa.conf.d'),
|
|
'/etc/foo.conf.d']
|
|
|
|
self.useFixture(fixtures.MonkeyPatch('sys.argv', ['foo']))
|
|
self.useFixture(fixtures.MonkeyPatch('os.path.exists',
|
|
lambda p: p in config_dirs))
|
|
|
|
self.assertEqual(cfg.find_config_dirs(project='blaa'), config_dirs)
|
|
|
|
def test_find_config_dirs_snap(self):
|
|
config_dirs = ['/var/snap/nova/common/etc/blaa/blaa.conf.d']
|
|
fake_env = {'SNAP': '/snap/nova/current/',
|
|
'SNAP_COMMON': '/var/snap/nova/common/'}
|
|
|
|
self.useFixture(fixtures.MonkeyPatch('sys.argv', ['foo']))
|
|
self.useFixture(fixtures.MonkeyPatch('os.path.exists',
|
|
lambda p: p in config_dirs))
|
|
self.useFixture(fixtures.MonkeyPatch('os.environ', fake_env))
|
|
|
|
self.assertEqual(cfg.find_config_dirs(project='blaa'), config_dirs)
|
|
|
|
def test_find_config_dirs_non_exists(self):
|
|
self.useFixture(fixtures.MonkeyPatch('sys.argv', ['foo']))
|
|
self.assertEqual(cfg.find_config_dirs(project='blaa'), [])
|
|
|
|
def test_find_config_dirs_with_extension(self):
|
|
config_dirs = ['/etc/foo.json.d']
|
|
|
|
self.useFixture(fixtures.MonkeyPatch('sys.argv', ['foo']))
|
|
self.useFixture(fixtures.MonkeyPatch('os.path.exists',
|
|
lambda p: p in config_dirs))
|
|
|
|
self.assertEqual(cfg.find_config_dirs(project='blaa'), [])
|
|
self.assertEqual(cfg.find_config_dirs(project='blaa',
|
|
extension='.json.d'),
|
|
config_dirs)
|
|
|
|
|
|
class DefaultConfigFilesTestCase(BaseTestCase):
|
|
|
|
def test_use_default(self):
|
|
self.conf.register_opt(cfg.StrOpt('foo'))
|
|
paths = self.create_tempfiles([('foo-', '[DEFAULT]\n''foo = bar\n')])
|
|
|
|
self.conf.register_cli_opt(cfg.StrOpt('config-file-foo'))
|
|
self.conf(args=['--config-file-foo', 'foo.conf'],
|
|
default_config_files=[paths[0]])
|
|
|
|
self.assertEqual([paths[0]], self.conf.config_file)
|
|
self.assertEqual('bar', self.conf.foo)
|
|
|
|
def test_do_not_use_default_multi_arg(self):
|
|
self.conf.register_opt(cfg.StrOpt('foo'))
|
|
paths = self.create_tempfiles([('foo-', '[DEFAULT]\n''foo = bar\n')])
|
|
|
|
self.conf(args=['--config-file', paths[0]],
|
|
default_config_files=['bar.conf'])
|
|
|
|
self.assertEqual([paths[0]], self.conf.config_file)
|
|
self.assertEqual('bar', self.conf.foo)
|
|
|
|
def test_do_not_use_default_single_arg(self):
|
|
self.conf.register_opt(cfg.StrOpt('foo'))
|
|
paths = self.create_tempfiles([('foo-', '[DEFAULT]\n''foo = bar\n')])
|
|
|
|
self.conf(args=['--config-file=' + paths[0]],
|
|
default_config_files=['bar.conf'])
|
|
|
|
self.assertEqual([paths[0]], self.conf.config_file)
|
|
self.assertEqual('bar', self.conf.foo)
|
|
|
|
def test_no_default_config_file(self):
|
|
self.conf(args=[])
|
|
self.assertEqual([], self.conf.config_file)
|
|
|
|
def test_find_default_config_file(self):
|
|
paths = self.create_tempfiles([('def', '[DEFAULT]')])
|
|
|
|
self.useFixture(fixtures.MonkeyPatch(
|
|
'oslo_config.cfg.find_config_files',
|
|
lambda project, prog: paths))
|
|
|
|
self.conf(args=[], default_config_files=None)
|
|
self.assertEqual(paths, self.conf.config_file)
|
|
|
|
def test_default_config_file(self):
|
|
paths = self.create_tempfiles([('def', '[DEFAULT]')])
|
|
|
|
self.conf(args=[], default_config_files=paths)
|
|
|
|
self.assertEqual(paths, self.conf.config_file)
|
|
|
|
def test_default_config_file_with_value(self):
|
|
self.conf.register_cli_opt(cfg.StrOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('def', '[DEFAULT]\n''foo = bar\n')])
|
|
|
|
self.conf(args=[], default_config_files=paths)
|
|
|
|
self.assertEqual(paths, self.conf.config_file)
|
|
self.assertEqual('bar', self.conf.foo)
|
|
|
|
def test_default_config_file_priority(self):
|
|
self.conf.register_cli_opt(cfg.StrOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('def', '[DEFAULT]\n''foo = bar\n')])
|
|
|
|
self.conf(args=['--foo=blaa'], default_config_files=paths)
|
|
|
|
self.assertEqual(paths, self.conf.config_file)
|
|
self.assertEqual('blaa', self.conf.foo)
|
|
|
|
|
|
class DefaultConfigDirsTestCase(BaseTestCase):
|
|
|
|
def test_use_default(self):
|
|
self.conf.register_opt(cfg.StrOpt('foo'))
|
|
paths = self.create_tempfiles([('foo.conf.d/foo',
|
|
'[DEFAULT]\n''foo = bar\n')])
|
|
p = os.path.dirname(paths[0])
|
|
self.conf.register_cli_opt(cfg.StrOpt('config-dir-foo'))
|
|
self.conf(args=['--config-dir-foo', 'foo.conf.d'],
|
|
default_config_dirs=[p])
|
|
|
|
self.assertEqual([p], self.conf.config_dir)
|
|
self.assertEqual('bar', self.conf.foo)
|
|
|
|
def test_do_not_use_default_multi_arg(self):
|
|
self.conf.register_opt(cfg.StrOpt('foo'))
|
|
paths = self.create_tempfiles([('foo.conf.d/foo',
|
|
'[DEFAULT]\n''foo = bar\n')])
|
|
p = os.path.dirname(paths[0])
|
|
self.conf(args=['--config-dir', p],
|
|
default_config_dirs=['bar.conf.d'])
|
|
|
|
self.assertEqual([p], self.conf.config_dirs)
|
|
self.assertEqual('bar', self.conf.foo)
|
|
|
|
def test_do_not_use_default_single_arg(self):
|
|
self.conf.register_opt(cfg.StrOpt('foo'))
|
|
paths = self.create_tempfiles([('foo.conf.d/foo',
|
|
'[DEFAULT]\n''foo = bar\n')])
|
|
p = os.path.dirname(paths[0])
|
|
self.conf(args=['--config-dir=' + p],
|
|
default_config_dirs=['bar.conf.d'])
|
|
|
|
self.assertEqual([p], self.conf.config_dir)
|
|
self.assertEqual('bar', self.conf.foo)
|
|
|
|
def test_no_default_config_dir(self):
|
|
self.conf(args=[])
|
|
self.assertEqual([], self.conf.config_dir)
|
|
|
|
def test_find_default_config_dir(self):
|
|
paths = self.create_tempfiles([('def.conf.d/def',
|
|
'[DEFAULT]')])
|
|
p = os.path.dirname(paths[0])
|
|
self.useFixture(fixtures.MonkeyPatch(
|
|
'oslo_config.cfg.find_config_dirs',
|
|
lambda project, prog: p))
|
|
|
|
self.conf(args=[], default_config_dirs=None)
|
|
self.assertEqual([p], self.conf.config_dir)
|
|
|
|
def test_default_config_dir(self):
|
|
paths = self.create_tempfiles([('def.conf.d/def',
|
|
'[DEFAULT]')])
|
|
p = os.path.dirname(paths[0])
|
|
self.conf(args=[], default_config_dirs=[p])
|
|
|
|
self.assertEqual([p], self.conf.config_dir)
|
|
|
|
def test_default_config_dir_with_value(self):
|
|
self.conf.register_cli_opt(cfg.StrOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('def.conf.d/def',
|
|
'[DEFAULT]\n''foo = bar\n')])
|
|
p = os.path.dirname(paths[0])
|
|
self.conf(args=[], default_config_dirs=[p])
|
|
|
|
self.assertEqual([p], self.conf.config_dir)
|
|
self.assertEqual('bar', self.conf.foo)
|
|
|
|
def test_default_config_dir_priority(self):
|
|
self.conf.register_cli_opt(cfg.StrOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('def.conf.d/def',
|
|
'[DEFAULT]\n''foo = bar\n')])
|
|
p = os.path.dirname(paths[0])
|
|
self.conf(args=['--foo=blaa'], default_config_dirs=[p])
|
|
|
|
self.assertEqual([p], self.conf.config_dir)
|
|
self.assertEqual('blaa', self.conf.foo)
|
|
|
|
|
|
class CliOptsTestCase(BaseTestCase):
|
|
"""Test CLI Options.
|
|
|
|
Each test scenario takes a name for the scenarios, as well as a dict:
|
|
opt_class - class of the type of option that should be tested
|
|
default - a default value for the option
|
|
cli_args - a list containing a representation of an input command line
|
|
value - the result value that is expected to be found
|
|
deps - a tuple of deprecated name/group
|
|
"""
|
|
|
|
IPv4Opt = functools.partial(cfg.IPOpt, version=4)
|
|
IPv6Opt = functools.partial(cfg.IPOpt, version=6)
|
|
|
|
multi_int = functools.partial(cfg.MultiOpt, item_type=types.Integer())
|
|
multi_float = functools.partial(cfg.MultiOpt, item_type=types.Float())
|
|
multi_string = functools.partial(cfg.MultiOpt, item_type=types.String())
|
|
|
|
scenarios = [
|
|
('str_default',
|
|
dict(opt_class=cfg.StrOpt, default=None, cli_args=[], value=None,
|
|
deps=(None, None))),
|
|
('str_arg',
|
|
dict(opt_class=cfg.StrOpt, default=None, cli_args=['--foo', 'bar'],
|
|
value='bar', deps=(None, None))),
|
|
('str_arg_deprecated_name',
|
|
dict(opt_class=cfg.StrOpt, default=None,
|
|
cli_args=['--oldfoo', 'bar'], value='bar',
|
|
deps=('oldfoo', None))),
|
|
('str_arg_deprecated_group',
|
|
dict(opt_class=cfg.StrOpt, default=None,
|
|
cli_args=['--old-foo', 'bar'], value='bar',
|
|
deps=(None, 'old'))),
|
|
('str_arg_deprecated_group_default',
|
|
dict(opt_class=cfg.StrOpt, default=None, cli_args=['--foo', 'bar'],
|
|
value='bar', deps=(None, 'DEFAULT'))),
|
|
('str_arg_deprecated_group_and_name',
|
|
dict(opt_class=cfg.StrOpt, default=None,
|
|
cli_args=['--old-oof', 'bar'], value='bar',
|
|
deps=('oof', 'old'))),
|
|
('bool_default',
|
|
dict(opt_class=cfg.BoolOpt, default=False,
|
|
cli_args=[], value=False, deps=(None, None))),
|
|
('bool_arg',
|
|
dict(opt_class=cfg.BoolOpt, default=None,
|
|
cli_args=['--foo'], value=True, deps=(None, None))),
|
|
('bool_arg_deprecated_name',
|
|
dict(opt_class=cfg.BoolOpt, default=None,
|
|
cli_args=['--oldfoo'], value=True,
|
|
deps=('oldfoo', None))),
|
|
('bool_arg_deprecated_group',
|
|
dict(opt_class=cfg.BoolOpt, default=None,
|
|
cli_args=['--old-foo'], value=True,
|
|
deps=(None, 'old'))),
|
|
('bool_arg_deprecated_group_default',
|
|
dict(opt_class=cfg.BoolOpt, default=None,
|
|
cli_args=['--foo'], value=True,
|
|
deps=(None, 'DEFAULT'))),
|
|
('bool_arg_deprecated_group_and_name',
|
|
dict(opt_class=cfg.BoolOpt, default=None,
|
|
cli_args=['--old-oof'], value=True,
|
|
deps=('oof', 'old'))),
|
|
('bool_arg_inverse',
|
|
dict(opt_class=cfg.BoolOpt, default=None,
|
|
cli_args=['--foo', '--nofoo'], value=False, deps=(None, None))),
|
|
('bool_arg_inverse_deprecated_name',
|
|
dict(opt_class=cfg.BoolOpt, default=None,
|
|
cli_args=['--oldfoo', '--nooldfoo'], value=False,
|
|
deps=('oldfoo', None))),
|
|
('bool_arg_inverse_deprecated_group',
|
|
dict(opt_class=cfg.BoolOpt, default=None,
|
|
cli_args=['--old-foo', '--old-nofoo'], value=False,
|
|
deps=(None, 'old'))),
|
|
('bool_arg_inverse_deprecated_group_default',
|
|
dict(opt_class=cfg.BoolOpt, default=None,
|
|
cli_args=['--foo', '--nofoo'], value=False,
|
|
deps=(None, 'DEFAULT'))),
|
|
('bool_arg_inverse_deprecated_group_and_name',
|
|
dict(opt_class=cfg.BoolOpt, default=None,
|
|
cli_args=['--old-oof', '--old-nooof'], value=False,
|
|
deps=('oof', 'old'))),
|
|
('int_default',
|
|
dict(opt_class=cfg.IntOpt, default=10,
|
|
cli_args=[], value=10, deps=(None, None))),
|
|
('int_arg',
|
|
dict(opt_class=cfg.IntOpt, default=None,
|
|
cli_args=['--foo=20'], value=20, deps=(None, None))),
|
|
('int_arg_deprecated_name',
|
|
dict(opt_class=cfg.IntOpt, default=None,
|
|
cli_args=['--oldfoo=20'], value=20, deps=('oldfoo', None))),
|
|
('int_arg_deprecated_group',
|
|
dict(opt_class=cfg.IntOpt, default=None,
|
|
cli_args=['--old-foo=20'], value=20, deps=(None, 'old'))),
|
|
('int_arg_deprecated_group_default',
|
|
dict(opt_class=cfg.IntOpt, default=None,
|
|
cli_args=['--foo=20'], value=20, deps=(None, 'DEFAULT'))),
|
|
('int_arg_deprecated_group_and_name',
|
|
dict(opt_class=cfg.IntOpt, default=None,
|
|
cli_args=['--old-oof=20'], value=20, deps=('oof', 'old'))),
|
|
('float_default',
|
|
dict(opt_class=cfg.FloatOpt, default=1.0,
|
|
cli_args=[], value=1.0, deps=(None, None))),
|
|
('float_arg',
|
|
dict(opt_class=cfg.FloatOpt, default=None,
|
|
cli_args=['--foo', '2.0'], value=2.0, deps=(None, None))),
|
|
('float_arg_deprecated_name',
|
|
dict(opt_class=cfg.FloatOpt, default=None,
|
|
cli_args=['--oldfoo', '2.0'], value=2.0, deps=('oldfoo', None))),
|
|
('float_arg_deprecated_group',
|
|
dict(opt_class=cfg.FloatOpt, default=None,
|
|
cli_args=['--old-foo', '2.0'], value=2.0, deps=(None, 'old'))),
|
|
('float_arg_deprecated_group_default',
|
|
dict(opt_class=cfg.FloatOpt, default=None,
|
|
cli_args=['--foo', '2.0'], value=2.0, deps=(None, 'DEFAULT'))),
|
|
('float_arg_deprecated_group_and_name',
|
|
dict(opt_class=cfg.FloatOpt, default=None,
|
|
cli_args=['--old-oof', '2.0'], value=2.0, deps=('oof', 'old'))),
|
|
('float_default_as_integer',
|
|
dict(opt_class=cfg.FloatOpt, default=2,
|
|
cli_args=['--old-oof', '2.0'], value=2.0, deps=('oof', 'old'))),
|
|
('ipv4addr_arg',
|
|
dict(opt_class=IPv4Opt, default=None,
|
|
cli_args=['--foo', '192.168.0.1'], value='192.168.0.1',
|
|
deps=(None, None))),
|
|
('ipaddr_arg_implicitv4',
|
|
dict(opt_class=cfg.IPOpt, default=None,
|
|
cli_args=['--foo', '192.168.0.1'], value='192.168.0.1',
|
|
deps=(None, None))),
|
|
('ipaddr_arg_implicitv6',
|
|
dict(opt_class=cfg.IPOpt, default=None,
|
|
cli_args=['--foo', 'abcd:ef::1'], value='abcd:ef::1',
|
|
deps=(None, None))),
|
|
('ipv6addr_arg',
|
|
dict(opt_class=IPv6Opt, default=None,
|
|
cli_args=['--foo', 'abcd:ef::1'], value='abcd:ef::1',
|
|
deps=(None, None))),
|
|
('list_default',
|
|
dict(opt_class=cfg.ListOpt, default=['bar'],
|
|
cli_args=[], value=['bar'], deps=(None, None))),
|
|
('list_arg',
|
|
dict(opt_class=cfg.ListOpt, default=None,
|
|
cli_args=['--foo', 'blaa,bar'], value=['blaa', 'bar'],
|
|
deps=(None, None))),
|
|
('list_arg_with_spaces',
|
|
dict(opt_class=cfg.ListOpt, default=None,
|
|
cli_args=['--foo', 'blaa ,bar'], value=['blaa', 'bar'],
|
|
deps=(None, None))),
|
|
('list_arg_deprecated_name',
|
|
dict(opt_class=cfg.ListOpt, default=None,
|
|
cli_args=['--oldfoo', 'blaa,bar'], value=['blaa', 'bar'],
|
|
deps=('oldfoo', None))),
|
|
('list_arg_deprecated_group',
|
|
dict(opt_class=cfg.ListOpt, default=None,
|
|
cli_args=['--old-foo', 'blaa,bar'], value=['blaa', 'bar'],
|
|
deps=(None, 'old'))),
|
|
('list_arg_deprecated_group_default',
|
|
dict(opt_class=cfg.ListOpt, default=None,
|
|
cli_args=['--foo', 'blaa,bar'], value=['blaa', 'bar'],
|
|
deps=(None, 'DEFAULT'))),
|
|
('list_arg_deprecated_group_and_name',
|
|
dict(opt_class=cfg.ListOpt, default=None,
|
|
cli_args=['--old-oof', 'blaa,bar'], value=['blaa', 'bar'],
|
|
deps=('oof', 'old'))),
|
|
('dict_default',
|
|
dict(opt_class=cfg.DictOpt, default={'foo': 'bar'},
|
|
cli_args=[], value={'foo': 'bar'}, deps=(None, None))),
|
|
('dict_arg',
|
|
dict(opt_class=cfg.DictOpt, default=None,
|
|
cli_args=['--foo', 'key1:blaa,key2:bar'],
|
|
value={'key1': 'blaa', 'key2': 'bar'}, deps=(None, None))),
|
|
('dict_arg_multiple_keys_last_wins',
|
|
dict(opt_class=cfg.DictOpt, default=None,
|
|
cli_args=['--foo', 'key1:blaa', '--foo', 'key2:bar'],
|
|
value={'key2': 'bar'}, deps=(None, None))),
|
|
('dict_arg_with_spaces',
|
|
dict(opt_class=cfg.DictOpt, default=None,
|
|
cli_args=['--foo', 'key1:blaa ,key2:bar'],
|
|
value={'key1': 'blaa', 'key2': 'bar'}, deps=(None, None))),
|
|
('dict_arg_deprecated_name',
|
|
dict(opt_class=cfg.DictOpt, default=None,
|
|
cli_args=['--oldfoo', 'key1:blaa', '--oldfoo', 'key2:bar'],
|
|
value={'key2': 'bar'}, deps=('oldfoo', None))),
|
|
('dict_arg_deprecated_group',
|
|
dict(opt_class=cfg.DictOpt, default=None,
|
|
cli_args=['--old-foo', 'key1:blaa,key2:bar'],
|
|
value={'key1': 'blaa', 'key2': 'bar'}, deps=(None, 'old'))),
|
|
('dict_arg_deprecated_group2',
|
|
dict(opt_class=cfg.DictOpt, default=None,
|
|
cli_args=['--old-foo', 'key1:blaa', '--old-foo', 'key2:bar'],
|
|
value={'key2': 'bar'}, deps=(None, 'old'))),
|
|
('dict_arg_deprecated_group_default',
|
|
dict(opt_class=cfg.DictOpt, default=None,
|
|
cli_args=['--foo', 'key1:blaa', '--foo', 'key2:bar'],
|
|
value={'key2': 'bar'}, deps=(None, 'DEFAULT'))),
|
|
('dict_arg_deprecated_group_and_name',
|
|
dict(opt_class=cfg.DictOpt, default=None,
|
|
cli_args=['--old-oof', 'key1:blaa,key2:bar'],
|
|
value={'key1': 'blaa', 'key2': 'bar'}, deps=('oof', 'old'))),
|
|
('dict_arg_deprecated_group_and_name2',
|
|
dict(opt_class=cfg.DictOpt, default=None,
|
|
cli_args=['--old-oof', 'key1:blaa', '--old-oof', 'key2:bar'],
|
|
value={'key2': 'bar'}, deps=('oof', 'old'))),
|
|
('port_default',
|
|
dict(opt_class=cfg.PortOpt, default=80,
|
|
cli_args=[], value=80, deps=(None, None))),
|
|
('port_arg',
|
|
dict(opt_class=cfg.PortOpt, default=None,
|
|
cli_args=['--foo=80'], value=80, deps=(None, None))),
|
|
('port_arg_deprecated_name',
|
|
dict(opt_class=cfg.PortOpt, default=None,
|
|
cli_args=['--oldfoo=80'], value=80, deps=('oldfoo', None))),
|
|
('port_arg_deprecated_group',
|
|
dict(opt_class=cfg.PortOpt, default=None,
|
|
cli_args=['--old-foo=80'], value=80, deps=(None, 'old'))),
|
|
('port_arg_deprecated_group_default',
|
|
dict(opt_class=cfg.PortOpt, default=None,
|
|
cli_args=['--foo=80'], value=80, deps=(None, 'DEFAULT'))),
|
|
('port_arg_deprecated_group_and_name',
|
|
dict(opt_class=cfg.PortOpt, default=None,
|
|
cli_args=['--old-oof=80'], value=80, deps=('oof', 'old'))),
|
|
('uri_default',
|
|
dict(opt_class=cfg.URIOpt, default='http://example.com',
|
|
cli_args=[], value='http://example.com', deps=(None, None))),
|
|
('uri_arg',
|
|
dict(opt_class=cfg.URIOpt, default=None,
|
|
cli_args=['--foo', 'http://example.com'],
|
|
value='http://example.com', deps=(None, None))),
|
|
('multistr_default',
|
|
dict(opt_class=cfg.MultiStrOpt, default=['bar'], cli_args=[],
|
|
value=['bar'], deps=(None, None))),
|
|
('multistr_arg',
|
|
dict(opt_class=cfg.MultiStrOpt, default=None,
|
|
cli_args=['--foo', 'blaa', '--foo', 'bar'],
|
|
value=['blaa', 'bar'], deps=(None, None))),
|
|
('multistr_arg_deprecated_name',
|
|
dict(opt_class=cfg.MultiStrOpt, default=None,
|
|
cli_args=['--oldfoo', 'blaa', '--oldfoo', 'bar'],
|
|
value=['blaa', 'bar'], deps=('oldfoo', None))),
|
|
('multistr_arg_deprecated_group',
|
|
dict(opt_class=cfg.MultiStrOpt, default=None,
|
|
cli_args=['--old-foo', 'blaa', '--old-foo', 'bar'],
|
|
value=['blaa', 'bar'], deps=(None, 'old'))),
|
|
('multistr_arg_deprecated_group_default',
|
|
dict(opt_class=cfg.MultiStrOpt, default=None,
|
|
cli_args=['--foo', 'blaa', '--foo', 'bar'],
|
|
value=['blaa', 'bar'], deps=(None, 'DEFAULT'))),
|
|
('multistr_arg_deprecated_group_and_name',
|
|
dict(opt_class=cfg.MultiStrOpt, default=None,
|
|
cli_args=['--old-oof', 'blaa', '--old-oof', 'bar'],
|
|
value=['blaa', 'bar'], deps=('oof', 'old'))),
|
|
('multiopt_arg_int',
|
|
dict(opt_class=multi_int, default=None,
|
|
cli_args=['--foo', '1', '--foo', '2'],
|
|
value=[1, 2], deps=(None, None))),
|
|
('multiopt_float_int',
|
|
dict(opt_class=multi_float, default=None,
|
|
cli_args=['--foo', '1.2', '--foo', '2.3'],
|
|
value=[1.2, 2.3], deps=(None, None))),
|
|
('multiopt_string',
|
|
dict(opt_class=multi_string, default=None,
|
|
cli_args=['--foo', 'bar', '--foo', 'baz'],
|
|
value=["bar", "baz"], deps=(None, None))),
|
|
]
|
|
|
|
def test_cli(self):
|
|
|
|
self.conf.register_cli_opt(
|
|
self.opt_class('foo', default=self.default,
|
|
deprecated_name=self.deps[0],
|
|
deprecated_group=self.deps[1]))
|
|
|
|
self.conf(self.cli_args)
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEqual(self.value, self.conf.foo)
|
|
|
|
|
|
class CliSpecialOptsTestCase(BaseTestCase):
|
|
|
|
def test_help(self):
|
|
self.useFixture(fixtures.MonkeyPatch('sys.stdout', io.StringIO()))
|
|
self.assertRaises(SystemExit, self.conf, ['--help'])
|
|
self.assertIn('usage: test', sys.stdout.getvalue())
|
|
self.assertIn('[--version]', sys.stdout.getvalue())
|
|
self.assertIn('[-h]', sys.stdout.getvalue())
|
|
self.assertIn('--help', sys.stdout.getvalue())
|
|
self.assertIn('[--config-dir DIR]', sys.stdout.getvalue())
|
|
self.assertIn('[--config-file PATH]', sys.stdout.getvalue())
|
|
|
|
def test_version(self):
|
|
stream_name = 'stdout'
|
|
self.useFixture(fixtures.MonkeyPatch("sys.%s" % stream_name,
|
|
io.StringIO()))
|
|
self.assertRaises(SystemExit, self.conf, ['--version'])
|
|
self.assertIn('1.0', getattr(sys, stream_name).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.assertEqual(paths, self.conf.config_file)
|
|
|
|
|
|
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,
|
|
required=False))
|
|
|
|
self.conf(cli_args)
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEqual(value, self.conf.foo)
|
|
|
|
def test_positional_str_none_default(self):
|
|
self._do_pos_test(cfg.StrOpt, None, [], None)
|
|
|
|
def test_positional_str_default(self):
|
|
self._do_pos_test(cfg.StrOpt, 'bar', [], 'bar')
|
|
|
|
def test_positional_str_arg(self):
|
|
self._do_pos_test(cfg.StrOpt, None, ['bar'], 'bar')
|
|
|
|
def test_positional_int_none_default(self):
|
|
self._do_pos_test(cfg.IntOpt, None, [], None)
|
|
|
|
def test_positional_int_default(self):
|
|
self._do_pos_test(cfg.IntOpt, 10, [], 10)
|
|
|
|
def test_positional_int_arg(self):
|
|
self._do_pos_test(cfg.IntOpt, None, ['20'], 20)
|
|
|
|
def test_positional_float_none_default(self):
|
|
self._do_pos_test(cfg.FloatOpt, None, [], None)
|
|
|
|
def test_positional_float_default(self):
|
|
self._do_pos_test(cfg.FloatOpt, 1.0, [], 1.0)
|
|
|
|
def test_positional_float_arg(self):
|
|
self._do_pos_test(cfg.FloatOpt, None, ['2.0'], 2.0)
|
|
|
|
def test_positional_list_none_default(self):
|
|
self._do_pos_test(cfg.ListOpt, None, [], None)
|
|
|
|
def test_positional_list_empty_default(self):
|
|
self._do_pos_test(cfg.ListOpt, [], [], [])
|
|
|
|
def test_positional_list_default(self):
|
|
self._do_pos_test(cfg.ListOpt, ['bar'], [], ['bar'])
|
|
|
|
def test_positional_list_arg(self):
|
|
self._do_pos_test(cfg.ListOpt, None,
|
|
['blaa,bar'], ['blaa', 'bar'])
|
|
|
|
def test_positional_dict_none_default(self):
|
|
self._do_pos_test(cfg.DictOpt, None, [], None)
|
|
|
|
def test_positional_dict_empty_default(self):
|
|
self._do_pos_test(cfg.DictOpt, {}, [], {})
|
|
|
|
def test_positional_dict_default(self):
|
|
self._do_pos_test(cfg.DictOpt, {'key1': 'bar'}, [], {'key1': 'bar'})
|
|
|
|
def test_positional_dict_arg(self):
|
|
self._do_pos_test(cfg.DictOpt, None,
|
|
['key1:blaa,key2:bar'],
|
|
{'key1': 'blaa', 'key2': 'bar'})
|
|
|
|
def test_positional_ip_none_default(self):
|
|
self._do_pos_test(cfg.IPOpt, None, [], None)
|
|
|
|
def test_positional_ip_default(self):
|
|
self._do_pos_test(cfg.IPOpt, '127.0.0.1', [], '127.0.0.1')
|
|
|
|
def test_positional_ip_arg(self):
|
|
self._do_pos_test(cfg.IPOpt, None, ['127.0.0.1'], '127.0.0.1')
|
|
|
|
def test_positional_port_none_default(self):
|
|
self._do_pos_test(cfg.PortOpt, None, [], None)
|
|
|
|
def test_positional_port_default(self):
|
|
self._do_pos_test(cfg.PortOpt, 80, [], 80)
|
|
|
|
def test_positional_port_arg(self):
|
|
self._do_pos_test(cfg.PortOpt, None, ['443'], 443)
|
|
|
|
def test_positional_uri_default(self):
|
|
self._do_pos_test(cfg.URIOpt, 'http://example.com', [],
|
|
'http://example.com')
|
|
|
|
def test_positional_uri_none_default(self):
|
|
self._do_pos_test(cfg.URIOpt, None, [], None)
|
|
|
|
def test_positional_uri_arg(self):
|
|
self._do_pos_test(cfg.URIOpt, None, ['http://example.com'],
|
|
'http://example.com')
|
|
|
|
def test_positional_multistr_none_default(self):
|
|
self._do_pos_test(cfg.MultiStrOpt, None, [], None)
|
|
|
|
def test_positional_multistr_empty_default(self):
|
|
self._do_pos_test(cfg.MultiStrOpt, [], [], [])
|
|
|
|
def test_positional_multistr_default(self):
|
|
self._do_pos_test(cfg.MultiStrOpt, ['bar'], [], ['bar'])
|
|
|
|
def test_positional_multistr_arg(self):
|
|
self._do_pos_test(cfg.MultiStrOpt, None,
|
|
['blaa', 'bar'], ['blaa', 'bar'])
|
|
|
|
def test_positional_bool(self):
|
|
self.assertRaises(ValueError, cfg.BoolOpt, 'foo', positional=True)
|
|
|
|
def test_required_positional_opt_defined(self):
|
|
self.conf.register_cli_opt(
|
|
cfg.StrOpt('foo', required=True, positional=True))
|
|
|
|
self.useFixture(fixtures.MonkeyPatch('sys.stdout', io.StringIO()))
|
|
self.assertRaises(SystemExit, self.conf, ['--help'])
|
|
self.assertIn(' foo\n', sys.stdout.getvalue())
|
|
|
|
self.conf(['bar'])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEqual('bar', self.conf.foo)
|
|
|
|
def test_required_positional_opt_undefined(self):
|
|
self.conf.register_cli_opt(
|
|
cfg.StrOpt('foo', required=True, positional=True))
|
|
|
|
self.useFixture(fixtures.MonkeyPatch('sys.stdout', io.StringIO()))
|
|
self.assertRaises(SystemExit, self.conf, ['--help'])
|
|
self.assertIn(' foo\n', sys.stdout.getvalue())
|
|
|
|
self.assertRaises(SystemExit, self.conf, [])
|
|
|
|
def test_optional_positional_opt_defined(self):
|
|
self.conf.register_cli_opt(
|
|
cfg.StrOpt('foo', required=False, positional=True))
|
|
|
|
self.useFixture(fixtures.MonkeyPatch('sys.stdout', io.StringIO()))
|
|
self.assertRaises(SystemExit, self.conf, ['--help'])
|
|
self.assertIn(' [foo]\n', sys.stdout.getvalue())
|
|
|
|
self.conf(['bar'])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEqual('bar', self.conf.foo)
|
|
|
|
def test_optional_positional_opt_undefined(self):
|
|
self.conf.register_cli_opt(
|
|
cfg.StrOpt('foo', required=False, positional=True))
|
|
|
|
self.useFixture(fixtures.MonkeyPatch('sys.stdout', io.StringIO()))
|
|
self.assertRaises(SystemExit, self.conf, ['--help'])
|
|
self.assertIn(' [foo]\n', sys.stdout.getvalue())
|
|
|
|
self.conf([])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertIsNone(self.conf.foo)
|
|
|
|
def test_optional_positional_hyphenated_opt_defined(self):
|
|
self.conf.register_cli_opt(
|
|
cfg.StrOpt('foo-bar', required=False, positional=True))
|
|
|
|
self.useFixture(fixtures.MonkeyPatch('sys.stdout', io.StringIO()))
|
|
self.assertRaises(SystemExit, self.conf, ['--help'])
|
|
self.assertIn(' [foo_bar]\n', sys.stdout.getvalue())
|
|
|
|
self.conf(['baz'])
|
|
self.assertTrue(hasattr(self.conf, 'foo_bar'))
|
|
self.assertEqual('baz', self.conf.foo_bar)
|
|
|
|
def test_optional_positional_hyphenated_opt_undefined(self):
|
|
self.conf.register_cli_opt(
|
|
cfg.StrOpt('foo-bar', required=False, positional=True))
|
|
|
|
self.useFixture(fixtures.MonkeyPatch('sys.stdout', io.StringIO()))
|
|
self.assertRaises(SystemExit, self.conf, ['--help'])
|
|
self.assertIn(' [foo_bar]\n', sys.stdout.getvalue())
|
|
|
|
self.conf([])
|
|
self.assertTrue(hasattr(self.conf, 'foo_bar'))
|
|
self.assertIsNone(self.conf.foo_bar)
|
|
|
|
def test_required_positional_hyphenated_opt_defined(self):
|
|
self.conf.register_cli_opt(
|
|
cfg.StrOpt('foo-bar', required=True, positional=True))
|
|
|
|
self.useFixture(fixtures.MonkeyPatch('sys.stdout', io.StringIO()))
|
|
self.assertRaises(SystemExit, self.conf, ['--help'])
|
|
self.assertIn(' foo_bar\n', sys.stdout.getvalue())
|
|
|
|
self.conf(['baz'])
|
|
self.assertTrue(hasattr(self.conf, 'foo_bar'))
|
|
self.assertEqual('baz', self.conf.foo_bar)
|
|
|
|
def test_required_positional_hyphenated_opt_undefined(self):
|
|
self.conf.register_cli_opt(
|
|
cfg.StrOpt('foo-bar', required=True, positional=True))
|
|
|
|
self.useFixture(fixtures.MonkeyPatch('sys.stdout', io.StringIO()))
|
|
self.assertRaises(SystemExit, self.conf, ['--help'])
|
|
self.assertIn(' foo_bar\n', sys.stdout.getvalue())
|
|
|
|
self.assertRaises(SystemExit, self.conf, [])
|
|
|
|
def test_missing_required_cli_opt(self):
|
|
self.conf.register_cli_opt(
|
|
cfg.StrOpt('foo', required=True, positional=True))
|
|
self.assertRaises(SystemExit, self.conf, [])
|
|
|
|
def test_positional_opts_order(self):
|
|
self.conf.register_cli_opts((
|
|
cfg.StrOpt('command', positional=True),
|
|
cfg.StrOpt('arg1', positional=True),
|
|
cfg.StrOpt('arg2', positional=True))
|
|
)
|
|
|
|
self.conf(['command', 'arg1', 'arg2'])
|
|
|
|
self.assertEqual('command', self.conf.command)
|
|
self.assertEqual('arg1', self.conf.arg1)
|
|
self.assertEqual('arg2', self.conf.arg2)
|
|
|
|
def test_positional_opt_order(self):
|
|
self.conf.register_cli_opt(
|
|
cfg.StrOpt('command', positional=True))
|
|
self.conf.register_cli_opt(
|
|
cfg.StrOpt('arg1', positional=True))
|
|
self.conf.register_cli_opt(
|
|
cfg.StrOpt('arg2', positional=True))
|
|
|
|
self.conf(['command', 'arg1', 'arg2'])
|
|
|
|
self.assertEqual('command', self.conf.command)
|
|
self.assertEqual('arg1', self.conf.arg1)
|
|
self.assertEqual('arg2', self.conf.arg2)
|
|
|
|
def test_positional_opt_unregister(self):
|
|
command = cfg.StrOpt('command', positional=True)
|
|
arg1 = cfg.StrOpt('arg1', positional=True)
|
|
arg2 = cfg.StrOpt('arg2', positional=True)
|
|
self.conf.register_cli_opt(command)
|
|
self.conf.register_cli_opt(arg1)
|
|
self.conf.register_cli_opt(arg2)
|
|
|
|
self.conf(['command', 'arg1', 'arg2'])
|
|
|
|
self.assertEqual('command', self.conf.command)
|
|
self.assertEqual('arg1', self.conf.arg1)
|
|
self.assertEqual('arg2', self.conf.arg2)
|
|
|
|
self.conf.reset()
|
|
|
|
self.conf.unregister_opt(arg1)
|
|
self.conf.unregister_opt(arg2)
|
|
|
|
arg0 = cfg.StrOpt('arg0', positional=True)
|
|
self.conf.register_cli_opt(arg0)
|
|
self.conf.register_cli_opt(arg1)
|
|
|
|
self.conf(['command', 'arg0', 'arg1'])
|
|
|
|
self.assertEqual('command', self.conf.command)
|
|
self.assertEqual('arg0', self.conf.arg0)
|
|
self.assertEqual('arg1', self.conf.arg1)
|
|
|
|
|
|
# The real report_deprecated_feature has caching that causes races in our
|
|
# unit tests. This replicates the relevant functionality.
|
|
def _fake_deprecated_feature(logger, msg, *args, **kwargs):
|
|
stdmsg = 'Deprecated: %s' % msg
|
|
logger.warning(stdmsg, *args, **kwargs)
|
|
|
|
|
|
@mock.patch('oslo_log.versionutils.report_deprecated_feature',
|
|
_fake_deprecated_feature)
|
|
class ConfigFileOptsTestCase(BaseTestCase):
|
|
|
|
def setUp(self):
|
|
super(ConfigFileOptsTestCase, self).setUp()
|
|
self.logger = self.useFixture(
|
|
fixtures.FakeLogger(
|
|
format='%(message)s',
|
|
level=logging.WARNING,
|
|
nuke_handlers=True,
|
|
)
|
|
)
|
|
|
|
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.assertEqual(result, self.conf.newfoo)
|
|
|
|
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(cfg.StrOpt('foo', default='bar'))
|
|
|
|
paths = self.create_tempfiles([('test', '[DEFAULT]\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEqual('bar', self.conf.foo)
|
|
|
|
def test_conf_file_str_value(self):
|
|
self.conf.register_opt(cfg.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.assertEqual('bar', self.conf.foo)
|
|
|
|
def test_conf_file_str_value_override(self):
|
|
self.conf.register_cli_opt(cfg.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.assertEqual('baaar', self.conf.foo)
|
|
|
|
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(
|
|
cfg.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.assertTrue(hasattr(self.conf, 'oldfoo'))
|
|
self.assertEqual('last', self.conf.newfoo)
|
|
log_out = self.logger.output
|
|
self.assertIn('is deprecated', log_out)
|
|
self.assertIn('Use option "newfoo"', log_out)
|
|
|
|
def test_use_deprecated_for_removal_without_reason(self):
|
|
self.conf.register_cli_opt(
|
|
cfg.StrOpt('oldfoo',
|
|
deprecated_for_removal=True))
|
|
|
|
paths = self.create_tempfiles([('0',
|
|
'[DEFAULT]\n'
|
|
'oldfoo = middle\n')])
|
|
|
|
self.conf(['--oldfoo', 'first',
|
|
'--config-file', paths[0]])
|
|
|
|
log_out = self.logger.output
|
|
self.assertIn('deprecated for removal.', log_out)
|
|
|
|
def test_use_deprecated_for_removal_with_reason(self):
|
|
self.conf.register_cli_opt(
|
|
cfg.StrOpt('oldfoo',
|
|
deprecated_for_removal=True,
|
|
deprecated_reason='a very good reason'))
|
|
|
|
paths = self.create_tempfiles([('0',
|
|
'[DEFAULT]\n'
|
|
'oldfoo = middle\n')])
|
|
|
|
self.conf(['--oldfoo', 'first',
|
|
'--config-file', paths[0]])
|
|
|
|
log_out = self.logger.output
|
|
self.assertIn('deprecated for removal (a very good reason).', log_out)
|
|
|
|
def test_conf_file_str_use_dname(self):
|
|
self._do_dname_test_use(cfg.StrOpt, 'value1', 'value1')
|
|
|
|
def test_conf_file_str_use_dgroup(self):
|
|
self._do_dgroup_test_use(cfg.StrOpt, 'value1', 'value1')
|
|
|
|
def test_conf_file_str_use_default_dgroup(self):
|
|
self._do_default_dgroup_test_use(cfg.StrOpt, 'value1', 'value1')
|
|
|
|
def test_conf_file_str_use_dgroup_and_dname(self):
|
|
self._do_dgroup_and_dname_test_use(cfg.StrOpt, 'value1', 'value1')
|
|
|
|
def test_conf_file_str_ignore_dname(self):
|
|
self._do_dname_test_ignore(cfg.StrOpt, 'value2', 'value2')
|
|
|
|
def test_conf_file_str_ignore_dgroup(self):
|
|
self._do_dgroup_test_ignore(cfg.StrOpt, 'value2', 'value2')
|
|
|
|
def test_conf_file_str_ignore_dgroup_and_dname(self):
|
|
self._do_dgroup_and_dname_test_ignore(cfg.StrOpt, 'value2', 'value2')
|
|
|
|
def test_conf_file_str_value_with_good_choice_value(self):
|
|
self.conf.register_opt(cfg.StrOpt('foo', choices=['bar', 'baz']))
|
|
|
|
paths = self.create_tempfiles([('test', '[DEFAULT]\n''foo = bar\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEqual('bar', self.conf.foo)
|
|
|
|
def test_conf_file_bool_default_none(self):
|
|
self.conf.register_opt(cfg.BoolOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertIsNone(self.conf.foo)
|
|
|
|
def test_conf_file_bool_default_false(self):
|
|
self.conf.register_opt(cfg.BoolOpt('foo', default=False))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertFalse(self.conf.foo)
|
|
|
|
def test_conf_file_bool_value(self):
|
|
self.conf.register_opt(cfg.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.assertTrue(self.conf.foo)
|
|
|
|
def test_conf_file_bool_cli_value_override(self):
|
|
self.conf.register_cli_opt(cfg.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.assertFalse(self.conf.foo)
|
|
|
|
def test_conf_file_bool_cli_inverse_override(self):
|
|
self.conf.register_cli_opt(cfg.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.assertTrue(self.conf.foo)
|
|
|
|
def test_conf_file_bool_cli_order_override(self):
|
|
self.conf.register_cli_opt(cfg.BoolOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('1',
|
|
'[DEFAULT]\n'
|
|
'foo = false\n')])
|
|
|
|
self.conf(['--config-file', paths[0],
|
|
'--foo'])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertTrue(self.conf.foo)
|
|
|
|
def test_conf_file_bool_file_value_override(self):
|
|
self.conf.register_cli_opt(cfg.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.assertTrue(self.conf.foo)
|
|
|
|
def test_conf_file_bool_use_dname(self):
|
|
self._do_dname_test_use(cfg.BoolOpt, 'yes', True)
|
|
|
|
def test_conf_file_bool_use_dgroup(self):
|
|
self._do_dgroup_test_use(cfg.BoolOpt, 'yes', True)
|
|
|
|
def test_conf_file_bool_use_default_dgroup(self):
|
|
self._do_default_dgroup_test_use(cfg.BoolOpt, 'yes', True)
|
|
|
|
def test_conf_file_bool_use_dgroup_and_dname(self):
|
|
self._do_dgroup_and_dname_test_use(cfg.BoolOpt, 'yes', True)
|
|
|
|
def test_conf_file_bool_ignore_dname(self):
|
|
self._do_dname_test_ignore(cfg.BoolOpt, 'no', False)
|
|
|
|
def test_conf_file_bool_ignore_dgroup(self):
|
|
self._do_dgroup_test_ignore(cfg.BoolOpt, 'no', False)
|
|
|
|
def test_conf_file_bool_ignore_group_and_dname(self):
|
|
self._do_dgroup_and_dname_test_ignore(cfg.BoolOpt, 'no', False)
|
|
|
|
def test_conf_file_int_default(self):
|
|
self.conf.register_opt(cfg.IntOpt('foo', default=666))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEqual(666, self.conf.foo)
|
|
|
|
def test_conf_file_int_string_default_type(self):
|
|
self.conf.register_opt(cfg.IntOpt('foo', default='666'))
|
|
self.conf([])
|
|
self.assertEqual(666, self.conf.foo)
|
|
|
|
def test_conf_file_int_value(self):
|
|
self.conf.register_opt(cfg.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.assertEqual(666, self.conf.foo)
|
|
|
|
def test_conf_file_int_value_override(self):
|
|
self.conf.register_cli_opt(cfg.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.assertEqual(666, self.conf.foo)
|
|
|
|
def test_conf_file_int_min_max(self):
|
|
self.conf.register_opt(cfg.IntOpt('foo', min=1, max=5))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = 10\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
self.assertRaises(cfg.ConfigFileValueError, self.conf._get, 'foo')
|
|
|
|
def test_conf_file_int_min_greater_max(self):
|
|
self.assertRaises(ValueError, cfg.IntOpt, 'foo', min=5, max=1)
|
|
|
|
def test_conf_file_int_use_dname(self):
|
|
self._do_dname_test_use(cfg.IntOpt, '66', 66)
|
|
|
|
def test_conf_file_int_use_dgroup(self):
|
|
self._do_dgroup_test_use(cfg.IntOpt, '66', 66)
|
|
|
|
def test_conf_file_int_use_default_dgroup(self):
|
|
self._do_default_dgroup_test_use(cfg.IntOpt, '66', 66)
|
|
|
|
def test_conf_file_int_use_dgroup_and_dname(self):
|
|
self._do_dgroup_and_dname_test_use(cfg.IntOpt, '66', 66)
|
|
|
|
def test_conf_file_int_ignore_dname(self):
|
|
self._do_dname_test_ignore(cfg.IntOpt, '64', 64)
|
|
|
|
def test_conf_file_int_ignore_dgroup(self):
|
|
self._do_dgroup_test_ignore(cfg.IntOpt, '64', 64)
|
|
|
|
def test_conf_file_int_ignore_dgroup_and_dname(self):
|
|
self._do_dgroup_and_dname_test_ignore(cfg.IntOpt, '64', 64)
|
|
|
|
def test_conf_file_float_default(self):
|
|
self.conf.register_opt(cfg.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.assertEqual(6.66, self.conf.foo)
|
|
|
|
def test_conf_file_float_default_wrong_type(self):
|
|
self.assertRaises(cfg.DefaultValueError, cfg.FloatOpt, 'foo',
|
|
default='foobar6.66')
|
|
|
|
def test_conf_file_float_value(self):
|
|
self.conf.register_opt(cfg.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.assertEqual(6.66, self.conf.foo)
|
|
|
|
def test_conf_file_float_value_override(self):
|
|
self.conf.register_cli_opt(cfg.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.assertEqual(6.66, self.conf.foo)
|
|
|
|
def test_conf_file_float_use_dname(self):
|
|
self._do_dname_test_use(cfg.FloatOpt, '66.54', 66.54)
|
|
|
|
def test_conf_file_float_use_dgroup(self):
|
|
self._do_dgroup_test_use(cfg.FloatOpt, '66.54', 66.54)
|
|
|
|
def test_conf_file_float_use_default_dgroup(self):
|
|
self._do_default_dgroup_test_use(cfg.FloatOpt, '66.54', 66.54)
|
|
|
|
def test_conf_file_float_use_dgroup_and_dname(self):
|
|
self._do_dgroup_and_dname_test_use(cfg.FloatOpt, '66.54', 66.54)
|
|
|
|
def test_conf_file_float_ignore_dname(self):
|
|
self._do_dname_test_ignore(cfg.FloatOpt, '64.54', 64.54)
|
|
|
|
def test_conf_file_float_ignore_dgroup(self):
|
|
self._do_dgroup_test_ignore(cfg.FloatOpt, '64.54', 64.54)
|
|
|
|
def test_conf_file_float_ignore_dgroup_and_dname(self):
|
|
self._do_dgroup_and_dname_test_ignore(cfg.FloatOpt, '64.54', 64.54)
|
|
|
|
def test_conf_file_float_min_max_above_max(self):
|
|
self.conf.register_opt(cfg.FloatOpt('foo', min=1.1, max=5.5))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = 10.5\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
self.assertRaises(cfg.ConfigFileValueError, self.conf._get, 'foo')
|
|
|
|
def test_conf_file_float_only_max_above_max(self):
|
|
self.conf.register_opt(cfg.FloatOpt('foo', max=5.5))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = 10.5\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
self.assertRaises(cfg.ConfigFileValueError, self.conf._get, 'foo')
|
|
|
|
def test_conf_file_float_min_max_below_min(self):
|
|
self.conf.register_opt(cfg.FloatOpt('foo', min=1.1, max=5.5))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = 0.5\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
self.assertRaises(cfg.ConfigFileValueError, self.conf._get, 'foo')
|
|
|
|
def test_conf_file_float_only_min_below_min(self):
|
|
self.conf.register_opt(cfg.FloatOpt('foo', min=1.1))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = 0.5\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
self.assertRaises(cfg.ConfigFileValueError, self.conf._get, 'foo')
|
|
|
|
def test_conf_file_float_min_max_in_range(self):
|
|
self.conf.register_opt(cfg.FloatOpt('foo', min=1.1, max=5.5))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = 4.5\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEqual(4.5, self.conf.foo)
|
|
|
|
def test_conf_file_float_only_max_in_range(self):
|
|
self.conf.register_opt(cfg.FloatOpt('foo', max=5.5))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = 4.5\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEqual(4.5, self.conf.foo)
|
|
|
|
def test_conf_file_float_only_min_in_range(self):
|
|
self.conf.register_opt(cfg.FloatOpt('foo', min=3.5))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = 4.5\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEqual(4.5, self.conf.foo)
|
|
|
|
def test_conf_file_float_min_greater_max(self):
|
|
self.assertRaises(ValueError, cfg.FloatOpt, 'foo', min=5.5, max=1.5)
|
|
|
|
def test_conf_file_list_default(self):
|
|
self.conf.register_opt(cfg.ListOpt('foo', default=['bar']))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEqual(['bar'], self.conf.foo)
|
|
|
|
def test_conf_file_list_default_wrong_type(self):
|
|
self.assertRaises(cfg.DefaultValueError, cfg.ListOpt, 'foo',
|
|
default=25)
|
|
|
|
def test_conf_file_list_value(self):
|
|
self.conf.register_opt(cfg.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.assertEqual(['bar'], self.conf.foo)
|
|
|
|
def test_conf_file_list_value_override(self):
|
|
self.conf.register_cli_opt(cfg.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.assertEqual(['b', 'a', 'r'], self.conf.foo)
|
|
|
|
def test_conf_file_list_item_type(self):
|
|
self.conf.register_cli_opt(cfg.ListOpt('foo',
|
|
item_type=types.Integer()))
|
|
|
|
paths = self.create_tempfiles([('1',
|
|
'[DEFAULT]\n'
|
|
'foo = 1,2\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEqual([1, 2], self.conf.foo)
|
|
|
|
def test_conf_file_list_item_wrong_type(self):
|
|
self.assertRaises(cfg.DefaultValueError, cfg.ListOpt, 'foo',
|
|
default="bar", item_type=types.Integer())
|
|
|
|
def test_conf_file_list_bounds(self):
|
|
self.conf.register_cli_opt(cfg.ListOpt('foo',
|
|
item_type=types.Integer(),
|
|
default="[1,2]",
|
|
bounds=True))
|
|
self.conf([])
|
|
self.assertEqual([1, 2], self.conf.foo)
|
|
|
|
def test_conf_file_list_use_dname(self):
|
|
self._do_dname_test_use(cfg.ListOpt, 'a,b,c', ['a', 'b', 'c'])
|
|
|
|
def test_conf_file_list_use_dgroup(self):
|
|
self._do_dgroup_test_use(cfg.ListOpt, 'a,b,c', ['a', 'b', 'c'])
|
|
|
|
def test_conf_file_list_use_default_dgroup(self):
|
|
self._do_default_dgroup_test_use(cfg.ListOpt, 'a,b,c', ['a', 'b', 'c'])
|
|
|
|
def test_conf_file_list_use_dgroup_and_dname(self):
|
|
self._do_dgroup_and_dname_test_use(cfg.ListOpt, 'a,b,c',
|
|
['a', 'b', 'c'])
|
|
|
|
def test_conf_file_list_ignore_dname(self):
|
|
self._do_dname_test_ignore(cfg.ListOpt, 'd,e,f', ['d', 'e', 'f'])
|
|
|
|
def test_conf_file_list_ignore_dgroup(self):
|
|
self._do_dgroup_test_ignore(cfg.ListOpt, 'd,e,f', ['d', 'e', 'f'])
|
|
|
|
def test_conf_file_list_ignore_dgroup_and_dname(self):
|
|
self._do_dgroup_and_dname_test_ignore(
|
|
cfg.ListOpt, 'd,e,f', ['d', 'e', 'f'])
|
|
|
|
def test_conf_file_list_spaces_use_dname(self):
|
|
self._do_dname_test_use(cfg.ListOpt, 'a, b, c', ['a', 'b', 'c'])
|
|
|
|
def test_conf_file_list_spaces_use_dgroup(self):
|
|
self._do_dgroup_test_use(cfg.ListOpt, 'a, b, c', ['a', 'b', 'c'])
|
|
|
|
def test_conf_file_list_spaces_use_default_dgroup(self):
|
|
self._do_default_dgroup_test_use(
|
|
cfg.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(
|
|
cfg.ListOpt, 'a, b, c', ['a', 'b', 'c'])
|
|
|
|
def test_conf_file_list_spaces_ignore_dname(self):
|
|
self._do_dname_test_ignore(cfg.ListOpt, 'd, e, f', ['d', 'e', 'f'])
|
|
|
|
def test_conf_file_list_spaces_ignore_dgroup(self):
|
|
self._do_dgroup_test_ignore(cfg.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(cfg.ListOpt, 'd, e, f',
|
|
['d', 'e', 'f'])
|
|
|
|
def test_conf_file_dict_default(self):
|
|
self.conf.register_opt(cfg.DictOpt('foo', default={'key': 'bar'}))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEqual({'key': 'bar'}, self.conf.foo)
|
|
|
|
def test_conf_file_dict_value(self):
|
|
self.conf.register_opt(cfg.DictOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = key:bar\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEqual({'key': 'bar'}, self.conf.foo)
|
|
|
|
def test_conf_file_dict_colon_in_value(self):
|
|
self.conf.register_opt(cfg.DictOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = key:bar:baz\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEqual({'key': 'bar:baz'}, self.conf.foo)
|
|
|
|
def test_conf_file_dict_value_no_colon(self):
|
|
self.conf.register_opt(cfg.DictOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = key:bar,baz\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertRaises(cfg.ConfigFileValueError, self.conf._get, 'foo')
|
|
self.assertRaises(ValueError, getattr, self.conf, 'foo')
|
|
|
|
def test_conf_file_dict_value_duplicate_key(self):
|
|
self.conf.register_opt(cfg.DictOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = key:bar,key:baz\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertRaises(cfg.ConfigFileValueError, self.conf._get, 'foo')
|
|
self.assertRaises(ValueError, getattr, self.conf, 'foo')
|
|
|
|
def test_conf_file_dict_values_override_deprecated(self):
|
|
self.conf.register_cli_opt(cfg.DictOpt('foo',
|
|
deprecated_name='oldfoo'))
|
|
|
|
paths = self.create_tempfiles([('1',
|
|
'[DEFAULT]\n'
|
|
'foo = key1:bar1\n'),
|
|
('2',
|
|
'[DEFAULT]\n'
|
|
'oldfoo = key2:bar2\n'
|
|
'oldfoo = key3:bar3\n')])
|
|
|
|
self.conf(['--foo', 'key0:bar0',
|
|
'--config-file', paths[0],
|
|
'--config-file', paths[1]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
|
|
self.assertEqual({'key3': 'bar3'}, self.conf.foo)
|
|
|
|
def test_conf_file_dict_deprecated(self):
|
|
self.conf.register_opt(cfg.DictOpt('newfoo', deprecated_name='oldfoo'))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'oldfoo= key1:bar1\n'
|
|
'oldfoo = key2:bar2\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
self.assertTrue(hasattr(self.conf, 'newfoo'))
|
|
self.assertEqual({'key2': 'bar2'}, self.conf.newfoo)
|
|
|
|
def test_conf_file_dict_value_override(self):
|
|
self.conf.register_cli_opt(cfg.DictOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('1',
|
|
'[DEFAULT]\n'
|
|
'foo = key:bar,key2:bar\n'),
|
|
('2',
|
|
'[DEFAULT]\n'
|
|
'foo = k1:v1,k2:v2\n')])
|
|
|
|
self.conf(['--foo', 'x:y,x2:y2',
|
|
'--config-file', paths[0],
|
|
'--config-file', paths[1]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEqual({'k1': 'v1', 'k2': 'v2'}, self.conf.foo)
|
|
|
|
def test_conf_file_dict_use_dname(self):
|
|
self._do_dname_test_use(cfg.DictOpt,
|
|
'k1:a,k2:b,k3:c',
|
|
{'k1': 'a', 'k2': 'b', 'k3': 'c'})
|
|
|
|
def test_conf_file_dict_use_dgroup(self):
|
|
self._do_dgroup_test_use(cfg.DictOpt,
|
|
'k1:a,k2:b,k3:c',
|
|
{'k1': 'a', 'k2': 'b', 'k3': 'c'})
|
|
|
|
def test_conf_file_dict_use_default_dgroup(self):
|
|
self._do_default_dgroup_test_use(cfg.DictOpt,
|
|
'k1:a,k2:b,k3:c',
|
|
{'k1': 'a', 'k2': 'b', 'k3': 'c'})
|
|
|
|
def test_conf_file_dict_use_dgroup_and_dname(self):
|
|
self._do_dgroup_and_dname_test_use(cfg.DictOpt,
|
|
'k1:a,k2:b,k3:c',
|
|
{'k1': 'a', 'k2': 'b', 'k3': 'c'})
|
|
|
|
def test_conf_file_dict_ignore_dname(self):
|
|
self._do_dname_test_ignore(cfg.DictOpt,
|
|
'k1:d,k2:e,k3:f',
|
|
{'k1': 'd', 'k2': 'e', 'k3': 'f'})
|
|
|
|
def test_conf_file_dict_ignore_dgroup(self):
|
|
self._do_dgroup_test_ignore(cfg.DictOpt,
|
|
'k1:d,k2:e,k3:f',
|
|
{'k1': 'd', 'k2': 'e', 'k3': 'f'})
|
|
|
|
def test_conf_file_dict_ignore_dgroup_and_dname(self):
|
|
self._do_dgroup_and_dname_test_ignore(cfg.DictOpt,
|
|
'k1:d,k2:e,k3:f',
|
|
{'k1': 'd',
|
|
'k2': 'e',
|
|
'k3': 'f'})
|
|
|
|
def test_conf_file_dict_spaces_use_dname(self):
|
|
self._do_dname_test_use(cfg.DictOpt,
|
|
'k1:a,k2:b,k3:c',
|
|
{'k1': 'a', 'k2': 'b', 'k3': 'c'})
|
|
|
|
def test_conf_file_dict_spaces_use_dgroup(self):
|
|
self._do_dgroup_test_use(cfg.DictOpt,
|
|
'k1:a,k2:b,k3:c',
|
|
{'k1': 'a', 'k2': 'b', 'k3': 'c'})
|
|
|
|
def test_conf_file_dict_spaces_use_default_dgroup(self):
|
|
self._do_default_dgroup_test_use(cfg.DictOpt,
|
|
'k1:a,k2:b,k3:c',
|
|
{'k1': 'a', 'k2': 'b', 'k3': 'c'})
|
|
|
|
def test_conf_file_dict_spaces_use_dgroup_and_dname(self):
|
|
self._do_dgroup_and_dname_test_use(cfg.DictOpt,
|
|
'k1:a,k2:b,k3:c',
|
|
{'k1': 'a', 'k2': 'b', 'k3': 'c'})
|
|
|
|
def test_conf_file_dict_spaces_ignore_dname(self):
|
|
self._do_dname_test_ignore(cfg.DictOpt,
|
|
'k1:d,k2:e,k3:f',
|
|
{'k1': 'd', 'k2': 'e', 'k3': 'f'})
|
|
|
|
def test_conf_file_dict_spaces_ignore_dgroup(self):
|
|
self._do_dgroup_test_ignore(cfg.DictOpt,
|
|
'k1:d,k2:e,k3:f',
|
|
{'k1': 'd', 'k2': 'e', 'k3': 'f'})
|
|
|
|
def test_conf_file_dict_spaces_ignore_dgroup_and_dname(self):
|
|
self._do_dgroup_and_dname_test_ignore(cfg.DictOpt,
|
|
'k1:d,k2:e,k3:f',
|
|
{'k1': 'd',
|
|
'k2': 'e',
|
|
'k3': 'f'})
|
|
|
|
def test_conf_file_port_outside_range(self):
|
|
self.conf.register_opt(cfg.PortOpt('foo'))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = 65536\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
self.assertRaises(cfg.ConfigFileValueError, self.conf._get, 'foo')
|
|
|
|
def test_conf_file_port_list(self):
|
|
self.conf.register_opt(cfg.ListOpt('foo', item_type=types.Port()))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = 22, 80\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEqual([22, 80], self.conf.foo)
|
|
|
|
def test_conf_file_port_list_default(self):
|
|
self.conf.register_opt(cfg.ListOpt('foo', item_type=types.Port(),
|
|
default=[55, 77]))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = 22, 80\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEqual([22, 80], self.conf.foo)
|
|
|
|
def test_conf_file_port_list_only_default(self):
|
|
self.conf.register_opt(cfg.ListOpt('foo', item_type=types.Port(),
|
|
default=[55, 77]))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEqual([55, 77], self.conf.foo)
|
|
|
|
def test_conf_file_port_list_outside_range(self):
|
|
self.conf.register_opt(cfg.ListOpt('foo', item_type=types.Port()))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = 1,65536\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
self.assertRaises(cfg.ConfigFileValueError, self.conf._get, 'foo')
|
|
|
|
def test_conf_file_port_min_max_above_max(self):
|
|
self.conf.register_opt(cfg.PortOpt('foo', min=1, max=5))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = 10\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
self.assertRaises(cfg.ConfigFileValueError, self.conf._get, 'foo')
|
|
|
|
def test_conf_file_port_only_max_above_max(self):
|
|
self.conf.register_opt(cfg.PortOpt('foo', max=500))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = 600\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
self.assertRaises(cfg.ConfigFileValueError, self.conf._get, 'foo')
|
|
|
|
def test_conf_file_port_min_max_below_min(self):
|
|
self.conf.register_opt(cfg.PortOpt('foo', min=100, max=500))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = 99\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
self.assertRaises(cfg.ConfigFileValueError, self.conf._get, 'foo')
|
|
|
|
def test_conf_file_port_only_min_below_min(self):
|
|
self.conf.register_opt(cfg.PortOpt('foo', min=1025))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = 1024\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
self.assertRaises(cfg.ConfigFileValueError, self.conf._get, 'foo')
|
|
|
|
def test_conf_file_port_min_max_in_range(self):
|
|
self.conf.register_opt(cfg.PortOpt('foo', min=1025, max=6000))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = 2500\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEqual(2500, self.conf.foo)
|
|
|
|
def test_conf_file_port_only_max_in_range(self):
|
|
self.conf.register_opt(cfg.PortOpt('foo', max=5000))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = 45\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEqual(45, self.conf.foo)
|
|
|
|
def test_conf_file_port_only_min_in_range(self):
|
|
self.conf.register_opt(cfg.PortOpt('foo', min=35))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n'
|
|
'foo = 45\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEqual(45, self.conf.foo)
|
|
|
|
def test_conf_file_port_min_greater_max(self):
|
|
self.assertRaises(ValueError, cfg.PortOpt, 'foo', min=55, max=15)
|
|
|
|
def test_conf_file_multistr_default(self):
|
|
self.conf.register_opt(cfg.MultiStrOpt('foo', default=['bar']))
|
|
|
|
paths = self.create_tempfiles([('test',
|
|
'[DEFAULT]\n')])
|
|
|
|
self.conf(['--config-file', paths[0]])
|
|
|
|
self.assertTrue(hasattr(self.conf, 'foo'))
|
|
self.assertEqual(['bar'], self.conf.foo)
|
|
|
|
def test_conf_file_multistr_value(self):
|
|
self.conf.register_opt(cfg.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.assertEqual(['bar'], self.conf.foo)
|
|
|
|
def test_conf_file_multistr_values_append_deprecated(self):
|
|
self.conf.register_cli_opt(cfg.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.assertEqual(['bar0', 'bar1', 'bar2', 'bar3'], self.conf.foo)
|
|
|
|
def test_conf_file_multistr_values_append(self):
|
|
self.conf.register_cli_opt(cfg.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.assertEqual(['bar0', 'bar1', 'bar2', 'bar3'], self.conf.foo)
|
|
|
|
def test_conf_file_multistr_deprecated(self):
|
|
self.conf.register_opt(
|
|
cfg.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.assertEqual(['bar1', 'bar2'], self.conf.newfoo)
|
|
|
|
def test_conf_file_multiple_opts(self):
|
|
self.conf.register_opts([cfg.StrOpt('foo'), cfg.StrOpt('bar')])
|
|
|
|
|