Create a model structure for requests

Author: gmr

consulate/models/__init__.py

@@ -0,0 +1,2 @@
+# coding=utf-8
+"""Consulate Data Models"""

consulate/models/base.py

@@ -0,0 +1,151 @@
+# coding=utf-8
+"""
+Base Model
+
+"""
+import collections
+
+
+class Model(collections.Iterable):
+    """A model contains an __attribute__ map that defines the name,
+    its type for type validation, an optional validation method, a method
+    used to
+
+    .. python::
+
+        class MyModel(Model):
+
+            __attributes__ = {
+                'ID': {
+                    'type': uuid.UUID,
+                    'required': False,
+                    'default': None,
+                    'cast_from': str,
+                    'cast_to': str
+                },
+                'Serial': {
+                    'type': int
+                    'required': True,
+                    'default': 0,
+                    'validator': lambda v: v >= 0 end,
+                }
+            }
+
+    """
+
+    __attributes__ = {}
+    """The attributes that define the data elements of the model"""
+
+    def __init__(self, **kwargs):
+        super(Model, self).__init__()
+        [setattr(self, key, value) for key, value in kwargs.items()]
+        [self._set_default(k) for k in self.__attributes__.keys()
+         if k not in kwargs.keys()]
+
+    def __iter__(self):
+        """Iterate through the model's key, value pairs.
+
+        :rtype: iterator
+
+        """
+        for name in self.__attributes__.keys():
+            value = self._maybe_cast_value(name)
+            if value is not None:
+                yield self._maybe_return_key(name), value
+
+    def __setattr__(self, name, value):
+        """Set the value for an attribute of the model, validating the
+        attribute name and its type if the type is defined in ``__types__``.
+
+        :param str name: The attribute name
+        :param mixed value: The value to set
+        :raises: AttributeError
+        :raises: TypeError
+        :raises: ValueError
+
+        """
+        if name not in self.__attributes__:
+            raise AttributeError('Invalid attribute "{}"'.format(name))
+        value = self._validate_value(name, value)
+        super(Model, self).__setattr__(name, value)
+
+    def _maybe_cast_value(self, name):
+        """Return the attribute value, possibly cast to a different type if
+        the ``cast_to`` item is set in the attribute definition.
+
+        :param str name: The attribute name
+        :rtype: mixed
+
+        """
+        value = getattr(self, name)
+        if value is not None and self.__attributes__[name].get('cast_to'):
+            return self.__attributes__[name]['cast_to'](value)
+        return value
+
+    def _maybe_return_key(self, name):
+        """Return the attribute name as specified in it's ``key`` definition,
+        if specified. This is to map python attribute names to their Consul
+        alternatives.
+
+        :param str name: The attribute name
+        :rtype: mixed
+
+        """
+        if self.__attributes__[name].get('key'):
+            return self.__attributes__[name]['key']
+        return name
+
+    def _required_attr(self, name):
+        """Returns :data:`True` if the attribute is required.
+
+        :param str name: The attribute name
+        :rtype: bool
+
+        """
+        return self.__attributes__[name].get('required', False)
+
+    def _set_default(self, name):
+        """Set the default value for the attribute name.
+
+        :param str name: The attribute name
+
+        """
+        setattr(self, name, self.__attributes__[name].get('default', None))
+
+    def _validate_value(self, name, value):
+        """Ensures the the value validates based upon the type or a validation
+        function, raising an error if it does not.
+
+        :param str name: The attribute name
+        :param mixed value: The value that is being set
+        :rtype: mixed
+        :raises: TypeError
+        :raises: ValueError
+
+        """
+        if value is None and self._required_attr(name):
+            raise ValueError('Attribute "{}" is required'.format(name))
+
+        if value is not None:
+            if not isinstance(value, self.__attributes__[name].get('type')):
+                cast_from = self.__attributes__[name].get('cast_from')
+                if cast_from and isinstance(value, cast_from):
+                    value = self.__attributes__[name]['type'](value)
+                else:
+                    raise TypeError(
+                        'Attribute "{}" must be of type {} not {}'.format(
+                            name, self.__attributes__[name]['type'].__name__,
+                            value.__class__.__name__))
+
+            if self.__attributes__[name].get('enum') \
+                    and value not in self.__attributes__[name]['enum']:
+                raise ValueError(
+                    'Attribute "{}" value {!r} not valid'.format(name, value))
+
+        validator = self.__attributes__[name].get('validator')
+        if callable(validator):
+            if not validator(value):
+                raise ValueError(
+                    'Attribute "{}" value {!r} did not validate'.format(
+                        name, value))
+        return value

tests/base_model_tests.py

@@ -0,0 +1,139 @@
+# coding=utf-8
+"""Tests for the Base Model"""
+import unittest
+import uuid
+
+from consulate.models import base
+
+
+class TestModel(base.Model):
+    """Model to perform tests against"""
+    __slots__ = ['id', 'serial', 'name', 'value']
+    __attributes__ = {
+        'id': {
+            'key': 'ID',
+            'type': uuid.UUID,
+            'cast_from': str,
+            'cast_to': str,
+        },
+        'serial': {
+            'key': 'Serial',
+            'type': int,
+            'default': 0,
+            'required': True,
+            'validator': lambda v: v >= 0,
+        },
+        'name': {
+            'key': 'Name',
+            'type': str,
+            'required': True
+        },
+        'value': {
+            'type': str
+        },
+        'type': {
+            'key': 'Type',
+            'type': str,
+            'enum': {'client', 'server'}
+        }
+    }
+
+
+class TestCase(unittest.TestCase):
+
+    def test_happy_case_with_defaults(self):
+        kwargs = {
+            'id': uuid.uuid4(),
+            'name': str(uuid.uuid4())
+        }
+        model = TestModel(**kwargs)
+        for key, value in kwargs.items():
+            self.assertEqual(getattr(model, key), value)
+        self.assertEqual(model.serial, 0)
+
+    def test_happy_case_with_all_values(self):
+        kwargs = {
+            'id': uuid.uuid4(),
+            'serial': 1,
+            'name': str(uuid.uuid4()),
+            'value': str(uuid.uuid4())
+        }
+        model = TestModel(**kwargs)
+        for key, value in kwargs.items():
+            self.assertEqual(getattr(model, key), value)
+
+    def test_cast_from_str(self):
+        expectation = uuid.uuid4()
+        kwargs = {
+            'id': str(expectation),
+            'name': str(uuid.uuid4())
+        }
+        model = TestModel(**kwargs)
+        self.assertEqual(model.id, expectation)
+
+    def test_validator_failure(self):
+        kwargs = {
+            'id': uuid.uuid4(),
+            'name': str(uuid.uuid4()),
+            'serial': -1
+        }
+        with self.assertRaises(ValueError):
+            TestModel(**kwargs)
+
+    def test_type_failure(self):
+        kwargs = {
+            'id': True,
+            'name': str(uuid.uuid4())
+        }
+        with self.assertRaises(TypeError):
+            TestModel(**kwargs)
+
+    def test_missing_requirement(self):
+        with self.assertRaises(ValueError):
+            TestModel()
+
+    def test_invalid_attribute(self):
+        kwargs = {'name': str(uuid.uuid4()), 'foo': 'bar'}
+        with self.assertRaises(AttributeError):
+            TestModel(**kwargs)
+
+    def test_invalid_attribute_assignment(self):
+        kwargs = {'name': str(uuid.uuid4())}
+        model = TestModel(**kwargs)
+        with self.assertRaises(AttributeError):
+            model.foo = 'bar'
+
+    def test_invalid_enum_assignment(self):
+        kwargs = {'name': str(uuid.uuid4()), 'type': 'invalid'}
+        with self.assertRaises(ValueError):
+            TestModel(**kwargs)
+
+    def test_cast_to_dict(self):
+        kwargs = {
+            'id': uuid.uuid4(),
+            'serial': 1,
+            'name': str(uuid.uuid4()),
+            'value': str(uuid.uuid4()),
+            'type': 'client'
+        }
+        expectation = {
+            'ID': str(kwargs['id']),
+            'Serial': kwargs['serial'],
+            'Name': kwargs['name'],
+            'value': kwargs['value'],
+            'Type': kwargs['type']
+        }
+        model = TestModel(**kwargs)
+        self.assertDictEqual(dict(model), expectation)
+
+    def test_cast_to_dict_only_requirements(self):
+        kwargs = {
+            'serial': 1,
+            'name': str(uuid.uuid4())
+        }
+        expectation = {
+            'Serial': kwargs['serial'],
+            'Name': kwargs['name']
+        }
+        model = TestModel(**kwargs)
+        self.assertDictEqual(dict(model), expectation)