def test_adapter_two_sources():
    reg = Registry()

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

        def foo(self):
            pass

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

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

    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

def test_register_dispatch_predicates_twice():
    @dispatch_external_predicates()
    def foo(obj):
        pass

    def for_bar(obj):
        return "for bar"

    def for_qux(obj):
        return "for qux"

    class Bar(object):
        pass

    class Qux(object):
        pass

    registry = Registry()

    registry.register_dispatch_predicates(
        foo, [match_instance('obj',
                             lambda obj: obj)])
    assert foo in registry.initialized
    # second time has no effect
    registry.register_dispatch_predicates(
        foo, [match_instance('obj',
                             lambda obj: obj)])

def test_component_inheritance_old_style_class():
    reg = Registry()
    foo = object()

    class Gamma:
        pass

    class Delta(Gamma):
        pass

    @generic
    def target():
        pass

    reg.register(target, [Gamma], foo)

    gamma = Gamma()
    delta = Delta()

    assert reg.component(target, [gamma]) is foo
    assert target.component(gamma, lookup=reg) is foo

    # inheritance case
    assert reg.component(target, [delta]) is foo
    assert target.component(delta, lookup=reg) is foo

def test_call_two_sources():
    reg = Registry()

    @generic
    def target(a, b):
        pass

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

        def foo(self):
            pass

    reg.register(target, [IAlpha, IBeta], Adapted)

    alpha = Alpha()
    beta = Beta()
    adapted = reg.call(target, [alpha, beta])

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

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

def test_dispatch_match_instance():
    @dispatch(match_instance('obj', lambda obj: obj))
    def foo(obj):
        pass

    def for_bar(obj):
        return obj.method()

    def for_qux(obj):
        return obj.method()

    class Bar(object):
        def method(self):
            return "bar's method"

    class Qux(object):
        def method(self):
            return "qux's method"

    registry = Registry()

    registry.register_function(foo, for_bar, obj=Bar)
    registry.register_function(foo, for_qux, obj=Qux)

    lookup = registry.lookup()
    assert foo(Bar(), lookup=lookup) == "bar's method"
    assert foo(Qux(), lookup=lookup) == "qux's method"

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

def test_component_class_based_registration():
    reg = Registry()
    foo = object()
    reg.register(ITarget, (Alpha,), foo)

    alpha = Alpha()
    assert reg.component(ITarget, [alpha]) is foo
    assert ITarget.component(alpha, lookup=reg) is foo

def test_non_adapter_looked_up_as_adapter():
    reg = Registry()
    foo = object()
    reg.register(ITarget, [Alpha], foo)
    alpha = Alpha()

    with py.test.raises(TypeError):
        ITarget.adapt(alpha, lookup=reg)

def test_register_no_external_predicates_for_external():
    @dispatch_external_predicates()
    def foo():
        pass

    r = Registry()
    with pytest.raises(RegistrationError):
        r.register_dispatch(foo)

def test_adapter_returns_none():
    def adapt(obj):
        return None
    reg = Registry()
    reg.register(ITarget, [Alpha], adapt)
    alpha = Alpha()
    with py.test.raises(ComponentLookupError):
        ITarget.adapt(alpha, lookup=reg)
    assert ITarget.adapt(alpha, lookup=reg, default='default') == 'default'

def test_interface_component():
    class IFoo(Interface):
        pass

    registry = Registry()

    registry.register(IFoo, (), "test component")

    assert IFoo.component(lookup=registry) == 'test component'

def test_lookup_passed_along_fallback():
    @dispatch()
    def a(lookup):
        return "fallback"

    reg = Registry()
    reg.register_dispatch(a)

    assert a(lookup=reg.lookup()) == 'fallback'

def test_dict_to_predicate_key_for_unknown_dispatch():
    @dispatch()
    def foo():
        pass

    r = Registry()

    with pytest.raises(KeyError):
        r.key_dict_to_predicate_key(foo, {})

def test_component():
    @generic
    def foo():
        pass

    registry = Registry()

    registry.register(foo, (), "test component")

    assert foo.component(lookup=registry) == 'test component'

def test_component_to_itself():
    reg = Registry()
    alpha = Alpha()

    foo = object()

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

    assert reg.component(IAlpha, [alpha]) is foo
    assert IAlpha.component(alpha, lookup=reg) is foo

def test_implicit_component_lookup():
    class ITarget(Interface):
        pass

    reg = Registry()

    reg.register(ITarget, (), 'test component')

    implicit.initialize(reg)
    assert ITarget.component() == 'test component'

def test_extra_kw():
    reg = Registry()
    foo = object()

    reg.register(ITarget, [Alpha], 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'

def test_fallback_to_fallback():

    def fallback(obj):
        return 'fallback!'

    @dispatch(match_instance('obj', lambda obj: obj,
                             fallback=fallback))
    def target(obj):
        return 'not the fallback we want'

    reg = Registry()

    def specific_target(obj):
        return 'specific'

    reg.register_dispatch(target)
    reg.register_function(target, specific_target, obj=Alpha)

    beta = Beta()
    assert target(beta, lookup=reg.lookup()) == 'fallback!'
    # this is *not* a registered fallback so won't be returned here
    assert target.fallback(beta, lookup=reg.lookup()) is fallback
    # we cannot find a fallback for alpha, as it doesn't hit the fallback
    assert target(Alpha(), lookup=reg.lookup()) == 'specific'
    assert target.fallback(Alpha(), lookup=reg.lookup()) is NOT_FOUND

def test_registry_sources():
    reg = Registry()

    class Document(object):
        pass

    class SpecialDocument(Document):
        pass

    class LineCount(object):
        pass

    reg.register(LineCount, (Document,), 'document line count')
    reg.register(LineCount, (SpecialDocument,), 'special document line count')

    assert (reg.component(LineCount, (Document(),)) ==
            'document line count')

    assert (reg.component(LineCount, (SpecialDocument(),)) ==
            'special document line count')

    class AnotherDocument(Document):
        pass

    assert (reg.component(LineCount, (AnotherDocument(),)) ==
            'document line count')

    class Other(object):
        pass

    assert reg.component(LineCount, (Other(),), default=None) is None

def test_registry_target_find_specific():
    reg = Registry()

    class Document(object):
        pass

    class LineCount(object):
        pass

    class SpecialLineCount(LineCount):
        pass

    class SpecialDocument(Document):
        pass

    reg.register(LineCount, (Document,), 'line count')
    reg.register(SpecialLineCount, (Document,), 'special line count')

    assert reg.component(LineCount, (Document(),)) == 'line count'
    assert (reg.component(SpecialLineCount, (Document(),)) ==
            'special line count')

    assert reg.component(LineCount, (SpecialDocument(),)) == 'line count'
    assert (reg.component(SpecialLineCount, (SpecialDocument(),)) ==
            'special line count')