fix sync variant

mxschmitt · mxschmitt · commit 81c097c64776 · 2021-05-07T17:39:33.000+02:00
diff --git a/playwright/_impl/_browser_type.py b/playwright/_impl/_browser_type.py
@@ -172,7 +172,9 @@ async def connect(
         slow_mo: float = None,
         headers: Dict[str, str] = None,
     ) -> Browser:
-        transport = WebSocketTransport(self._connection._loop, ws_endpoint, timeout, headers)
+        transport = WebSocketTransport(
+            self._connection._loop, ws_endpoint, timeout, headers
+        )
 
         connection = Connection(
             self._connection._dispatcher_fiber,
@@ -182,7 +184,7 @@ async def connect(
         connection._is_sync = self._connection._is_sync
         connection._loop = self._connection._loop
         connection._loop.create_task(connection.run())
-        await connection.wait_until_started()
+        await connection.initialize()
         playwright = await connection.wait_for_object_with_known_name("Playwright")
         self._connection._child_ws_connections.append(connection)
         pre_launched_browser = playwright._initializer.get("preLaunchedBrowser")
diff --git a/playwright/_impl/_connection.py b/playwright/_impl/_connection.py
@@ -165,19 +165,21 @@ def __init__(
         self._is_sync = False
         self._api_name = ""
         self._child_ws_connections: List["Connection"] = []
+        self._initialized = False
 
     async def run_as_sync(self) -> None:
         self._is_sync = True
         await self.run()
-        await self.wait_until_started()
+        await self.initialize()
 
     async def run(self) -> None:
         self._loop = asyncio.get_running_loop()
         self._root_object = RootChannelOwner(self)
         await self._transport.run()
 
-    async def wait_until_started(self) -> None:
-        await self._transport.wait_until_started
+    async def initialize(self) -> None:
+        await self._transport.wait_until_initialized
+        self._initialized = True
 
     def stop_sync(self) -> None:
         self._transport.request_stop()
@@ -194,6 +196,7 @@ def cleanup(self) -> None:
             ws_connection._transport.dispose()
 
     async def wait_for_object_with_known_name(self, guid: str) -> Any:
+        assert self._initialized
         if guid in self._objects:
             return self._objects[guid]
         callback = self._loop.create_future()
diff --git a/playwright/_impl/_transport.py b/playwright/_impl/_transport.py
@@ -46,12 +46,12 @@ def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
         self.on_error_future: asyncio.Future
         self.on_message = lambda _: None
 
-        self.wait_until_started: asyncio.Future = loop.create_future()
-        self._wait_until_started_set_success = (
-            lambda: self.wait_until_started.set_result(True)
+        self.wait_until_initialized: asyncio.Future = loop.create_future()
+        self._wait_until_initialized_set_success = (
+            lambda: self.wait_until_initialized.set_result(True)
         )
-        self._wait_until_started_set_exception = (
-            lambda exc: self.wait_until_started.set_exception(exc)
+        self._wait_until_initialized_set_exception = (
+            lambda exc: self.wait_until_initialized.set_exception(exc)
         )
 
     @abstractmethod
@@ -88,7 +88,9 @@ def deserialize_message(self, data: bytes) -> Any:
 
 
 class PipeTransport(Transport):
-    def __init__(self, loop: asyncio.AbstractEventLoop, driver_executable: Path) -> None:
+    def __init__(
+        self, loop: asyncio.AbstractEventLoop, driver_executable: Path
+    ) -> None:
         super().__init__(loop)
         self._stopped = False
         self._driver_executable = driver_executable
@@ -115,17 +117,11 @@ async def run(self) -> None:
                 stderr=_get_stderr_fileno(),
                 limit=32768,
             )
-        except FileNotFoundError:
-            self._wait_until_started_set_exception(
-                Error(
-                    "playwright's driver is not found, You can read the contributing guide "
-                    "for some guidance on how to get everything setup for working on the code "
-                    "https://github.com/microsoft/playwright-python/blob/master/CONTRIBUTING.md"
-                )
-            )
+        except Exception as exc:
+            self._wait_until_initialized_set_exception(exc)
             return
 
-        self._wait_until_started_set_success()
+        self._wait_until_initialized_set_success()
 
         assert proc.stdout
         assert proc.stdin
@@ -161,16 +157,19 @@ def send(self, message: Dict) -> None:
 
 class WebSocketTransport(AsyncIOEventEmitter, Transport):
     def __init__(
-        self, loop: asyncio.AbstractEventLoop, ws_endpoint: str, timeout: float = None, headers: Dict[str, str] = None
+        self,
+        loop: asyncio.AbstractEventLoop,
+        ws_endpoint: str,
+        timeout: float = None,
+        headers: Dict[str, str] = None,
     ) -> None:
-        super().__init__()
+        super().__init__(loop)
         Transport.__init__(self, loop)
 
         self._stopped = False
         self.ws_endpoint = ws_endpoint
-        self.timeout = timeout
+        self.timeout = timeout or 30000
         self.headers = headers
-        self._loop: asyncio.AbstractEventLoop
 
     def request_stop(self) -> None:
         self._stopped = True
@@ -189,17 +188,18 @@ async def run(self) -> None:
         if self.timeout is not None:
             options["close_timeout"] = self.timeout / 1000
             options["ping_timeout"] = self.timeout / 1000
-        if self.headers is not None:
+
+        if self.headers:
             options["extra_headers"] = self.headers
         try:
             self._connection = await websockets.connect(self.ws_endpoint, **options)
         except Exception as err:
-            self._wait_until_started_set_exception(
+            self._wait_until_initialized_set_exception(
                 Error(f"playwright's websocket endpoint connection error: {err}")
             )
             return
 
-        self._wait_until_started_set_success()
+        self._wait_until_initialized_set_success()
 
         while not self._stopped:
             try:
diff --git a/playwright/async_api/_context_manager.py b/playwright/async_api/_context_manager.py
@@ -28,12 +28,14 @@ def __init__(self) -> None:
 
     async def __aenter__(self) -> AsyncPlaywright:
         self._connection = Connection(
-            None, create_remote_object, PipeTransport(asyncio.get_event_loop(), compute_driver_executable())
+            None,
+            create_remote_object,
+            PipeTransport(asyncio.get_event_loop(), compute_driver_executable()),
         )
         loop = asyncio.get_running_loop()
         self._connection._loop = loop
         loop.create_task(self._connection.run())
-        await self._connection.wait_until_started()
+        await self._connection.initialize()
         playwright = AsyncPlaywright(
             await self._connection.wait_for_object_with_known_name("Playwright")
         )
