Test updates

Squashed commit of the following:

commit 834095e593bcfec29b1e42745b71164bb481f414
Author: Eugenio Lacuesta <eugenio.lacuesta@gmail.com>
Date:   Mon Jun 15 16:10:46 2026 -0300

    Fix NOQA comment

commit 603ea0a
Author: Eugenio Lacuesta <eugenio.lacuesta@gmail.com>
Date:   Mon Jun 15 15:53:23 2026 -0300

    Linting

commit 9bcf393
Author: Eugenio Lacuesta <eugenio.lacuesta@gmail.com>
Date:   Mon Jun 15 15:42:47 2026 -0300

    Replace IsolatedAsyncioTestCase when not needed

commit 7c80d8f
Author: Eugenio Lacuesta <eugenio.lacuesta@gmail.com>
Date:   Mon Jun 15 15:22:43 2026 -0300

    Merge test cases

Author: elacuesta

pylintrc

@@ -3,6 +3,7 @@ disable=
     attribute-defined-outside-init,
     broad-except,
     invalid-name,
+    line-too-long,
     missing-class-docstring,
     missing-function-docstring,
     missing-module-docstring,

tests/__init__.py

@@ -38,15 +38,22 @@ def allow_windows(test_method):
         return test_method
 
 
-@asynccontextmanager
-async def make_handler(settings_dict: Optional[dict] = None):
-    """Convenience function to obtain an initialized handler and close it gracefully"""
+def create_handler(settings_dict: Optional[dict] = None):
     from scrapy_playwright.handler import ScrapyPlaywrightDownloadHandler
 
     settings: dict = settings_dict or {}
     settings.setdefault("TELNETCONSOLE_ENABLED", False)
     crawler = get_crawler(settings_dict=settings)
     handler = ScrapyPlaywrightDownloadHandler(crawler=crawler)
+    return handler
+
+
+@asynccontextmanager
+async def make_handler(settings_dict: Optional[dict] = None):
+    """Convenience function to obtain an initialized handler and close it gracefully"""
+    from scrapy_playwright.handler import ScrapyPlaywrightDownloadHandler
+
+    handler: ScrapyPlaywrightDownloadHandler = create_handler(settings_dict)
     try:
         await handler._maybe_launch_in_thread()
     except:  # noqa (E722), pylint: disable=bare-except

tests/tests_asyncio/test_page_methods.py

@@ -2,7 +2,7 @@
 import platform
 import subprocess
 from tempfile import NamedTemporaryFile
-from unittest import IsolatedAsyncioTestCase
+from unittest import IsolatedAsyncioTestCase, TestCase
 
 import pytest
 from scrapy import Spider, Request
@@ -24,9 +24,8 @@ def get_mimetype(file):
     ).stdout.strip()
 
 
-class TestPageMethods(IsolatedAsyncioTestCase):
-    @allow_windows
-    async def test_page_methods(self):
+class TestPageMethods(TestCase):
+    def test_page_methods(self):
         screenshot = PageMethod("screenshot", "foo", 123, path="/tmp/file", type="png")
         assert screenshot.method == "screenshot"
         assert screenshot.args == ("foo", 123)

tests/tests_asyncio/test_playwright_requests.py

@@ -209,48 +209,28 @@ async def test_route_continue_exception(self, logger):
                 await req_handler(route, playwright_request)
 
     @allow_windows
-    async def test_event_handler_dialog_callable(self):
+    async def test_event_handler_dialog(self):
         async with make_handler({"PLAYWRIGHT_BROWSER_TYPE": self.browser_type}) as handler:
             with StaticMockServer() as server:
-                spider = DialogSpider()
-                req = Request(
-                    url=server.urljoin("/index.html"),
-                    meta={
-                        "playwright": True,
-                        "playwright_page_methods": [
-                            # trigger an alert
-                            PageMethod("evaluate", "alert('foobar');"),
-                        ],
-                        "playwright_page_event_handlers": {
-                            "dialog": spider.handle_dialog,
-                        },
-                    },
-                )
-                await handler._download_request(req, spider)
-
-            assert spider.dialog_message == "foobar"
-
-    @allow_windows
-    async def test_event_handler_dialog_str(self):
-        async with make_handler({"PLAYWRIGHT_BROWSER_TYPE": self.browser_type}) as handler:
-            with StaticMockServer() as server:
-                spider = DialogSpider()
-                req = Request(
-                    url=server.urljoin("/index.html"),
-                    meta={
-                        "playwright": True,
-                        "playwright_page_methods": [
-                            # trigger an alert
-                            PageMethod("evaluate", "alert('foobar');"),
-                        ],
-                        "playwright_page_event_handlers": {
-                            "dialog": "handle_dialog",
+                for use_callable in (True, False):
+                    spider = DialogSpider()
+                    req = Request(
+                        url=server.urljoin("/index.html"),
+                        meta={
+                            "playwright": True,
+                            "playwright_page_methods": [
+                                # trigger an alert
+                                PageMethod("evaluate", "alert('foobar');"),
+                            ],
+                            "playwright_page_event_handlers": {
+                                "dialog": (
+                                    spider.handle_dialog if use_callable else "handle_dialog"
+                                ),
+                            },
                         },
-                    },
-                )
-                await handler._download_request(req, spider)
-
-            assert spider.dialog_message == "foobar"
+                    )
+                    await handler._download_request(req, spider)
+                    assert spider.dialog_message == "foobar"
 
     @allow_windows
     async def test_event_handler_dialog_missing(self):
@@ -435,56 +415,40 @@ async def test_logging_record_spider(self):
         assert any(getattr(rec, "spider", None) is spider for rec in self._caplog.records)
 
     @allow_windows
-    @patch("scrapy_playwright.handler._make_request_logger")
-    async def test_request_logger_disabled(self, make_request_logger: MagicMock):
-        self._caplog.set_level(logging.DEBUG + 1, "scrapy-playwright")
-        async with make_handler({"PLAYWRIGHT_BROWSER_TYPE": self.browser_type}) as handler:
-            with MockServer() as server:
-                req = Request(url=server.urljoin("/index.html"), meta={"playwright": True})
-                await handler._download_request(req, Spider("foo"))
-
-        debug_message = (
-            f"[Context=default] Request: <{req.method} {req.url}> (resource type: document)"
-        )
-        assert not any(rec.message == debug_message for rec in self._caplog.records)
-        make_request_logger.assert_not_called()
-
-    @allow_windows
-    async def test_request_logger_enabled(self):
-        self._caplog.set_level(logging.DEBUG, "scrapy-playwright")
+    async def test_request_logger(self):
         async with make_handler({"PLAYWRIGHT_BROWSER_TYPE": self.browser_type}) as handler:
             with MockServer() as server:
+                with self._caplog.at_level(logging.DEBUG + 1, logger="scrapy-playwright"):
+                    with patch("scrapy_playwright.handler._make_request_logger") as mock_logger:
+                        req = Request(url=server.urljoin("/index.html"), meta={"playwright": True})
+                        await handler._download_request(req, Spider("foo"))
+                msg = f"[Context=default] Request: <{req.method} {req.url}> (resource type: document)"  # noqa: E501
+                assert not any(rec.message == msg for rec in self._caplog.records)
+                mock_logger.assert_not_called()
+
+                self._caplog.set_level(logging.DEBUG, "scrapy-playwright")
                 req = Request(url=server.urljoin("/index.html"), meta={"playwright": True})
                 await handler._download_request(req, Spider("foo"))
-
-        debug_message = (
-            f"[Context=default] Request: <{req.method} {req.url}> (resource type: document)"
-        )
-        assert any(rec.message == debug_message for rec in self._caplog.records)
+                msg = f"[Context=default] Request: <{req.method} {req.url}> (resource type: document)"  # noqa: E501
+                assert any(rec.message == msg for rec in self._caplog.records)
 
     @allow_windows
-    @patch("scrapy_playwright.handler._make_response_logger")
-    async def test_response_logger_disabled(self, make_response_logger: MagicMock):
-        self._caplog.set_level(logging.DEBUG + 1, "scrapy-playwright")
-        async with make_handler({"PLAYWRIGHT_BROWSER_TYPE": self.browser_type}) as handler:
-            with MockServer() as server:
-                req = Request(url=server.urljoin("/index.html"), meta={"playwright": True})
-                response = await handler._download_request(req, Spider("foo"))
-
-        debug_message = f"[Context=default] Response: <{response.status} {response.url}>"
-        assert not any(rec.message == debug_message for rec in self._caplog.records)
-        make_response_logger.assert_not_called()
-
-    @allow_windows
-    async def test_response_logger_enabled(self):
-        self._caplog.set_level(logging.DEBUG, "scrapy-playwright")
+    async def test_response_logger(self):
         async with make_handler({"PLAYWRIGHT_BROWSER_TYPE": self.browser_type}) as handler:
             with MockServer() as server:
+                with self._caplog.at_level(logging.DEBUG + 1, logger="scrapy-playwright"):
+                    with patch("scrapy_playwright.handler._make_response_logger") as mock_logger:
+                        req = Request(url=server.urljoin("/index.html"), meta={"playwright": True})
+                        response = await handler._download_request(req, Spider("foo"))
+                debug_message = f"[Context=default] Response: <{response.status} {response.url}>"
+                assert not any(rec.message == debug_message for rec in self._caplog.records)
+                mock_logger.assert_not_called()
+
+                self._caplog.set_level(logging.DEBUG, "scrapy-playwright")
                 request = Request(url=server.urljoin("/index.html"), meta={"playwright": True})
                 response = await handler._download_request(request, Spider("foo"))
-
-        debug_message = f"[Context=default] Response: <{response.status} {response.url}>"
-        assert any(rec.message == debug_message for rec in self._caplog.records)
+                debug_message = f"[Context=default] Response: <{response.status} {response.url}>"
+                assert any(rec.message == debug_message for rec in self._caplog.records)
 
     @allow_windows
     async def test_download_file_ok(self):

tests/tests_asyncio/test_settings.py

@@ -1,16 +1,16 @@
-from unittest import IsolatedAsyncioTestCase
+from unittest import TestCase
 
 import pytest
 from scrapy.exceptions import NotSupported
 from scrapy.settings import Settings
 
 from scrapy_playwright.handler import Config
 
-from tests import allow_windows, make_handler
+from tests import create_handler
 
 
-class TestSettings(IsolatedAsyncioTestCase):
-    async def test_settings_timeout_value(self):
+class TestSettings(TestCase):
+    def test_settings_timeout_value(self):
         config = Config.from_settings(Settings({}))
         assert config.navigation_timeout_ms is None
 
@@ -26,14 +26,14 @@ async def test_settings_timeout_value(self):
         config = Config.from_settings(Settings({"PLAYWRIGHT_DEFAULT_NAVIGATION_TIMEOUT": 0.5}))
         assert config.navigation_timeout_ms == 0.5
 
-    async def test_max_pages_per_context(self):
+    def test_max_pages_per_context(self):
         config = Config.from_settings(Settings({"PLAYWRIGHT_MAX_PAGES_PER_CONTEXT": 1234}))
         assert config.max_pages_per_context == 1234
 
         config = Config.from_settings(Settings({"CONCURRENT_REQUESTS": 9876}))
         assert config.max_pages_per_context == 9876
 
-    async def test_connect_remote_urls(self):
+    def test_connect_remote_urls(self):
         with pytest.raises(NotSupported) as exc_info:
             Config.from_settings(
                 Settings({"PLAYWRIGHT_CONNECT_URL": "asdf", "PLAYWRIGHT_CDP_URL": "qwerty"})
@@ -43,10 +43,9 @@ async def test_connect_remote_urls(self):
             == "Setting both PLAYWRIGHT_CDP_URL and PLAYWRIGHT_CONNECT_URL is not supported"
         )
 
-    @allow_windows
-    async def test_max_contexts(self):
-        async with make_handler({"PLAYWRIGHT_MAX_CONTEXTS": None}) as handler:
-            assert not hasattr(handler, "context_semaphore")
+    def test_max_contexts(self):
+        handler = create_handler({"PLAYWRIGHT_MAX_CONTEXTS": None})
+        assert not hasattr(handler, "context_semaphore")
 
-        async with make_handler({"PLAYWRIGHT_MAX_CONTEXTS": 1234}) as handler:
-            assert handler.context_semaphore._value == 1234
+        handler = create_handler({"PLAYWRIGHT_MAX_CONTEXTS": 1234})
+        assert handler.context_semaphore._value == 1234

tests/tests_asyncio/test_utils.py

@@ -1,6 +1,6 @@
 import logging
 from decimal import Decimal
-from unittest import IsolatedAsyncioTestCase
+from unittest import IsolatedAsyncioTestCase, TestCase
 from unittest.mock import AsyncMock
 
 import pytest
@@ -71,7 +71,7 @@ async def test_get_page_content_reraise_unknown_exception(self):
             )
 
 
-class TestBodyEncoding(IsolatedAsyncioTestCase):
+class TestBodyEncoding(TestCase):
     @staticmethod
     def body_str(charset: str, content: str = "áéíóú") -> str:
         return f"""
@@ -86,7 +86,7 @@ def body_str(charset: str, content: str = "áéíóú") -> str:
             </html>
         """.strip()
 
-    async def test_encode_from_headers(self):
+    def test_encode_from_headers(self):
         """Charset declared in headers takes precedence"""
         text = self.body_str(charset="gb2312")
         body, encoding = _encode_body(
@@ -96,21 +96,21 @@ async def test_encode_from_headers(self):
         assert encoding == "cp1252"
         assert body == text.encode(encoding)
 
-    async def test_encode_from_body(self):
+    def test_encode_from_body(self):
         """No charset declared in headers, use the one declared in the body"""
         text = self.body_str(charset="gb2312")
         body, encoding = _encode_body(headers=Headers({}), text=text)
         assert encoding == "gb18030"
         assert body == text.encode(encoding)
 
-    async def test_encode_fallback_utf8(self):
+    def test_encode_fallback_utf8(self):
         """No charset declared, use utf-8 as fallback"""
         text = "<html>áéíóú</html>"
         body, encoding = _encode_body(headers=Headers(), text=text)
         assert encoding == "utf-8"
         assert body == text.encode(encoding)
 
-    async def test_encode_mismatch(self):
+    def test_encode_mismatch(self):
         """Charset declared in headers and body do not match, and the headers
         one fails to encode: use the one in the body (first one that works)
         """
@@ -152,8 +152,8 @@ async def _awaitable_identity(x):
         assert await _maybe_await(1234) == 1234
 
 
-class TestGetFloatSetting(IsolatedAsyncioTestCase):
-    async def test_get_float_setting(self):
+class TestGetFloatSetting(TestCase):
+    def test_get_float_setting(self):
         settings = Settings(
             {
                 "ZERO": 0,