async-solipsism 0.5__tar.gz → 0.7__tar.gz

async_solipsism-0.7/.github/workflows/test.yml

@@ -0,0 +1,36 @@
+name: Run tests
+
+on: [push, pull_request]
+
+jobs:
+  lint:
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python 3.8
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.8"
+      - name: Install dependencies
+        run: pip install -r requirements.txt
+      - name: Run pre-commit
+        run: pre-commit run --all-files
+
+  build:
+    runs-on: ubuntu-22.04
+    strategy:
+      matrix:
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          allow-prereleases: true
+      - name: Install dependencies
+        run: pip install -r requirements.txt
+      - name: Install package
+        run: pip install .
+      - name: Run pytest
+        run: pytest

{async-solipsism-0.5 → async_solipsism-0.7}/.gitignore

@@ -1,2 +1,3 @@
 *.egg-info
 __pycache__
+/dist

async_solipsism-0.7/.pre-commit-config.yaml

@@ -0,0 +1,12 @@
+repos:
+  - repo: https://github.com/pycqa/flake8
+    rev: "7.0.0"
+    hooks:
+      - id: flake8
+  - repo: https://github.com/jazzband/pip-tools
+    rev: 7.4.1
+    hooks:
+      - id: pip-compile
+        language_version: python3.8
+        args: ["--output-file=requirements.txt", "--extra=test", "--strip-extras", "pyproject.toml"]
+        files: '^(?:pyproject\.toml|requirements\.txt)$'

{async-solipsism-0.5/src/async_solipsism.egg-info → async_solipsism-0.7}/PKG-INFO

@@ -1,22 +1,25 @@
 Metadata-Version: 2.1
 Name: async-solipsism
-Version: 0.5
+Version: 0.7
 Summary: Asyncio event loop that doesn't interact with the outside world
-Home-page: https://github.com/bmerry/async-solipsism
-Author: Bruce Merry
-Author-email: bmerry@gmail.com
-Classifier: Development Status :: 3 - Alpha
+Author-email: Bruce Merry <bmerry@gmail.com>
+Project-URL: Homepage, https://github.com/bmerry/async-solipsism
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Framework :: AsyncIO
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Topic :: Software Development :: Testing :: Mocking
-Requires-Python: >=3.6
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Provides-Extra: test
 License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pre-commit; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio>=0.23; extra == "test"
+Requires-Dist: pytest-mock; extra == "test"
 
 # A solipsist event loop
 
-async-solipsism provide a Python asyncio event loop that does not interact with
+async-solipsism provides a Python asyncio event loop that does not interact with
 the outside world at all. This is ideal for writing unit tests that intend to
 mock out real-world interactions. It makes for tests that are reliable
 (unaffected by network outages), reproducible (not affected by random timing
@@ -107,8 +110,17 @@ port number of 0, and async-solipsism will bind the first port number above
 ### Integration with pytest-asyncio
 
 async-solipsism and pytest-asyncio complement each other well: just write a
-custom `event_loop` fixture in your test file or `conftest.py` and it will
-override the default provided by pytest-asyncio:
+custom `event_loop_policy` fixture in your test file or `conftest.py` and it
+will override the default provided by pytest-asyncio:
+
+```python
+@pytest.fixture
+def event_loop_policy():
+    return async_solipsism.EventLoopPolicy()
+```
+
+The above is for pytest-asyncio 0.23+. If you're using an older version, then
+instead you should do this:
 
 ```python
 @pytest.fixture
@@ -118,7 +130,14 @@ def event_loop():
     loop.close()
 ```
 
-### Integration with pytest-aiohttp
+### Integration with aiohappyeyeballs
+
+Unfortunately `aiohappyeyeballs.start_connection` doesn't work out of the box
+because it relies on creating a real socket. I've created a replacement
+`async_solipsism.aiohappyeyeballs_start_connection` that can be used to
+replace it. See the aiohttp section below for example code.
+
+### Integration with aiohttp
 
 A little extra work is required to work with aiohttp's test utilities, but it
 is possible. The example below requires at least aiohttp 3.8.0.
@@ -130,10 +149,14 @@ from aiohttp import web, test_utils
 
 
 @pytest.fixture
-def event_loop():
-    loop = async_solipsism.EventLoop()
-    yield loop
-    loop.close()
+def event_loop_policy():
+    return async_solipsism.EventLoopPolicy()
+
+
+@pytest.fixture(autouse=True)
+def mock_start_connection(monkeypatch):
+    monkeypatch.setattr("aiohappyeyeballs.start_connection",
+                        async_solipsism.aiohappyeyeballs_start_connection)
 
 
 def socket_factory(host, port, family):
@@ -183,6 +206,25 @@ Calling functions that are not supported will generally raise
 
 ## Changelog
 
+### 0.7
+
+- Add a replacement function for `aiohappyeyeballs.start_connection`.
+
+### 0.6
+
+- Drop support for Python 3.6 and 3.7, which have reached end of life.
+- Add `EventLoopPolicy` to simplify integration with pytest-asyncio 0.23+,
+  and use it for the internal tests.
+- Make `Socket.write` and `Socket.recv_into` accept arbitrary buffer-protocol
+  objects.
+- Various packaging and developer experience improvements:
+  - Put the packaging metadata in pyproject.toml, removing setup.cfg.
+  - Pin versions for CI in requirements.txt using pip-compile.
+  - Use pre-commit to enforce flake8 and pip-compile.
+  - Remove wheel from `build-system.requires` (on setuptools advice).
+  - Test against Python 3.11 and 3.12.
+  - Run CI workflow against pull requests.
+
 ### 0.5
 
 - Map port 0 to an unused port.

async-solipsism-0.5/PKG-INFO → async_solipsism-0.7/README.md

@@ -1,22 +1,6 @@
-Metadata-Version: 2.1
-Name: async-solipsism
-Version: 0.5
-Summary: Asyncio event loop that doesn't interact with the outside world
-Home-page: https://github.com/bmerry/async-solipsism
-Author: Bruce Merry
-Author-email: bmerry@gmail.com
-Classifier: Development Status :: 3 - Alpha
-Classifier: Framework :: AsyncIO
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
-Classifier: Topic :: Software Development :: Testing :: Mocking
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-Provides-Extra: test
-License-File: LICENSE
-
 # A solipsist event loop
 
-async-solipsism provide a Python asyncio event loop that does not interact with
+async-solipsism provides a Python asyncio event loop that does not interact with
 the outside world at all. This is ideal for writing unit tests that intend to
 mock out real-world interactions. It makes for tests that are reliable
 (unaffected by network outages), reproducible (not affected by random timing
@@ -107,8 +91,17 @@ port number of 0, and async-solipsism will bind the first port number above
 ### Integration with pytest-asyncio
 
 async-solipsism and pytest-asyncio complement each other well: just write a
-custom `event_loop` fixture in your test file or `conftest.py` and it will
-override the default provided by pytest-asyncio:
+custom `event_loop_policy` fixture in your test file or `conftest.py` and it
+will override the default provided by pytest-asyncio:
+
+```python
+@pytest.fixture
+def event_loop_policy():
+    return async_solipsism.EventLoopPolicy()
+```
+
+The above is for pytest-asyncio 0.23+. If you're using an older version, then
+instead you should do this:
 
 ```python
 @pytest.fixture
@@ -118,7 +111,14 @@ def event_loop():
     loop.close()
 ```
 
-### Integration with pytest-aiohttp
+### Integration with aiohappyeyeballs
+
+Unfortunately `aiohappyeyeballs.start_connection` doesn't work out of the box
+because it relies on creating a real socket. I've created a replacement
+`async_solipsism.aiohappyeyeballs_start_connection` that can be used to
+replace it. See the aiohttp section below for example code.
+
+### Integration with aiohttp
 
 A little extra work is required to work with aiohttp's test utilities, but it
 is possible. The example below requires at least aiohttp 3.8.0.
@@ -130,10 +130,14 @@ from aiohttp import web, test_utils
 
 
 @pytest.fixture
-def event_loop():
-    loop = async_solipsism.EventLoop()
-    yield loop
-    loop.close()
+def event_loop_policy():
+    return async_solipsism.EventLoopPolicy()
+
+
+@pytest.fixture(autouse=True)
+def mock_start_connection(monkeypatch):
+    monkeypatch.setattr("aiohappyeyeballs.start_connection",
+                        async_solipsism.aiohappyeyeballs_start_connection)
 
 
 def socket_factory(host, port, family):
@@ -183,6 +187,25 @@ Calling functions that are not supported will generally raise
 
 ## Changelog
 
+### 0.7
+
+- Add a replacement function for `aiohappyeyeballs.start_connection`.
+
+### 0.6
+
+- Drop support for Python 3.6 and 3.7, which have reached end of life.
+- Add `EventLoopPolicy` to simplify integration with pytest-asyncio 0.23+,
+  and use it for the internal tests.
+- Make `Socket.write` and `Socket.recv_into` accept arbitrary buffer-protocol
+  objects.
+- Various packaging and developer experience improvements:
+  - Put the packaging metadata in pyproject.toml, removing setup.cfg.
+  - Pin versions for CI in requirements.txt using pip-compile.
+  - Use pre-commit to enforce flake8 and pip-compile.
+  - Remove wheel from `build-system.requires` (on setuptools advice).
+  - Test against Python 3.11 and 3.12.
+  - Run CI workflow against pull requests.
+
 ### 0.5
 
 - Map port 0 to an unused port.

async_solipsism-0.7/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=64", "setuptools-scm>=8.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "async-solipsism"
+dynamic = ["version", "readme"]
+description = "Asyncio event loop that doesn't interact with the outside world"
+authors = [
+    {name = "Bruce Merry", email = "bmerry@gmail.com"}
+]
+requires-python = ">=3.8"
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Framework :: AsyncIO",
+    "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
+    "Topic :: Software Development :: Testing :: Mocking",
+]
+
+[project.urls]
+Homepage = "https://github.com/bmerry/async-solipsism"
+
+[project.optional-dependencies]
+test = [
+    "pre-commit",
+    "pytest",
+    "pytest-asyncio>=0.23",
+    "pytest-mock",
+]
+
+[tool.setuptools_scm]
+
+[tool.setuptools.dynamic]
+version = {attr = "async_solipsism.__version__"}
+readme = {file = ["README.md"], content-type = "text/markdown"}

async_solipsism-0.7/requirements.in

@@ -0,0 +1,4 @@
+pre-commit
+pytest
+pytest-asyncio>=0.23
+pytest-mock

async_solipsism-0.7/requirements.txt

@@ -0,0 +1,46 @@
+#
+# This file is autogenerated by pip-compile with Python 3.8
+# by the following command:
+#
+#    pip-compile --extra=test --output-file=requirements.txt --strip-extras pyproject.toml
+#
+cfgv==3.4.0
+    # via pre-commit
+distlib==0.3.8
+    # via virtualenv
+exceptiongroup==1.2.0
+    # via pytest
+filelock==3.13.1
+    # via virtualenv
+identify==2.5.35
+    # via pre-commit
+iniconfig==2.0.0
+    # via pytest
+nodeenv==1.8.0
+    # via pre-commit
+packaging==24.0
+    # via pytest
+platformdirs==4.2.0
+    # via virtualenv
+pluggy==1.4.0
+    # via pytest
+pre-commit==3.5.0
+    # via async-solipsism (pyproject.toml)
+pytest==8.1.1
+    # via
+    #   async-solipsism (pyproject.toml)
+    #   pytest-asyncio
+    #   pytest-mock
+pytest-asyncio==0.23.6
+    # via async-solipsism (pyproject.toml)
+pytest-mock==3.14.0
+    # via async-solipsism (pyproject.toml)
+pyyaml==6.0.1
+    # via pre-commit
+tomli==2.0.1
+    # via pytest
+virtualenv==20.25.1
+    # via pre-commit
+
+# The following packages are considered to be unsafe in a requirements file:
+# setuptools

async_solipsism-0.7/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

{async-solipsism-0.5 → async_solipsism-0.7}/src/async_solipsism/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2020-2022 Bruce Merry
+# Copyright 2020-2022, 2024 Bruce Merry
 #
 # This file is part of async-solipsism.
 #
@@ -19,4 +19,4 @@ from .exceptions import *  # noqa
 from .socket import *      # noqa
 from .loop import *        # noqa
 
-__version__ = '0.5'
+__version__ = '0.7'

{async-solipsism-0.5 → async_solipsism-0.7}/src/async_solipsism/loop.py

@@ -1,4 +1,4 @@
-# Copyright 2020, 2022 Bruce Merry
+# Copyright 2020, 2022, 2024 Bruce Merry
 #
 # This file is part of async-solipsism.
 #
@@ -24,7 +24,7 @@ from . import selector, socket as _socket
 from .exceptions import SolipsismError
 
 
-__all__ = ('EventLoop', 'stream_pairs')
+__all__ = ('EventLoop', 'EventLoopPolicy', 'aiohappyeyeballs_start_connection', 'stream_pairs')
 
 
 class EventLoop(asyncio.selector_events.BaseSelectorEventLoop):
@@ -133,6 +133,27 @@ class EventLoop(asyncio.selector_events.BaseSelectorEventLoop):
             **kwargs
         )
 
+    async def aiohappyeyeballs_start_connection(self,
+                                                addr_infos,
+                                                *,
+                                                local_addr_infos=None,
+                                                happy_eyeballs_delay=None,
+                                                interleave=None):
+        for addr_info in addr_infos:
+            addr = addr_info[4]
+            addr = _socket._normalise_ipv6_sockaddr(addr)
+            if addr in self.__listening_sockets:
+                listener = self.__listening_sockets[addr]
+                if local_addr_infos:
+                    local_addr_info = local_addr_infos[0]
+                else:
+                    port = self.__next_port
+                    self.__next_port += 1
+                    local_addr_info = ('::1', port, 0, 0)
+                sock = await listener.make_connection(local_addr_info)
+                return sock
+        raise ConnectionRefusedError('No socket listening on requested addresses')
+
     async def connect_read_pipe(self, protocol_factory, pipe):
         raise SolipsismError("connect_read_pipe is not supported")
 
@@ -197,8 +218,27 @@ class EventLoop(asyncio.selector_events.BaseSelectorEventLoop):
         super()._stop_serving(sock)
 
 
+class EventLoopPolicy(asyncio.DefaultEventLoopPolicy):
+    def new_event_loop(self) -> EventLoop:
+        return EventLoop()
+
+
 async def stream_pairs(capacity=None):
     sock1, sock2 = _socket.socketpair(capacity=capacity)
     streams1 = await asyncio.open_connection(sock=sock1)
     streams2 = await asyncio.open_connection(sock=sock2)
     return streams1, streams2
+
+
+async def aiohappyeyeballs_start_connection(addr_infos,
+                                            *,
+                                            local_addr_infos=None,
+                                            happy_eyeballs_delay=None,
+                                            interleave=None,
+                                            loop=None):
+    if loop is None:
+        loop = asyncio.get_running_loop()
+    return await loop.aiohappyeyeballs_start_connection(addr_infos,
+                                                        local_addr_infos=local_addr_infos,
+                                                        happy_eyeballs_delay=happy_eyeballs_delay,
+                                                        interleave=interleave)

{async-solipsism-0.5 → async_solipsism-0.7}/src/async_solipsism/socket.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Bruce Merry
+# Copyright 2020, 2024 Bruce Merry
 #
 # This file is part of async-solipsism.
 #
@@ -30,6 +30,11 @@ DEFAULT_CAPACITY = 65536
 __all__ = ('Socket', 'ListenSocket', 'Queue', 'socketpair')
 
 
+def _view(bytes):
+    """Get a 1D byte-typed memoryview of an object implementing the buffer protocol."""
+    return memoryview(bytes).cast("B")
+
+
 class Queue:
     def __init__(self, capacity=None):
         self.capacity = capacity or DEFAULT_CAPACITY
@@ -50,11 +55,14 @@ class Queue:
             raise BrokenPipeError(errno.EPIPE, 'Broken pipe')
         if len(self) >= self.capacity:
             return None
-        n = len(data)
-        if len(self) + n > self.capacity:
-            n = self.capacity - len(self)
-            data = memoryview(data)[:n]
-        self._buffer += data
+        with _view(data) as view:
+            n = len(view)
+            if len(self) + n > self.capacity:
+                n = self.capacity - len(self)
+                with view[:n] as prefix:
+                    self._buffer += prefix
+            else:
+                self._buffer += view
         return n
 
     def read(self, size=-1):
@@ -68,7 +76,8 @@ class Queue:
             self._buffer = bytearray()
         else:
             n = min(size, len(self._buffer))
-            ret = bytes(memoryview(self._buffer))[:n]
+            with memoryview(self._buffer) as view, view[:n] as prefix:
+                ret = bytes(prefix)
             self._buffer = self._buffer[n:]
         return ret
 
@@ -93,7 +102,7 @@ class SocketFd:
         return hash(self.socket)
 
     def __eq__(self, other):
-        if type(other) == SocketFd:
+        if type(other) is SocketFd:
             return self.socket is other.socket
         return NotImplemented
 
@@ -111,7 +120,7 @@ class _SocketBase:
 
     def setblocking(self, flag):
         if flag:
-            raise SolipsismError('Socket only support non-blocking operation')
+            raise SolipsismError('Socket only supports non-blocking operation')
 
     def setsockopt(self, level, optname, value, optlen=None):
         key = (level, optname)
@@ -164,11 +173,16 @@ class Socket(_SocketBase):
 
     def recv_into(self, buffer, nbytes=0, flags=0):
         # TODO: implement more efficiently?
-        if not nbytes:
-            nbytes = len(buffer)
-        data = self.recv(nbytes)
-        buffer[:len(data)] = data
-        return len(data)
+        with _view(buffer) as view:
+            if not nbytes:
+                nbytes = len(view)
+            if nbytes < 0:
+                raise ValueError("negative buffersize in recv_into")
+            if nbytes > len(view):
+                raise ValueError("buffer too small for requested bytes")
+            data = self.recv(nbytes)
+            view[:len(data)] = data
+            return len(data)
 
     def send(self, bytes, flags=0):
         self._check_closed()

async-solipsism-0.5/README.md → async_solipsism-0.7/src/async_solipsism.egg-info/PKG-INFO

@@ -1,6 +1,25 @@
+Metadata-Version: 2.1
+Name: async-solipsism
+Version: 0.7
+Summary: Asyncio event loop that doesn't interact with the outside world
+Author-email: Bruce Merry <bmerry@gmail.com>
+Project-URL: Homepage, https://github.com/bmerry/async-solipsism
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: AsyncIO
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Topic :: Software Development :: Testing :: Mocking
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pre-commit; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio>=0.23; extra == "test"
+Requires-Dist: pytest-mock; extra == "test"
+
 # A solipsist event loop
 
-async-solipsism provide a Python asyncio event loop that does not interact with
+async-solipsism provides a Python asyncio event loop that does not interact with
 the outside world at all. This is ideal for writing unit tests that intend to
 mock out real-world interactions. It makes for tests that are reliable
 (unaffected by network outages), reproducible (not affected by random timing
@@ -91,8 +110,17 @@ port number of 0, and async-solipsism will bind the first port number above
 ### Integration with pytest-asyncio
 
 async-solipsism and pytest-asyncio complement each other well: just write a
-custom `event_loop` fixture in your test file or `conftest.py` and it will
-override the default provided by pytest-asyncio:
+custom `event_loop_policy` fixture in your test file or `conftest.py` and it
+will override the default provided by pytest-asyncio:
+
+```python
+@pytest.fixture
+def event_loop_policy():
+    return async_solipsism.EventLoopPolicy()
+```
+
+The above is for pytest-asyncio 0.23+. If you're using an older version, then
+instead you should do this:
 
 ```python
 @pytest.fixture
@@ -102,7 +130,14 @@ def event_loop():
     loop.close()
 ```
 
-### Integration with pytest-aiohttp
+### Integration with aiohappyeyeballs
+
+Unfortunately `aiohappyeyeballs.start_connection` doesn't work out of the box
+because it relies on creating a real socket. I've created a replacement
+`async_solipsism.aiohappyeyeballs_start_connection` that can be used to
+replace it. See the aiohttp section below for example code.
+
+### Integration with aiohttp
 
 A little extra work is required to work with aiohttp's test utilities, but it
 is possible. The example below requires at least aiohttp 3.8.0.
@@ -114,10 +149,14 @@ from aiohttp import web, test_utils
 
 
 @pytest.fixture
-def event_loop():
-    loop = async_solipsism.EventLoop()
-    yield loop
-    loop.close()
+def event_loop_policy():
+    return async_solipsism.EventLoopPolicy()
+
+
+@pytest.fixture(autouse=True)
+def mock_start_connection(monkeypatch):
+    monkeypatch.setattr("aiohappyeyeballs.start_connection",
+                        async_solipsism.aiohappyeyeballs_start_connection)
 
 
 def socket_factory(host, port, family):
@@ -167,6 +206,25 @@ Calling functions that are not supported will generally raise
 
 ## Changelog
 
+### 0.7
+
+- Add a replacement function for `aiohappyeyeballs.start_connection`.
+
+### 0.6
+
+- Drop support for Python 3.6 and 3.7, which have reached end of life.
+- Add `EventLoopPolicy` to simplify integration with pytest-asyncio 0.23+,
+  and use it for the internal tests.
+- Make `Socket.write` and `Socket.recv_into` accept arbitrary buffer-protocol
+  objects.
+- Various packaging and developer experience improvements:
+  - Put the packaging metadata in pyproject.toml, removing setup.cfg.
+  - Pin versions for CI in requirements.txt using pip-compile.
+  - Use pre-commit to enforce flake8 and pip-compile.
+  - Remove wheel from `build-system.requires` (on setuptools advice).
+  - Test against Python 3.11 and 3.12.
+  - Run CI workflow against pull requests.
+
 ### 0.5
 
 - Map port 0 to an unused port.

{async-solipsism-0.5 → async_solipsism-0.7}/src/async_solipsism.egg-info/SOURCES.txt

@@ -1,11 +1,12 @@
 .flake8
 .gitignore
+.pre-commit-config.yaml
 LICENSE
 README.md
 pyproject.toml
 pytest.ini
+requirements.in
 requirements.txt
-setup.cfg
 setup.py
 .github/workflows/test.yml
 src/async_solipsism/__init__.py

async_solipsism-0.7/src/async_solipsism.egg-info/requires.txt

@@ -0,0 +1,6 @@
+
+[test]
+pre-commit
+pytest
+pytest-asyncio>=0.23
+pytest-mock

{async-solipsism-0.5 → async_solipsism-0.7}/test/test_loop.py

@@ -25,13 +25,12 @@ import async_solipsism
 
 
 @pytest.fixture
-def event_loop():
-    loop = async_solipsism.EventLoop()
-    yield loop
-    loop.close()
+def event_loop_policy():
+    return async_solipsism.EventLoopPolicy()
 
 
-async def test_sleep(event_loop):
+async def test_sleep():
+    event_loop = asyncio.get_running_loop()
     assert event_loop.time() == 0.0
     await asyncio.sleep(2)
     assert event_loop.time() == 2.0
@@ -53,7 +52,9 @@ def test_sleep_forever(event_loop):
     ]
 )
 @pytest.mark.parametrize('delay', [False, True])
-async def test_delayed_sock_recv(method, delay, event_loop):
+async def test_delayed_sock_recv(method, delay):
+    event_loop = asyncio.get_running_loop()
+
     async def delayed_write(wsock):
         await asyncio.sleep(1)
         wsock.send(b'Hello')
@@ -76,7 +77,9 @@ async def test_delayed_sock_recv(method, delay, event_loop):
 
 
 @pytest.mark.parametrize('size', [10, 10**7])
-async def test_sock_sendall(size, event_loop):
+async def test_sock_sendall(size):
+    event_loop = asyncio.get_running_loop()
+
     async def delayed_read(rsock):
         n = 0
         while True:
@@ -99,7 +102,8 @@ async def test_sock_sendall(size, event_loop):
     assert n == size
 
 
-async def test_connect_existing(event_loop, mocker):
+async def test_connect_existing(mocker):
+    event_loop = asyncio.get_running_loop()
     sock1, sock2 = async_solipsism.socketpair()
     transport1, protocol1 = await event_loop.connect_accepted_socket(
         mocker.MagicMock, sock1)
@@ -128,7 +132,9 @@ async def test_stream():
 
 
 @pytest.mark.parametrize('manual_socket', [False, True])
-async def test_server(event_loop, manual_socket):
+async def test_server(manual_socket):
+    event_loop = asyncio.get_running_loop()
+
     def callback(reader, writer):
         server_conn.set_result((reader, writer))
 
@@ -156,7 +162,7 @@ async def test_server(event_loop, manual_socket):
     await server.wait_closed()
 
 
-async def test_unused_port(event_loop):
+async def test_unused_port():
     def callback(reader, writer):
         pass
 
@@ -172,7 +178,8 @@ async def test_unused_port(event_loop):
     await server2.wait_closed()
 
 
-async def test_close_server(event_loop):
+async def test_close_server():
+    event_loop = asyncio.get_running_loop()
     server = await asyncio.start_server(lambda reader, writer: None, 'test.invalid', 1234)
     server.close()
     await server.wait_closed()
@@ -180,18 +187,21 @@ async def test_close_server(event_loop):
         await event_loop.create_connection('test.invalid', 1234)
 
 
-async def test_create_connection_no_listener(event_loop):
+async def test_create_connection_no_listener():
+    event_loop = asyncio.get_running_loop()
     with pytest.raises(ConnectionRefusedError):
         await event_loop.create_connection('test.invalid', 1234)
 
 
-async def test_run_in_executor_implicit(event_loop):
+async def test_run_in_executor_implicit():
+    event_loop = asyncio.get_running_loop()
     thread_id = await event_loop.run_in_executor(None, threading.get_ident)
     assert isinstance(thread_id, int)
     assert thread_id != threading.get_ident()
 
 
-async def test_run_in_executor_explicit(event_loop):
+async def test_run_in_executor_explicit():
+    event_loop = asyncio.get_running_loop()
     my_executor = concurrent.futures.ThreadPoolExecutor(1)
     expected_thread_id = my_executor.submit(threading.get_ident).result()
     assert isinstance(expected_thread_id, int)
@@ -201,7 +211,8 @@ async def test_run_in_executor_explicit(event_loop):
 
 
 @pytest.mark.skipif("sys.version_info < (3, 7)")
-async def test_sendfile(event_loop, tmp_path):
+async def test_sendfile(tmp_path):
+    event_loop = asyncio.get_running_loop()
     tmp_file = tmp_path / 'test_sendfile.txt'
     tmp_file.write_bytes(b'Hello world\n')
     ((reader1, writer1), (reader2, writer2)) = await async_solipsism.stream_pairs()
@@ -215,14 +226,17 @@ async def test_sendfile(event_loop, tmp_path):
     await writer2.wait_closed()
 
 
-async def test_call_soon_threadsafe(event_loop):
+async def test_call_soon_threadsafe():
+    event_loop = asyncio.get_running_loop()
     future = event_loop.create_future()
     event_loop.call_soon_threadsafe(future.set_result, 3)
     result = await future
     assert result == 3
 
 
-async def test_call_soon_threadsafe_wrong_thread(event_loop):
+async def test_call_soon_threadsafe_wrong_thread():
+    event_loop = asyncio.get_running_loop()
+
     def thread_func():
         event_loop.call_soon_threadsafe(lambda: None)
 

{async-solipsism-0.5 → async_solipsism-0.7}/test/test_socket.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Bruce Merry
+# Copyright 2020, 2024 Bruce Merry
 #
 # This file is part of async-solipsism.
 #
@@ -15,7 +15,9 @@
 # You should have received a copy of the GNU General Public License
 # along with async-solipsism.  If not, see <https://www.gnu.org/licenses/>.
 
+import array
 import socket
+import struct
 
 import pytest
 
@@ -69,3 +71,41 @@ def test_use_after_shutdown(end):
     assert sock0.recv(1) == b''
     with pytest.raises(BrokenPipeError):
         sock1.send(b'hello')
+
+
+def test_recv_into_array():
+    sock1, sock2 = async_solipsism.socketpair()
+    data = array.array("I", [1, 2, 3])
+    sock1.send(b"\xDE\xAD\xBE\xEF")
+    nbytes = sock2.recv_into(data)
+    assert nbytes == 4
+    assert data[0] == struct.unpack("I", b"\xDE\xAD\xBE\xEF")[0]
+    assert data[1] == 2
+    assert data[2] == 3
+
+
+def test_recv_into_array_partial():
+    sock1, sock2 = async_solipsism.socketpair()
+    data = array.array("I", [1, 2, 3])
+    sock1.send(b"\xDE\xAD\xBE\xEF\xCA\xFE")
+    nbytes = sock2.recv_into(data, 4)
+    assert nbytes == 4
+    assert data[0] == struct.unpack("I", b"\xDE\xAD\xBE\xEF")[0]
+    assert data[1] == 2
+    assert data[2] == 3
+
+
+def test_write_array():
+    sock1, sock2 = async_solipsism.socketpair(capacity=100)
+    data = array.array("I", range(64))
+    nbytes = sock1.send(data)
+    assert nbytes == 100
+    received = sock2.recv(-1)
+    assert len(received) == 100
+    assert memoryview(received) == memoryview(data).cast("B")[:100]
+
+
+@pytest.mark.parametrize("nbytes", [-1, 5])
+def test_recv_into_bad_nbytes(sock, nbytes):
+    with pytest.raises(ValueError):
+        sock.recv_into(bytearray(4), nbytes=nbytes)

async-solipsism-0.5/.github/workflows/test.yml

@@ -1,25 +0,0 @@
-name: Run tests
-
-on: [push]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version: ["3.6", "3.7", "3.8", "3.9", "3.10"]
-
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v2
-        with:
-          python-version: ${{ matrix.python-version }}
-      - name: Install dependencies
-        run: pip install -r requirements.txt
-      - name: Run flake8
-        run: flake8
-      - name: Install package
-        run: pip install .
-      - name: Run pytest
-        run: pytest

async-solipsism-0.5/pyproject.toml

@@ -1,2 +0,0 @@
-[build-system]
-requires = ["setuptools", "wheel", "setuptools-scm"]

async-solipsism-0.5/requirements.txt

@@ -1,4 +0,0 @@
-flake8
-pytest
-pytest-asyncio
-pytest-mock

async-solipsism-0.5/setup.cfg

@@ -1,34 +0,0 @@
-[metadata]
-name = async-solipsism
-version = attr: src.async_solipsism.__version__
-description = Asyncio event loop that doesn't interact with the outside world
-long_description = file:README.md
-long_description_content_type = text/markdown
-author = Bruce Merry
-author_email = bmerry@gmail.com
-url = https://github.com/bmerry/async-solipsism
-classifiers = 
-	Development Status :: 3 - Alpha
-	Framework :: AsyncIO
-	License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
-	Topic :: Software Development :: Testing :: Mocking
-
-[options]
-package_dir = 
-	= src
-packages = find:
-python_requires = >= 3.6
-
-[options.packages.find]
-where = src
-
-[options.extras_require]
-test = 
-	pytest
-	pytest-asyncio
-	pytest-mock
-
-[egg_info]
-tag_build = 
-tag_date = 0
-

async-solipsism-0.5/src/async_solipsism.egg-info/requires.txt

@@ -1,5 +0,0 @@
-
-[test]
-pytest
-pytest-asyncio
-pytest-mock