def test_argparse_token(self):
c = config.OpenStackConfig(config_files=[self.cloud_yaml],
vendor_files=[self.vendor_yaml])
parser = argparse.ArgumentParser()
c.register_argparse_arguments(parser, [])
# novaclient will add this
parser.add_argument('--os-auth-token')
opts, _remain = parser.parse_known_args(
['--os-auth-token', 'very-bad-things', '--os-auth-type', 'token'])
cc = c.get_one(argparse=opts, validate=False)
self.assertEqual(cc.config['auth_type'], 'token')
self.assertEqual(cc.config['auth']['token'], 'very-bad-things')
def test_register_argparse_not_password(self):
c = config.OpenStackConfig(config_files=[self.cloud_yaml],
vendor_files=[self.vendor_yaml])
parser = argparse.ArgumentParser()
args = [
'--os-auth-type',
'v3token',
'--os-token',
'some-secret',
]
c.register_argparse_arguments(parser, args)
opts, _remain = parser.parse_known_args(args)
self.assertEqual(opts.os_token, 'some-secret')
def test_get_one_with_config_files(self):
c = config.OpenStackConfig(config_files=[self.cloud_yaml],
vendor_files=[self.vendor_yaml],
secure_files=[self.secure_yaml])
self.assertIsInstance(c.cloud_config, dict)
self.assertIn('cache', c.cloud_config)
self.assertIsInstance(c.cloud_config['cache'], dict)
self.assertIn('max_age', c.cloud_config['cache'])
self.assertIn('path', c.cloud_config['cache'])
cc = c.get_one('_test-cloud_')
self._assert_cloud_details(cc)
cc = c.get_one('_test_cloud_no_vendor')
self._assert_cloud_details(cc)
def test_get_cloud_names(self):
c = config.OpenStackConfig(config_files=[self.cloud_yaml],
secure_files=[self.no_yaml])
self.assertEqual([
'_test-cloud-domain-id_',
'_test-cloud-domain-scoped_',
'_test-cloud-int-project_',
'_test-cloud-networks_',
'_test-cloud_',
'_test-cloud_no_region',
'_test_cloud_hyphenated',
'_test_cloud_no_vendor',
'_test_cloud_regions',
], sorted(c.get_cloud_names()))
c = config.OpenStackConfig(config_files=[self.no_yaml],
vendor_files=[self.no_yaml],
secure_files=[self.no_yaml])
for k in os.environ.keys():
if k.startswith('OS_'):
self.useFixture(fixtures.EnvironmentVariable(k))
c.get_one(cloud='defaults', validate=False)
self.assertEqual(['defaults'], sorted(c.get_cloud_names()))
def setUp(self):
super(BaseFunctionalTestCase, self).setUp()
self._demo_name = os.environ.get('OPENSTACKSDK_DEMO_CLOUD', 'devstack')
self._op_name = os.environ.get(
'OPENSTACKSDK_OPERATOR_CLOUD', 'devstack-admin')
self.config = occ.OpenStackConfig()
self._set_user_cloud()
self._set_operator_cloud()
self.identity_version = \
self.operator_cloud.config.get_api_version('identity')
def test_register_argparse_password(self):
c = config.OpenStackConfig(config_files=[self.cloud_yaml],
vendor_files=[self.vendor_yaml])
parser = argparse.ArgumentParser()
args = [
'--os-password',
'some-secret',
]
c.register_argparse_arguments(parser, args)
opts, _remain = parser.parse_known_args(args)
self.assertEqual(opts.os_password, 'some-secret')
with testtools.ExpectedException(AttributeError):
opts.os_token
def test_have_envvars(self):
self.useFixture(fixtures.EnvironmentVariable('NOVA_USERNAME', 'nova'))
self.useFixture(
fixtures.EnvironmentVariable('OS_AUTH_URL', 'http://example.com'))
self.useFixture(fixtures.EnvironmentVariable('OS_USERNAME', 'user'))
self.useFixture(fixtures.EnvironmentVariable('OS_PASSWORD',
'password'))
self.useFixture(
fixtures.EnvironmentVariable('OS_PROJECT_NAME', 'project'))
c = config.OpenStackConfig(config_files=[self.cloud_yaml],
vendor_files=[self.vendor_yaml])
cc = c.get_one_cloud('envvars')
self.assertEqual(cc.config['auth']['username'], 'user')
def test_argparse_default_no_token(self):
c = config.OpenStackConfig(config_files=[self.cloud_yaml],
vendor_files=[self.vendor_yaml])
parser = argparse.ArgumentParser()
c.register_argparse_arguments(parser, [])
# novaclient will add this
parser.add_argument('--os-auth-token')
opts, _remain = parser.parse_known_args()
cc = c.get_one(
cloud='_test_cloud_regions', argparse=opts)
self.assertEqual(cc.config['auth_type'], 'password')
self.assertNotIn('token', cc.config['auth'])
def test_get_all_clouds(self):
# Ensure the alias is in place
c = config.OpenStackConfig(config_files=[self.cloud_yaml],
vendor_files=[self.vendor_yaml],
secure_files=[self.no_yaml])
clouds = c.get_all_clouds()
# We add one by hand because the regions cloud is going to exist
# twice since it has two regions in it
user_clouds = [
cloud for cloud in base.USER_CONF['clouds'].keys()
] + ['_test_cloud_regions']
configured_clouds = [cloud.name for cloud in clouds]
self.assertItemsEqual(user_clouds, configured_clouds)
def test_backwards_network_fail(self):
c = config.OpenStackConfig(config_files=[self.cloud_yaml],
vendor_files=[self.vendor_yaml])
cloud = {
'external_network': 'public',
'networks': [
{
'name': 'private',
'routes_externally': False
},
]
}
self.assertRaises(exceptions.ConfigException,
c._fix_backwards_networks, cloud)
def test_environ_exists(self):
c = config.OpenStackConfig(config_files=[self.cloud_yaml],
vendor_files=[self.vendor_yaml],
secure_files=[self.secure_yaml])
cc = c.get_one_cloud('envvars')
self._assert_cloud_details(cc)
self.assertNotIn('auth_url', cc.config)
self.assertIn('auth_url', cc.config['auth'])
self.assertNotIn('project_id', cc.config['auth'])
self.assertNotIn('auth_url', cc.config)
cc = c.get_one_cloud('_test-cloud_')
self._assert_cloud_details(cc)
cc = c.get_one_cloud('_test_cloud_no_vendor')
self._assert_cloud_details(cc)
def test_get_one_with_hyphenated_kwargs(self):
c = config.OpenStackConfig(config_files=[self.cloud_yaml],
vendor_files=[self.vendor_yaml])
args = {
'auth': {
'username': '******',
'password': '******',
'project-id': '12345',
'auth-url': 'http://example.com/v2',
},
'region_name': 'test-region',
}
cc = c.get_one(**args)
self.assertEqual('http://example.com/v2', cc.auth['auth_url'])
def test_get_one_cloud_osc_password_brace(self):
c = config.OpenStackConfig(config_files=[self.cloud_yaml],
vendor_files=[self.vendor_yaml])
password = '******' # Would raise ValueError, single brace
self.options.password = password
cc = c.get_one_cloud_osc(
cloud='_test_cloud_regions', argparse=self.options, validate=False)
self.assertEqual(cc.password, password)
password = '******' # Would raise KeyError, 'bar' not found
self.options.password = password
cc = c.get_one_cloud_osc(
cloud='_test_cloud_regions', argparse=self.options, validate=False)
self.assertEqual(cc.password, password)
def test_argparse_underscores_duplicate(self):
c = config.OpenStackConfig(config_files=[self.no_yaml],
vendor_files=[self.no_yaml],
secure_files=[self.no_yaml])
parser = argparse.ArgumentParser()
parser.add_argument('--os_username')
argv = [
'--os_username', 'user', '--os_password', 'pass',
'--os-username', 'user1', '--os-password', 'pass1',
'--os-auth-url', 'auth-url', '--os-project-name', 'project']
self.assertRaises(
exceptions.ConfigException,
c.register_argparse_arguments,
parser=parser, argv=argv)
def test_get_one_prompt(self):
c = config.OpenStackConfig(
config_files=[self.cloud_yaml],
vendor_files=[self.vendor_yaml],
pw_func=prompt_for_password,
)
# This needs a cloud definition without a password.
# If this starts failing unexpectedly check that the cloud_yaml
# and/or vendor_yaml do not have a password in the selected cloud.
cc = c.get_one(
cloud='_test_cloud_no_vendor',
argparse=self.options,
)
self.assertEqual('promptpass', cc.auth['password'])
def test_argparse_underscores(self):
c = config.OpenStackConfig(config_files=[self.no_yaml],
vendor_files=[self.no_yaml],
secure_files=[self.no_yaml])
parser = argparse.ArgumentParser()
parser.add_argument('--os_username')
argv = [
'--os_username', 'user', '--os_password', 'pass',
'--os-auth-url', 'auth-url', '--os-project-name', 'project']
c.register_argparse_arguments(parser, argv=argv)
opts, _remain = parser.parse_known_args(argv)
cc = c.get_one(argparse=opts)
self.assertEqual(cc.config['auth']['username'], 'user')
self.assertEqual(cc.config['auth']['password'], 'pass')
self.assertEqual(cc.config['auth']['auth_url'], 'auth-url')
def test_get_one_networks(self):
c = config.OpenStackConfig(config_files=[self.cloud_yaml],
vendor_files=[self.vendor_yaml])
cc = c.get_one('_test-cloud-networks_')
self.assertEqual(['a-public', 'another-public', 'split-default'],
cc.get_external_networks())
self.assertEqual(['a-private', 'another-private', 'split-no-default'],
cc.get_internal_networks())
self.assertEqual('a-public', cc.get_nat_source())
self.assertEqual('another-private', cc.get_nat_destination())
self.assertEqual('another-public', cc.get_default_network())
self.assertEqual(['a-public', 'another-public', 'split-no-default'],
cc.get_external_ipv4_networks())
self.assertEqual(['a-public', 'another-public', 'split-default'],
cc.get_external_ipv6_networks())
def test_get_one_dash_kwargs(self):
c = config.OpenStackConfig(config_files=[self.cloud_yaml],
vendor_files=[self.vendor_yaml])
args = {
'auth-url': 'http://example.com/v2',
'username': '******',
'password': '******',
'project_name': 'project',
'region_name': 'other-test-region',
'snack_type': 'cookie',
}
cc = c.get_one(**args)
self.assertIsNone(cc.cloud)
self.assertEqual(cc.region_name, 'other-test-region')
self.assertEqual(cc.snack_type, 'cookie')
def test_set_no_default(self):
c = config.OpenStackConfig(config_files=[self.cloud_yaml],
vendor_files=[self.vendor_yaml])
cloud = {
'identity_endpoint_type': 'admin',
'compute_endpoint_type': 'private',
'endpoint_type': 'public',
'auth_type': 'v3password',
}
result = c._fix_backwards_interface(cloud)
expected = {
'identity_interface': 'admin',
'compute_interface': 'private',
'interface': 'public',
'auth_type': 'v3password',
}
self.assertDictEqual(expected, result)
def test_single_default_interface(self):
c = config.OpenStackConfig(config_files=[self.cloud_yaml],
vendor_files=[self.vendor_yaml])
cloud = {
'networks': [
{
'name': 'blue',
'default_interface': True
},
{
'name': 'purple',
'default_interface': True
},
]
}
self.assertRaises(exceptions.ConfigException,
c._fix_backwards_networks, cloud)
def setUp(self, cloud_config_fixture='clouds.yaml'):
"""Run before each test method to initialize test environment."""
super(BaseTestCase, self).setUp()
# Sleeps are for real testing, but unit tests shouldn't need them
realsleep = time.sleep
def _nosleep(seconds):
return realsleep(seconds * 0.0001)
self.sleep_fixture = self.useFixture(
fixtures.MonkeyPatch('time.sleep', _nosleep))
self.fixtures_directory = 'shade/tests/unit/fixtures'
# Isolate os-client-config from test environment
config = tempfile.NamedTemporaryFile(delete=False)
cloud_path = '%s/clouds/%s' % (self.fixtures_directory,
cloud_config_fixture)
with open(cloud_path, 'rb') as f:
content = f.read()
config.write(content)
config.close()
vendor = tempfile.NamedTemporaryFile(delete=False)
vendor.write(b'{}')
vendor.close()
# set record mode depending on environment
record_mode = os.environ.get('BETAMAX_RECORD_FIXTURES', False)
if record_mode:
self.record_fixtures = 'new_episodes'
else:
self.record_fixtures = None
test_cloud = os.environ.get('SHADE_OS_CLOUD', '_test_cloud_')
self.config = occ.OpenStackConfig(config_files=[config.name],
vendor_files=[vendor.name],
secure_files=['non-existant'])
self.cloud_config = self.config.get_one_cloud(cloud=test_cloud,
validate=False)
self.cloud = shade.OpenStackCloud(cloud_config=self.cloud_config)
self.strict_cloud = shade.OpenStackCloud(
cloud_config=self.cloud_config, strict=True)
self.op_cloud = shade.OperatorCloud(cloud_config=self.cloud_config)
def main(args=sys.argv[1:]):
config = os_config.OpenStackConfig()
args = _parse_args(args, config)
_configure_logging(args)
if args.quiet:
formatter = _format.NULL_FORMAT
else:
formatter = _format.FORMATS[args.format](columns=args.columns,
sort_column=args.sort_column)
region = config.get_one(argparse=args)
api = _provisioner.Provisioner(cloud_region=region, dry_run=args.dry_run)
try:
args.func(api, args, formatter)
except Exception as exc:
LOG.critical('%s', exc, exc_info=args.debug)
sys.exit(1)
def test_get_one_default_cloud_from_file(self):
single_conf = base._write_yaml({
'clouds': {
'single': {
'auth': {
'auth_url': 'http://example.com/v2',
'username': '******',
'password': '******',
'project_name': 'testproject',
},
'region_name': 'test-region',
}
}
})
c = config.OpenStackConfig(config_files=[single_conf],
vendor_files=[self.vendor_yaml])
cc = c.get_one()
self.assertEqual(cc.name, 'single')
def test_normalize_network(self):
c = config.OpenStackConfig(config_files=[self.cloud_yaml],
vendor_files=[self.vendor_yaml])
cloud = {
'networks': [
{'name': 'private'}
]
}
result = c._fix_backwards_networks(cloud)
expected = {
'networks': [
{'name': 'private', 'routes_externally': False,
'nat_destination': False, 'default_interface': False,
'nat_source': False,
'routes_ipv4_externally': False,
'routes_ipv6_externally': False},
]
}
self.assertEqual(expected, result)
def test_backwards_network(self):
c = config.OpenStackConfig(config_files=[self.cloud_yaml],
vendor_files=[self.vendor_yaml])
cloud = {
'external_network': 'public',
'internal_network': 'private',
}
result = c._fix_backwards_networks(cloud)
expected = {
'external_network': 'public',
'internal_network': 'private',
'networks': [
{'name': 'public', 'routes_externally': True,
'nat_destination': False, 'default_interface': True},
{'name': 'private', 'routes_externally': False,
'nat_destination': True, 'default_interface': False},
]
}
self.assertEqual(expected, result)
def test_project_password(self):
c = config.OpenStackConfig(config_files=[self.cloud_yaml],
vendor_files=[self.vendor_yaml])
cloud = {
'auth_type': 'password',
'auth': {
'project-name': 'my_project_name',
'project-id': 'my_project_id'
}
}
result = c._fix_backwards_project(cloud)
expected = {
'auth_type': 'password',
'auth': {
'project_name': 'my_project_name',
'project_id': 'my_project_id'
}
}
self.assertEqual(expected, result)
def test_extra_config(self):
c = config.OpenStackConfig(config_files=[self.cloud_yaml],
vendor_files=[self.vendor_yaml])
defaults = {'use_hostnames': False, 'other-value': 'something'}
ansible_options = c.get_extra_config('ansible', defaults)
# This should show that the default for use_hostnames above is
# overridden by the value in the config file defined in base.py
# It should also show that other-value key is normalized and passed
# through even though there is no corresponding value in the config
# file, and that expand-hostvars key is normalized and the value
# from the config comes through even though there is no default.
self.assertDictEqual(
{
'expand_hostvars': False,
'use_hostnames': True,
'other_value': 'something',
}, ansible_options)
def setUp(self, cloud_config_fixture='clouds.yaml'):
"""Run before each test method to initialize test environment."""
super(BaseTestCase, self).setUp()
# Sleeps are for real testing, but unit tests shouldn't need them
realsleep = time.sleep
def _nosleep(seconds):
return realsleep(seconds * 0.0001)
self.sleep_fixture = self.useFixture(
fixtures.MonkeyPatch('time.sleep', _nosleep))
self.fixtures_directory = 'openstack/tests/unit/fixtures'
# Isolate os-client-config from test environment
config = tempfile.NamedTemporaryFile(delete=False)
cloud_path = '%s/clouds/%s' % (self.fixtures_directory,
cloud_config_fixture)
with open(cloud_path, 'rb') as f:
content = f.read()
config.write(content)
config.close()
vendor = tempfile.NamedTemporaryFile(delete=False)
vendor.write(b'{}')
vendor.close()
test_cloud = os.environ.get('OPENSTACKSDK_OS_CLOUD', '_test_cloud_')
self.config = occ.OpenStackConfig(config_files=[config.name],
vendor_files=[vendor.name],
secure_files=['non-existant'])
self.cloud_config = self.config.get_one_cloud(cloud=test_cloud,
validate=False)
self.cloud = openstack.OpenStackCloud(cloud_config=self.cloud_config,
log_inner_exceptions=True)
self.strict_cloud = openstack.OpenStackCloud(
cloud_config=self.cloud_config,
log_inner_exceptions=True,
strict=True)
self.op_cloud = openstack.OperatorCloud(cloud_config=self.cloud_config,
log_inner_exceptions=True)
def test_register_argparse_network_service_type(self):
c = config.OpenStackConfig(config_files=[self.cloud_yaml],
vendor_files=[self.vendor_yaml])
parser = argparse.ArgumentParser()
args = [
'--os-endpoint-type', 'admin',
'--network-api-version', '4',
]
c.register_argparse_arguments(parser, args, ['network'])
opts, _remain = parser.parse_known_args(args)
self.assertEqual(opts.os_service_type, 'network')
self.assertEqual(opts.os_endpoint_type, 'admin')
self.assertIsNone(opts.os_network_service_type)
self.assertIsNone(opts.os_network_api_version)
self.assertEqual(opts.network_api_version, '4')
cloud = c.get_one(argparse=opts, validate=False)
self.assertEqual(cloud.config['service_type'], 'network')
self.assertEqual(cloud.config['interface'], 'admin')
self.assertEqual(cloud.config['network_api_version'], '4')
self.assertNotIn('http_timeout', cloud.config)
def test_get_one_precedence_no_argparse(self):
c = config.OpenStackConfig(config_files=[self.cloud_yaml],
vendor_files=[self.vendor_yaml])
kwargs = {
'auth': {
'username': '******',
'password': '******',
'project-id': 'testproject',
'auth_url': 'http://example.com/v2',
},
'region_name': 'kwarg_region',
'password': '******',
'arbitrary': 'value',
}
cc = c.get_one(**kwargs)
self.assertEqual(cc.region_name, 'kwarg_region')
self.assertEqual(cc.auth['password'], 'authpass')
self.assertIsNone(cc.password)
