Register a processor which has injections about in-n-out HOT 5 CLOSED

def test_processors_with_injections() -> None:
    """Test that we can use processors with injections."""

    class ThingToProcess:
        ...

    class InjectedDep:
        ...

    dep = InjectedDep()
    t2p = ThingToProcess()
    mock = Mock()

    # this function processes a ThingToProcess, but also requires
    # an InjectedDep to be injected before it will work
    @ino.register_processor
    @ino.inject
    def processor_that_has_injections(p0: ThingToProcess, p1: InjectedDep) -> None:
        mock(p0, p1)

    # "inject processors" of this function... 
    # meaning: when `return_a_thing ` is called, the t2p return value should be processed
    #  (as a side effect of calling the function)
    @ino.inject_processors
    def return_a_thing() -> ThingToProcess:
        return t2p

    # at the moment, our `processor_that_has_injections` function still doesn't have a
    # p1 InjectedDep, so `return_a_thing`'s return value won't be processed successfully
    with pytest.warns(UserWarning, match="Processor .* failed to process result"):
        return_a_thing()

    # but if we register a something that provides an InjectedDep...
    @ino.register_provider
    def provide_other_thing() -> InjectedDep:
        return dep

    # then the processor should work as expected ...
    return_a_thing()
    mock.assert_called_once_with(t2p, dep)

import in_n_out as ino

def test_processors_with_injections() -> None:

    class Dummy:
        pass

    class Thing:
        def __init__(self):
            self.list = []

    def dummy_provider() -> Dummy:
        return Dummy()

    @ino.inject
    @ino.inject_processors
    def thing_provider(dummy: Dummy) -> Thing:
        return Thing()

    ino.register_provider(dummy_provider)
    ino.register_provider(thing_provider)

    # def add_item(thing: Thing):
    #     thing.list.append("item")

    @ino.inject
    def add_item(dummy: Dummy, thing: Thing):
        thing.list.append("item")

    # def add_item(thing: Thing):
    #     @ino.inject
    #     def inner(dummy: Dummy):
    #         thing.list.append("item")
    #     inner()

    ino.register_processor(add_item)
    ino.register_processor(add_item)
    ino.register_processor(add_item)

    @ino.inject
    def func(thing: Thing):
        return thing.list

    assert func() == ["item"] * 3

@ino.inject
    def add_item(dummy: Dummy, thing: Thing):
        ...

ino.register_processor(add_item, type_hint=Thing)