예제 #1
0
def test_repr():
    id_ = hex(id(perfect))
    assert str(perfect) == f"<perfect.decorator object at {id_}>"
    assert str(perfect.decorator) != f"<perfect.decorator object at {id_}>"
    assert str(decorator) == str(perfect.decorator)

    assert repr(perfect) == f"<perfect.decorator object at {id_}>"
    assert repr(perfect.decorator) != f"<perfect.decorator object at {id_}>"
    assert repr(decorator) == repr(perfect.decorator)

    assert perfect is not perfect.decorator
    assert perfect is not decorator
    assert perfect.decorator is decorator

    assert str(perfect()) != f"<perfect.decorator object at {id_}>"
    assert str(perfect.decorator()) != f"<perfect.decorator object at {id_}>"
    assert str(decorator()) != f"<perfect.decorator object at {id_}>"

    assert repr(perfect()) != f"<perfect.decorator object at {id_}>"
    assert repr(perfect.decorator()) != f"<perfect.decorator object at {id_}>"
    assert repr(decorator()) != f"<perfect.decorator object at {id_}>"

    assert str(perfect()).startswith("<perfect.decorator object at")
    assert str(perfect.decorator()).startswith("<perfect.decorator object at")
    assert str(decorator()).startswith("<perfect.decorator object at")

    assert repr(perfect()).startswith("<perfect.decorator object at")
    assert repr(perfect.decorator()).startswith("<perfect.decorator object at")
    assert repr(decorator()).startswith("<perfect.decorator object at")

    assert str(perfect()) != str(perfect)
    assert str(perfect()) != str(perfect())
    assert str(perfect()) != str(perfect.decorator())
    assert str(perfect()) != str(decorator())
예제 #2
0
def test_wrapped_repr():
    id_ = hex(id(perfect))
    assert str(perfect) == f"<perfect.decorator object at {id_}>"
    assert str(perfect.decorator) != f"<perfect.decorator object at {id_}>"
    assert str(decorator) == str(perfect.decorator)

    def wrapped_func():
        pass

    func_id = hex(id(wrapped_func))
    func = perfect(wrapped_func)

    start_str = "function test_wrapped_repr.<locals>.wrapped_func at"

    assert str(func) != f"<{start_str} {id_}>"
    assert str(func) == f"<{start_str} {func_id}>"
    assert repr(func) != f"<{start_str} {id_}>"
    assert repr(func) == f"<{start_str} {func_id}>"

    func = perfect(4711, 1338, a=1, b=2, **{"id": 55})(wrapped_func)
    assert str(func) != f"<{start_str} {id_}>"
    assert str(func) == f"<{start_str} {func_id}>"
    assert repr(func) != f"<{start_str} {id_}>"
    assert repr(func) == f"<{start_str} {func_id}>"

    func = perfect.decorator(wrapped_func)
    assert str(func) != f"<{start_str} {id_}>"
    assert str(func) == f"<{start_str} {func_id}>"
    assert repr(func) != f"<{start_str} {id_}>"
    assert repr(func) == f"<{start_str} {func_id}>"

    func = perfect.decorator()(wrapped_func)
    assert str(func) != f"<{start_str} {id_}>"
    assert str(func) == f"<{start_str} {func_id}>"
    assert repr(func) != f"<{start_str} {id_}>"
    assert repr(func) == f"<{start_str} {func_id}>"
예제 #3
0
        def clsmethod(cls, id_=0):
            def _fn(id_=0):
                cls.called += 1
                return id_

            return perfect.decorator(1, 2, 3, 4)(_fn)(id_=id_)
예제 #4
0
def test_class_methods():
    class X:
        called = 0

        @classmethod
        def clsmethod(cls, id_=0):
            def _fn(id_=0):
                cls.called += 1
                return id_

            return perfect.decorator(1, 2, 3, 4)(_fn)(id_=id_)

        @perfect
        @classmethod
        def classicclassmethod(cls, id_=0):
            def _fn(id_=0):
                cls.called += 1
                return id_

            return _fn(id_=id_)

        @perfect(value="yes")
        def func(self, id_=0):
            @perfect
            def _fn(id_=0):
                return id_

            return _fn(id_=id_)

        @staticmethod
        def stat(*args, **kwargs):
            kw_value = kwargs.get("id_", None)
            if kw_value is None and args:
                return args[0]
            return kw_value

        @perfect.decorator
        @staticmethod
        def dstat(*args, **kwargs):
            kw_value = kwargs.get("type_", None)
            if kw_value is None and args:
                return args[0]
            return kw_value

    @perfect(id=4711, id_=1338, type_=0)
    def local_func(id_, type_):
        return id_ * type_

    assert X.clsmethod(id_=20) == 20
    assert X().clsmethod(id_=19) == 19
    assert perfect(X.clsmethod)(id_=18) == 18
    assert perfect(X.clsmethod)(17) == 17
    assert perfect.decorator(X().clsmethod)(16) == 16

    assert X.called == 5

    assert X().func(id_=15) == 15
    assert X().func(14) == 14

    assert X.stat(id_=13) == 13
    assert X().stat(id_=12) == 12
    assert perfect(X.stat)(id_=11) == 11
    assert perfect(X().stat)(10) == 10

    assert X.dstat(9) == 9
    assert X().dstat(8) == 8
    assert X.dstat(type_=7) == 7
    assert X().dstat(type_=6) == 6

    assert local_func(**{"id_": 13, "type_": 7}) - 86 == 5
    assert local_func(13, 7) - 87 == 4
    assert local_func(type_=7, **{"id_": 13}) - 88 == 3

    assert X.classicclassmethod(id_=2) == 2
    assert X().classicclassmethod(id_=1) == 1

    assert X.called == 7

    assert X.classicclassmethod() == 0
    assert X().classicclassmethod(-1) == -1

    assert X.called == 9
예제 #5
0
import pytest

import perfect
from perfect import decorator


@pytest.mark.parametrize("value", [
    perfect, decorator, perfect.decorator,
    perfect(),
    decorator(),
    perfect.decorator()
])
def test_wrapper(value):
    func = value(lambda x: x)
    assert func("input_data") == "input_data"


@pytest.mark.parametrize("value", [
    perfect, decorator, perfect.decorator,
    perfect(),
    decorator(),
    perfect.decorator()
])
def test_wrapped_class_func(value):
    class X:
        def func(self, data=0):
            return data

    assert value(X().func)(4711) == 4711
    assert value(X().func)() == 0
    assert value(X().func)(data=1337) == 1337
예제 #6
0
import pytest

import perfect
from perfect import decorator


@pytest.mark.parametrize(
    "value",
    [perfect(), decorator(), perfect.decorator()])
def test_missing_func(value):
    with pytest.raises(TypeError):
        value()


@pytest.mark.parametrize("value", [perfect, decorator, perfect.decorator])
def test_invalid_construct(value):
    assert value._meta is True

    new_value = value()
    assert new_value._meta is False
    with pytest.raises(TypeError):
        new_value()

    new_value = value(4, 3, True, kw="yes")
    assert new_value._meta is False
    with pytest.raises(TypeError):
        new_value()
    with pytest.raises(TypeError):
        new_value(55)
    with pytest.raises(TypeError):
        new_value(lambda: None, extras=[])