Stop requiring loop in WebSocketCommonProtocol.

Change tests to avoid passing a loop argument.

Fix #988.

Author: aaugustin

src/websockets/legacy/client.py

@@ -514,10 +514,11 @@ def __init__(
         legacy_recv: bool = kwargs.pop("legacy_recv", False)
 
         # Backwards compatibility: the loop parameter used to be supported.
-        loop: Optional[asyncio.AbstractEventLoop] = kwargs.pop("loop", None)
-        if loop is None:
+        _loop: Optional[asyncio.AbstractEventLoop] = kwargs.pop("loop", None)
+        if _loop is None:
             loop = asyncio.get_event_loop()
         else:
+            loop = _loop
             warnings.warn("remove loop argument", DeprecationWarning)
 
         wsuri = parse_uri(uri)
@@ -543,7 +544,7 @@ def __init__(
             max_queue=max_queue,
             read_limit=read_limit,
             write_limit=write_limit,
-            loop=loop,
+            loop=_loop,
             host=wsuri.host,
             port=wsuri.port,
             secure=wsuri.secure,

src/websockets/legacy/protocol.py

@@ -124,6 +124,12 @@ def __init__(
         if close_timeout is None:
             close_timeout = timeout
 
+        # Backwards compatibility: the loop parameter used to be supported.
+        if loop is None:
+            loop = asyncio.get_event_loop()
+        else:
+            warnings.warn("remove loop argument", DeprecationWarning)
+
         self.ping_interval = ping_interval
         self.ping_timeout = ping_timeout
         self.close_timeout = close_timeout
@@ -145,8 +151,6 @@ def __init__(
         # Track if DEBUG is enabled. Shortcut logging calls if it isn't.
         self.debug = logger.isEnabledFor(logging.DEBUG)
 
-        assert loop is not None
-        # Remove when dropping Python < 3.10 - use get_running_loop instead.
         self.loop = loop
 
         self._host = host

src/websockets/legacy/server.py

@@ -1024,10 +1024,11 @@ def __init__(
         legacy_recv: bool = kwargs.pop("legacy_recv", False)
 
         # Backwards compatibility: the loop parameter used to be supported.
-        loop: Optional[asyncio.AbstractEventLoop] = kwargs.pop("loop", None)
-        if loop is None:
+        _loop: Optional[asyncio.AbstractEventLoop] = kwargs.pop("loop", None)
+        if _loop is None:
             loop = asyncio.get_event_loop()
         else:
+            loop = _loop
             warnings.warn("remove loop argument", DeprecationWarning)
 
         ws_server = WebSocketServer(logger=logger, loop=loop)
@@ -1053,7 +1054,7 @@ def __init__(
             max_queue=max_queue,
             read_limit=read_limit,
             write_limit=write_limit,
-            loop=loop,
+            loop=_loop,
             legacy_recv=legacy_recv,
             origins=origins,
             extensions=extensions,

tests/legacy/test_client_server.py

@@ -213,17 +213,17 @@ def start_server(self, deprecation_warnings=None, **kwargs):
         kwargs.setdefault("compression", None)
         # Disable pings by default in tests.
         kwargs.setdefault("ping_interval", None)
-        # Python 3.10 dislikes not having a running event loop
-        if sys.version_info[:2] >= (3, 10):  # pragma: no cover
-            kwargs.setdefault("loop", self.loop)
 
         with warnings.catch_warnings(record=True) as recorded_warnings:
             start_server = serve(handler, "localhost", 0, **kwargs)
             self.server = self.loop.run_until_complete(start_server)
 
         expected_warnings = [] if deprecation_warnings is None else deprecation_warnings
-        if sys.version_info[:2] >= (3, 10):  # pragma: no cover
-            expected_warnings += ["remove loop argument"]
+        if (
+            sys.version_info[:2] >= (3, 10)
+            and "remove loop argument" not in expected_warnings
+        ):  # pragma: no cover
+            expected_warnings += ["There is no current event loop"]
         self.assertDeprecationWarnings(recorded_warnings, expected_warnings)
 
     def start_redirecting_server(
@@ -234,10 +234,6 @@ def start_redirecting_server(
         deprecation_warnings=None,
         **kwargs,
     ):
-        # Python 3.10 dislikes not having a running event loop
-        if sys.version_info[:2] >= (3, 10):  # pragma: no cover
-            kwargs.setdefault("loop", self.loop)
-
         async def process_request(path, headers):
             server_uri = get_server_uri(self.server, self.secure, path)
             if force_insecure:
@@ -259,8 +255,11 @@ async def process_request(path, headers):
             self.redirecting_server = self.loop.run_until_complete(start_server)
 
         expected_warnings = [] if deprecation_warnings is None else deprecation_warnings
-        if sys.version_info[:2] >= (3, 10):  # pragma: no cover
-            expected_warnings += ["remove loop argument"]
+        if (
+            sys.version_info[:2] >= (3, 10)
+            and "remove loop argument" not in expected_warnings
+        ):  # pragma: no cover
+            expected_warnings += ["There is no current event loop"]
         self.assertDeprecationWarnings(recorded_warnings, expected_warnings)
 
     def start_client(
@@ -270,9 +269,6 @@ def start_client(
         kwargs.setdefault("compression", None)
         # Disable pings by default in tests.
         kwargs.setdefault("ping_interval", None)
-        # Python 3.10 dislikes not having a running event loop
-        if sys.version_info[:2] >= (3, 10):  # pragma: no cover
-            kwargs.setdefault("loop", self.loop)
 
         secure = kwargs.get("ssl") is not None
         try:
@@ -286,8 +282,11 @@ def start_client(
             self.client = self.loop.run_until_complete(start_client)
 
         expected_warnings = [] if deprecation_warnings is None else deprecation_warnings
-        if sys.version_info[:2] >= (3, 10):  # pragma: no cover
-            expected_warnings += ["remove loop argument"]
+        if (
+            sys.version_info[:2] >= (3, 10)
+            and "remove loop argument" not in expected_warnings
+        ):  # pragma: no cover
+            expected_warnings += ["There is no current event loop"]
         self.assertDeprecationWarnings(recorded_warnings, expected_warnings)
 
     def stop_client(self):
@@ -409,8 +408,6 @@ def test_infinite_redirect(self):
         with temp_test_redirecting_server(
             self,
             http.HTTPStatus.FOUND,
-            loop=self.loop,
-            deprecation_warnings=["remove loop argument"],
         ):
             self.server = self.redirecting_server
             with self.assertRaises(InvalidHandshake):
@@ -430,7 +427,7 @@ def test_redirect_missing_location(self):
                 with temp_test_client(self):
                     self.fail("Did not raise")  # pragma: no cover
 
-    def test_explicit_event_loop(self):
+    def test_loop_backwards_compatibility(self):
         with self.temp_server(
             loop=self.loop, deprecation_warnings=["remove loop argument"]
         ):

tests/legacy/test_protocol.py

@@ -1,5 +1,6 @@
 import asyncio
 import contextlib
+import sys
 import unittest
 import unittest.mock
 import warnings
@@ -86,8 +87,9 @@ class CommonTests:
 
     def setUp(self):
         super().setUp()
-        # Disable pings to make it easier to test what frames are sent exactly.
-        self.protocol = WebSocketCommonProtocol(ping_interval=None, loop=self.loop)
+        with warnings.catch_warnings(record=True):
+            # Disable pings to make it easier to test what frames are sent exactly.
+            self.protocol = WebSocketCommonProtocol(ping_interval=None)
         self.transport = TransportMock()
         self.transport.setup_mock(self.loop, self.protocol)
 
@@ -309,14 +311,29 @@ def assertCompletesWithin(self, min_time, max_time):
     # Test constructor.
 
     def test_timeout_backwards_compatibility(self):
-        with warnings.catch_warnings(record=True) as recorded_warnings:
-            protocol = WebSocketCommonProtocol(timeout=5, loop=self.loop)
+        with warnings.catch_warnings(record=True) as recorded:
+            protocol = WebSocketCommonProtocol(timeout=5)
 
         self.assertEqual(protocol.close_timeout, 5)
 
-        self.assertDeprecationWarnings(
-            recorded_warnings, ["rename timeout to close_timeout"]
-        )
+        expected = ["rename timeout to close_timeout"]
+        if sys.version_info[:2] >= (3, 10):  # pragma: no cover
+            expected += ["There is no current event loop"]
+
+        self.assertDeprecationWarnings(recorded, expected)
+
+    def test_loop_backwards_compatibility(self):
+        loop = asyncio.new_event_loop()
+        self.addCleanup(loop.close)
+
+        with warnings.catch_warnings(record=True) as recorded:
+            protocol = WebSocketCommonProtocol(loop=loop)
+
+        self.assertEqual(protocol.loop, loop)
+
+        expected = ["remove loop argument"]
+
+        self.assertDeprecationWarnings(recorded, expected)
 
     # Test public attributes.
 
@@ -1116,11 +1133,11 @@ def restart_protocol_with_keepalive_ping(
         self.transport.close()
         self.loop.run_until_complete(self.protocol.close())
         # copied from setUp, but enables keepalive pings
-        self.protocol = WebSocketCommonProtocol(
-            ping_interval=ping_interval,
-            ping_timeout=ping_timeout,
-            loop=self.loop,
-        )
+        with warnings.catch_warnings(record=True):
+            self.protocol = WebSocketCommonProtocol(
+                ping_interval=ping_interval,
+                ping_timeout=ping_timeout,
+            )
         self.transport = TransportMock()
         self.transport.setup_mock(self.loop, self.protocol)
         self.protocol.is_client = initial_protocol.is_client