218 lines
7.9 KiB
Python
218 lines
7.9 KiB
Python
# 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 uuid
|
|
|
|
import fixtures
|
|
import mock
|
|
|
|
from keystoneauth1 import loading
|
|
from keystoneauth1.loading import cli
|
|
from keystoneauth1.tests.unit.loading import utils
|
|
|
|
|
|
TesterPlugin, TesterLoader = utils.create_plugin(
|
|
opts=[
|
|
loading.Opt('test-opt',
|
|
help='tester',
|
|
deprecated=[loading.Opt('test-other')])
|
|
]
|
|
)
|
|
|
|
|
|
class CliTests(utils.TestCase):
|
|
|
|
def setUp(self):
|
|
super(CliTests, self).setUp()
|
|
self.p = argparse.ArgumentParser()
|
|
|
|
def env(self, name, value=None):
|
|
if value is not None:
|
|
# environment variables are always strings
|
|
value = str(value)
|
|
|
|
return self.useFixture(fixtures.EnvironmentVariable(name, value))
|
|
|
|
def test_creating_with_no_args(self):
|
|
ret = loading.register_auth_argparse_arguments(self.p, [])
|
|
self.assertIsNone(ret)
|
|
self.assertIn('--os-auth-type', self.p.format_usage())
|
|
|
|
def test_load_with_nothing(self):
|
|
loading.register_auth_argparse_arguments(self.p, [])
|
|
opts = self.p.parse_args([])
|
|
self.assertIsNone(loading.load_auth_from_argparse_arguments(opts))
|
|
|
|
@utils.mock_plugin()
|
|
def test_basic_params_added(self, m):
|
|
name = uuid.uuid4().hex
|
|
argv = ['--os-auth-plugin', name]
|
|
ret = loading.register_auth_argparse_arguments(self.p, argv)
|
|
self.assertIsInstance(ret, utils.MockLoader)
|
|
|
|
for n in ('--os-a-int', '--os-a-bool', '--os-a-float'):
|
|
self.assertIn(n, self.p.format_usage())
|
|
|
|
m.assert_called_once_with(name)
|
|
|
|
@utils.mock_plugin()
|
|
def test_param_loading(self, m):
|
|
name = uuid.uuid4().hex
|
|
argv = ['--os-auth-type', name,
|
|
'--os-a-int', str(self.a_int),
|
|
'--os-a-float', str(self.a_float),
|
|
'--os-a-bool', str(self.a_bool)]
|
|
|
|
klass = loading.register_auth_argparse_arguments(self.p, argv)
|
|
self.assertIsInstance(klass, utils.MockLoader)
|
|
|
|
opts = self.p.parse_args(argv)
|
|
self.assertEqual(name, opts.os_auth_type)
|
|
|
|
a = loading.load_auth_from_argparse_arguments(opts)
|
|
self.assertTestVals(a)
|
|
|
|
self.assertEqual(name, opts.os_auth_type)
|
|
self.assertEqual(str(self.a_int), opts.os_a_int)
|
|
self.assertEqual(str(self.a_float), opts.os_a_float)
|
|
self.assertEqual(str(self.a_bool), opts.os_a_bool)
|
|
|
|
@utils.mock_plugin()
|
|
def test_default_options(self, m):
|
|
name = uuid.uuid4().hex
|
|
argv = ['--os-auth-type', name,
|
|
'--os-a-float', str(self.a_float)]
|
|
|
|
klass = loading.register_auth_argparse_arguments(self.p, argv)
|
|
self.assertIsInstance(klass, utils.MockLoader)
|
|
|
|
opts = self.p.parse_args(argv)
|
|
self.assertEqual(name, opts.os_auth_type)
|
|
|
|
a = loading.load_auth_from_argparse_arguments(opts)
|
|
|
|
self.assertEqual(self.a_float, a['a_float'])
|
|
self.assertEqual(3, a['a_int'])
|
|
|
|
@utils.mock_plugin()
|
|
def test_with_default_string_value(self, m):
|
|
name = uuid.uuid4().hex
|
|
klass = loading.register_auth_argparse_arguments(self.p,
|
|
[],
|
|
default=name)
|
|
self.assertIsInstance(klass, utils.MockLoader)
|
|
m.assert_called_once_with(name)
|
|
|
|
@utils.mock_plugin()
|
|
def test_overrides_default_string_value(self, m):
|
|
name = uuid.uuid4().hex
|
|
default = uuid.uuid4().hex
|
|
argv = ['--os-auth-type', name]
|
|
klass = loading.register_auth_argparse_arguments(self.p,
|
|
argv,
|
|
default=default)
|
|
self.assertIsInstance(klass, utils.MockLoader)
|
|
m.assert_called_once_with(name)
|
|
|
|
@utils.mock_plugin()
|
|
def test_with_default_type_value(self, m):
|
|
default = utils.MockLoader()
|
|
klass = loading.register_auth_argparse_arguments(self.p,
|
|
[],
|
|
default=default)
|
|
self.assertIsInstance(klass, utils.MockLoader)
|
|
self.assertEqual(0, m.call_count)
|
|
|
|
@utils.mock_plugin()
|
|
def test_overrides_default_type_value(self, m):
|
|
# using this test plugin would fail if called because there
|
|
# is no get_options() function
|
|
class TestLoader(object):
|
|
pass
|
|
name = uuid.uuid4().hex
|
|
argv = ['--os-auth-type', name]
|
|
klass = loading.register_auth_argparse_arguments(self.p,
|
|
argv,
|
|
default=TestLoader)
|
|
self.assertIsInstance(klass, utils.MockLoader)
|
|
m.assert_called_once_with(name)
|
|
|
|
@utils.mock_plugin()
|
|
def test_env_overrides_default_opt(self, m):
|
|
name = uuid.uuid4().hex
|
|
val = uuid.uuid4().hex
|
|
self.env('OS_A_STR', val)
|
|
|
|
klass = loading.register_auth_argparse_arguments(self.p,
|
|
[],
|
|
default=name)
|
|
self.assertIsInstance(klass, utils.MockLoader)
|
|
opts = self.p.parse_args([])
|
|
a = loading.load_auth_from_argparse_arguments(opts)
|
|
|
|
self.assertEqual(val, a['a_str'])
|
|
|
|
def test_deprecated_cli_options(self):
|
|
cli._register_plugin_argparse_arguments(self.p, TesterLoader())
|
|
val = uuid.uuid4().hex
|
|
opts = self.p.parse_args(['--os-test-other', val])
|
|
self.assertEqual(val, opts.os_test_opt)
|
|
|
|
def test_deprecated_multi_cli_options(self):
|
|
cli._register_plugin_argparse_arguments(self.p, TesterLoader())
|
|
val1 = uuid.uuid4().hex
|
|
val2 = uuid.uuid4().hex
|
|
# argarse rules say that the last specified wins.
|
|
opts = self.p.parse_args(['--os-test-other', val2,
|
|
'--os-test-opt', val1])
|
|
self.assertEqual(val1, opts.os_test_opt)
|
|
|
|
def test_deprecated_env_options(self):
|
|
val = uuid.uuid4().hex
|
|
|
|
with mock.patch.dict('os.environ', {'OS_TEST_OTHER': val}):
|
|
cli._register_plugin_argparse_arguments(self.p, TesterLoader())
|
|
|
|
opts = self.p.parse_args([])
|
|
self.assertEqual(val, opts.os_test_opt)
|
|
|
|
def test_deprecated_env_multi_options(self):
|
|
val1 = uuid.uuid4().hex
|
|
val2 = uuid.uuid4().hex
|
|
|
|
with mock.patch.dict('os.environ', {'OS_TEST_OPT': val1,
|
|
'OS_TEST_OTHER': val2}):
|
|
cli._register_plugin_argparse_arguments(self.p, TesterLoader())
|
|
|
|
opts = self.p.parse_args([])
|
|
self.assertEqual(val1, opts.os_test_opt)
|
|
|
|
def test_adapter_service_type(self):
|
|
argv = ['--os-service-type', 'compute']
|
|
|
|
loading.register_adapter_argparse_arguments(self.p, 'compute')
|
|
|
|
opts = self.p.parse_args(argv)
|
|
self.assertEqual('compute', opts.os_service_type)
|
|
self.assertFalse(hasattr(opts, 'os_compute_service_type'))
|
|
|
|
def test_adapter_service_type_per_service(self):
|
|
argv = ['--os-compute-service-type', 'weirdness']
|
|
|
|
loading.register_adapter_argparse_arguments(self.p, 'compute')
|
|
loading.register_service_adapter_argparse_arguments(self.p, 'compute')
|
|
|
|
opts = self.p.parse_args(argv)
|
|
self.assertEqual('compute', opts.os_service_type)
|
|
self.assertEqual('weirdness', opts.os_compute_service_type)
|