Add Collection and Collection field

Author: rmk135

domain_models/collections.py

@@ -0,0 +1,81 @@
+"""Collections module."""
+
+import six
+
+from . import errors
+
+
+class Collection(list):
+    """Collection."""
+
+    def __init__(self, value_type, iterable=None, type_check=True):
+        """Initializer."""
+        if not isinstance(value_type, six.class_types):
+            raise errors.Error('Collection value_type should be valid type, '
+                               'instead got - {0}'.format(value_type))
+        self.value_type = value_type
+
+        if not iterable:
+            iterable = tuple()
+
+        if type_check:
+            iterable = self._ensure_iterable_is_valid(iterable)
+
+        super(Collection, self).__init__(iterable)
+
+    def append(self, value):
+        """Add an item to the end of the list."""
+        return super(Collection, self).append(
+            self._ensure_value_is_valid(value))
+
+    def extend(self, iterable):
+        """Extend the list by appending all the items in the given list."""
+        return super(Collection, self).extend(
+            self._ensure_iterable_is_valid(iterable))
+
+    def insert(self, index, value):
+        """Insert an item at a given position."""
+        return super(Collection, self).insert(
+            index, self._ensure_value_is_valid(value))
+
+    def __setitem__(self, index, value):
+        """Set an item at a given position."""
+        if isinstance(index, slice):
+            return super(Collection, self).__setitem__(
+                index, self.__class__(self.value_type, value))
+        else:
+            return super(Collection, self).__setitem__(
+                index, self._ensure_value_is_valid(value))
+
+    def __getitem__(self, index):
+        """Return value by index or slice of values if index is slice."""
+        value = super(Collection, self).__getitem__(index)
+        if isinstance(index, slice):
+            return self.__class__(self.value_type, value, type_check=False)
+        return value
+
+    if six.PY2:  # pragma: nocover
+        def __getslice__(self, start, stop):
+            """Return slice of values."""
+            return self.__class__(self.value_type,
+                                  super(Collection, self).__getslice__(start,
+                                                                       stop),
+                                  type_check=False)
+
+        def __setslice__(self, start, stop, iterable):
+            """Set slice of values."""
+            iterable = self.__class__(self.value_type, iterable)
+            super(Collection, self).__setslice__(start, stop, iterable)
+
+    def _ensure_iterable_is_valid(self, iterable):
+        """Ensure that iterable values are a valid collection's values."""
+        for value in iterable:
+            self._ensure_value_is_valid(value)
+        return iterable
+
+    def _ensure_value_is_valid(self, value):
+        """Ensure that value is a valid collection's value."""
+        if not isinstance(value, self.value_type):
+            raise TypeError('{0} is not valid collection value, instance '
+                            'of {1} required'.format(value, self.value_type))
+        return value

domain_models/errors.py

@@ -1,4 +1,4 @@
-"""Domain models error module."""
+"""Errors module."""
 
 
 class Error(Exception):

domain_models/fields.py

@@ -1,9 +1,10 @@
-"""Domain models fields."""
+"""Fields module."""
 
 import datetime
 
 import six
 
+from . import collections
 from . import errors
 
 
@@ -129,3 +130,23 @@ def _converter(self, value):
                             '{1} required'.format(value,
                                                   self.related_model_cls))
         return value
+
+
+class Collection(Field):
+    """Models collection relation field."""
+
+    def __init__(self, related_model_cls, default=None):
+        """Initializer."""
+        super(Collection, self).__init__(default=default)
+
+        self.related_model_cls = related_model_cls
+
+    def _converter(self, value):
+        """Convert raw input value of the field."""
+        if isinstance(value, collections.Collection):
+            if value.value_type is not self.related_model_cls:
+                value = collections.Collection(self.related_model_cls, value)
+        else:
+            value = collections.Collection(self.related_model_cls, value)
+
+        return value

domain_models/model.py renamed to domain_models/models.py

@@ -1,4 +1,6 @@
-"""Domain models model."""
+"""Models module."""
+
+from __future__ import absolute_import
 
 import collections
 import six

tests/test_collections.py

@@ -0,0 +1,161 @@
+"""Collections tests."""
+
+import unittest2
+
+from domain_models import collections
+from domain_models import errors
+
+
+class CollectionTests(unittest2.TestCase):
+    """Collection tests."""
+
+    def test_init_empty(self):
+        """Test creation of collection."""
+        collection = collections.Collection(int)
+
+        self.assertIsInstance(collection, collections.Collection)
+        self.assertIsInstance(collection, list)
+
+    def test_init_with_correct_values(self):
+        """Test creation of collection."""
+        collection = collections.Collection(int, (1, 2, 3))
+
+        self.assertEqual(collection, [1, 2, 3])
+
+    def test_init_with_incorrect_values(self):
+        """Test creation of collection."""
+        with self.assertRaises(TypeError):
+            collections.Collection(int, ('1', '2', '3'))
+
+    def test_init_without_value_type(self):
+        """Test creation of collection."""
+        with self.assertRaises(errors.Error):
+            collections.Collection(None)
+
+        with self.assertRaises(errors.Error):
+            collections.Collection(1)
+
+        with self.assertRaises(errors.Error):
+            collections.Collection(object())
+
+    def test_append_valid_type(self):
+        """Test append."""
+        collection = collections.Collection(int)
+
+        collection.append(1)
+
+        self.assertEqual(collection, [1])
+
+    def test_append_invalid_type(self):
+        """Test append."""
+        collection = collections.Collection(int)
+
+        with self.assertRaises(TypeError):
+            collection.append('1')
+
+    def test_extend_valid_type(self):
+        """Test extend."""
+        collection = collections.Collection(int)
+
+        collection.extend([1])
+
+        self.assertEqual(collection, [1])
+
+    def test_extend_invalid_type(self):
+        """Test extend."""
+        collection = collections.Collection(int)
+
+        with self.assertRaises(TypeError):
+            collection.extend(['1'])
+
+    def test_insert_valid_type(self):
+        """Test insert."""
+        collection = collections.Collection(int)
+
+        collection.insert(0, 1)
+
+        self.assertEqual(collection, [1])
+
+    def test_insert_invalid_type(self):
+        """Test insert."""
+        collection = collections.Collection(int)
+
+        with self.assertRaises(TypeError):
+            collection.insert(0, '1')
+
+    def test_set_valid_type(self):
+        """Test set."""
+        collection = collections.Collection(int, [0])
+
+        collection[0] = 1
+
+        self.assertEqual(collection, [1])
+
+    def test_set_invalid_type(self):
+        """Test set."""
+        collection = collections.Collection(int, [0])
+
+        with self.assertRaises(TypeError):
+            collection[0] = '1'
+
+    def test_set_valid_slice(self):
+        """Test set slice."""
+        collection = collections.Collection(int, [1, 2, 3])
+
+        collection[0:3] = [7, 7, 7]
+
+        self.assertEqual(collection, [7, 7, 7])
+
+    def test_set_invalid_slice(self):
+        """Test set slice."""
+        collection = collections.Collection(int, [1, 2, 3])
+
+        with self.assertRaises(TypeError):
+            collection[0:3] = [7, '7', 7]
+
+        self.assertEqual(collection, [1, 2, 3])
+
+    def test_set_valid_slice_setitem(self):
+        """Test set slice."""
+        collection = collections.Collection(int, [1, 2, 3])
+
+        collection.__setitem__(slice(0, 3), [7, 7, 7])
+
+        self.assertEqual(collection, [7, 7, 7])
+
+    def test_set_invalid_slice_setitem(self):
+        """Test set slice."""
+        collection = collections.Collection(int, [1, 2, 3])
+
+        with self.assertRaises(TypeError):
+            collection.__setitem__(slice(0, 3), [7, '7', 7])
+
+        self.assertEqual(collection, [1, 2, 3])
+
+    def test_get_item(self):
+        """Test getting of item."""
+        collection = collections.Collection(int, [1, 2, 3])
+
+        self.assertEqual(collection[0], 1)
+        self.assertEqual(collection[1], 2)
+        self.assertEqual(collection[2], 3)
+
+    def test_get_slice(self):
+        """Test getting of slice."""
+        collection = collections.Collection(int, [1, 2, 3])
+
+        collection_slice = collection[0:2]
+
+        self.assertEqual(collection_slice, [1, 2])
+        self.assertIsInstance(collection_slice, collections.Collection)
+        self.assertIs(collection.value_type, collection_slice.value_type)
+
+    def test_getitem_slice(self):
+        """Test getting of slice."""
+        collection = collections.Collection(int, [1, 2, 3])
+
+        collection_slice = collection.__getitem__(slice(0, 2))
+
+        self.assertEqual(collection_slice, [1, 2])
+        self.assertIsInstance(collection_slice, collections.Collection)
+        self.assertIs(collection.value_type, collection_slice.value_type)