fixed tests

mxschmitt · mxschmitt · commit bd6820d0451e · 2021-04-21T12:15:19.000+02:00
diff --git a/local-requirements.txt b/local-requirements.txt
@@ -11,8 +11,9 @@ pixelmatch==0.2.3
 pre-commit==2.10.1
 pyOpenSSL==20.0.1
 pytest==6.2.2
-pytest-asyncio==0.14.0
+pytest-asyncio==0.15.0
 pytest-cov==2.11.1
+pytest-repeat==0.9.1
 pytest-sugar==0.9.4
 pytest-timeout==1.4.2
 pytest-xdist==2.2.1
diff --git a/playwright/_impl/_browser_type.py b/playwright/_impl/_browser_type.py
@@ -141,17 +141,29 @@ async def connect(
     ) -> Browser:
         transport = WebSocketTransport(ws_endpoint, timeout)
 
-        connection = Connection(None, self._connection._object_factory, transport)
+        connection = Connection(
+            self._connection._dispatcher_fiber,
+            self._connection._object_factory,
+            transport,
+        )
         connection._loop = self._connection._loop
         connection._loop.create_task(connection.run())
+        self._connection._child_ws_connections.append(connection)
         playwright = await connection.wait_for_object_with_known_name("Playwright")
         pre_launched_browser = playwright._initializer.get("preLaunchedBrowser")
         assert pre_launched_browser
         browser = cast(Browser, from_channel(pre_launched_browser))
         browser._is_remote = True
         browser._is_connected_over_websocket = True
 
-        transport.on("close", browser._on_close)
+        def handle_transport_close() -> None:
+            browser._on_close()
+
+        transport.on("close", handle_transport_close)
+        browser.once(
+            Browser.Events.Disconnected,
+            lambda b: transport.remove_listener("close", handle_transport_close),
+        )
 
         return browser
 
diff --git a/playwright/_impl/_connection.py b/playwright/_impl/_connection.py
@@ -163,6 +163,7 @@ def __init__(
         self._object_factory = object_factory
         self._is_sync = False
         self._api_name = ""
+        self._child_ws_connections: List["Connection"] = []
 
     async def run_as_sync(self) -> None:
         self._is_sync = True
@@ -176,10 +177,16 @@ async def run(self) -> None:
     def stop_sync(self) -> None:
         self._transport.stop()
         self._dispatcher_fiber.switch()
+        self.cleanup()
 
     async def stop_async(self) -> None:
         self._transport.stop()
         await self._transport.wait_until_stopped()
+        self.cleanup()
+
+    def cleanup(self) -> None:
+        for ws_connection in self._child_ws_connections:
+            ws_connection._transport.cleanup()
 
     async def wait_for_object_with_known_name(self, guid: str) -> Any:
         if guid in self._objects:
diff --git a/playwright/_impl/_transport.py b/playwright/_impl/_transport.py
@@ -43,19 +43,21 @@ def _get_stderr_fileno() -> Optional[int]:
 class Transport(ABC):
     def __init__(self) -> None:
         self.on_message = lambda _: None
-        self.on_error_future = asyncio.Future()
 
     @abstractmethod
     def stop(self) -> None:
         pass
 
+    def cleanup(self) -> None:
+        pass
+
     @abstractmethod
     async def wait_until_stopped(self) -> None:
         pass
 
-    @abstractmethod
     async def run(self) -> None:
-        pass
+        self._loop = asyncio.get_running_loop()
+        self.on_error_future: asyncio.Future[bool] = asyncio.Future()
 
     @abstractmethod
     def send(self, message: Dict) -> None:
@@ -91,7 +93,7 @@ async def wait_until_stopped(self) -> None:
         await self._proc.wait()
 
     async def run(self) -> None:
-        self._loop = asyncio.get_running_loop()
+        await super().run()
         self._stopped_future: asyncio.Future = asyncio.Future()
 
         self._proc = proc = await asyncio.create_subprocess_exec(
@@ -148,11 +150,14 @@ def stop(self) -> None:
         self._stopped = True
         self._loop.create_task(self._connection.close())
 
+    def cleanup(self) -> None:
+        self.on_error_future.cancel()
+
     async def wait_until_stopped(self) -> None:
         await self._connection.wait_closed()
 
     async def run(self) -> None:
-        self._loop = asyncio.get_running_loop()
+        await super().run()
 
         options = {}
         if self.timeout is not None:
@@ -180,6 +185,6 @@ def send(self, message: Dict) -> None:
         data = self.serialize_message(message)
         self._loop.create_task(self._connection.send(data))
 
-    def test_if_closed(self):
+    def test_if_closed(self) -> None:
         if self._stopped or self._connection.closed:
             raise Error("Playwright connection closed")
diff --git a/setup.py b/setup.py
@@ -134,6 +134,7 @@ def run(self) -> None:
     packages=["playwright"],
     include_package_data=True,
     install_requires=[
+        "websockets>=8.1",
         "greenlet>=0.4",
         "pyee>=8.0.1",
         "typing-extensions;python_version<='3.8'",
diff --git a/tests/async/test_browsertype_connect.py b/tests/async/test_browsertype_connect.py
@@ -28,6 +28,7 @@ async def test_browser_type_connect_should_be_able_to_reconnect_to_a_browser(
     browser_context = await browser.new_context()
     assert len(browser_context.pages) == 0
     page = await browser_context.new_page()
+    assert len(browser_context.pages) == 1
     assert await page.evaluate("11 * 11") == 121
     await page.goto(server.EMPTY_PAGE)
     await browser.close()
@@ -40,7 +41,7 @@ async def test_browser_type_connect_should_be_able_to_reconnect_to_a_browser(
 
 
 async def test_browser_type_connect_should_be_able_to_connect_two_browsers_at_the_same_time(
-    server: Server, browser_type: BrowserType, launch_server
+    browser_type: BrowserType, launch_server
 ):
     remote_server = launch_server()
     browser1 = await browser_type.connect(remote_server.ws_endpoint)
@@ -63,7 +64,7 @@ async def test_browser_type_connect_should_be_able_to_connect_two_browsers_at_th
 
 
 async def test_browser_type_connect_disconnected_event_should_be_emitted_when_browser_is_closed_or_server_is_closed(
-    server: Server, browser_type: BrowserType, launch_server
+    browser_type: BrowserType, launch_server
 ):
     # Launch another server to not affect other tests.
     remote = launch_server()
@@ -72,27 +73,27 @@ async def test_browser_type_connect_disconnected_event_should_be_emitted_when_br
     browser2 = await browser_type.connect(remote.ws_endpoint)
 
     disconnected1 = []
-    disconnected2_event_future: asyncio.Future[bool] = asyncio.Future()
+    disconnected2 = []
     browser1.on("disconnected", lambda: disconnected1.append(True))
-    browser2.on("disconnected", lambda: disconnected2_event_future.set_result(True))
+    browser2.on("disconnected", lambda: disconnected2.append(True))
 
     page2 = await browser2.new_page()
 
     await browser1.close()
     assert len(disconnected1) == 1
-    assert disconnected2_event_future.done() is False
+    assert len(disconnected2) == 0
 
     remote.kill()
     assert len(disconnected1) == 1
 
     with pytest.raises(Error):
         # Tickle connection so that it gets a chance to dispatch disconnect event.
         await page2.title()
-    await disconnected2_event_future
+    assert len(disconnected2) == 1
 
 
 async def test_browser_type_disconnected_event_should_have_browser_as_argument(
-    server: Server, browser_type: BrowserType, launch_server
+    browser_type: BrowserType, launch_server
 ):
     remote_server = launch_server()
     browser = await browser_type.connect(remote_server.ws_endpoint)
@@ -103,7 +104,7 @@ async def test_browser_type_disconnected_event_should_have_browser_as_argument(
 
 
 async def test_browser_type_connect_set_browser_connected_state(
-    server: Server, browser_type: BrowserType, launch_server
+    browser_type: BrowserType, launch_server
 ):
     remote_server = launch_server()
     browser = await browser_type.connect(remote_server.ws_endpoint)
@@ -113,26 +114,17 @@ async def test_browser_type_connect_set_browser_connected_state(
 
 
 async def test_browser_type_connect_should_throw_when_used_after_is_connected_returns_false(
-    server: Server, browser_type: BrowserType, launch_server
+    browser_type: BrowserType, launch_server
 ):
     remote_server = launch_server()
     browser = await browser_type.connect(remote_server.ws_endpoint)
     page = await browser.new_page()
 
-    disconnected_event_future: asyncio.Future[bool] = asyncio.Future()
-    browser.on("disconnected", lambda: disconnected_event_future.set_result(True))
-
     remote_server.kill()
 
-    # Wait until the process and its WS connection is closed
-    await disconnected_event_future
-
     with pytest.raises(Error) as exc_info:
         await page.evaluate("1 + 1")
-    assert "Protocol error (Runtime.evaluate): Target closed." in exc_info.value.message
-    on_disconnected: asyncio.Future[None] = asyncio.Future()
-    browser.on("disconnected", lambda: on_disconnected.set_result(None))
-    await on_disconnected
+    assert "Playwright connection closed" == exc_info.value.message
     assert browser.is_connected() is False
 
 
@@ -142,7 +134,7 @@ async def test_browser_type_connect_should_reject_navigation_when_browser_closes
     remote_server = launch_server()
     browser = await browser_type.connect(remote_server.ws_endpoint)
     page = await browser.new_page()
-    server.set_route("/one-style.css", lambda: None)
+    server.set_route("/one-style.css", lambda r: None)
     page.on("request", lambda: asyncio.create_task(browser.close()))
 
     with pytest.raises(Error) as exc_info:
diff --git a/tests/conftest.py b/tests/conftest.py
@@ -13,18 +13,18 @@
 # limitations under the License.
 
 import asyncio
+import inspect
 import io
-import os
-import signal
 import subprocess
 import sys
+from pathlib import Path
 
 import pytest
 from PIL import Image
 from pixelmatch import pixelmatch
 from pixelmatch.contrib.PIL import from_PIL_to_raw_data
 
-from playwright._impl._driver import compute_driver_executable
+import playwright
 from playwright._impl._path_utils import get_file_dirname
 
 from .server import test_server
@@ -208,17 +208,28 @@ def compare(received_raw: bytes, golden_name: str):
 
 class RemoteServer:
     def __init__(self, browser_name: str) -> None:
-        self.process = subprocess.Popen(
-            [compute_driver_executable(), "launch-server", browser_name],
+        driver_dir = Path(inspect.getfile(playwright)).parent / "driver"
+        if sys.platform == "win32":
+            node_executable = driver_dir / "node.exe"
+        else:
+            node_executable = driver_dir / "node"
+        cli_js = driver_dir / "package" / "lib" / "cli" / "cli.js"
+        self.process = subprocess.Popen(  # type: ignore
+            [str(node_executable), str(cli_js), "launch-server", browser_name],
             stdout=subprocess.PIPE,
-            preexec_fn=os.setsid,
+            stderr=sys.stderr,
+            cwd=driver_dir,
         )
         assert self.process.stdout
         self.ws_endpoint = self.process.stdout.readline().decode().strip()
 
     def kill(self):
         # Send the signal to all the process groups
-        os.killpg(os.getpgid(self.process.pid), signal.SIGTERM)
+        if sys.platform == "win32":
+            subprocess.check_call(f"taskkill /F /PID {self.process.pid}")
+        else:
+            self.process.kill()
+        self.process.wait()
 
 
 @pytest.fixture
diff --git a/tests/sync/test_browsertype_connect.py b/tests/sync/test_browsertype_connect.py
