@ajksunkang-aios/kgraph-linux-x64 0.1.2 → 0.1.3

package/lib/site-packages/trio/_tests/test_fakenet.py

@@ -0,0 +1,317 @@
+import errno
+import re
+import socket
+import sys
+
+import pytest
+
+import trio
+from trio.testing._fake_net import FakeNet
+
+# ENOTCONN gives different messages on different platforms
+if sys.platform == "linux":
+    ENOTCONN_MSG = r"^\[Errno 107\] (Transport endpoint is|Socket) not connected$"
+elif sys.platform == "darwin":
+    ENOTCONN_MSG = r"^\[Errno 57\] Socket is not connected$"
+else:
+    ENOTCONN_MSG = r"^\[Errno 10057\] Unknown error$"
+
+
+def fn() -> FakeNet:
+    fn = FakeNet()
+    fn.enable()
+    return fn
+
+
+async def test_basic_udp() -> None:
+    fn()
+    s1 = trio.socket.socket(type=trio.socket.SOCK_DGRAM)
+    s2 = trio.socket.socket(type=trio.socket.SOCK_DGRAM)
+
+    await s1.bind(("127.0.0.1", 0))
+    ip, port = s1.getsockname()
+    assert ip == "127.0.0.1"
+    assert port != 0
+
+    with pytest.raises(
+        OSError,
+        match=r"^\[\w+ \d+\] Invalid argument$",
+    ) as exc:  # Cannot rebind.
+        await s1.bind(("192.0.2.1", 0))
+    assert exc.value.errno == errno.EINVAL
+
+    # Cannot bind multiple sockets to the same address
+    with pytest.raises(
+        OSError,
+        match=r"^\[\w+ \d+\] (Address (already )?in use|Unknown error)$",
+    ) as exc:
+        await s2.bind(("127.0.0.1", port))
+    assert exc.value.errno == errno.EADDRINUSE
+
+    await s2.sendto(b"xyz", s1.getsockname())
+    data, addr = await s1.recvfrom(10)
+    assert data == b"xyz"
+    assert addr == s2.getsockname()
+    await s1.sendto(b"abc", s2.getsockname())
+    data, addr = await s2.recvfrom(10)
+    assert data == b"abc"
+    assert addr == s1.getsockname()
+
+
+async def test_msg_trunc() -> None:
+    fn()
+    s1 = trio.socket.socket(type=trio.socket.SOCK_DGRAM)
+    s2 = trio.socket.socket(type=trio.socket.SOCK_DGRAM)
+    await s1.bind(("127.0.0.1", 0))
+    await s2.sendto(b"xyz", s1.getsockname())
+    await s1.recvfrom(10)
+
+
+async def test_recv_methods() -> None:
+    """Test all recv methods for codecov"""
+    fn()
+    s1 = trio.socket.socket(type=trio.socket.SOCK_DGRAM)
+    s2 = trio.socket.socket(type=trio.socket.SOCK_DGRAM)
+
+    # receiving on an unbound socket is a bad idea (I think?)
+    with pytest.raises(NotImplementedError, match="code will most likely hang"):
+        await s2.recv(10)
+
+    await s1.bind(("127.0.0.1", 0))
+    ip, port = s1.getsockname()
+    assert ip == "127.0.0.1"
+    assert port != 0
+
+    # recvfrom
+    await s2.sendto(b"abc", s1.getsockname())
+    data, addr = await s1.recvfrom(10)
+    assert data == b"abc"
+    assert addr == s2.getsockname()
+
+    # recv
+    await s1.sendto(b"def", s2.getsockname())
+    data = await s2.recv(10)
+    assert data == b"def"
+
+    # recvfrom_into
+    assert await s1.sendto(b"ghi", s2.getsockname()) == 3
+    buf = bytearray(10)
+
+    with pytest.raises(NotImplementedError, match=r"^partial recvfrom_into$"):
+        nbytes, addr = await s2.recvfrom_into(buf, nbytes=2)
+
+    nbytes, addr = await s2.recvfrom_into(buf)
+    assert nbytes == 3
+    assert buf == b"ghi" + b"\x00" * 7
+    assert addr == s1.getsockname()
+
+    # recv_into
+    assert await s1.sendto(b"jkl", s2.getsockname()) == 3
+    buf2 = bytearray(10)
+    nbytes = await s2.recv_into(buf2)
+    assert nbytes == 3
+    assert buf2 == b"jkl" + b"\x00" * 7
+
+    if sys.platform == "linux" and sys.implementation.name == "cpython":
+        flags: int = socket.MSG_MORE
+    else:
+        flags = 1
+
+    # Send seems explicitly non-functional
+    with pytest.raises(OSError, match=ENOTCONN_MSG) as exc:
+        await s2.send(b"mno")
+    assert exc.value.errno == errno.ENOTCONN
+    with pytest.raises(
+        NotImplementedError, match=r"^FakeNet send flags must be 0, not"
+    ):
+        await s2.send(b"mno", flags)
+
+    # sendto errors
+    # it's successfully used earlier
+    with pytest.raises(
+        NotImplementedError, match=r"^FakeNet send flags must be 0, not"
+    ):
+        await s2.sendto(b"mno", flags, s1.getsockname())
+    with pytest.raises(TypeError, match=r"wrong number of arguments$"):
+        await s2.sendto(b"mno", flags, s1.getsockname(), "extra arg")  # type: ignore[call-overload]
+
+
+@pytest.mark.skipif(
+    sys.platform == "win32",
+    reason="functions not in socket on windows",
+)
+async def test_nonwindows_functionality() -> None:
+    # mypy doesn't support a good way of aborting typechecking on different platforms
+    if sys.platform != "win32":  # pragma: no branch
+        fn()
+        s1 = trio.socket.socket(type=trio.socket.SOCK_DGRAM)
+        s2 = trio.socket.socket(type=trio.socket.SOCK_DGRAM)
+        await s2.bind(("127.0.0.1", 0))
+
+        # sendmsg
+        with pytest.raises(OSError, match=ENOTCONN_MSG) as exc:
+            await s2.sendmsg([b"mno"])
+        assert exc.value.errno == errno.ENOTCONN
+
+        assert await s1.sendmsg([b"jkl"], (), 0, s2.getsockname()) == 3
+        data, ancdata, msg_flags, addr = await s2.recvmsg(10)
+        assert data == b"jkl"
+        assert ancdata == []
+        assert msg_flags == 0
+        assert addr == s1.getsockname()
+
+        # TODO: recvmsg
+
+        # recvmsg_into
+        assert await s1.sendto(b"xyzw", s2.getsockname()) == 4
+        buf1 = bytearray(2)
+        buf2 = bytearray(3)
+        ret = await s2.recvmsg_into([buf1, buf2])
+        nbytes, ancdata, msg_flags, addr = ret
+        assert nbytes == 4
+        assert buf1 == b"xy"
+        assert buf2 == b"zw" + b"\x00"
+        assert ancdata == []
+        assert msg_flags == 0
+        assert addr == s1.getsockname()
+
+        # recvmsg_into with MSG_TRUNC set
+        assert await s1.sendto(b"xyzwv", s2.getsockname()) == 5
+        buf1 = bytearray(2)
+        ret = await s2.recvmsg_into([buf1])
+        nbytes, ancdata, msg_flags, addr = ret
+        assert nbytes == 2
+        assert buf1 == b"xy"
+        assert ancdata == []
+        assert msg_flags == socket.MSG_TRUNC
+        assert addr == s1.getsockname()
+
+        with pytest.raises(
+            AttributeError,
+            match=r"^'FakeSocket' object has no attribute 'share'$",
+        ):
+            await s1.share(0)  # type: ignore[attr-defined]
+
+
+@pytest.mark.skipif(
+    sys.platform != "win32",
+    reason="windows-specific fakesocket testing",
+)
+async def test_windows_functionality() -> None:
+    # mypy doesn't support a good way of aborting typechecking on different platforms
+    if sys.platform == "win32":  # pragma: no branch
+        fn()
+        s1 = trio.socket.socket(type=trio.socket.SOCK_DGRAM)
+        s2 = trio.socket.socket(type=trio.socket.SOCK_DGRAM)
+        await s1.bind(("127.0.0.1", 0))
+        with pytest.raises(
+            AttributeError,
+            match=r"^'FakeSocket' object has no attribute 'sendmsg'$",
+        ):
+            await s1.sendmsg([b"jkl"], (), 0, s2.getsockname())  # type: ignore[attr-defined]
+        with pytest.raises(
+            AttributeError,
+            match=r"^'FakeSocket' object has no attribute 'recvmsg'$",
+        ):
+            s2.recvmsg(0)  # type: ignore[attr-defined]
+        with pytest.raises(
+            AttributeError,
+            match=r"^'FakeSocket' object has no attribute 'recvmsg_into'$",
+        ):
+            s2.recvmsg_into([])  # type: ignore[attr-defined]
+        with pytest.raises(NotImplementedError):
+            s1.share(0)
+
+
+async def test_basic_tcp() -> None:
+    fn()
+    with pytest.raises(NotImplementedError):
+        trio.socket.socket()
+
+
+async def test_not_implemented_functions() -> None:
+    fn()
+    s1 = trio.socket.socket(type=trio.socket.SOCK_DGRAM)
+
+    # getsockopt
+    with pytest.raises(
+        OSError,
+        match=r"^FakeNet doesn't implement getsockopt\(\d, \d\)$",
+    ):
+        s1.getsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY)
+
+    # setsockopt
+    with pytest.raises(
+        NotImplementedError,
+        match=r"^FakeNet always has IPV6_V6ONLY=True$",
+    ):
+        s1.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, False)
+    with pytest.raises(
+        OSError,
+        match=r"^FakeNet doesn't implement setsockopt\(\d+, \d+, \.\.\.\)$",
+    ):
+        s1.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, True)
+    with pytest.raises(
+        OSError,
+        match=r"^FakeNet doesn't implement setsockopt\(\d+, \d+, \.\.\.\)$",
+    ):
+        s1.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+
+    # set_inheritable
+    s1.set_inheritable(False)
+    with pytest.raises(
+        NotImplementedError,
+        match=r"^FakeNet can't make inheritable sockets$",
+    ):
+        s1.set_inheritable(True)
+
+    # get_inheritable
+    assert not s1.get_inheritable()
+
+
+async def test_getpeername() -> None:
+    fn()
+    s1 = trio.socket.socket(type=trio.socket.SOCK_DGRAM)
+    with pytest.raises(OSError, match=ENOTCONN_MSG) as exc:
+        s1.getpeername()
+    assert exc.value.errno == errno.ENOTCONN
+
+    await s1.bind(("127.0.0.1", 0))
+
+    with pytest.raises(
+        AssertionError,
+        match=r"^This method seems to assume that self._binding has a remote UDPEndpoint$",
+    ):
+        s1.getpeername()
+
+
+async def test_init() -> None:
+    fn()
+    with pytest.raises(
+        NotImplementedError,
+        match=re.escape(
+            f"FakeNet doesn't (yet) support type={trio.socket.SOCK_STREAM}",
+        ),
+    ):
+        s1 = trio.socket.socket()
+
+    # getsockname on unbound ipv4 socket
+    s1 = trio.socket.socket(type=trio.socket.SOCK_DGRAM)
+    assert s1.getsockname() == ("0.0.0.0", 0)
+
+    # getsockname on bound ipv4 socket
+    await s1.bind(("0.0.0.0", 0))
+    ip, port = s1.getsockname()
+    assert ip == "127.0.0.1"
+    assert port != 0
+
+    # getsockname on unbound ipv6 socket
+    s2 = trio.socket.socket(family=socket.AF_INET6, type=socket.SOCK_DGRAM)
+    assert s2.getsockname() == ("::", 0)
+
+    # getsockname on bound ipv6 socket
+    await s2.bind(("::", 0))
+    ip, port, *_ = s2.getsockname()
+    assert ip == "::1"
+    assert port != 0
+    assert _ == [0, 0]

package/lib/site-packages/trio/_tests/test_file_io.py

@@ -0,0 +1,269 @@
+from __future__ import annotations
+
+import importlib
+import io
+import os
+import re
+from typing import TYPE_CHECKING
+from unittest import mock
+from unittest.mock import sentinel
+
+import pytest
+
+import trio
+from trio import _core, _file_io
+from trio._file_io import _FILE_ASYNC_METHODS, _FILE_SYNC_ATTRS, AsyncIOWrapper
+
+if TYPE_CHECKING:
+    import pathlib
+
+
+@pytest.fixture
+def path(tmp_path: pathlib.Path) -> str:
+    return os.fspath(tmp_path / "test")
+
+
+@pytest.fixture
+def wrapped() -> mock.Mock:
+    return mock.Mock(spec_set=io.StringIO)
+
+
+@pytest.fixture
+def async_file(wrapped: mock.Mock) -> AsyncIOWrapper[mock.Mock]:
+    return trio.wrap_file(wrapped)
+
+
+def test_wrap_invalid() -> None:
+    with pytest.raises(TypeError):
+        trio.wrap_file("")
+
+
+def test_wrap_non_iobase() -> None:
+    class FakeFile:
+        def close(self) -> None:  # pragma: no cover
+            pass
+
+        def write(self) -> None:  # pragma: no cover
+            pass
+
+    wrapped = FakeFile()
+    assert not isinstance(wrapped, io.IOBase)
+
+    async_file = trio.wrap_file(wrapped)
+    assert isinstance(async_file, AsyncIOWrapper)
+
+    del FakeFile.write
+
+    with pytest.raises(TypeError):
+        trio.wrap_file(FakeFile())
+
+
+def test_wrapped_property(
+    async_file: AsyncIOWrapper[mock.Mock],
+    wrapped: mock.Mock,
+) -> None:
+    assert async_file.wrapped is wrapped
+
+
+def test_dir_matches_wrapped(
+    async_file: AsyncIOWrapper[mock.Mock],
+    wrapped: mock.Mock,
+) -> None:
+    attrs = _FILE_SYNC_ATTRS.union(_FILE_ASYNC_METHODS)
+
+    # all supported attrs in wrapped should be available in async_file
+    assert all(attr in dir(async_file) for attr in attrs if attr in dir(wrapped))
+    # all supported attrs not in wrapped should not be available in async_file
+    assert not any(
+        attr in dir(async_file) for attr in attrs if attr not in dir(wrapped)
+    )
+
+
+def test_unsupported_not_forwarded() -> None:
+    class FakeFile(io.RawIOBase):
+        def unsupported_attr(self) -> None:  # pragma: no cover
+            pass
+
+    async_file = trio.wrap_file(FakeFile())
+
+    assert hasattr(async_file.wrapped, "unsupported_attr")
+
+    with pytest.raises(AttributeError):
+        # B018 "useless expression"
+        async_file.unsupported_attr  # type: ignore[attr-defined] # noqa: B018
+
+
+def test_type_stubs_match_lists() -> None:
+    """Check the manual stubs match the list of wrapped methods."""
+    # Fetch the module's source code.
+    assert _file_io.__spec__ is not None
+    loader = _file_io.__spec__.loader
+    assert isinstance(loader, importlib.abc.SourceLoader)
+    source = io.StringIO(loader.get_source("trio._file_io"))
+
+    # Find the class, then find the TYPE_CHECKING block.
+    for line in source:
+        if "class AsyncIOWrapper" in line:
+            break
+    else:  # pragma: no cover - should always find this
+        pytest.fail("No class definition line?")
+
+    for line in source:
+        if "if TYPE_CHECKING" in line:
+            break
+    else:  # pragma: no cover - should always find this
+        pytest.fail("No TYPE CHECKING line?")
+
+    # Now we should be at the type checking block.
+    found: list[tuple[str, str]] = []
+    for line in source:  # pragma: no branch - expected to break early
+        if line.strip() and not line.startswith(" " * 8):
+            break  # Dedented out of the if TYPE_CHECKING block.
+        match = re.match(r"\s*(async )?def ([a-zA-Z0-9_]+)\(", line)
+        if match is not None:
+            kind = "async" if match.group(1) is not None else "sync"
+            found.append((match.group(2), kind))
+
+    # Compare two lists so that we can easily see duplicates, and see what is different overall.
+    expected = [(fname, "async") for fname in _FILE_ASYNC_METHODS]
+    expected += [(fname, "sync") for fname in _FILE_SYNC_ATTRS]
+    # Ignore order, error if duplicates are present.
+    found.sort()
+    expected.sort()
+    assert found == expected
+
+
+def test_sync_attrs_forwarded(
+    async_file: AsyncIOWrapper[mock.Mock],
+    wrapped: mock.Mock,
+) -> None:
+    for attr_name in _FILE_SYNC_ATTRS:
+        if attr_name not in dir(async_file):
+            continue
+
+        assert getattr(async_file, attr_name) is getattr(wrapped, attr_name)
+
+
+def test_sync_attrs_match_wrapper(
+    async_file: AsyncIOWrapper[mock.Mock],
+    wrapped: mock.Mock,
+) -> None:
+    for attr_name in _FILE_SYNC_ATTRS:
+        if attr_name in dir(async_file):
+            continue
+
+        with pytest.raises(AttributeError):
+            getattr(async_file, attr_name)
+
+        with pytest.raises(AttributeError):
+            getattr(wrapped, attr_name)
+
+
+def test_async_methods_generated_once(async_file: AsyncIOWrapper[mock.Mock]) -> None:
+    for meth_name in _FILE_ASYNC_METHODS:
+        if meth_name not in dir(async_file):
+            continue
+
+        assert getattr(async_file, meth_name) is getattr(async_file, meth_name)
+
+
+# I gave up on typing this one
+def test_async_methods_signature(async_file: AsyncIOWrapper[mock.Mock]) -> None:
+    # use read as a representative of all async methods
+    assert async_file.read.__name__ == "read"
+    assert async_file.read.__qualname__ == "AsyncIOWrapper.read"
+
+    assert async_file.read.__doc__ is not None
+    assert "io.StringIO.read" in async_file.read.__doc__
+
+
+async def test_async_methods_wrap(
+    async_file: AsyncIOWrapper[mock.Mock],
+    wrapped: mock.Mock,
+) -> None:
+    for meth_name in _FILE_ASYNC_METHODS:
+        if meth_name not in dir(async_file):
+            continue
+
+        meth = getattr(async_file, meth_name)
+        wrapped_meth = getattr(wrapped, meth_name)
+
+        value = await meth(sentinel.argument, keyword=sentinel.keyword)
+
+        wrapped_meth.assert_called_once_with(
+            sentinel.argument,
+            keyword=sentinel.keyword,
+        )
+        assert value == wrapped_meth()
+
+        wrapped.reset_mock()
+
+
+def test_async_methods_match_wrapper(
+    async_file: AsyncIOWrapper[mock.Mock],
+    wrapped: mock.Mock,
+) -> None:
+    for meth_name in _FILE_ASYNC_METHODS:
+        if meth_name in dir(async_file):
+            continue
+
+        with pytest.raises(AttributeError):
+            getattr(async_file, meth_name)
+
+        with pytest.raises(AttributeError):
+            getattr(wrapped, meth_name)
+
+
+async def test_open(path: pathlib.Path) -> None:
+    f = await trio.open_file(path, "w")
+
+    assert isinstance(f, AsyncIOWrapper)
+
+    await f.aclose()
+
+
+async def test_open_context_manager(path: pathlib.Path) -> None:
+    async with await trio.open_file(path, "w") as f:
+        assert isinstance(f, AsyncIOWrapper)
+        assert not f.closed
+
+    assert f.closed
+
+
+async def test_async_iter() -> None:
+    async_file = trio.wrap_file(io.StringIO("test\nfoo\nbar"))
+    expected = list(async_file.wrapped)
+    async_file.wrapped.seek(0)
+
+    result = [line async for line in async_file]
+
+    assert result == expected
+
+
+async def test_aclose_cancelled(path: pathlib.Path) -> None:
+    with _core.CancelScope() as cscope:
+        f = await trio.open_file(path, "w")
+        cscope.cancel()
+
+        with pytest.raises(_core.Cancelled):
+            await f.write("a")
+
+        with pytest.raises(_core.Cancelled):
+            await f.aclose()
+
+    assert f.closed
+
+
+async def test_detach_rewraps_asynciobase(tmp_path: pathlib.Path) -> None:
+    tmp_file = tmp_path / "filename"
+    tmp_file.touch()
+    # flake8-async does not like opening files in async mode
+    with open(tmp_file, mode="rb", buffering=0) as raw:  # noqa: ASYNC230
+        buffered = io.BufferedReader(raw)
+
+        async_file = trio.wrap_file(buffered)
+
+        detached = await async_file.detach()
+
+        assert isinstance(detached, AsyncIOWrapper)
+        assert detached.wrapped is raw

package/lib/site-packages/trio/_tests/test_highlevel_generic.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from typing import NoReturn
+
+import attrs
+import pytest
+
+from .._highlevel_generic import StapledStream
+from ..abc import ReceiveStream, SendStream
+
+
+@attrs.define(slots=False)
+class RecordSendStream(SendStream):
+    record: list[str | tuple[str, object]] = attrs.Factory(list)
+
+    async def send_all(self, data: object) -> None:
+        self.record.append(("send_all", data))
+
+    async def wait_send_all_might_not_block(self) -> None:
+        self.record.append("wait_send_all_might_not_block")
+
+    async def aclose(self) -> None:
+        self.record.append("aclose")
+
+
+@attrs.define(slots=False)
+class RecordReceiveStream(ReceiveStream):
+    record: list[str | tuple[str, int | None]] = attrs.Factory(list)
+
+    async def receive_some(self, max_bytes: int | None = None) -> bytes:
+        self.record.append(("receive_some", max_bytes))
+        return b""
+
+    async def aclose(self) -> None:
+        self.record.append("aclose")
+
+
+async def test_StapledStream() -> None:
+    send_stream = RecordSendStream()
+    receive_stream = RecordReceiveStream()
+    stapled = StapledStream(send_stream, receive_stream)
+
+    assert stapled.send_stream is send_stream
+    assert stapled.receive_stream is receive_stream
+
+    await stapled.send_all(b"foo")
+    await stapled.wait_send_all_might_not_block()
+    assert send_stream.record == [
+        ("send_all", b"foo"),
+        "wait_send_all_might_not_block",
+    ]
+    send_stream.record.clear()
+
+    await stapled.send_eof()
+    assert send_stream.record == ["aclose"]
+    send_stream.record.clear()
+
+    async def fake_send_eof() -> None:
+        send_stream.record.append("send_eof")
+
+    send_stream.send_eof = fake_send_eof  # type: ignore[attr-defined]
+    await stapled.send_eof()
+    assert send_stream.record == ["send_eof"]
+
+    send_stream.record.clear()
+    assert receive_stream.record == []
+
+    await stapled.receive_some(1234)
+    assert receive_stream.record == [("receive_some", 1234)]
+    assert send_stream.record == []
+    receive_stream.record.clear()
+
+    await stapled.aclose()
+    assert receive_stream.record == ["aclose"]
+    assert send_stream.record == ["aclose"]
+
+
+async def test_StapledStream_with_erroring_close() -> None:
+    # Make sure that if one of the aclose methods errors out, then the other
+    # one still gets called.
+    class BrokenSendStream(RecordSendStream):
+        async def aclose(self) -> NoReturn:
+            await super().aclose()
+            raise ValueError("send error")
+
+    class BrokenReceiveStream(RecordReceiveStream):
+        async def aclose(self) -> NoReturn:
+            await super().aclose()
+            raise ValueError("recv error")
+
+    stapled = StapledStream(BrokenSendStream(), BrokenReceiveStream())
+
+    with pytest.raises(ValueError, match=r"^(send|recv) error$") as excinfo:
+        await stapled.aclose()
+    assert isinstance(excinfo.value.__context__, ValueError)
+
+    assert stapled.send_stream.record == ["aclose"]
+    assert stapled.receive_stream.record == ["aclose"]