fc8579dfa8
This change applies a regular expression in order to filter flavor extraspects keys with invalid characters. The characters allowed are: letters, numbers, underscores, periods, colons, spaces and hyphens. A new test flavor has been created which doesn't check the keys in the post body. This flavor has been created in the third place (instead of in the last) in order to keep working existent test cases which depend on the last flavor received in the get method. Change-Id: Ifd86bed23a05a5946ae8b9ba6f6c9bf4b24b1d4c Partial-Bug: #1256119
305 lines
10 KiB
Python
305 lines
10 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 sys
|
|
|
|
import mock
|
|
import six
|
|
|
|
from novaclient import base
|
|
from novaclient import exceptions
|
|
from novaclient.tests import utils as test_utils
|
|
from novaclient import utils
|
|
|
|
UUID = '8e8ec658-c7b0-4243-bdf8-6f7f2952c0d0'
|
|
|
|
|
|
class FakeResource(object):
|
|
NAME_ATTR = 'name'
|
|
|
|
def __init__(self, _id, properties):
|
|
self.id = _id
|
|
try:
|
|
self.name = properties['name']
|
|
except KeyError:
|
|
pass
|
|
|
|
|
|
class FakeManager(base.ManagerWithFind):
|
|
|
|
resource_class = FakeResource
|
|
|
|
resources = [
|
|
FakeResource('1234', {'name': 'entity_one'}),
|
|
FakeResource(UUID, {'name': 'entity_two'}),
|
|
FakeResource('5678', {'name': '9876'}),
|
|
FakeResource('01234', {'name': 'entity_three'})
|
|
]
|
|
|
|
is_alphanum_id_allowed = None
|
|
|
|
def __init__(self, alphanum_id_allowed=False):
|
|
self.is_alphanum_id_allowed = alphanum_id_allowed
|
|
|
|
def get(self, resource_id):
|
|
for resource in self.resources:
|
|
if resource.id == str(resource_id):
|
|
return resource
|
|
raise exceptions.NotFound(resource_id)
|
|
|
|
def list(self):
|
|
return self.resources
|
|
|
|
|
|
class FakeDisplayResource(object):
|
|
NAME_ATTR = 'display_name'
|
|
|
|
def __init__(self, _id, properties):
|
|
self.id = _id
|
|
try:
|
|
self.display_name = properties['display_name']
|
|
except KeyError:
|
|
pass
|
|
|
|
|
|
class FakeDisplayManager(FakeManager):
|
|
|
|
resource_class = FakeDisplayResource
|
|
|
|
resources = [
|
|
FakeDisplayResource('4242', {'display_name': 'entity_three'}),
|
|
]
|
|
|
|
|
|
class FindResourceTestCase(test_utils.TestCase):
|
|
|
|
def setUp(self):
|
|
super(FindResourceTestCase, self).setUp()
|
|
self.manager = FakeManager(None)
|
|
|
|
def test_find_none(self):
|
|
"""Test a few non-valid inputs."""
|
|
self.assertRaises(exceptions.CommandError,
|
|
utils.find_resource,
|
|
self.manager,
|
|
'asdf')
|
|
self.assertRaises(exceptions.CommandError,
|
|
utils.find_resource,
|
|
self.manager,
|
|
None)
|
|
self.assertRaises(exceptions.CommandError,
|
|
utils.find_resource,
|
|
self.manager,
|
|
{})
|
|
|
|
def test_find_by_integer_id(self):
|
|
output = utils.find_resource(self.manager, 1234)
|
|
self.assertEqual(output, self.manager.get('1234'))
|
|
|
|
def test_find_by_str_id(self):
|
|
output = utils.find_resource(self.manager, '1234')
|
|
self.assertEqual(output, self.manager.get('1234'))
|
|
|
|
def test_find_by_uuid(self):
|
|
output = utils.find_resource(self.manager, UUID)
|
|
self.assertEqual(output, self.manager.get(UUID))
|
|
|
|
def test_find_by_str_name(self):
|
|
output = utils.find_resource(self.manager, 'entity_one')
|
|
self.assertEqual(output, self.manager.get('1234'))
|
|
|
|
def test_find_by_str_displayname(self):
|
|
display_manager = FakeDisplayManager(None)
|
|
output = utils.find_resource(display_manager, 'entity_three')
|
|
self.assertEqual(output, display_manager.get('4242'))
|
|
|
|
def test_find_in_alphanum_allowd_manager_by_str_id_(self):
|
|
alphanum_manager = FakeManager(True)
|
|
output = utils.find_resource(alphanum_manager, '01234')
|
|
self.assertEqual(output, alphanum_manager.get('01234'))
|
|
|
|
|
|
class _FakeResult(object):
|
|
def __init__(self, name, value):
|
|
self.name = name
|
|
self.value = value
|
|
|
|
|
|
class PrintResultTestCase(test_utils.TestCase):
|
|
@mock.patch('sys.stdout', six.StringIO())
|
|
def test_print_dict(self):
|
|
dict = {'key': 'value'}
|
|
utils.print_dict(dict)
|
|
self.assertEqual(sys.stdout.getvalue(),
|
|
'+----------+-------+\n'
|
|
'| Property | Value |\n'
|
|
'+----------+-------+\n'
|
|
'| key | value |\n'
|
|
'+----------+-------+\n')
|
|
|
|
@mock.patch('sys.stdout', six.StringIO())
|
|
def test_print_dict_wrap(self):
|
|
dict = {'key1': 'not wrapped',
|
|
'key2': 'this will be wrapped'}
|
|
utils.print_dict(dict, wrap=16)
|
|
self.assertEqual(sys.stdout.getvalue(),
|
|
'+----------+--------------+\n'
|
|
'| Property | Value |\n'
|
|
'+----------+--------------+\n'
|
|
'| key1 | not wrapped |\n'
|
|
'| key2 | this will be |\n'
|
|
'| | wrapped |\n'
|
|
'+----------+--------------+\n')
|
|
|
|
@mock.patch('sys.stdout', six.StringIO())
|
|
def test_print_list_sort_by_str(self):
|
|
objs = [_FakeResult("k1", 1),
|
|
_FakeResult("k3", 2),
|
|
_FakeResult("k2", 3)]
|
|
|
|
utils.print_list(objs, ["Name", "Value"], sortby_index=0)
|
|
|
|
self.assertEqual(sys.stdout.getvalue(),
|
|
'+------+-------+\n'
|
|
'| Name | Value |\n'
|
|
'+------+-------+\n'
|
|
'| k1 | 1 |\n'
|
|
'| k2 | 3 |\n'
|
|
'| k3 | 2 |\n'
|
|
'+------+-------+\n')
|
|
|
|
@mock.patch('sys.stdout', six.StringIO())
|
|
def test_print_list_sort_by_integer(self):
|
|
objs = [_FakeResult("k1", 1),
|
|
_FakeResult("k3", 2),
|
|
_FakeResult("k2", 3)]
|
|
|
|
utils.print_list(objs, ["Name", "Value"], sortby_index=1)
|
|
|
|
self.assertEqual(sys.stdout.getvalue(),
|
|
'+------+-------+\n'
|
|
'| Name | Value |\n'
|
|
'+------+-------+\n'
|
|
'| k1 | 1 |\n'
|
|
'| k3 | 2 |\n'
|
|
'| k2 | 3 |\n'
|
|
'+------+-------+\n')
|
|
|
|
# without sorting
|
|
@mock.patch('sys.stdout', six.StringIO())
|
|
def test_print_list_sort_by_none(self):
|
|
objs = [_FakeResult("k1", 1),
|
|
_FakeResult("k3", 3),
|
|
_FakeResult("k2", 2)]
|
|
|
|
utils.print_list(objs, ["Name", "Value"], sortby_index=None)
|
|
|
|
self.assertEqual(sys.stdout.getvalue(),
|
|
'+------+-------+\n'
|
|
'| Name | Value |\n'
|
|
'+------+-------+\n'
|
|
'| k1 | 1 |\n'
|
|
'| k3 | 3 |\n'
|
|
'| k2 | 2 |\n'
|
|
'+------+-------+\n')
|
|
|
|
@mock.patch('sys.stdout', six.StringIO())
|
|
def test_print_dict_dictionary(self):
|
|
dict = {'k': {'foo': 'bar'}}
|
|
utils.print_dict(dict)
|
|
self.assertEqual(sys.stdout.getvalue(),
|
|
'+----------+----------------+\n'
|
|
'| Property | Value |\n'
|
|
'+----------+----------------+\n'
|
|
'| k | {"foo": "bar"} |\n'
|
|
'+----------+----------------+\n')
|
|
|
|
@mock.patch('sys.stdout', six.StringIO())
|
|
def test_print_dict_list_dictionary(self):
|
|
dict = {'k': [{'foo': 'bar'}]}
|
|
utils.print_dict(dict)
|
|
self.assertEqual(sys.stdout.getvalue(),
|
|
'+----------+------------------+\n'
|
|
'| Property | Value |\n'
|
|
'+----------+------------------+\n'
|
|
'| k | [{"foo": "bar"}] |\n'
|
|
'+----------+------------------+\n')
|
|
|
|
@mock.patch('sys.stdout', six.StringIO())
|
|
def test_print_dict_list(self):
|
|
dict = {'k': ['foo', 'bar']}
|
|
utils.print_dict(dict)
|
|
self.assertEqual(sys.stdout.getvalue(),
|
|
'+----------+----------------+\n'
|
|
'| Property | Value |\n'
|
|
'+----------+----------------+\n'
|
|
'| k | ["foo", "bar"] |\n'
|
|
'+----------+----------------+\n')
|
|
|
|
|
|
class FlattenTestCase(test_utils.TestCase):
|
|
def test_flattening(self):
|
|
squashed = utils.flatten_dict(
|
|
{'a1': {'b1': 1234,
|
|
'b2': 'string',
|
|
'b3': set((1, 2, 3)),
|
|
'b4': {'c1': ['l', 'l', ['l']],
|
|
'c2': 'string'}},
|
|
'a2': ['l'],
|
|
'a3': ('t',)})
|
|
|
|
self.assertEqual({'a1_b1': 1234,
|
|
'a1_b2': 'string',
|
|
'a1_b3': set([1, 2, 3]),
|
|
'a1_b4_c1': ['l', 'l', ['l']],
|
|
'a1_b4_c2': 'string',
|
|
'a2': ['l'],
|
|
'a3': ('t',)},
|
|
squashed)
|
|
|
|
def test_pretty_choice_list(self):
|
|
l = []
|
|
r = utils.pretty_choice_list(l)
|
|
self.assertEqual(r, "")
|
|
|
|
l = ["v1", "v2", "v3"]
|
|
r = utils.pretty_choice_list(l)
|
|
self.assertEqual(r, "'v1', 'v2', 'v3'")
|
|
|
|
def test_pretty_choice_dict(self):
|
|
d = {}
|
|
r = utils.pretty_choice_dict(d)
|
|
self.assertEqual(r, "")
|
|
|
|
d = {"k1": "v1",
|
|
"k2": "v2",
|
|
"k3": "v3"}
|
|
r = utils.pretty_choice_dict(d)
|
|
self.assertEqual(r, "'k1=v1', 'k2=v2', 'k3=v3'")
|
|
|
|
|
|
class ValidationsTestCase(test_utils.TestCase):
|
|
def test_validate_flavor_metadata_keys_with_valid_keys(self):
|
|
valid_keys = ['key1', 'month.price', 'I-Am:AK-ey.01-', 'spaces and _']
|
|
for key in valid_keys:
|
|
utils.validate_flavor_metadata_keys(valid_keys)
|
|
|
|
def test_validate_flavor_metadata_keys_with_invalid_keys(self):
|
|
invalid_keys = ['/1', '?1', '%1', '<', '>', '\1']
|
|
for key in invalid_keys:
|
|
try:
|
|
utils.validate_flavor_metadata_keys([key])
|
|
self.assertFail()
|
|
except exceptions.CommandError as ce:
|
|
self.assertTrue(key in str(ce))
|