finoex/tests/test_yaml.py

# -*- coding: utf-8 -*-

import pytest

import os
import yaml
import dingguo
import difflib
import datetime

def get_figure_a():
    return dingguo.Figure(12.3, u'km')

def get_figure_b():
    return dingguo.Figure(12300, u'米')

def get_sum_a():
    return dingguo.Sum(1.23, u'EUR')

def get_sum_b():
    return dingguo.Sum(20.45, u'€')

def get_item_a():
    return dingguo.Item(
            name = u'item a',
            price_brutto = get_sum_a(),
            )

def get_item_b():
    return dingguo.Item(
            name = u'item β',
            price_brutto = get_sum_b(),
            )

def get_article():
    return dingguo.Article(
            authors = ['a', 'b'],
            name = u'article name',
            price_brutto = get_sum_a(),
            quantity = 1,
            reseller = u'seller',
            shipper = u'shipper',
            state = u'goood',
            )

def get_transportation():
    return dingguo.Transportation(
            name = u'ticket',
            price_brutto = get_sum_a(),
            departure_point = u'home',
            destination_point = u'city',
            distance = dingguo.Distance(3.21, u'km'),
            )

def get_discount_a():
    return dingguo.Discount(
            name = u'discount a',
            amount = get_sum_a(),
            )

def get_discount_b():
    return dingguo.Discount(
            name = u'discount β',
            amount = get_sum_b(),
            )

def get_order_a():
    order = dingguo.Order(
            platform = u'platformπ',
            order_id = u'id',
            order_date = datetime.datetime(2016, 5, 8, 0, 18, 17),
            customer_id = u'customer',
            )
    order.items.append(get_item_a())
    order.items.append(get_item_b())
    order.discounts.append(get_discount_a())
    order.discounts.append(get_discount_b())
    return order

def get_distance():
    return dingguo.Distance(2.4142, u'km')

def to_yaml(data):
    return yaml.dump(data, default_flow_style = False, allow_unicode = True).decode('utf-8')

def yaml_diff(a, b):
    return '\n'.join(difflib.ndiff(
        to_yaml(a).split('\n'),
        to_yaml(b).split('\n'),
        ))

def test_figure_to_yaml():
    assert to_yaml(get_figure_a()) == u"""!figure
unit: km
value: 12.3
"""

def test_figure_to_yaml_unicode():
    assert to_yaml(get_figure_b()) == u"""!figure
unit: 米
value: 12300
"""

def test_figure_from_yaml():
    assert get_figure_a() == yaml.load(u"""!figure
unit: km
value: 12.3
""")

def test_figure_to_yaml_unicode():
    assert get_figure_b() == yaml.load(u"""!figure
unit: 米
value: 12300
""")

def test_sum_to_yaml_a():
    assert to_yaml(get_sum_a()) == u"!sum '1.23 EUR'\n"

def test_sum_to_yaml_b():
    assert to_yaml(get_sum_b()) == u"!sum '20.45 EUR'\n"

def test_sum_from_yaml_a():
    assert get_sum_a() == yaml.load(u"!sum 1.23 EUR")

def test_sum_from_yaml_a_sign():
    assert get_sum_a() == yaml.load(u"!sum 1.23 €")

def test_sum_from_yaml_a_quotes():
    assert get_sum_a() == yaml.load(u"!sum '1.23 EUR'")

def test_item_to_yaml_a():
    assert to_yaml(get_item_a()) == u"""!item
name: item a
price_brutto: !sum '1.23 EUR'
"""

def test_item_to_yaml_b():
    assert to_yaml(get_item_b()) == u"""!item
name: item β
price_brutto: !sum '20.45 EUR'
"""

def test_item_from_yaml_a():
    assert get_item_a() == yaml.load(u"""!item
name: item a
price_brutto: !sum '1.23 EUR'
""")

def test_item_from_yaml_b():
    assert get_item_b() == yaml.load(u"""!item
name: item β
price_brutto: !sum '20.45 EUR'
""")

def test_discount_to_yaml_a():
    assert to_yaml(get_discount_a()) == u"""!discount
amount: !sum '1.23 EUR'
name: discount a
"""

def test_discount_to_yaml_b():
    assert to_yaml(get_discount_b()) == u"""!discount
amount: !sum '20.45 EUR'
name: discount β
"""

def test_discount_from_yaml_a():
    assert get_discount_a() == yaml.load(u"""!discount
name: discount a
amount: !sum '1.23 EUR'
""")

def test_discount_from_yaml_b():
    assert get_discount_b() == yaml.load(u"""!discount
name: discount β
amount: !sum '20.45 EUR'
""")

def test_order_to_yaml():
    assert to_yaml(get_order_a()) == u"""!order
customer_id: customer
discounts:
- !discount
  amount: !sum '1.23 EUR'
  name: discount a
- !discount
  amount: !sum '20.45 EUR'
  name: discount β
items:
- !item
  name: item a
  price_brutto: !sum '1.23 EUR'
- !item
  name: item β
  price_brutto: !sum '20.45 EUR'
order_date: 2016-05-08
order_id: id
platform: platformπ
"""

def test_order_from_yaml():
    order_loaded = yaml.load(u"""!order
customer_id: customer
discounts:
- !discount
  amount: !sum '1.23 EUR'
  name: discount a
- !discount
  amount: !sum '20.45 EUR'
  name: discount β
items:
- !item
  name: item a
  price_brutto: !sum '1.23 EUR'
- !item
  name: item β
  price_brutto: !sum '20.45 EUR'
order_date: 2016-05-08
order_id: id
platform: platformπ
""")
    order_expected = get_order_a()
    assert order_expected == order_loaded, yaml_diff(order_expected, order_loaded)

def test_scalar_figure_to_yaml():
    assert to_yaml(dingguo.ScalarFigure(1.34, u'μm')) == u"!scalar '1.34 μm'\n"

def test_scalar_figure_from_yaml():
    assert dingguo.ScalarFigure(1.34, u'μm') == yaml.load(u"!scalar '1.34 μm'")

def test_distance_to_yaml():
    assert to_yaml(dingguo.Distance(1.34, u'km')) == u"!distance '1.34 km'\n"

def test_distance_from_yaml():
    assert dingguo.Distance(1.34, u'km') == yaml.load(u"!distance '1.34 km'\n")

def test_article_to_yaml():
    assert to_yaml(get_article()) == u"""!article
authors:
- a
- b
delivery_date: null
name: article name
price_brutto: !sum '1.23 EUR'
quantity: 1
reseller: seller
shipper: shipper
state: goood
"""

def test_article_to_yaml():
    assert get_article() == yaml.load(u"""!article
authors:
- a
- b
delivery_date: null
name: article name
price_brutto: !sum '1.23 EUR'
quantity: 1
reseller: seller
shipper: shipper
state: goood
""")

def test_transportation_to_yaml():
    assert to_yaml(get_transportation()) == u"""!transportation
departure_point: home
destination_point: city
distance: !distance '3.21 km'
name: ticket
price_brutto: !sum '1.23 EUR'
route_map: null
"""

def test_transportation_from_yaml():
    assert get_transportation() == yaml.load(u"""!transportation
departure_point: home
destination_point: city
distance: !distance '3.21 km'
name: ticket
price_brutto: !sum '1.23 EUR'
route_map: null
""")