test_callback_di.py

# BSD 3-Clause License
#
# Copyright (c) 2020-2025, Faster Speeding
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice, this
#   list of conditions and the following disclaimer.
#
# * Redistributions in binary form must reproduce the above copyright notice,
#   this list of conditions and the following disclaimer in the documentation
#   and/or other materials provided with the distribution.
#
# * Neither the name of the copyright holder nor the names of its
#   contributors may be used to endorse or promote products derived from
#   this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

# pyright: reportUnknownMemberType=none
# pyright: reportPrivateUsage=none
# pyright: reportIncompatibleMethodOverride=none


import inspect
import typing
import warnings
from unittest import mock

import pytest

import alluka


class MockType(int): ...


class MockOtherType(int): ...


@pytest.fixture
def client() -> alluka.Client:
    return alluka.Client()


@pytest.fixture
def context(client: alluka.Client) -> alluka.Context:
    return alluka.Context(client)


#############################
# Sync dependency injection #
#############################


# TODO: test cases for type scoped dependencies
# TODO: test cases for cached callback results
def test_call_with_di_when_no_di(context: alluka.Context) -> None:
    def callback(value_1: int, value_2: str) -> str:
        assert value_1 == 42
        assert value_2 == "ok"
        return "nyaa"

    result = context.call_with_di(callback, 42, value_2="ok")

    assert result == "nyaa"


def test_call_with_async_di_with_missing_annotations(context: alluka.Context) -> None:
    def callback(value_1, value_2) -> str:  # type: ignore  # type: ignore  # noqa: ANN001  # Missing type anno
        assert value_1 == 543123
        assert value_2 == "sdasd"
        return "meow"

    result = context.call_with_di(callback, 543123, value_2="sdasd")  # type: ignore

    assert result == "meow"


def test_call_with_di_prioritises_defaults_over_annotations(context: alluka.Context) -> None:
    mock_value = mock.Mock()
    mock_other_value = mock.Mock()
    mock_callback = mock.Mock()

    def dependency(
        result: typing.Annotated[float, alluka.inject(type=123)] = alluka.inject(callback=mock_callback),
    ) -> str:
        assert result is mock_callback.return_value
        return "sexual catgirls"

    def callback(
        value_1: int,
        value_2: str,
        value_3: alluka.Injected[str] = alluka.inject(type=MockType),  # type: ignore
        value_4: typing.Annotated[int, alluka.inject(type=float)] = alluka.inject(type=MockOtherType),
        value_5: typing.Annotated[str, alluka.inject(callback=mock.Mock)] = alluka.inject(callback=dependency),
    ) -> str:
        assert value_1 == 69
        assert value_2 == "rew"
        assert value_3 is mock_value
        assert value_4 is mock_other_value
        assert value_5 == "sexual catgirls"
        return "meow"

    context.injection_client.set_type_dependency(MockType, mock_value).set_type_dependency(
        MockOtherType, mock_other_value
    )

    result = context.call_with_di(callback, 69, value_2="rew")

    assert result == "meow"
    mock_callback.assert_called_once_with()


def test_call_with_di_with_type_dependency_and_callback(context: alluka.Context) -> None:
    mock_value = mock.Mock()
    mock_other_value = mock.Mock()
    mock_callback = mock.Mock()

    def callback(
        value_1: int,
        value_2: str,
        value_3: MockType = alluka.inject(type=MockType),
        value_4: MockOtherType = alluka.inject(type=MockOtherType),
        value_5: typing.Any = alluka.inject(callback=mock_callback),
    ) -> str:
        assert value_1 == 69
        assert value_2 == "rew"
        assert value_3 is mock_value
        assert value_4 is mock_other_value
        assert value_5 is mock_callback.return_value
        return "meow"

    context.injection_client.set_type_dependency(MockType, mock_value).set_type_dependency(
        MockOtherType, mock_other_value
    )

    result = context.call_with_di(callback, 69, value_2="rew")

    assert result == "meow"
    mock_callback.assert_called_once_with()


def test_call_with_di_with_type_dependency(context: alluka.Context) -> None:
    mock_value = mock.Mock()
    mock_other_value = mock.Mock()

    def callback(
        value_1: int,
        value_2: str,
        value_3: MockType = alluka.inject(type=MockType),
        value_4: MockOtherType = alluka.inject(type=MockOtherType),
    ) -> str:
        assert value_1 == 69
        assert value_2 == "rew"
        assert value_3 is mock_value
        assert value_4 is mock_other_value
        return "meow"

    context.injection_client.set_type_dependency(MockType, mock_value).set_type_dependency(
        MockOtherType, mock_other_value
    )

    result = context.call_with_di(callback, 69, value_2="rew")

    assert result == "meow"


def test_call_with_di_with_type_dependency_inferred_from_type(context: alluka.Context) -> None:
    mock_value = mock.Mock()
    mock_other_value = mock.Mock()

    def callback(
        nyaa: str, meow: int, value_1: MockType = alluka.inject(), value_2: MockOtherType = alluka.inject()
    ) -> str:
        assert nyaa == "5412"
        assert meow == 34123
        assert value_1 is mock_value
        assert value_2 is mock_other_value
        return "heeee"

    context.injection_client.set_type_dependency(MockType, mock_value).set_type_dependency(
        MockOtherType, mock_other_value
    )

    result = context.call_with_di(callback, "5412", meow=34123)

    assert result == "heeee"


def test_call_with_di_with_type_dependency_inferred_from_annotated_type(context: alluka.Context) -> None:
    mock_value = mock.Mock()
    mock_other_value = mock.Mock()

    def callback(
        nyaa: str,
        meow: int,
        value_1: typing.Annotated[MockType, ..., int] = alluka.inject(),
        value_2: typing.Annotated[MockOtherType, int, str] = alluka.inject(),
    ) -> str:
        assert nyaa == "5412"
        assert meow == 34123
        assert value_1 is mock_value
        assert value_2 is mock_other_value
        return "heeee"

    context.injection_client.set_type_dependency(MockType, mock_value).set_type_dependency(
        MockOtherType, mock_other_value
    )

    result = context.call_with_di(callback, "5412", meow=34123)

    assert result == "heeee"


@pytest.mark.anyio
def test_call_with_di_with_type_dependency_inferred_from_missing_type(context: alluka.Context) -> None:
    def callback(
        nyaa: str,
        meow: int,
        _: MockType = alluka.inject(),
        value_1=alluka.inject(),  # type: ignore  # noqa: ANN001  # Missing type anno
    ) -> str:
        raise NotImplementedError

    with pytest.raises(ValueError, match="Could not resolve type for parameter 'value_1' with no annotation"):
        context.call_with_di(callback, "5412", meow=34123)


def test_call_with_di_with_type_dependency_not_found(context: alluka.Context) -> None:
    mock_value = mock.Mock()

    def callback(
        _: int, value_1: str, __: MockType = alluka.inject(type=MockType), ___: int = alluka.inject(type=MockOtherType)
    ) -> str:
        raise NotImplementedError

    context.injection_client.set_type_dependency(MockType, mock_value)

    with pytest.raises(alluka.MissingDependencyError) as exc:
        context.call_with_di(callback, 69, value_1="rew")

    assert exc.value.message == f"Couldn't resolve injected type(s) {MockOtherType} to actual value"
    assert exc.value.dependency_type is MockOtherType


def test_call_with_di_with_defaulting_type_dependency(context: alluka.Context) -> None:  # TODO: THIS
    mock_value = mock.Mock()

    def callback(
        value_1: int, value_2: str, value_3: typing.Optional[MockType] = alluka.inject(type=typing.Optional[MockType])
    ) -> str:
        assert value_1 == 69
        assert value_2 == "rew"
        assert value_3 is mock_value
        return "meow"

    context.injection_client.set_type_dependency(MockType, mock_value)

    result = context.call_with_di(callback, 69, value_2="rew")

    assert result == "meow"


def test_call_with_di_with_defaulting_type_dependency_not_found(context: alluka.Context) -> None:
    def callback(
        yeet: int, raw: str, value_1: typing.Optional[MockType] = alluka.inject(type=typing.Optional[MockType])
    ) -> str:
        assert yeet == 420
        assert raw == "uwu"
        assert value_1 is None
        return "yeet"

    result = context.call_with_di(callback, 420, raw="uwu")

    assert result == "yeet"


def test_call_with_di_with_3_10_union_type_dependency(context: alluka.Context) -> None:
    mock_value = MockType()

    context.injection_client.set_type_dependency(MockType, mock_value)

    def callback(
        value_1: int, value_2: str, cope: MockOtherType | MockType = alluka.inject(type=MockOtherType | MockType)
    ) -> float:
        assert value_1 == 123
        assert value_2 == "ok"
        assert cope is mock_value
        return 451.123

    result = context.call_with_di(callback, 123, "ok")

    assert result == 451.123


def test_call_with_di_with_3_10_union_type_dependency_not_found(context: alluka.Context) -> None:
    def callback(
        _: int, __: str, cope: MockOtherType | MockType = alluka.inject(type=MockOtherType | MockType)
    ) -> float:
        raise NotImplementedError

    with pytest.raises(alluka.MissingDependencyError) as exc_info:
        context.call_with_di(callback, 123, "ok")

    assert exc_info.value.dependency_type == MockOtherType | MockType
    assert exc_info.value.message == f"Couldn't resolve injected type(s) {MockOtherType | MockType} to actual value"


def test_call_with_di_with_3_10_union_type_dependency_defaulting(context: alluka.Context) -> None:
    mock_value = MockType()

    context.injection_client.set_type_dependency(MockType, mock_value)

    def callback(
        value_1: int,
        value_2: str,
        cope: MockOtherType | MockType | None = alluka.inject(type=MockOtherType | MockType | None),
    ) -> float:
        assert value_1 == 123
        assert value_2 == "ok"
        assert cope is mock_value
        return 451.123

    result = context.call_with_di(callback, 123, "ok")

    assert result == 451.123


def test_call_with_di_with_3_10_union_type_dependency_defaulting_not_found(context: alluka.Context) -> None:
    def callback(
        value_1: int,
        value_2: str,
        cope: MockOtherType | MockType | None = alluka.inject(type=MockOtherType | MockType | None),
    ) -> float:
        assert value_1 == 123
        assert value_2 == "ok"
        assert cope is None
        return 451.123

    result = context.call_with_di(callback, 123, "ok")

    assert result == 451.123


def test_call_with_di_with_typing_union_type_dependency(context: alluka.Context) -> None:
    mock_value = mock.Mock()
    context.injection_client.set_type_dependency(MockOtherType, mock_value)

    def callback(
        value_1: int,
        value_2: str,
        cope: typing.Union[MockType, MockOtherType] = alluka.inject(type=typing.Union[MockType, MockOtherType]),
    ) -> float:
        assert value_1 == 123
        assert value_2 == "ok"
        assert cope is mock_value
        return 243.234

    result = context.call_with_di(callback, 123, "ok")

    assert result == 243.234


def test_call_with_di_with_typing_union_type_dependency_not_found(context: alluka.Context) -> None:
    def callback(
        _: int,
        __: str,
        cope: typing.Union[MockType, MockOtherType] = alluka.inject(type=typing.Union[MockType, MockOtherType]),
    ) -> float:
        raise NotImplementedError

    with pytest.raises(alluka.MissingDependencyError) as exc_info:
        context.call_with_di(callback, 123, "ok")

    assert exc_info.value.dependency_type == typing.Union[MockType, MockOtherType]
    assert exc_info.value.message == (
        f"Couldn't resolve injected type(s) {typing.Union[MockType, MockOtherType]} to actual value"
    )


def test_call_with_di_with_defaulting_typing_union_type_dependency(context: alluka.Context) -> None:
    mock_value = mock.Mock()
    context.injection_client.set_type_dependency(MockOtherType, mock_value)

    def callback(
        value_1: int,
        value_2: str,
        cope: typing.Union[MockType, MockOtherType, None] = alluka.inject(
            type=typing.Union[MockType, MockOtherType, None]
        ),
    ) -> float:
        assert value_1 == 123
        assert value_2 == "ok"
        assert cope is mock_value
        return 243.234

    result = context.call_with_di(callback, 123, "ok")

    assert result == 243.234


def test_call_with_di_with_defaulting_typing_union_type_dependency_not_found(context: alluka.Context) -> None:
    def callback(
        value_1: float, value_2: int, cope: typing.Optional[MockType] = alluka.inject(type=typing.Optional[MockType])
    ) -> float:
        assert value_1 == 123.321
        assert value_2 == 543
        assert cope is None
        return 321.123

    result = context.call_with_di(callback, 123.321, 543)

    assert result == 321.123


def test_call_with_di_with_annotated_type_dependency(context: alluka.Context) -> None:
    mock_value = mock.Mock()
    mock_other_value = mock.Mock()

    def callback(
        rawr: int,
        xd: float,
        meowmeow: typing.Annotated[str, alluka.inject(type=MockType)],
        imacow: typing.Annotated[int, alluka.inject(type=MockOtherType)],
    ) -> str:
        assert rawr == 69
        assert xd == "rew"
        assert meowmeow is mock_value
        assert imacow is mock_other_value
        return "meow"

    context.injection_client.set_type_dependency(MockType, mock_value).set_type_dependency(
        MockOtherType, mock_other_value
    )

    result = context.call_with_di(callback, rawr=69, xd="rew")

    assert result == "meow"


def test_call_with_di_with_annotated_type_dependency_inferred_from_type(context: alluka.Context) -> None:
    mock_value = mock.Mock()
    mock_other_value = mock.Mock()

    def callback(
        meow: int,
        nyaa: float,
        meowmeow: typing.Annotated[MockType, alluka.inject()],
        imacow: typing.Annotated[MockOtherType, alluka.inject()],
    ) -> str:
        assert meow == 2222
        assert nyaa == "xxxxx"
        assert meowmeow is mock_value
        assert imacow is mock_other_value
        return "wewewewew"

    context.injection_client.set_type_dependency(MockType, mock_value).set_type_dependency(
        MockOtherType, mock_other_value
    )

    result = context.call_with_di(callback, meow=2222, nyaa="xxxxx")

    assert result == "wewewewew"


def test_call_with_di_with_annotated_type_dependency_not_found(context: alluka.Context) -> None:
    mock_other_value = mock.Mock()

    def callback(
        meow: int,
        nyaa: float,
        meowmeow: typing.Annotated[int, alluka.inject(type=MockType)],
        imacow: typing.Annotated[str, alluka.inject(type=MockOtherType)],
    ) -> str:
        raise NotImplementedError

    context.injection_client.set_type_dependency(MockOtherType, mock_other_value)

    with pytest.raises(alluka.MissingDependencyError) as exc_info:
        context.call_with_di(callback, meow=2222, nyaa="xxxxx")

    assert exc_info.value.dependency_type is MockType
    assert exc_info.value.message == f"Couldn't resolve injected type(s) {MockType} to actual value"


def test_call_with_di_with_annotated_3_10_union_type_dependency(context: alluka.Context) -> None:
    mock_value = MockType()

    def callback(
        yeee: str, nyaa: bool, yeet: typing.Annotated[str, alluka.inject(type=MockType | MockOtherType)]
    ) -> str:
        assert yeee == "yeee"
        assert nyaa is True
        assert yeet is mock_value
        return "hey"

    context.injection_client.set_type_dependency(MockOtherType, mock_value)

    result = context.call_with_di(callback, yeee="yeee", nyaa=True)

    assert result == "hey"


def test_call_with_di_with_annotated_3_10_union_type_dependency_not_found(context: alluka.Context) -> None:
    def callback(_: int, __: str, cope: typing.Annotated[int, alluka.inject(type=MockOtherType | MockType)]) -> float:
        raise NotImplementedError

    with pytest.raises(alluka.MissingDependencyError) as exc_info:
        context.call_with_di(callback, 123, "ok")

    assert exc_info.value.dependency_type == MockOtherType | MockType
    assert exc_info.value.message == f"Couldn't resolve injected type(s) {MockOtherType | MockType} to actual value"


def test_call_with_di_with_annotated_3_10_union_type_dependency_defaulting(context: alluka.Context) -> None:
    mock_value = MockType()

    context.injection_client.set_type_dependency(MockType, mock_value)

    def callback(
        value_1: int, value_2: str, cope: typing.Annotated[int, alluka.inject(type=MockOtherType | MockType | None)]
    ) -> float:
        assert value_1 == 123
        assert value_2 == "ok"
        assert cope is mock_value
        return 451.123

    result = context.call_with_di(callback, 123, "ok")

    assert result == 451.123


def test_call_with_di_with_annotated_3_10_union_type_dependency_defaulting_not_found(context: alluka.Context) -> None:
    def callback(
        value_1: int, value_2: str, cope: typing.Annotated[int, alluka.inject(type=MockOtherType | MockType | None)]
    ) -> float:
        assert value_1 == 123
        assert value_2 == "ok"
        assert cope is None
        return 451.123

    result = context.call_with_di(callback, 123, "ok")

    assert result == 451.123


def test_call_with_di_with_annotated_3_10_union_type_dependency_natural_defaulting(context: alluka.Context) -> None:
    mock_value = MockType()

    context.injection_client.set_type_dependency(MockType, mock_value)

    def callback(
        value_1: int,
        value_2: str,
        cope: typing.Annotated[int, alluka.inject(type=MockOtherType | MockType | None)] = 123,
    ) -> float:
        assert value_1 == 123
        assert value_2 == "ok"
        assert cope is mock_value
        return 451.123

    result = context.call_with_di(callback, 123, "ok")

    assert result == 451.123


def test_call_with_di_with_annotated_3_10_union_type_dependency_natural_defaulting_not_found(
    context: alluka.Context,
) -> None:
    def callback(
        value_1: int, value_2: str, cope: typing.Annotated[int, alluka.inject(type=MockOtherType | MockType)] = 43123
    ) -> float:
        assert value_1 == 123
        assert value_2 == "ok"
        assert cope == 43123
        return 451.123

    result = context.call_with_di(callback, 123, "ok")

    assert result == 451.123


def test_call_with_di_with_annotated_typing_union_type_dependency(context: alluka.Context) -> None:
    mock_value = mock.Mock()

    def callback(meow: int, meowmeow: typing.Annotated[typing.Union[MockType, MockOtherType], alluka.inject()]) -> str:
        assert meow == 1233212
        assert meowmeow is mock_value
        return "yay"

    context.injection_client.set_type_dependency(MockOtherType, mock_value)

    result = context.call_with_di(callback, 1233212)

    assert result == "yay"


def test_call_with_di_with_annotated_typing_union_type_dependency_not_found(context: alluka.Context) -> None:
    def callback(
        yeee: str, nyaa: bool, yeet: typing.Annotated[int, alluka.inject(type=typing.Union[MockType, MockOtherType])]
    ) -> str:
        raise NotImplementedError

    with pytest.raises(alluka.MissingDependencyError) as exc_info:
        context.call_with_di(callback, yeee="yeee", nyaa=True)

    assert exc_info.value.dependency_type == typing.Union[MockType, MockOtherType]
    assert (
        exc_info.value.message
        == f"Couldn't resolve injected type(s) {typing.Union[MockType, MockOtherType]} to actual value"
    )


def test_call_with_di_with_annotated_defaulting_optional_type_dependency(context: alluka.Context) -> None:
    mock_value = mock.Mock()
    context.injection_client.set_type_dependency(MockType, mock_value)

    def callback(
        eaaaa: str, nyaa: bool, yeet: typing.Annotated[str, alluka.inject(type=typing.Optional[MockType])]
    ) -> str:
        assert eaaaa == "easd"
        assert nyaa is False
        assert yeet is mock_value
        return "aaaaa"

    result = context.call_with_di(callback, "easd", nyaa=False)

    assert result == "aaaaa"


def test_call_with_di_with_annotated_defaulting_optional_type_dependency_not_found(context: alluka.Context) -> None:
    def callback(
        eaaaa: str, nyaa: bool, yeet: typing.Annotated[str, alluka.inject(type=typing.Optional[MockType])]
    ) -> str:
        assert eaaaa == "easd"
        assert nyaa is False
        assert yeet is None
        return "aaaaa"

    result = context.call_with_di(callback, "easd", nyaa=False)

    assert result == "aaaaa"


def test_call_with_di_with_annotated_natural_defaulting_type_dependency(context: alluka.Context) -> None:
    mock_value = mock.Mock()
    context.injection_client.set_type_dependency(MockType, mock_value)

    def callback(eaaaa: str, nyaa: bool, yeet: typing.Annotated[str, alluka.inject(type=MockType)] = "default") -> str:
        assert eaaaa == "easd"
        assert nyaa is False
        assert yeet is mock_value
        return "aaaaa"

    result = context.call_with_di(callback, "easd", nyaa=False)

    assert result == "aaaaa"


def test_call_with_di_with_annotated_natural_defaulting_type_dependency_not_found(context: alluka.Context) -> None:
    def callback(eaaaa: str, nyaa: bool, yeet: typing.Annotated[int, alluka.inject(type=MockType)] = 123) -> str:
        assert eaaaa == "easd"
        assert nyaa is False
        assert yeet == 123
        return "aaaaa"

    result = context.call_with_di(callback, "easd", nyaa=False)

    assert result == "aaaaa"


def test_call_with_di_with_annotated_defaulting_typing_union_type_dependency(context: alluka.Context) -> None:
    mock_value = mock.Mock()
    context.injection_client.set_type_dependency(MockOtherType, mock_value)

    def callback(
        vvvvv: int, value: typing.Annotated[str, alluka.inject(type=typing.Union[MockType, MockOtherType])]
    ) -> str:
        assert vvvvv == 123
        assert value is mock_value
        return "ea sports"

    result = context.call_with_di(callback, 123)

    assert result == "ea sports"


def test_call_with_di_with_annotated_defaulting_typing_union_type_dependency_not_found(context: alluka.Context) -> None:
    def callback(vvvvv: int, value: typing.Annotated[str, alluka.inject(type=typing.Union[MockType, None])]) -> str:
        assert vvvvv == 123
        assert value is None
        return "yeeee"

    result = context.call_with_di(callback, 123)

    assert result == "yeeee"


def test_call_with_di_with_annotated_natural_defaulting_typing_union_type_dependency(context: alluka.Context) -> None:
    mock_value = mock.Mock()
    context.injection_client.set_type_dependency(MockOtherType, mock_value)

    def callback(
        vvvvv: int, value: typing.Annotated[str, alluka.inject(type=typing.Union[MockType, MockOtherType])] = "default"
    ) -> str:
        assert vvvvv == 123
        assert value is mock_value
        return "ea sports"

    result = context.call_with_di(callback, 123)

    assert result == "ea sports"


def test_call_with_di_with_annotated_natural_defaulting_typing_union_type_dependency_not_found(
    context: alluka.Context,
) -> None:
    def callback(
        vvvvv: int,
        value: typing.Annotated[str, alluka.inject(type=typing.Union[MockType, MockOtherType, None])] = "default 2",
    ) -> str:
        assert vvvvv == 123
        assert value == "default 2"
        return "yeeee"

    result = context.call_with_di(callback, 123)

    assert result == "yeeee"


def test_call_with_di_with_shorthand_annotated_type_dependency(context: alluka.Context) -> None:
    mock_value = mock.Mock()
    mock_other_value = mock.Mock()

    def callback(
        rawr: int, xd: float, meowmeow: alluka.Injected[MockType], other: alluka.Injected[MockOtherType]
    ) -> str:
        assert rawr == 1233212
        assert xd == "seee"
        assert meowmeow is mock_value
        assert other is mock_other_value
        return "eeesss"

    context.injection_client.set_type_dependency(MockType, mock_value).set_type_dependency(
        MockOtherType, mock_other_value
    )

    result = context.call_with_di(callback, 1233212, xd="seee")

    assert result == "eeesss"


def test_call_with_di_with_shorthand_annotated_type_dependency_not_found(context: alluka.Context) -> None:
    mock_other_value = mock.Mock()

    def callback(
        meow: int, nyaa: float, meowmeow: alluka.Injected[MockType], imacow: alluka.Injected[MockOtherType]
    ) -> str:
        raise NotImplementedError

    context.injection_client.set_type_dependency(MockOtherType, mock_other_value)

    with pytest.raises(alluka.MissingDependencyError) as exc_info:
        context.call_with_di(callback, meow=2222, nyaa="xxxxx")

    assert exc_info.value.dependency_type is MockType
    assert exc_info.value.message == f"Couldn't resolve injected type(s) {MockType} to actual value"


def test_call_with_di_with_shorthand_annotated_3_10_union_type_dependency(context: alluka.Context) -> None:
    mock_value = MockType()

    def callback(yeee: str, nyaa: bool, yeet: alluka.Injected[MockType | MockOtherType]) -> str:
        assert yeee == "yeee"
        assert nyaa is True
        assert yeet is mock_value
        return "hey"

    context.injection_client.set_type_dependency(MockOtherType, mock_value)

    result = context.call_with_di(callback, yeee="yeee", nyaa=True)

    assert result == "hey"


def test_call_with_di_with_shorthand_annotated_3_10_union_type_dependency_not_found(context: alluka.Context) -> None:
    def callback(_: int, __: str, cope: alluka.Injected[MockType | MockOtherType]) -> float:
        raise NotImplementedError

    with pytest.raises(alluka.MissingDependencyError) as exc_info:
        context.call_with_di(callback, 123, "ok")

    assert exc_info.value.dependency_type == MockType | MockOtherType
    assert exc_info.value.message == f"Couldn't resolve injected type(s) {MockType | MockOtherType} to actual value"


def test_call_with_di_with_shorthand_annotated_3_10_union_type_dependency_defaulting(context: alluka.Context) -> None:
    mock_value = MockType()

    context.injection_client.set_type_dependency(MockType, mock_value)

    def callback(value_1: int, value_2: str, cope: alluka.Injected[MockOtherType | MockType | None]) -> float:
        assert value_1 == 123
        assert value_2 == "ok"
        assert cope is mock_value
        return 451.123

    result = context.call_with_di(callback, 123, "ok")

    assert result == 451.123


def test_call_with_di_with_shorthand_annotated_3_10_union_type_dependency_defaulting_not_found(
    context: alluka.Context,
) -> None:
    def callback(value_1: int, value_2: str, cope: alluka.Injected[MockOtherType | MockType | None]) -> float:
        assert value_1 == 123
        assert value_2 == "ok"
        assert cope is None
        return 451.123

    result = context.call_with_di(callback, 123, "ok")

    assert result == 451.123


def test_call_with_di_with_shorthand_annotated_3_10_union_type_dependency_natural_defaulting(
    context: alluka.Context,
) -> None:
    mock_value = MockType()

    context.injection_client.set_type_dependency(MockType, mock_value)

    def callback(
        value_1: int, value_2: str, cope: alluka.Injected[MockOtherType | MockType | None] = MockOtherType()
    ) -> float:
        assert value_1 == 123
        assert value_2 == "ok"
        assert cope is mock_value
        return 451.123

    result = context.call_with_di(callback, 123, "ok")

    assert result == 451.123


def test_call_with_di_with_shorthand_annotated_3_10_union_type_dependency_natural_defaulting_not_found(
    context: alluka.Context,
) -> None:
    mock_default = mock.Mock()

    def callback(value_1: int, value_2: str, cope: alluka.Injected[MockOtherType | MockType] = mock_default) -> float:
        assert value_1 == 123
        assert value_2 == "ok"
        assert cope is mock_default
        return 451.123

    result = context.call_with_di(callback, 123, "ok")

    assert result == 451.123


def test_call_with_di_with_shorthand_annotated_typing_union_type_dependency(context: alluka.Context) -> None:
    mock_value = mock.Mock()

    def callback(meow: int, meowmeow: alluka.Injected[typing.Union[MockType, MockOtherType]]) -> str:
        assert meow == 1233212
        assert meowmeow is mock_value
        return "yay"

    context.injection_client.set_type_dependency(MockOtherType, mock_value)

    result = context.call_with_di(callback, 1233212)

    assert result == "yay"


def test_call_with_di_with_shorthand_annotated_typing_union_type_dependency_not_found(context: alluka.Context) -> None:
    def callback(yeee: str, nyaa: bool, yeet: alluka.Injected[typing.Union[MockType, MockOtherType]]) -> str:
        raise NotImplementedError

    with pytest.raises(alluka.MissingDependencyError) as exc_info:
        context.call_with_di(callback, yeee="yeee", nyaa=True)

    assert exc_info.value.dependency_type == typing.Union[MockType, MockOtherType]
    # For whatever reason the order and format of the union in message's repr
    # isn't consistent here so it isn't tested.


def test_call_with_di_with_shorthand_annotated_defaulting_optional_type_dependency(context: alluka.Context) -> None:
    mock_value = mock.Mock()
    context.injection_client.set_type_dependency(MockType, mock_value)

    def callback(eaaaa: str, nyaa: bool, yeet: alluka.Injected[typing.Optional[MockType]]) -> str:
        assert eaaaa == "easd"
        assert nyaa is False
        assert yeet is mock_value
        return "aaaaa"

    result = context.call_with_di(callback, "easd", nyaa=False)

    assert result == "aaaaa"


def test_call_with_di_with_shorthand_annotated_defaulting_optional_type_dependency_not_found(
    context: alluka.Context,
) -> None:
    def callback(eaaaa: str, nyaa: bool, yeet: alluka.Injected[typing.Optional[MockType]]) -> str:
        assert eaaaa == "easd"
        assert nyaa is False
        assert yeet is None
        return "aaaaa"

    result = context.call_with_di(callback, "easd", nyaa=False)

    assert result == "aaaaa"


def test_call_with_di_with_shorthand_annotated_natural_defaulting_type_dependency(context: alluka.Context) -> None:
    mock_value = mock.Mock()
    context.injection_client.set_type_dependency(MockType, mock_value)

    def callback(eaaaa: str, nyaa: bool, yeet: alluka.Injected[MockType] = MockType(123321)) -> str:
        assert eaaaa == "easd"
        assert nyaa is False
        assert yeet is mock_value
        return "aaaaa"

    result = context.call_with_di(callback, "easd", nyaa=False)

    assert result == "aaaaa"


def test_call_with_di_with_shorthand_annotated_natural_defaulting_type_dependency_not_found(
    context: alluka.Context,
) -> None:
    def callback(eaaaa: str, nyaa: bool, yeet: alluka.Injected[MockType] = MockType(123)) -> str:
        assert eaaaa == "easd"
        assert nyaa is False
        assert yeet == 123
        return "aaaaa"

    result = context.call_with_di(callback, "easd", nyaa=False)

    assert result == "aaaaa"


def test_call_with_di_with_shorthand_annotated_defaulting_typing_union_type_dependency(context: alluka.Context) -> None:
    mock_value = mock.Mock()
    context.injection_client.set_type_dependency(MockOtherType, mock_value)

    def callback(vvvvv: int, value: alluka.Injected[typing.Union[MockType, MockOtherType]]) -> str:
        assert vvvvv == 123
        assert value is mock_value
        return "ea sports"

    result = context.call_with_di(callback, 123)

    assert result == "ea sports"


def test_call_with_di_with_shorthand_annotated_defaulting_typing_union_type_dependency_not_found(
    context: alluka.Context,
) -> None:
    def callback(vvvvv: int, value: alluka.Injected[typing.Union[MockType, None]]) -> str:
        assert vvvvv == 123
        assert value is None
        return "yeeee"

    result = context.call_with_di(callback, 123)

    assert result == "yeeee"


def test_call_with_di_with_shorthand_annotated_natural_defaulting_typing_union_type_dependency(
    context: alluka.Context,
) -> None:
    mock_value = mock.Mock()
    context.injection_client.set_type_dependency(MockOtherType, mock_value)

    def callback(vvvvv: int, value: alluka.Injected[typing.Union[MockType, MockOtherType]] = MockType(5431234)) -> str:
        assert vvvvv == 123
        assert value is mock_value
        return "ea sports"

    result = context.call_with_di(callback, 123)

    assert result == "ea sports"


def test_call_with_di_with_shorthand_annotated_natural_defaulting_typing_union_type_dependency_not_found(
    context: alluka.Context,
) -> None:
    def callback(
        vvvvv: int, value: alluka.Injected[typing.Union[MockType, MockOtherType, None]] = MockType(54123123)
    ) -> str:
        assert vvvvv == 123
        assert value == 54123123
        return "yeeee"

    result = context.call_with_di(callback, 123)

    assert result == "yeeee"


def test_call_with_di_with_callback_dependency(context: alluka.Context) -> None:
    mock_callback = mock.Mock()

    def callback(value_1: int, result: int = alluka.inject(callback=mock_callback)) -> int:
        assert value_1 == 123
        assert result is mock_callback.return_value
        return 43123

    result = context.call_with_di(callback, 123)

    assert result == 43123
    mock_callback.assert_called_once_with()


def test_call_with_di_with_sub_callback_dependency(context: alluka.Context) -> None:
    mock_callback = mock.Mock()

    def dependency(result: int = alluka.inject(callback=mock_callback)) -> int:
        assert result is mock_callback.return_value
        return 541232

    def callback(value_1: int, result: int = alluka.inject(callback=dependency)) -> str:
        assert value_1 == 123
        assert result == 541232
        return "43123"

    result = context.call_with_di(callback, 123)

    assert result == "43123"
    mock_callback.assert_called_once_with()


def test_call_with_di_with_annotated_callback_dependency(context: alluka.Context) -> None:
    mock_callback = mock.Mock()

    def callback(value_1: int, result: typing.Annotated[int, alluka.inject(callback=mock_callback)]) -> int:
        assert value_1 == 123
        assert result is mock_callback.return_value
        return 43123

    result = context.call_with_di(callback, 123)

    assert result == 43123
    mock_callback.assert_called_once_with()


def test_call_with_di_with_annotated_sub_callback_dependency(context: alluka.Context) -> None:
    mock_callback = mock.Mock()

    def dependency(result: typing.Annotated[int, alluka.inject(callback=mock_callback)]) -> int:
        assert result is mock_callback.return_value
        return 541232

    def callback(value_1: int, result: typing.Annotated[int, alluka.inject(callback=dependency)]) -> str:
        assert value_1 == 123
        assert result == 541232
        return "43123"

    result = context.call_with_di(callback, 123)

    assert result == "43123"
    mock_callback.assert_called_once_with()


def test_call_with_di_with_sub_type_dependency(context: alluka.Context) -> None:
    mock_value = mock.Mock()
    context.injection_client.set_type_dependency(MockType, mock_value)

    def dependency(result: MockType = alluka.inject(type=MockType)) -> int:
        assert result is mock_value
        return 123321

    def callback(value_1: int, result: int = alluka.inject(callback=dependency)) -> str:
        assert value_1 == 54123
        assert result == 123321
        return "asddsa"

    result = context.call_with_di(callback, 54123)

    assert result == "asddsa"


def test_call_with_di_with_sub_type_dependency_not_found(context: alluka.Context) -> None:
    def dependency(result: typing.Annotated[int, alluka.inject(type=MockType)]) -> int:
        raise NotImplementedError

    def callback(_: int, result: int = alluka.inject(callback=dependency)) -> str:
        raise NotImplementedError

    with pytest.raises(alluka.MissingDependencyError) as exc_info:
        context.call_with_di(callback, 54123)

    assert exc_info.value.dependency_type is MockType
    assert exc_info.value.message == (f"Couldn't resolve injected type(s) {MockType} to actual value")


def test_call_with_di_when_async_callback(context: alluka.Context) -> None:
    async def callback() -> None:
        raise NotImplementedError

    with warnings.catch_warnings():
        warnings.simplefilter("ignore", category=RuntimeWarning)

        with pytest.raises(alluka.SyncOnlyError):
            context.call_with_di(callback)


def test_call_with_di_with_async_dependency(context: alluka.Context) -> None:
    async def async_dependency() -> None:
        raise NotImplementedError

    def callback(result: None = alluka.inject(callback=async_dependency)) -> None:
        raise NotImplementedError

    with warnings.catch_warnings():
        warnings.simplefilter("ignore", category=RuntimeWarning)

        with pytest.raises(alluka.SyncOnlyError):
            context.call_with_di(callback)


def test_call_with_di_with_overridden_async_dependency(context: alluka.Context) -> None:
    async def override() -> None:
        raise NotImplementedError

    def dependency() -> None:
        raise NotImplementedError

    def callback(result: None = alluka.inject(callback=dependency)) -> None:
        raise NotImplementedError

    context.injection_client.set_callback_override(dependency, override)

    with warnings.catch_warnings():
        warnings.simplefilter("ignore", category=RuntimeWarning)

        with pytest.raises(alluka.SyncOnlyError):
            context.call_with_di(callback)


def test_call_with_di_with_sub_async_dependency(context: alluka.Context) -> None:
    async def async_sub_dependency() -> None:
        raise NotImplementedError

    def dependency(_: None = alluka.inject(callback=async_sub_dependency)) -> None:
        raise NotImplementedError

    def callback(result: None = alluka.inject(callback=dependency)) -> None:
        raise NotImplementedError

    with warnings.catch_warnings():
        warnings.simplefilter("ignore", category=RuntimeWarning)

        with pytest.raises(alluka.SyncOnlyError):
            context.call_with_di(callback)


def test_call_with_di_with_overridden_sub_async_dependency(context: alluka.Context) -> None:
    async def override() -> None:
        raise NotImplementedError

    def sub_dependency() -> None:
        raise NotImplementedError

    def dependency(result: None = alluka.inject(callback=sub_dependency)) -> None:
        raise NotImplementedError

    def callback(result: None = alluka.inject(callback=dependency)) -> None:
        raise NotImplementedError

    context.injection_client.set_callback_override(sub_dependency, override)

    with warnings.catch_warnings():
        warnings.simplefilter("ignore", category=RuntimeWarning)

        with pytest.raises(alluka.SyncOnlyError):
            context.call_with_di(callback)


def test_call_with_di_with_annotated_async_dependency(context: alluka.Context) -> None:
    async def async_dependency() -> None:
        raise NotImplementedError

    def callback(result: typing.Annotated[None, alluka.inject(callback=async_dependency)]) -> None:
        raise NotImplementedError

    with warnings.catch_warnings():
        warnings.simplefilter("ignore", category=RuntimeWarning)

        with pytest.raises(alluka.SyncOnlyError):
            context.call_with_di(callback)


def test_call_with_di_with_overridden_annotated_async_dependency(context: alluka.Context) -> None:
    async def override() -> None:
        raise NotImplementedError

    def dependency() -> None:
        raise NotImplementedError

    def callback(result: None = alluka.inject(callback=dependency)) -> None:
        raise NotImplementedError

    context.injection_client.set_callback_override(dependency, override)

    with warnings.catch_warnings():
        warnings.simplefilter("ignore", category=RuntimeWarning)

        with pytest.raises(alluka.SyncOnlyError):
            context.call_with_di(callback)


def test_call_with_di_with_annotated_sub_async_dependency(context: alluka.Context) -> None:
    async def async_sub_dependency() -> None:
        raise NotImplementedError

    def dependency(_: typing.Annotated[None, alluka.inject(callback=async_sub_dependency)]) -> None:
        raise NotImplementedError

    def callback(result: typing.Annotated[None, alluka.inject(callback=dependency)]) -> None:
        raise NotImplementedError

    with warnings.catch_warnings():
        warnings.simplefilter("ignore", category=RuntimeWarning)

        with pytest.raises(alluka.SyncOnlyError):
            context.call_with_di(callback)


def test_call_with_di_with_overridden_annotated_sub_async_dependency(context: alluka.Context) -> None:
    async def override() -> None:
        raise NotImplementedError

    def sub_dependency() -> None:
        raise NotImplementedError

    def dependency(result: typing.Annotated[None, alluka.inject(callback=sub_dependency)]) -> None:
        raise NotImplementedError

    def callback(result: typing.Annotated[None, alluka.inject(callback=dependency)]) -> None:
        raise NotImplementedError

    context.injection_client.set_callback_override(sub_dependency, override)

    with warnings.catch_warnings():
        warnings.simplefilter("ignore", category=RuntimeWarning)

        with pytest.raises(alluka.SyncOnlyError):
            context.call_with_di(callback)


################################
# Positional-only dependencies #
################################


def test_call_with_di_with_positional_only_type_dependency(context: alluka.Context) -> None:
    def callback(_: int, __: float = alluka.inject(type=float), /, ___: float = alluka.inject(type=float)) -> None:
        raise NotImplementedError

    with pytest.raises(ValueError, match="Injected positional only arguments are not supported"):
        context.call_with_di(callback)


def test_call_with_di_with_positional_only_callback_dependency(context: alluka.Context) -> None:
    mock_dependency = mock.Mock()

    def callback(
        _: int, __: str = alluka.inject(callback=mock_dependency), /, ___: float = alluka.inject(type=float)
    ) -> None:
        raise NotImplementedError

    with pytest.raises(ValueError, match="Injected positional only arguments are not supported"):
        context.call_with_di(callback)


def test_call_with_di_with_sub_positional_only_callback_dependency(context: alluka.Context) -> None:
    sub_dependency = mock.Mock()

    def dependency(_: str = alluka.inject(callback=sub_dependency), /) -> str:
        raise NotImplementedError

    def callback(
        _: int, __: str = alluka.inject(callback=dependency), /, ___: float = alluka.inject(type=float)
    ) -> None:
        raise NotImplementedError

    with pytest.raises(ValueError, match="Injected positional only arguments are not supported"):
        context.call_with_di(callback)


def test_call_with_di_with_sub_positional_only_type_dependency(context: alluka.Context) -> None:
    def dependency(_: str = alluka.inject(type=str), /) -> str:
        raise NotImplementedError

    def callback(
        _: int, __: str = alluka.inject(callback=dependency), /, ___: float = alluka.inject(type=float)
    ) -> None:
        raise NotImplementedError

    with pytest.raises(ValueError, match="Injected positional only arguments are not supported"):
        context.call_with_di(callback)


##############
# Edge cases #
##############


def test_call_with_di_with_signature_less_callback(context: alluka.Context) -> None:
    """Ensure signature-less callbacks are handled."""
    with pytest.raises(ValueError, match="no signature found for builtin type <class 'str'>"):
        inspect.signature(str)

    result = context.call_with_di(str, b"ok")

    assert result == "b'ok'"


def test_call_with_di_with_signature_less_callback_dependency(context: alluka.Context) -> None:
    """Ensure signature-less callbacks are handled as callback dependencies."""
    with pytest.raises(ValueError, match="no signature found for builtin type <class 'int'>"):
        inspect.signature(int)

    def callback(value: int = alluka.inject(callback=int)) -> int:
        assert value == 0
        return 222

    result = context.call_with_di(callback)

    assert result == 222


def test_call_with_di_when_internal_argument_names_used(context: alluka.Context) -> None:
    """Test that internal argument won't name conflict with user function arguments."""

    def callback(ctx: str, callback: str) -> int:
        assert ctx == "123"
        assert callback == "456"
        return 999

    result = context.call_with_di(callback, ctx="123", callback="456")

    assert result == 999