import pytest
from flexmock import flexmock

from delphi_api.core.base_struct import BaseStruct


class TestBaseStruct:

    def test_iter(self, base_struct_child):
        try:
            iter(base_struct_child)
        except Exception as e:
            pytest.fail(str(e))

    def test_setitem(self, base_struct_child):
        obj = base_struct_child
        assert hasattr(obj, 'foo')
        obj['foo'] = 'foo-value'
        assert obj['foo'] == 'foo-value'
        assert not hasattr(obj, 'notprop')
        obj['notprop'] = 'notprop-value'
        assert not hasattr(obj, 'notprop')

    def test_len(self, base_struct_child):
        assert len(base_struct_child) == len(vars(base_struct_child))

    def test_str(self, base_struct_child):
        (flexmock(base_struct_child).should_call('to_dict'))
        out = str(base_struct_child)
        assert isinstance(out, str)

    def test_to_dict(self, base_struct_child):
        data = {'foo': 'foo val', 'bar': 'bar val', 'hidden': 'noshow'}
        obj = base_struct_child.from_dict(data)
        out = obj.to_dict()
        assert 'hidden' not in out.keys()
        assert out['foo'] == data['foo']
        assert out['bar'] == data['bar']

    def test_to_clean_dict(self, base_struct_child):
        data = {'foo': 'foo val', 'bar': False, 'baz': None, 'hidden': 'noshow'}
        obj = base_struct_child.from_dict(data)
        out = obj.to_clean_dict()
        assert 'hidden' not in out.keys()
        assert 'empty_str_prop' not in out.keys()
        assert out['foo'] == data['foo']
        assert out['bar'] == data['bar']
        assert out['baz'] == data['baz']

    def test_from_dict(self, base_struct_child):
        data = None
        out = base_struct_child.from_dict(data)
        assert type(out) == type(base_struct_child)
        data = 'notadict but truthy'
        out = base_struct_child.from_dict(data)
        assert type(out) == type(base_struct_child)
        data = {'foo': 'foo val', 'bar': 'bar val'}
        out = base_struct_child.from_dict(data)
        assert out.foo == data['foo']
        assert out.bar == data['bar']

    def test_ignore_fields(self):
        out = BaseStruct()._ignore_fields()
        condition = isinstance(out, list) or isinstance(out, tuple)
        assert condition is True


@pytest.fixture
def base_struct_child():
    class BaseStructChild(BaseStruct):
        foo = None
        bar = None
        baz = None
        hidden = 'noshow'

        @property
        def some_prop(self):
            return 'some val'

        @property
        def empty_str_prop(self):
            return ''

        @property
        def false_prop(self):
            return False

        def _ignore_fields(self):
            return ['hidden']

    return BaseStructChild()