implemented Item.from_dict() and Discount.from_dict()

dingguo/__init__.py

@@ -28,6 +28,12 @@ class Figure(object):
     """ use property() instead of decorator to enable overriding """
     unit = property(get_unit, set_unit)
 
+    def __eq__(self, other):
+        return type(self) == type(other) and self.value == other.value and self.unit == other.unit
+
+    def __ne__(self, other):
+        return not (self == other)
+
 class Distance(Figure):
 
     def __init__(self, value, unit):
@@ -93,6 +99,19 @@ class Discount(object):
             'value_currency': self.amount.currency,
             }
 
+    @staticmethod
+    def from_dict(attr):
+        return Discount(
+                name = attr['name'],
+                amount = Sum(attr['value'], attr['value_currency']),
+                )
+
+    def __eq__(self, other):
+        return type(self) == type(other) and self.name == other.name and self.amount == other.amount
+
+    def __ne__(self, other):
+        return not (self == other)
+
 yaml.SafeDumper.add_representer(Discount, lambda dumper, discount: dumper.represent_dict(discount.dict_repr()))
 
 class Order(object):
@@ -132,8 +151,17 @@ class Order(object):
         if 'customer_id' in attr:
             order.customer_id = attr['customer_id']
 
-        order.items = attr['articles']
-        order.discounts = attr['discounts']
+        for item in attr['articles']:
+            if type(item) is dict:
+                item = Item.from_dict(item)
+            assert isinstance(item, Item)
+            order.items.append(item)
+
+        for discount in attr['discounts']:
+            if type(discount) is dict:
+                discount = Discount.from_dict(discount)
+            assert isinstance(discount, Discount)
+            order.discounts.append(discount)
 
         return order
 
@@ -158,6 +186,19 @@ class Item(object):
             'price_brutto_currency': self.price_brutto.currency,
             }
 
+    @staticmethod
+    def from_dict(attr):
+        return Item(
+                name = attr['name'],
+                price_brutto = Sum(attr['price_brutto'], attr['price_brutto_currency']),
+                )
+
+    def __eq__(self, other):
+        return type(self) == type(other) and self.name == other.name and self.price_brutto == other.price_brutto
+
+    def __ne__(self, other):
+        return not (self == other)
+
 yaml.SafeDumper.add_representer(Item, lambda dumper, item: dumper.represent_dict(item.dict_repr()))
 
 class Article(Item):

tests/test_.py

@@ -38,7 +38,7 @@ def test_order_dict_repr():
             'platform': u'platform',
             }
 
-def test_order_from_dict():
+def test_order_from_dict_flat():
 
     item_0 = dingguo.Item(name = u'item 0', price_brutto = dingguo.Sum(1.0, u'EUR'))
     item_1 = dingguo.Item(name = u'item 1', price_brutto = dingguo.Sum(2.0, u'EUR'))
@@ -60,3 +60,171 @@ def test_order_from_dict():
     assert order.order_date == datetime.date(2016, 5, 8)
     assert order.order_id == u'id'
     assert order.platform == u'platform'
+
+def test_order_from_dict_tree():
+
+    order = dingguo.Order.from_dict({
+            'articles': [
+                {
+                    'name': u'item 0',
+                    'price_brutto': 1.0,
+                    'price_brutto_currency': u'EUR',
+                    },
+                {
+                    'name': u'item 1',
+                    'price_brutto': 2.0,
+                    'price_brutto_currency': u'EUR',
+                    },
+                ],
+            'customer_id': u'customer',
+            'discounts': [
+                {
+                    'name': u'discount 0',
+                    'value': 3.0,
+                    'value_currency': u'EUR',
+                    },
+                {
+                    'name': u'discount 1',
+                    'value': 4.0,
+                    'value_currency': u'EUR',
+                    },
+                ],
+            'order_date': u'2016-05-08',
+            'order_id': u'id',
+            'platform': u'platform',
+            })
+
+    assert order.items == [
+            dingguo.Item(name = u'item 0', price_brutto = dingguo.Sum(1.0, u'EUR')),
+            dingguo.Item(name = u'item 1', price_brutto = dingguo.Sum(2.0, u'EUR')),
+            ]
+    assert order.customer_id == u'customer'
+    assert order.discounts == [
+            dingguo.Discount(name = u'discount 0', amount = dingguo.Sum(3.0, u'EUR')),
+            dingguo.Discount(name = u'discount 1', amount = dingguo.Sum(4.0, u'EUR')),
+            ]
+    assert order.order_date == datetime.date(2016, 5, 8)
+    assert order.order_id == u'id'
+    assert order.platform == u'platform'
+
+def test_figure_eq():
+    assert dingguo.Figure(1, u'mm') == dingguo.Figure(1, u'mm')
+
+def test_figure_eq_inverted():
+    assert not dingguo.Figure(1, u'mm') == dingguo.Figure(2, u'mm')
+
+def test_figure_ne():
+    assert dingguo.Figure(1, u'mm') != dingguo.Figure(2, u'mm')
+
+def test_figure_ne_inverted():
+    assert not dingguo.Figure(1, u'mm') != dingguo.Figure(1, u'mm')
+
+def test_item_eq():
+    item_a = dingguo.Item(
+            name = u'item',
+            price_brutto = dingguo.Sum(1.0, u'EUR'),
+            )
+    item_b = dingguo.Item(
+            name = u'item',
+            price_brutto = dingguo.Sum(1.0, u'EUR'),
+            )
+    assert item_a == item_b
+
+def test_item_eq_inverted():
+    item_a = dingguo.Item(
+            name = u'item',
+            price_brutto = dingguo.Sum(1.0, u'EUR'),
+            )
+    item_b = dingguo.Item(
+            name = u'item',
+            price_brutto = dingguo.Sum(2.0, u'EUR'),
+            )
+    assert not item_a == item_b
+
+def test_item_ne():
+    item_a = dingguo.Item(
+            name = u'item',
+            price_brutto = dingguo.Sum(1.0, u'EUR'),
+            )
+    item_b = dingguo.Item(
+            name = u'item',
+            price_brutto = dingguo.Sum(2.0, u'EUR'),
+            )
+    assert item_a != item_b
+
+def test_item_ne_inverted():
+    item_a = dingguo.Item(
+            name = u'item',
+            price_brutto = dingguo.Sum(1.0, u'EUR'),
+            )
+    item_b = dingguo.Item(
+            name = u'item',
+            price_brutto = dingguo.Sum(1.0, u'EUR'),
+            )
+    assert not item_a != item_b
+
+def test_discount_eq():
+    discount_a = dingguo.Discount(
+            name = u'discount',
+            amount = dingguo.Sum(1.0, u'EUR'),
+            )
+    discount_b = dingguo.Discount(
+            name = u'discount',
+            amount = dingguo.Sum(1.0, u'EUR'),
+            )
+    assert discount_a == discount_b
+
+def test_discount_eq_inverted():
+    discount_a = dingguo.Discount(
+            name = u'discount',
+            amount = dingguo.Sum(1.0, u'EUR'),
+            )
+    discount_b = dingguo.Discount(
+            name = u'discount',
+            amount = dingguo.Sum(2.0, u'EUR'),
+            )
+    assert not discount_a == discount_b
+
+def test_discount_ne():
+    discount_a = dingguo.Discount(
+            name = u'discount',
+            amount = dingguo.Sum(1.0, u'EUR'),
+            )
+    discount_b = dingguo.Discount(
+            name = u'discount',
+            amount = dingguo.Sum(2.0, u'EUR'),
+            )
+    assert discount_a != discount_b
+
+def test_discount_ne_inverted():
+    discount_a = dingguo.Discount(
+            name = u'discount',
+            amount = dingguo.Sum(1.0, u'EUR'),
+            )
+    discount_b = dingguo.Discount(
+            name = u'discount',
+            amount = dingguo.Sum(1.0, u'EUR'),
+            )
+    assert not discount_a != discount_b
+
+def test_item_from_dict():
+
+    item = dingguo.Item.from_dict({
+            'name': u'item',
+            'price_brutto': 1.0,
+            'price_brutto_currency': u'EUR',
+            })
+
+    assert item.name == u'item'
+    assert item.price_brutto == dingguo.Sum(1.0, u'EUR')
+
+def test_discount_from_dict():
+
+    discount = dingguo.Discount.from_dict({
+            'name': u'discount',
+            'value': 1.0,
+            'value_currency': u'EUR',
+            })
+
+    assert discount.name == u'discount'
+    assert discount.amount == dingguo.Sum(1.0, u'EUR')