Example #1
0
def test_adapter_two_sources():
    reg = Registry()

    @implements(ITarget)
    class Adapted(object):
        def __init__(self, alpha, beta):
            self.alpha = alpha
            self.beta = beta

    reg.register([IAlpha, IBeta], ITarget, '', Adapted)

    alpha = Alpha()
    beta = Beta()
    adapted = reg.adapt([alpha, beta], ITarget, '')

    assert isinstance(adapted, Adapted)
    assert adapted.alpha is alpha
    assert adapted.beta is beta

    adapted = ITarget(alpha, beta, lookup=reg)
    assert isinstance(adapted, Adapted)
    assert adapted.alpha is alpha
    assert adapted.beta is beta

    adapted = ITarget.adapt(alpha, beta, lookup=reg)
    assert isinstance(adapted, Adapted)
    assert adapted.alpha is alpha
    assert adapted.beta is beta
Example #2
0
def test_non_adapter_looked_up_as_adapter():
    reg = Registry()
    foo = object()
    reg.register([Alpha], ITarget, '', foo)
    alpha = Alpha()
    with pytest.raises(TypeError):
        ITarget(alpha, lookup=reg)
Example #3
0
def test_name():
    reg = Registry()
    foo = object()
    reg.register([Alpha], ITarget, 'x', foo)
    alpha = Alpha()
    assert ITarget.component(alpha, lookup=reg, name='x') is foo
    assert ITarget.component(alpha, lookup=reg, default=None) is None
Example #4
0
def test_non_adapter_looked_up_as_adapter():
    reg = Registry()
    foo = object()
    reg.register([Alpha], ITarget, '', foo)
    alpha = Alpha()
    with py.test.raises(TypeError):
        ITarget(alpha, lookup=reg)
Example #5
0
def test_adapter_two_sources():
    reg = Registry()

    @implements(ITarget)
    class Adapted(object):
        def __init__(self, alpha, beta):
            self.alpha = alpha
            self.beta = beta

    reg.register([IAlpha, IBeta], ITarget, '', Adapted)

    alpha = Alpha()
    beta = Beta()
    adapted = reg.adapt([alpha, beta], ITarget, '')

    assert isinstance(adapted, Adapted)
    assert adapted.alpha is alpha
    assert adapted.beta is beta

    adapted = ITarget(alpha, beta, lookup=reg)
    assert isinstance(adapted, Adapted)
    assert adapted.alpha is alpha
    assert adapted.beta is beta

    adapted = ITarget.adapt(alpha, beta, lookup=reg)
    assert isinstance(adapted, Adapted)
    assert adapted.alpha is alpha
    assert adapted.beta is beta
Example #6
0
def test_name():
    reg = Registry()
    foo = object()
    reg.register([Alpha], ITarget, 'x', foo)
    alpha = Alpha()
    assert ITarget.component(alpha, lookup=reg, name='x') is foo
    assert ITarget.component(alpha, lookup=reg, default=None) is None
Example #7
0
def test_component_one_source():
    reg = Registry()
    foo = object()
    reg.register((IAlpha, ), ITarget, '', foo)

    alpha = Alpha()
    assert reg.lookup([alpha], ITarget, '') is foo
    assert ITarget.component(alpha, lookup=reg) is foo
Example #8
0
def test_component_one_source():
    reg = Registry()
    foo = object()
    reg.register((IAlpha,), ITarget, '', foo)

    alpha = Alpha()
    assert reg.lookup([alpha], ITarget, '') is foo
    assert ITarget.component(alpha, lookup=reg) is foo
Example #9
0
def test_component_class_based_registration():
    reg = Registry()
    foo = object()
    reg.register((Alpha,), ITarget, '', foo)

    alpha = Alpha()
    assert reg.lookup([alpha], ITarget, '') is foo
    assert ITarget.component(alpha, lookup=reg) is foo
Example #10
0
def test_component_class_based_registration():
    reg = Registry()
    foo = object()
    reg.register((Alpha, ), ITarget, '', foo)

    alpha = Alpha()
    assert reg.lookup([alpha], ITarget, '') is foo
    assert ITarget.component(alpha, lookup=reg) is foo
Example #11
0
def test_component_two_sources():
    reg = Registry()
    foo = object()
    reg.register((IAlpha, IBeta), ITarget, '', foo)

    alpha = Alpha()
    beta = Beta()
    assert reg.lookup([alpha, beta], ITarget, '') is foo
    assert ITarget.component(alpha, beta, lookup=reg) is foo
Example #12
0
def test_component_two_sources():
    reg = Registry()
    foo = object()
    reg.register((IAlpha, IBeta), ITarget, '', foo)

    alpha = Alpha()
    beta = Beta()
    assert reg.lookup([alpha, beta], ITarget, '') is foo
    assert ITarget.component(alpha, beta, lookup=reg) is foo
Example #13
0
def test_component_not_found():
    reg = Registry()
    
    assert reg.lookup([], ITarget, '') is None
    alpha = Alpha()
    assert reg.lookup([alpha], ITarget, '') is None
    assert ITarget.component(alpha, lookup=reg, default=None) is None
    with py.test.raises(ComponentLookupError):
        ITarget.component(alpha, lookup=reg)
Example #14
0
def test_component_not_found():
    reg = Registry()

    assert reg.lookup([], ITarget, '') is None
    alpha = Alpha()
    assert reg.lookup([alpha], ITarget, '') is None
    assert ITarget.component(alpha, lookup=reg, default=None) is None
    with pytest.raises(ComponentLookupError):
        ITarget.component(alpha, lookup=reg)
Example #15
0
def test_extra_kw():
    reg = Registry()
    foo = object()

    reg.register([Alpha], ITarget, '', foo)
    alpha = Alpha()

    with pytest.raises(TypeError) as e:
        ITarget.component(alpha, lookup=reg, extra="illegal")
    assert str(e.value) == 'Illegal extra keyword arguments: extra'
Example #16
0
def test_component_to_itself():
    reg = Registry()
    alpha = Alpha()

    foo = object()

    reg.register([IAlpha], IAlpha, '', foo)

    assert reg.lookup([alpha], IAlpha, '') is foo
    assert IAlpha.component(alpha, lookup=reg) is foo
Example #17
0
def test_component_to_itself():
    reg = Registry()
    alpha = Alpha()

    foo = object()
    
    reg.register([IAlpha], IAlpha, '', foo)

    assert reg.lookup([alpha], IAlpha, '') is foo
    assert IAlpha.component(alpha, lookup=reg) is foo
Example #18
0
def test_extra_kw():
    reg = Registry()
    foo = object()
    
    reg.register([Alpha], ITarget, '', foo)
    alpha = Alpha()
    
    with py.test.raises(TypeError) as e:
        ITarget.component(alpha, lookup=reg, extra="illegal")
    assert str(e.value) == 'Illegal extra keyword arguments: extra'
Example #19
0
def test_adapter_with_wrong_args():
    class Adapter(object):
        # takes no args
        def __init__(self):
            pass
    reg = Registry()
    reg.register([Alpha], ITarget, '', Adapter)
    alpha = Alpha()

    with pytest.raises(TypeError) as e:
        ITarget(alpha, lookup=reg)
Example #20
0
def test_adapter_with_wrong_args():
    class Adapter(object):
        # takes no args
        def __init__(self):
            pass

    reg = Registry()
    reg.register([Alpha], ITarget, '', Adapter)
    alpha = Alpha()

    with pytest.raises(TypeError) as e:
        ITarget(alpha, lookup=reg)
Example #21
0
def test_adapter_no_source():
    reg = Registry()

    foo = object()
    def factory():
        return foo
    
    reg.register((), ITarget, '', factory)

    assert reg.adapt([], ITarget, '') is foo
    assert ITarget.adapt(lookup=reg) is foo
    assert ITarget(lookup=reg) is foo
Example #22
0
def test_adapter_no_source():
    reg = Registry()

    foo = object()

    def factory():
        return foo

    reg.register((), ITarget, '', factory)

    assert reg.adapt([], ITarget, '') is foo
    assert ITarget.adapt(lookup=reg) is foo
    assert ITarget(lookup=reg) is foo
Example #23
0
def test_adapter_with_wrong_args():
    class Adapter(object):
        # takes no args
        def __init__(self):
            pass
    reg = Registry()
    reg.register([Alpha], ITarget, '', Adapter)
    alpha = Alpha()
    
    with py.test.raises(TypeError) as e:
        ITarget(alpha, lookup=reg)

    assert str(e.value) == ("__init__() takes exactly 1 argument (2 given) "
                            "(<class 'crom.tests.test_registry.Adapter'>)")
Example #24
0
def test_component_inheritance():
    reg = Registry()
    foo = object()

    class Gamma(object):
        pass

    class Delta(Gamma):
        pass
    
    reg.register([Gamma], ITarget, '', foo)

    delta = Delta()
    
    assert reg.lookup([delta], ITarget, '') is foo
    assert ITarget.component(delta, lookup=reg) is foo
Example #25
0
def test_component_inheritance():
    reg = Registry()
    foo = object()

    class Gamma(object):
        pass

    class Delta(Gamma):
        pass

    reg.register([Gamma], ITarget, '', foo)

    delta = Delta()

    assert reg.lookup([delta], ITarget, '') is foo
    assert ITarget.component(delta, lookup=reg) is foo
Example #26
0
def test_adapter_one_source():
    reg = Registry()

    @implements(ITarget)
    class Adapted(object):
        def __init__(self, context):
            self.context = context

    reg.register([IAlpha], ITarget, '', Adapted)

    alpha = Alpha()
    adapted = reg.adapt([alpha], ITarget, '')
    assert isinstance(adapted, Adapted)
    assert adapted.context is alpha
    adapted = ITarget(alpha, lookup=reg)
    assert isinstance(adapted, Adapted)
    assert adapted.context is alpha
    adapted = ITarget.adapt(alpha, lookup=reg)
    assert isinstance(adapted, Adapted)
    assert adapted.context is alpha
Example #27
0
def test_adapter_to_itself():
    reg = Registry()
    alpha = Alpha()

    @implements(IAlpha)
    class Adapter(object):
        def __init__(self, context):
            self.context = context

    # behavior without any registration; we get the object back
    assert reg.adapt([alpha], IAlpha, '') is alpha
    assert IAlpha(alpha, lookup=reg) is alpha

    # it works even without registry
    assert IAlpha(alpha) is alpha

    # behavior is the same with registration
    reg.register([IAlpha], IAlpha, '', Adapter)
    assert reg.adapt([alpha], IAlpha, '') is alpha
    assert IAlpha(alpha, lookup=reg) is alpha
    assert IAlpha(alpha) is alpha
Example #28
0
from dawnlight import ResolveError
from dawnlight.interfaces import IConsumer
from grokker import validator, ArgsDirective
from sanic.request import Request
from sanic.response import BaseHTTPResponse as Response
from urllib.parse import unquote
from zope.interface import Interface
from zope.location import ILocation, LocationProxy, locate
from .directives import traversable
from .interfaces import IResponseFactory, ITraverser, IView

shortcuts = {
    '@@': dawnlight.VIEW,
}

dawnlight_components = Registry()
_marker = object()


@crom.subscription
@crom.sources(Interface)
@crom.target(IConsumer)
@crom.order(1100)
@crom.registry(dawnlight_components)
async def attribute_consumer(request, obj, stack):
    traversables_attrs = traversable.get(obj)
    if traversables_attrs:
        ns, name = stack[0]
        if ns == dawnlight.DEFAULT and name in traversables_attrs:
            attr = getattr(obj, name, _marker)
            if attr is not _marker:
Example #29
0
def test_default():
    reg = Registry()
    assert ITarget.component(lookup=reg, default='blah') == 'blah'
Example #30
0
def test_component_no_source():
    reg = Registry()
    foo = object()
    reg.register((), ITarget, '', foo)
    assert reg.lookup([], ITarget, '') is foo
    assert ITarget.component(lookup=reg) is foo