async-solipsism 0.4__tar.gz → 0.6__tar.gz

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

@@ -0,0 +1,35 @@
+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"]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: pip install -r requirements.txt
+      - name: Install package
+        run: pip install .
+      - name: Run pytest
+        run: pytest

{async-solipsism-0.4 → async-solipsism-0.6}/.gitignore

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

async-solipsism-0.6/.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.4/src/async_solipsism.egg-info → async-solipsism-0.6}/PKG-INFO

@@ -1,22 +1,25 @@
 Metadata-Version: 2.1
 Name: async-solipsism
-Version: 0.4
+Version: 0.6
 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
+Author-email: Bruce Merry <bmerry@gmail.com>
+Project-URL: Homepage, https://github.com/bmerry/async-solipsism
 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
+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
@@ -100,11 +103,24 @@ The host and port are associated with the event loop, and are remembered until
 the server is closed. Attempting to connect after closing the server, or to an
 address that hasn't been registered, will raise a `ConnectionRefusedError`.
 
+If you don't want the bother of picking non-colliding ports, you can pass a
+port number of 0, and async-solipsism will bind the first port number above
+60000 that is unused.
+
 ### 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
@@ -126,14 +142,12 @@ 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()
 
 
 def socket_factory(host, port, family):
-    return async_solipsism.ListenSocket((host, port if port else 80))
+    return async_solipsism.ListenSocket((host, port))
 
 
 async def test_integration():
@@ -150,10 +164,6 @@ the socket factory, although it may be possible to do by monkeypatching. In
 practice you will probably want to define your own fixtures for the client
 and server.
 
-If you need to run more than one test server concurrently, you'll need to
-extend the socket factory to assign them each a different port
-(async-solipsism does not currently handle mapping port 0 to an unused port).
-
 ## Limitations
 
 The requirement to have no interaction with the outside world naturally
@@ -183,12 +193,31 @@ Calling functions that are not supported will generally raise
 
 ## Changelog
 
+### 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.
+
 ### 0.4
 
 - Allow `call_soon_threadsafe` from the same thread.
 - Don't warn when `SO_KEEPALIVE` is set on a socket.
 - Update instructions for use with aiohttp.
-- Add a pyproject.toml
+- Add a pyproject.toml.
 
 ### 0.3
 

async-solipsism-0.4/PKG-INFO → async-solipsism-0.6/README.md

@@ -1,22 +1,6 @@
-Metadata-Version: 2.1
-Name: async-solipsism
-Version: 0.4
-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
@@ -100,11 +84,24 @@ The host and port are associated with the event loop, and are remembered until
 the server is closed. Attempting to connect after closing the server, or to an
 address that hasn't been registered, will raise a `ConnectionRefusedError`.
 
+If you don't want the bother of picking non-colliding ports, you can pass a
+port number of 0, and async-solipsism will bind the first port number above
+60000 that is unused.
+
 ### 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
@@ -126,14 +123,12 @@ 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()
 
 
 def socket_factory(host, port, family):
-    return async_solipsism.ListenSocket((host, port if port else 80))
+    return async_solipsism.ListenSocket((host, port))
 
 
 async def test_integration():
@@ -150,10 +145,6 @@ the socket factory, although it may be possible to do by monkeypatching. In
 practice you will probably want to define your own fixtures for the client
 and server.
 
-If you need to run more than one test server concurrently, you'll need to
-extend the socket factory to assign them each a different port
-(async-solipsism does not currently handle mapping port 0 to an unused port).
-
 ## Limitations
 
 The requirement to have no interaction with the outside world naturally
@@ -183,12 +174,31 @@ Calling functions that are not supported will generally raise
 
 ## Changelog
 
+### 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.
+
 ### 0.4
 
 - Allow `call_soon_threadsafe` from the same thread.
 - Don't warn when `SO_KEEPALIVE` is set on a socket.
 - Update instructions for use with aiohttp.
-- Add a pyproject.toml
+- Add a pyproject.toml.
 
 ### 0.3
 

async-solipsism-0.6/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 :: 3 - Alpha",
+    "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.6/requirements.in

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

async-solipsism-0.6/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.6/setup.cfg

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

{async-solipsism-0.4 → async-solipsism-0.6}/src/async_solipsism/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2020-2021 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.4'
+__version__ = '0.6'

{async-solipsism-0.4 → async-solipsism-0.6}/src/async_solipsism/loop.py

@@ -24,7 +24,7 @@ from . import selector, socket as _socket
 from .exceptions import SolipsismError
 
 
-__all__ = ('EventLoop', 'stream_pairs')
+__all__ = ('EventLoop', 'EventLoopPolicy', 'stream_pairs')
 
 
 class EventLoop(asyncio.selector_events.BaseSelectorEventLoop):
@@ -113,8 +113,14 @@ class EventLoop(asyncio.selector_events.BaseSelectorEventLoop):
             # TODO: what if host is actually a list?
             addr = (host, port, 0, 0)
             sock = _socket.ListenSocket(addr)
-        else:
-            addr = sock.getsockname()
+        addr = sock.getsockname()
+        if addr[1] == 0:  # Port 0: pick a free port
+            addr_list = list(addr)
+            addr_list[1] = 60000
+            while tuple(addr_list) in self.__listening_sockets:
+                addr_list[1] += 1
+            addr = tuple(addr_list)
+            sock._sockname = addr
         if addr in self.__listening_sockets:
             raise SolipsismError("Reuse of listening addresses is not supported")
         self.__listening_sockets[addr] = sock
@@ -191,6 +197,11 @@ 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)

{async-solipsism-0.4 → async-solipsism-0.6}/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
 
@@ -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.4/README.md → async-solipsism-0.6/src/async_solipsism.egg-info/PKG-INFO

@@ -1,6 +1,25 @@
+Metadata-Version: 2.1
+Name: async-solipsism
+Version: 0.6
+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 :: 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.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
@@ -84,11 +103,24 @@ The host and port are associated with the event loop, and are remembered until
 the server is closed. Attempting to connect after closing the server, or to an
 address that hasn't been registered, will raise a `ConnectionRefusedError`.
 
+If you don't want the bother of picking non-colliding ports, you can pass a
+port number of 0, and async-solipsism will bind the first port number above
+60000 that is unused.
+
 ### 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
@@ -110,14 +142,12 @@ 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()
 
 
 def socket_factory(host, port, family):
-    return async_solipsism.ListenSocket((host, port if port else 80))
+    return async_solipsism.ListenSocket((host, port))
 
 
 async def test_integration():
@@ -134,10 +164,6 @@ the socket factory, although it may be possible to do by monkeypatching. In
 practice you will probably want to define your own fixtures for the client
 and server.
 
-If you need to run more than one test server concurrently, you'll need to
-extend the socket factory to assign them each a different port
-(async-solipsism does not currently handle mapping port 0 to an unused port).
-
 ## Limitations
 
 The requirement to have no interaction with the outside world naturally
@@ -167,12 +193,31 @@ Calling functions that are not supported will generally raise
 
 ## Changelog
 
+### 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.
+
 ### 0.4
 
 - Allow `call_soon_threadsafe` from the same thread.
 - Don't warn when `SO_KEEPALIVE` is set on a socket.
 - Update instructions for use with aiohttp.
-- Add a pyproject.toml
+- Add a pyproject.toml.
 
 ### 0.3
 

{async-solipsism-0.4 → async-solipsism-0.6}/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.6/src/async_solipsism.egg-info/requires.txt

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

{async-solipsism-0.4 → async-solipsism-0.6}/test/test_loop.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Bruce Merry
+# Copyright 2020, 2022 Bruce Merry
 #
 # This file is part of async-solipsism.
 #
@@ -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,24 @@ async def test_server(event_loop, manual_socket):
     await server.wait_closed()
 
 
-async def test_close_server(event_loop):
+async def test_unused_port():
+    def callback(reader, writer):
+        pass
+
+    listen_socket1 = async_solipsism.ListenSocket(('localhost', 0))
+    listen_socket2 = async_solipsism.ListenSocket(('localhost', 0))
+    server1 = await asyncio.start_server(callback, sock=listen_socket1)
+    server2 = await asyncio.start_server(callback, sock=listen_socket2)
+    assert listen_socket1.getsockname()[1] == 60000
+    assert listen_socket2.getsockname()[1] == 60001
+    server1.close()
+    server2.close()
+    await server1.wait_closed()
+    await server2.wait_closed()
+
+
+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()
@@ -164,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)
@@ -185,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()
@@ -193,16 +220,23 @@ async def test_sendfile(event_loop, tmp_path):
         await event_loop.sendfile(writer1.transport, f)
     line = await reader2.readline()
     assert line == b'Hello world\n'
+    writer1.close()
+    writer2.close()
+    await writer1.wait_closed()
+    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.4 → async-solipsism-0.6}/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.4/.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.4/pyproject.toml

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

async-solipsism-0.4/requirements.txt

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

async-solipsism-0.4/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.4/src/async_solipsism.egg-info/requires.txt

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