Пример #1
0
def test_it():
    from hidoi.testing import testConfigSlakky
    from hidoi.displayobject import DisplayObject
    from hidoi.tests.models import (
        Item,
        Bag
    )
    with testConfigSlakky() as config:
        # configuration phase
        config.add_display(Item)
        config.add_display(Bag)
        config.commit()

        # runtime phase
        request = config
        item0 = Item(name="portion", value="heal damage")
        bag0 = Bag(name="1stBag", items=[item0])

        dbag = _callFUT(request, bag0)
        assert isinstance(dbag, DisplayObject)
        assert dbag.name.required is True

        for i in dbag.items.value:
            di = _callFUT(request, i)
            assert isinstance(di, DisplayObject)
            assert di.created_at.required is False

        #  get from class (using this on create form)
        ditem = _callFUT(request, Item)
        assert isinstance(ditem, DisplayObject)
        assert print(ditem.name.value) is None
Пример #2
0
def test_prepare():
    from hidoi.testing import testConfigSlakky
    import sqlalchemy.types as t

    with testConfigSlakky() as config:
        config.commit()

        result = _callFUT(config, t.DateTime)
        assert "widget" not in result
        assert result["format"] == "date-time"  # added by default hook
Пример #3
0
def test_it():
    from hidoi.testing import testConfigSlakky
    import sqlalchemy.types as t

    with testConfigSlakky() as config:
        config.include("hidoi.custom.html5")
        config.commit()

        result = _callFUT(config, t.DateTime)
        assert result["widget"] == "datetime"
        assert result["format"] == "date-time"  # added by default hook
Пример #4
0
def test_it__swapping_normalize():
    from hidoi.testing import testConfigSlakky
    from hidoi.schema import DefaultRegistry
    with testConfigSlakky() as config:
        # configuration phase
        config.add_schema_convertion("date-time", normalize=normalize_invalid_call, jsonify=None)
        config.commit()

        # runtime phase
        request = config

        result = _callFUT(request)
        assert result.normalize[("string", "date-time")] == normalize_invalid_call
        assert result.jsonify[("string", "date-time")] == DefaultRegistry.jsonify[("string", "date-time")]
Пример #5
0
def test_it_swapping_to_schema():
    import sqlalchemy.types as t
    from hidoi.testing import testConfigSlakky
    from hidoi.schema import DefaultRegistry
    with testConfigSlakky() as config:
        # configuration phase
        config.add_sqla_column_convertion(t.Integer, to_schema="*secret*")
        config.commit()

        # runtime phase
        request = config

        result = _callFUT(request)
        assert result.column_to_schema[t.Integer] == "*secret*"
        assert result.restriction[t.DateTime] == DefaultRegistry.restriction[t.DateTime]
Пример #6
0
def test_it_swapping_to_schema():
    import sqlalchemy.types as t
    from hidoi.testing import testConfigSlakky
    from hidoi.schema import DefaultRegistry
    with testConfigSlakky() as config:
        # configuration phase
        config.add_sqla_column_convertion(t.Integer, to_schema="*secret*")
        config.commit()

        # runtime phase
        request = config

        result = _callFUT(request)
        assert result.column_to_schema[t.Integer] == "*secret*"
        assert result.restriction[t.DateTime] == DefaultRegistry.restriction[
            t.DateTime]
Пример #7
0
def test_it__call_with_another_name__missing():
    from hidoi.testing import testConfigSlakky
    with testConfigSlakky() as config:
        # configuration phase
        config.add_validation(Data, increment_validation, name="create")
        config.commit()

        # runtime phase
        request = config

        wrapper = None
        data = Data(0)

        assert data.value == 0
        result = _callFUT(request, data)
        result(wrapper, data)
        assert data.value == 0
Пример #8
0
def test_it_swapping_restriction():
    import sqlalchemy.types as t
    from hidoi.testing import testConfigSlakky
    import pytest

    with testConfigSlakky() as config:
        # configuration phase
        config.add_sqla_column_convertion(t.DateTime, restriction=restriction_invalid_call)
        config.commit()

        # runtime phase
        request = config

        result = _callFUT(request)

        with pytest.raises(Exception):
            for fn in result.restriction[t.DateTime]:
                fn(None, None)
Пример #9
0
def test_it__swapping_jsonify():
    from hidoi.testing import testConfigSlakky
    from hidoi.schema import DefaultRegistry
    with testConfigSlakky() as config:
        # configuration phase
        config.add_schema_convertion("date-time",
                                     jsonify=jsonify_invalid_call,
                                     normalize=None)
        config.commit()

        # runtime phase
        request = config

        result = _callFUT(request)
        assert result.jsonify[("string", "date-time")] == jsonify_invalid_call
        assert result.normalize[(
            "string", "date-time")] == DefaultRegistry.normalize[("string",
                                                                  "date-time")]
Пример #10
0
def test_schema_validation_invalid_type__error():
    import pytest
    from hidoi.formwrapper import ValidationError
    from hidoi.testing import testConfigSlakky
    from . import models

    with testConfigSlakky() as config:
        config.set_default_model_module(models)
        config.add_display(models.Bag)
        config.commit()

        request = _makeRequest(config)
        target = _makeOne(request, models.Bag)

        data = {"name": "foo", "id": "foo"}

        with pytest.raises(ValidationError):
            target.validate(data)
Пример #11
0
def test_child__without_child__min_of_items_is_1__found():
    from hidoi.testing import testConfigSlakky
    from hidoi.tests.models import (
        Item,
        Bag
    )
    with testConfigSlakky() as config:
        # configuration phase
        config.add_display(Item)
        config.add_display(Bag)
        config.commit()

        # runtime phase
        request = config
        item0 = Item(name="portion", value="heal damage")
        ditem = _callFUT(request, item0)

        dbag = ditem.child(ditem.bag, min_of_items=1)
        assert list(sorted(dbag._fieldnames)) == ['id', 'items', 'name']
Пример #12
0
def test_it():
    from hidoi.testing import testConfigSlakky
    from hidoi.displayobject import DisplayObject
    from hidoi.tests.models import Item

    with testConfigSlakky() as config:
        # configuration phase
        config.scan("hidoi.tests.all_fields_are_optional")
        config.commit()

        # runtime phase
        request = config
        item0 = Item(name="portion", value="heal damage")

        ditem = _callFUT(request, item0)
        assert isinstance(ditem, DisplayObject)
        assert ditem.name.required is False
        assert ditem.value.required is False
        assert ditem.id.required is False
Пример #13
0
def test_it_swapping_restriction():
    import sqlalchemy.types as t
    from hidoi.testing import testConfigSlakky
    import pytest

    with testConfigSlakky() as config:
        # configuration phase
        config.add_sqla_column_convertion(t.DateTime,
                                          restriction=restriction_invalid_call)
        config.commit()

        # runtime phase
        request = config

        result = _callFUT(request)

        with pytest.raises(Exception):
            for fn in result.restriction[t.DateTime]:
                fn(None, None)
Пример #14
0
def test_child__without_child__min_of_items_is_0_None():
    from hidoi.testing import testConfigSlakky
    from hidoi.tests.models import (
        Item,
        Bag
    )
    with testConfigSlakky() as config:
        # configuration phase
        config.add_display(Item)
        config.add_display(Bag)
        config.commit()

        # runtime phase
        request = config
        item0 = Item(name="portion", value="heal damage")
        ditem = _callFUT(request, item0)

        dbag = ditem.child(ditem.bag, min_of_items=0)
        assert dbag is None
Пример #15
0
def test_children__without_objects__min_of_items_is_1__found():
    from hidoi.testing import testConfigSlakky
    from hidoi.tests.models import (
        Item,
        Bag
    )
    with testConfigSlakky() as config:
        # configuration phase
        config.add_display(Item)
        config.add_display(Bag)
        config.commit()

        # runtime phase
        request = config
        bag0 = Bag(name="1stBag", items=[])
        dbag = _callFUT(request, bag0)
        items = dbag.children(dbag.items, min_of_items=1)

        assert len(items) == 1
        assert list(sorted(items[0]._fieldnames)) == ['bag', 'created_at', 'id', 'name', 'value']
Пример #16
0
def test_children__without_objects__min_of_items_is_0__empty():
    from hidoi.testing import testConfigSlakky
    from hidoi.tests.models import (
        Item,
        Bag
    )
    with testConfigSlakky() as config:
        # configuration phase
        config.add_display(Item)
        config.add_display(Bag)
        config.commit()

        # runtime phase
        request = config
        bag0 = Bag(name="1stBag", items=[])
        dbag = _callFUT(request, bag0)
        items = dbag.children(dbag.items, min_of_items=0)

        assert len(items) == 0
        assert items == []
Пример #17
0
def test_children__with_objects__normally_found():
    from hidoi.testing import testConfigSlakky
    from hidoi.tests.models import (
        Item,
        Bag
    )
    with testConfigSlakky() as config:
        # configuration phase
        config.add_display(Item)
        config.add_display(Bag)
        config.commit()

        # runtime phase
        request = config
        item0 = Item(name="portion", value="heal damage")
        item1 = Item(name="magic portion", value="heal stress damage")
        bag0 = Bag(name="1stBag", items=[item0, item1])
        dbag = _callFUT(request, bag0)
        items = dbag.children(dbag.items, min_of_items=1)

        assert len(items) == 2
        assert list(sorted(items[0]._fieldnames)) == ['bag', 'created_at', 'id', 'name', 'value']
Пример #18
0
def test_it0():
    from hidoi.testing import testConfigSlakky
    from hidoi.schema import DefaultRegistry
    with testConfigSlakky() as config:
        # configuration phase
        config.commit()

        # runtime phase
        request = config

        result = _callFUT(request)

        # value is eaual
        assert result.jsonify == DefaultRegistry.jsonify
        assert result.normalize == DefaultRegistry.normalize
        assert result.restriction == DefaultRegistry.restriction
        assert result.column_to_schema == DefaultRegistry.column_to_schema

        # but id is not same
        assert id(result.jsonify) != id(DefaultRegistry.jsonify)
        assert id(result.normalize) != id(DefaultRegistry.normalize)
        assert id(result.restriction) != id(DefaultRegistry.restriction)
        assert id(result.column_to_schema) != id(DefaultRegistry.column_to_schema)
Пример #19
0
def test_it0():
    from hidoi.testing import testConfigSlakky
    from hidoi.schema import DefaultRegistry
    with testConfigSlakky() as config:
        # configuration phase
        config.commit()

        # runtime phase
        request = config

        result = _callFUT(request)

        # value is eaual
        assert result.jsonify == DefaultRegistry.jsonify
        assert result.normalize == DefaultRegistry.normalize
        assert result.restriction == DefaultRegistry.restriction
        assert result.column_to_schema == DefaultRegistry.column_to_schema

        # but id is not same
        assert id(result.jsonify) != id(DefaultRegistry.jsonify)
        assert id(result.normalize) != id(DefaultRegistry.normalize)
        assert id(result.restriction) != id(DefaultRegistry.restriction)
        assert id(result.column_to_schema) != id(
            DefaultRegistry.column_to_schema)