saltstack/salt
1
0
Fork 0
mirror of https://github.com/saltstack/salt.git synced 2025-04-17 10:10:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Merge pull request #25106 from s0undt3ch/features/raas-17-salt-cloud-ng

Browse source 
Minor refactor + Unit tests for salt.utils.config + minor changes to 2 cloud drivers
This commit is contained in:
Pedro Algarvio 2015-07-02 11:58:34 +01:00
commit f65501fff4
4 changed files with 788 additions and 27 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
salt/cloud/clouds/aliyun.py
View file

@ -70,6 +70,8 @@ DEFAULT_LOCATION = 'cn-hangzhou'
DEFAULT_ALIYUN_API_VERSION = '2013-01-10'
__virtualname__ = 'aliyun'
# Only load in this module if the aliyun configurations are in place
def __virtual__():
@ -759,7 +761,6 @@ def query(params=None):
log.debug(request.url)
content = request.text
#print content
result = json.loads(content, object_hook=salt.utils.decode_dict)
if 'Code' in result:

4
salt/cloud/clouds/cloudstack.py
View file

@ -59,6 +59,8 @@ list_nodes_full = namespaced_function(list_nodes_full, globals())
list_nodes_select = namespaced_function(list_nodes_select, globals())
show_instance = namespaced_function(show_instance, globals())
__virtualname__ = 'cloudstack'
# Only load in this module if the CLOUDSTACK configurations are in place
def __virtual__():
@ -77,7 +79,7 @@ def get_configured_provider():
'''
return config.is_provider_configured(
__opts__,
__active_provider_name__ or 'cloudstack',
__active_provider_name__ or __virtualname__,
('apikey', 'secretkey', 'host', 'path')
)

66
salt/utils/config.py
View file

@ -581,7 +581,7 @@ class Configuration(six.with_metaclass(ConfigurationMeta, object)):
raise NotImplementedError
class BaseConfigItem(six.with_metaclass(BaseConfigItemMeta, object)):
class BaseItem(six.with_metaclass(BaseConfigItemMeta, object)):
'''
Base configuration items class.
@ -595,30 +595,11 @@ class BaseConfigItem(six.with_metaclass(BaseConfigItemMeta, object)):
__serialize_attr_aliases__ = None
def __init__(self, title=None, description=None, default=None, required=False, enum=None, **extra):
def __init__(self, required=False, **extra):
'''
:param title:
A short explanation about the purpose of the data described by this item.
:param description:
A detailed explanation about the purpose of the data described by this item.
:param default:
The default value for this configuration item. May be :data:`.Null` (a special value
to set the default value to null).
:param required: If the configuration item is required. Defaults to ``False``.
:param enum: A list(list, tuple, set) of valid choices.
'''
self.title = title
self.description = description or self.__doc__
self.default = default
self.required = required
if enum is not None:
if not isinstance(enum, (list, tuple, set)):
raise RuntimeError(
'Only the \'list\', \'tuple\' and \'set\' python types can be used '
'to define \'enum\''
)
enum = list(enum)
self.enum = enum
self.extra = extra
def _get_argname_value(self, argname):
@ -653,6 +634,41 @@ class BaseConfigItem(six.with_metaclass(BaseConfigItemMeta, object)):
serialized[argname] = argvalue
return serialized
class BaseConfigItem(BaseItem):
'''
Base configuration items class.
All configurations must subclass it
'''
def __init__(self, title=None, description=None, default=None, enum=None, **kwargs):
'''
:param required:
If the configuration item is required. Defaults to ``False``.
:param title:
A short explanation about the purpose of the data described by this item.
:param description:
A detailed explanation about the purpose of the data described by this item.
:param default:
The default value for this configuration item. May be :data:`.Null` (a special value
to set the default value to null).
:param enum:
A list(list, tuple, set) of valid choices.
'''
self.title = title
self.description = description or self.__doc__
self.default = default
if enum is not None:
if not isinstance(enum, (list, tuple, set)):
raise RuntimeError(
'Only the \'list\', \'tuple\' and \'set\' python types can be used '
'to define \'enum\''
)
enum = list(enum)
self.enum = enum
super(BaseConfigItem, self).__init__(**kwargs)
def render_as_rst(self, name):
'''
Render the configuration item as a restructured text string
@ -708,6 +724,8 @@ class StringConfig(BaseConfigItem):
max_length=None,
**kwargs):
'''
:param required:
If the configuration item is required. Defaults to ``False``.
:param title:
A short explanation about the purpose of the data described by this item.
:param description:
@ -715,8 +733,6 @@ class StringConfig(BaseConfigItem):
:param default:
The default value for this configuration item. May be :data:`.Null` (a special value
to set the default value to null).
:param required:
If the configuration item is required. Defaults to ``False``.
:param enum:
A list(list, tuple, set) of valid choices.
:param format:
@ -815,6 +831,8 @@ class NumberConfig(BaseConfigItem):
exclusive_maximum=None,
**kwargs):
'''
:param required:
If the configuration item is required. Defaults to ``False``.
:param title:
A short explanation about the purpose of the data described by this item.
:param description:
@ -822,8 +840,6 @@ class NumberConfig(BaseConfigItem):
:param default:
The default value for this configuration item. May be :data:`.Null` (a special value
to set the default value to null).
:param required:
If the configuration item is required. Defaults to ``False``.
:param enum:
A list(list, tuple, set) of valid choices.
:param multiple_of:

742
tests/unit/utils/config_test.py Normal file
View file

@ -0,0 +1,742 @@
# -*- coding: utf-8 -*-
# pylint: disable=function-redefined
# TODO: Remove the following PyLint disable as soon as we support YAML and RST rendering
# pylint: disable=abstract-method
# Import python libs
from __future__ import absolute_import
# Import Salt Testing Libs
from salttesting import TestCase, skipIf
from salttesting.helpers import ensure_in_syspath
ensure_in_syspath('../../')
# Import Salt Libs
from salt.utils import config
# Import 3rd-party libs
try:
import jsonschema
import jsonschema.exceptions
HAS_JSONSCHEMA = True
except ImportError:
HAS_JSONSCHEMA = False
# pylint: disable=unused-import
try:
import rfc3987
HAS_RFC3987 = True
except ImportError:
HAS_RFC3987 = False
try:
import strict_rfc3339
HAS_STRICT_RFC3339 = True
except ImportError:
HAS_STRICT_RFC3339 = False
try:
import isodate
HAS_ISODATE = True
except ImportError:
HAS_ISODATE = False
# pylint: enable=unused-import
class ConfigTestCase(TestCase):
'''
TestCase for salt.utils.config module
'''
def test_boolean_config(self):
item = config.BooleanConfig(title='Hungry', description='Are you hungry?')
self.assertDictEqual(
item.serialize(), {
'type': 'boolean',
'title': item.title,
'description': item.description
}
)
item = config.BooleanConfig(title='Hungry',
description='Are you hungry?',
default=False)
self.assertDictEqual(
item.serialize(), {
'type': 'boolean',
'title': item.title,
'description': item.description,
'default': item.default
}
)
@skipIf(HAS_JSONSCHEMA is False, 'The \'jsonschema\' library is missing')
def test_boolean_config_validation(self):
class TestConf(config.Configuration):
item = config.BooleanConfig(title='Hungry', description='Are you hungry?')
try:
jsonschema.validate({'item': False}, TestConf.serialize())
except jsonschema.exceptions.ValidationError as exc:
self.fail('ValidationError raised: {0}'.format(exc))
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': 1}, TestConf.serialize())
self.assertIn('is not of type', excinfo.exception.message)
def test_string_config(self):
item = config.StringConfig(title='Foo', description='Foo Item')
self.assertDictEqual(
item.serialize(), {
'type': 'string',
'title': item.title,
'description': item.description
}
)
item = config.StringConfig(title='Foo', description='Foo Item', min_length=1, max_length=3)
self.assertDictEqual(
item.serialize(), {
'type': 'string',
'title': item.title,
'description': item.description,
'minLength': item.min_length,
'maxLength': item.max_length
}
)
item = config.StringConfig(title='Foo',
description='Foo Item',
min_length=1,
max_length=3,
default='foo')
self.assertDictEqual(
item.serialize(), {
'type': 'string',
'title': item.title,
'description': item.description,
'minLength': item.min_length,
'maxLength': item.max_length,
'default': 'foo'
}
)
item = config.StringConfig(title='Foo',
description='Foo Item',
min_length=1,
max_length=3,
enum=('foo', 'bar'))
self.assertDictEqual(
item.serialize(), {
'type': 'string',
'title': item.title,
'description': item.description,
'minLength': item.min_length,
'maxLength': item.max_length,
'enum': ['foo', 'bar']
}
)
item = config.StringConfig(title='Foo',
description='Foo Item',
pattern=r'^([\w_-]+)$')
self.assertDictEqual(
item.serialize(), {
'type': 'string',
'title': item.title,
'description': item.description,
'pattern': item.pattern
}
)
@skipIf(HAS_JSONSCHEMA is False, 'The \'jsonschema\' library is missing')
def test_string_config_validation(self):
class TestConf(config.Configuration):
item = config.StringConfig(title='Foo', description='Foo Item')
try:
jsonschema.validate({'item': 'the item'}, TestConf.serialize())
except jsonschema.exceptions.ValidationError as exc:
self.fail('ValidationError raised: {0}'.format(exc))
class TestConf(config.Configuration):
item = config.StringConfig(title='Foo', description='Foo Item',
min_length=1, max_length=10)
try:
jsonschema.validate({'item': 'the item'}, TestConf.serialize())
except jsonschema.exceptions.ValidationError as exc:
self.fail('ValidationError raised: {0}'.format(exc))
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': 3}, TestConf.serialize())
self.assertIn('is not of type', excinfo.exception.message)
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': 'the item the item'}, TestConf.serialize())
self.assertIn('is too long', excinfo.exception.message)
class TestConf(config.Configuration):
item = config.StringConfig(title='Foo', description='Foo Item',
min_length=10, max_length=100)
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': 'the item'}, TestConf.serialize())
self.assertIn('is too short', excinfo.exception.message)
class TestConf(config.Configuration):
item = config.StringConfig(title='Foo',
description='Foo Item',
enum=('foo', 'bar'))
try:
jsonschema.validate({'item': 'foo'}, TestConf.serialize())
except jsonschema.exceptions.ValidationError as exc:
self.fail('ValidationError raised: {0}'.format(exc))
class TestConf(config.Configuration):
item = config.StringConfig(title='Foo',
description='Foo Item',
enum=('foo', 'bar'))
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': 'bin'}, TestConf.serialize())
self.assertIn('is not one of', excinfo.exception.message)
class TestConf(config.Configuration):
item = config.StringConfig(title='Foo', description='Foo Item',
pattern=r'^([\w_-]+)$')
try:
jsonschema.validate({'item': 'the-item'}, TestConf.serialize(),
format_checker=jsonschema.FormatChecker())
except jsonschema.exceptions.ValidationError as exc:
self.fail('ValidationError raised: {0}'.format(exc))
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': 'the item'}, TestConf.serialize(),
format_checker=jsonschema.FormatChecker())
self.assertIn('does not match', excinfo.exception.message)
def test_email_config(self):
item = config.EMailConfig(title='Foo', description='Foo Item')
self.assertDictEqual(
item.serialize(), {
'type': 'string',
'title': item.title,
'description': item.description,
'format': item.format
}
)
@skipIf(HAS_JSONSCHEMA is False, 'The \'jsonschema\' library is missing')
def test_email_config_validation(self):
class TestConf(config.Configuration):
item = config.EMailConfig(title='Item', description='Item description')
try:
jsonschema.validate({'item': 'nobody@nowhere.com'}, TestConf.serialize(),
format_checker=jsonschema.FormatChecker())
except jsonschema.exceptions.ValidationError as exc:
self.fail('ValidationError raised: {0}'.format(exc))
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': '3'}, TestConf.serialize(),
format_checker=jsonschema.FormatChecker())
self.assertIn('is not a', excinfo.exception.message)
def test_ipv4_config(self):
item = config.IPv4Config(title='Foo', description='Foo Item')
self.assertDictEqual(
item.serialize(), {
'type': 'string',
'title': item.title,
'description': item.description,
'format': item.format
}
)
@skipIf(HAS_JSONSCHEMA is False, 'The \'jsonschema\' library is missing')
def test_ipv4_config_validation(self):
class TestConf(config.Configuration):
item = config.IPv4Config(title='Item', description='Item description')
try:
jsonschema.validate({'item': '127.0.0.1'}, TestConf.serialize(),
format_checker=jsonschema.FormatChecker())
except jsonschema.exceptions.ValidationError as exc:
self.fail('ValidationError raised: {0}'.format(exc))
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': '3'}, TestConf.serialize(),
format_checker=jsonschema.FormatChecker())
self.assertIn('is not a', excinfo.exception.message)
def test_ipv6_config(self):
item = config.IPv6Config(title='Foo', description='Foo Item')
self.assertDictEqual(
item.serialize(), {
'type': 'string',
'title': item.title,
'description': item.description,
'format': item.format
}
)
@skipIf(HAS_JSONSCHEMA is False, 'The \'jsonschema\' library is missing')
def test_ipv6_config_validation(self):
class TestConf(config.Configuration):
item = config.IPv6Config(title='Item', description='Item description')
try:
jsonschema.validate({'item': '::1'}, TestConf.serialize(),
format_checker=jsonschema.FormatChecker())
except jsonschema.exceptions.ValidationError as exc:
self.fail('ValidationError raised: {0}'.format(exc))
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': '3'}, TestConf.serialize(),
format_checker=jsonschema.FormatChecker())
self.assertIn('is not a', excinfo.exception.message)
def test_hostname_config(self):
item = config.HostnameConfig(title='Foo', description='Foo Item')
self.assertDictEqual(
item.serialize(), {
'type': 'string',
'title': item.title,
'description': item.description,
'format': item.format
}
)
@skipIf(HAS_JSONSCHEMA is False, 'The \'jsonschema\' library is missing')
def test_hostname_config_validation(self):
class TestConf(config.Configuration):
item = config.HostnameConfig(title='Item', description='Item description')
try:
jsonschema.validate({'item': 'localhost'}, TestConf.serialize(),
format_checker=jsonschema.FormatChecker())
except jsonschema.exceptions.ValidationError as exc:
self.fail('ValidationError raised: {0}'.format(exc))
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': '3'}, TestConf.serialize(),
format_checker=jsonschema.FormatChecker())
self.assertIn('is not a', excinfo.exception.message)
def test_datetime_config(self):
item = config.DateTimeConfig(title='Foo', description='Foo Item')
self.assertDictEqual(
item.serialize(), {
'type': 'string',
'title': item.title,
'description': item.description,
'format': item.format
}
)
@skipIf(HAS_JSONSCHEMA is False, 'The \'jsonschema\' library is missing')
@skipIf(any([HAS_ISODATE, HAS_STRICT_RFC3339]) is False, 'The \'strict_rfc3339\' or \'isodate\' library is missing')
def test_datetime_config_validation(self):
class TestConf(config.Configuration):
item = config.DateTimeConfig(title='Item', description='Item description')
try:
jsonschema.validate({'item': '2015-07-01T18:05:27+01:00'}, TestConf.serialize(),
format_checker=jsonschema.FormatChecker())
except jsonschema.exceptions.ValidationError as exc:
self.fail('ValidationError raised: {0}'.format(exc))
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': '3'}, TestConf.serialize(),
format_checker=jsonschema.FormatChecker())
self.assertIn('is not a', excinfo.exception.message)
def test_secret_config(self):
item = config.SecretConfig(title='Foo', description='Foo Item')
self.assertDictEqual(
item.serialize(), {
'type': 'string',
'title': item.title,
'description': item.description,
'format': item.format
}
)
def test_uri_config(self):
item = config.UriConfig(title='Foo', description='Foo Item')
self.assertDictEqual(
item.serialize(), {
'type': 'string',
'title': item.title,
'description': item.description,
'format': item.format
}
)
@skipIf(HAS_JSONSCHEMA is False, 'The \'jsonschema\' library is missing')
@skipIf(HAS_RFC3987 is False, 'The \'rfc3987\' library is missing')
def test_uri_config_validation(self):
class TestConf(config.Configuration):
item = config.UriConfig(title='Item', description='Item description')
try:
jsonschema.validate({'item': 'ssh://localhost'}, TestConf.serialize(),
format_checker=jsonschema.FormatChecker())
except jsonschema.exceptions.ValidationError as exc:
self.fail('ValidationError raised: {0}'.format(exc))
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': '3'}, TestConf.serialize(),
format_checker=jsonschema.FormatChecker())
self.assertIn('is not a', excinfo.exception.message)
def test_number_config(self):
item = config.NumberConfig(title='How many dogs', description='Question')
self.assertDictEqual(
item.serialize(), {
'type': 'number',
'title': item.title,
'description': item.description
}
)
item = config.NumberConfig(title='How many dogs',
description='Question',
minimum=0,
maximum=10)
self.assertDictEqual(
item.serialize(), {
'type': 'number',
'title': item.title,
'description': item.description,
'minimum': item.minimum,
'maximum': item.maximum
}
)
item = config.NumberConfig(title='How many dogs',
description='Question',
multiple_of=2)
self.assertDictEqual(
item.serialize(), {
'type': 'number',
'title': item.title,
'description': item.description,
'multipleOf': item.multiple_of
}
)
item = config.NumberConfig(title='How many dogs',
description='Question',
minimum=0,
exclusive_minimum=True,
maximum=10,
exclusive_maximum=True)
self.assertDictEqual(
item.serialize(), {
'type': 'number',
'title': item.title,
'description': item.description,
'minimum': item.minimum,
'maximum': item.maximum,
'exclusiveMinimum': True,
'exclusiveMaximum': True
}
)
item = config.NumberConfig(title='How many dogs',
description='Question',
minimum=0,
maximum=10,
default=0)
self.assertDictEqual(
item.serialize(), {
'type': 'number',
'title': item.title,
'description': item.description,
'minimum': item.minimum,
'maximum': item.maximum,
'default': 0
}
)
item = config.NumberConfig(title='How many dogs',
description='Question',
minimum=0,
maximum=10,
default=0,
enum=(0, 2, 4, 6))
self.assertDictEqual(
item.serialize(), {
'type': 'number',
'title': item.title,
'description': item.description,
'minimum': item.minimum,
'maximum': item.maximum,
'default': 0,
'enum': [0, 2, 4, 6]
}
)
@skipIf(HAS_JSONSCHEMA is False, 'The \'jsonschema\' library is missing')
def test_number_config_validation(self):
class TestConf(config.Configuration):
item = config.NumberConfig(title='How many dogs', description='Question')
try:
jsonschema.validate({'item': 2}, TestConf.serialize())
except jsonschema.exceptions.ValidationError as exc:
self.fail('ValidationError raised: {0}'.format(exc))
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': '3'}, TestConf.serialize())
self.assertIn('is not of type', excinfo.exception.message)
class TestConf(config.Configuration):
item = config.NumberConfig(title='How many dogs',
description='Question',
multiple_of=2.2)
try:
jsonschema.validate({'item': 4.4}, TestConf.serialize())
except jsonschema.exceptions.ValidationError as exc:
self.fail('ValidationError raised: {0}'.format(exc))
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': 4}, TestConf.serialize())
self.assertIn('is not a multiple of', excinfo.exception.message)
class TestConf(config.Configuration):
item = config.NumberConfig(title='Foo', description='Foo Item',
minimum=1, maximum=10)
try:
jsonschema.validate({'item': 3}, TestConf.serialize())
except jsonschema.exceptions.ValidationError as exc:
self.fail('ValidationError raised: {0}'.format(exc))
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': 11}, TestConf.serialize())
self.assertIn('is greater than the maximum of', excinfo.exception.message)
class TestConf(config.Configuration):
item = config.NumberConfig(title='Foo', description='Foo Item',
minimum=10, maximum=100)
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': 3}, TestConf.serialize())
self.assertIn('is less than the minimum of', excinfo.exception.message)
class TestConf(config.Configuration):
item = config.NumberConfig(title='How many dogs',
description='Question',
minimum=0,
exclusive_minimum=True,
maximum=10,
exclusive_maximum=True)
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': 0}, TestConf.serialize())
self.assertIn('is less than or equal to the minimum of', excinfo.exception.message)
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': 10}, TestConf.serialize())
self.assertIn('is greater than or equal to the maximum of', excinfo.exception.message)
class TestConf(config.Configuration):
item = config.NumberConfig(title='Foo',
description='Foo Item',
enum=(0, 2, 4, 6))
try:
jsonschema.validate({'item': 4}, TestConf.serialize())
except jsonschema.exceptions.ValidationError as exc:
self.fail('ValidationError raised: {0}'.format(exc))
class TestConf(config.Configuration):
item = config.NumberConfig(title='Foo',
description='Foo Item',
enum=(0, 2, 4, 6))
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': 3}, TestConf.serialize())
self.assertIn('is not one of', excinfo.exception.message)
def test_integer_config(self):
item = config.IntegerConfig(title='How many dogs', description='Question')
self.assertDictEqual(
item.serialize(), {
'type': 'integer',
'title': item.title,
'description': item.description
}
)
item = config.IntegerConfig(title='How many dogs',
description='Question',
minimum=0,
maximum=10)
self.assertDictEqual(
item.serialize(), {
'type': 'integer',
'title': item.title,
'description': item.description,
'minimum': item.minimum,
'maximum': item.maximum
}
)
item = config.IntegerConfig(title='How many dogs',
description='Question',
multiple_of=2)
self.assertDictEqual(
item.serialize(), {
'type': 'integer',
'title': item.title,
'description': item.description,
'multipleOf': item.multiple_of
}
)
item = config.IntegerConfig(title='How many dogs',
description='Question',
minimum=0,
exclusive_minimum=True,
maximum=10,
exclusive_maximum=True)
self.assertDictEqual(
item.serialize(), {
'type': 'integer',
'title': item.title,
'description': item.description,
'minimum': item.minimum,
'maximum': item.maximum,
'exclusiveMinimum': True,
'exclusiveMaximum': True
}
)
item = config.IntegerConfig(title='How many dogs',
description='Question',
minimum=0,
maximum=10,
default=0)
self.assertDictEqual(
item.serialize(), {
'type': 'integer',
'title': item.title,
'description': item.description,
'minimum': item.minimum,
'maximum': item.maximum,
'default': 0
}
)
item = config.IntegerConfig(title='How many dogs',
description='Question',
minimum=0,
maximum=10,
default=0,
enum=(0, 2, 4, 6))
self.assertDictEqual(
item.serialize(), {
'type': 'integer',
'title': item.title,
'description': item.description,
'minimum': item.minimum,
'maximum': item.maximum,
'default': 0,
'enum': [0, 2, 4, 6]
}
)
@skipIf(HAS_JSONSCHEMA is False, 'The \'jsonschema\' library is missing')
def test_integer_config_validation(self):
class TestConf(config.Configuration):
item = config.IntegerConfig(title='How many dogs', description='Question')
try:
jsonschema.validate({'item': 2}, TestConf.serialize())
except jsonschema.exceptions.ValidationError as exc:
self.fail('ValidationError raised: {0}'.format(exc))
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': 3.1}, TestConf.serialize())
self.assertIn('is not of type', excinfo.exception.message)
class TestConf(config.Configuration):
item = config.IntegerConfig(title='How many dogs',
description='Question',
multiple_of=2)
try:
jsonschema.validate({'item': 4}, TestConf.serialize())
except jsonschema.exceptions.ValidationError as exc:
self.fail('ValidationError raised: {0}'.format(exc))
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': 3}, TestConf.serialize())
self.assertIn('is not a multiple of', excinfo.exception.message)
class TestConf(config.Configuration):
item = config.IntegerConfig(title='Foo', description='Foo Item',
minimum=1, maximum=10)
try:
jsonschema.validate({'item': 3}, TestConf.serialize())
except jsonschema.exceptions.ValidationError as exc:
self.fail('ValidationError raised: {0}'.format(exc))
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': 11}, TestConf.serialize())
self.assertIn('is greater than the maximum of', excinfo.exception.message)
class TestConf(config.Configuration):
item = config.IntegerConfig(title='Foo', description='Foo Item',
minimum=10, maximum=100)
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': 3}, TestConf.serialize())
self.assertIn('is less than the minimum of', excinfo.exception.message)
class TestConf(config.Configuration):
item = config.IntegerConfig(title='How many dogs',
description='Question',
minimum=0,
exclusive_minimum=True,
maximum=10,
exclusive_maximum=True)
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': 0}, TestConf.serialize())
self.assertIn('is less than or equal to the minimum of', excinfo.exception.message)
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': 10}, TestConf.serialize())
self.assertIn('is greater than or equal to the maximum of', excinfo.exception.message)
class TestConf(config.Configuration):
item = config.IntegerConfig(title='Foo',
description='Foo Item',
enum=(0, 2, 4, 6))
try:
jsonschema.validate({'item': 4}, TestConf.serialize())
except jsonschema.exceptions.ValidationError as exc:
self.fail('ValidationError raised: {0}'.format(exc))
class TestConf(config.Configuration):
item = config.IntegerConfig(title='Foo',
description='Foo Item',
enum=(0, 2, 4, 6))
with self.assertRaises(jsonschema.exceptions.ValidationError) as excinfo:
jsonschema.validate({'item': 3}, TestConf.serialize())
self.assertIn('is not one of', excinfo.exception.message)
if __name__ == '__main__':
from integration import run_tests
run_tests(ConfigTestCase, needs_daemon=False)