fix(api): remove browserType.connect() (microsoft#293)

Author: yury-s

CONTRIBUTING.md

@@ -1,3 +1,33 @@
+# Contributing
+
+## How to Contribute
+
+### Configuring python environment
+
+The project requires python version 3.8+. To set it as default in the environment run the following commands:
+
+```bash
+python3.8 -m venv env
+source ./env/bin/activate
+```
+
+Install required dependencies:
+
+```bash
+python -m pip install --upgrade pip wheel
+pip install -r local-requirements.txt
+pip install -e .
+```
+
+For more details look at the [CI configuration](./blob/master/.github/workflows/ci.yml).
+
+### Regenerating APIs
+
+```bash
+./scripts/update_api.sh
+pre-commit run --all-files
+```
+
 ## Contributor License Agreement
 
 This project welcomes contributions and suggestions.  Most contributions require you to agree to a

playwright/async_api.py

@@ -6310,32 +6310,6 @@ async def launchPersistentContext(
             )
         )
 
-    async def connect(
-        self, wsEndpoint: str, slowMo: int = None, timeout: int = None
-    ) -> "Browser":
-        """BrowserType.connect
-
-        This methods attaches Playwright to an existing browser instance.
-
-        Parameters
-        ----------
-        wsEndpoint : str
-            A browser websocket endpoint to connect to. **required**
-        slowMo : Optional[int]
-            Slows down Playwright operations by the specified amount of milliseconds. Useful so that you can see what is going on. Defaults to 0.
-        timeout : Optional[int]
-            Maximum time in milliseconds to wait for the connection to be established. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
-
-        Returns
-        -------
-        Browser
-        """
-        return mapping.from_impl(
-            await self._impl_obj.connect(
-                wsEndpoint=wsEndpoint, slowMo=slowMo, timeout=timeout
-            )
-        )
-
 
 mapping.register(BrowserTypeImpl, BrowserType)
 

playwright/browser_type.py

@@ -127,13 +127,6 @@ async def launchPersistentContext(
                 raise not_installed_error(f'"{self.name}" browser was not found.')
             raise e
 
-    async def connect(
-        self, wsEndpoint: str, slowMo: int = None, timeout: int = None
-    ) -> Browser:
-        return from_channel(
-            await self._channel.send("connect", locals_to_params(locals()))
-        )
-
 
 def normalize_launch_params(params: Dict) -> None:
     if "env" in params:

playwright/sync_api.py

@@ -6554,34 +6554,6 @@ def launchPersistentContext(
             )
         )
 
-    def connect(
-        self, wsEndpoint: str, slowMo: int = None, timeout: int = None
-    ) -> "Browser":
-        """BrowserType.connect
-
-        This methods attaches Playwright to an existing browser instance.
-
-        Parameters
-        ----------
-        wsEndpoint : str
-            A browser websocket endpoint to connect to. **required**
-        slowMo : Optional[int]
-            Slows down Playwright operations by the specified amount of milliseconds. Useful so that you can see what is going on. Defaults to 0.
-        timeout : Optional[int]
-            Maximum time in milliseconds to wait for the connection to be established. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
-
-        Returns
-        -------
-        Browser
-        """
-        return mapping.from_impl(
-            self._sync(
-                self._impl_obj.connect(
-                    wsEndpoint=wsEndpoint, slowMo=slowMo, timeout=timeout
-                )
-            )
-        )
-
 
 mapping.register(BrowserTypeImpl, BrowserType)
 

scripts/expected_api_mismatch.txt

@@ -107,7 +107,6 @@ Parameter not documented: Browser.newPage(defaultBrowserType=)
 # Logger
 Parameter not implemented: Browser.newContext(logger=)
 Parameter not implemented: BrowserType.launch(logger=)
-Parameter not implemented: BrowserType.connect(logger=)
 Parameter not implemented: BrowserType.launchPersistentContext(logger=)
 Parameter not implemented: Browser.newPage(logger=)
 

tests/async/test_launcher.py

@@ -104,150 +104,6 @@ async def test_browser_type_name_should_work(
         raise ValueError("Unknown browser")
 
 
-@pytest.mark.skip()
-async def test_browser_is_connected_should_set_connected_state(
-    browser_type, launch_arguments
-):
-    browser_server = await browser_type.launchServer(**launch_arguments)
-    remote = await browser_type.connect(wsEndpoint=browser_server.wsEndpoint)
-    assert remote.isConnected()
-    await remote.close()
-    assert remote.isConnected() is False
-    await browser_server.close()
-
-
-@pytest.mark.skip()
-async def test_browser_is_connected_should_throw_when_used_after_isConnected_returns_false(
-    browser_type, launch_arguments
-):
-    browser_server = await browser_type.launchServer(**launch_arguments)
-    remote = await browser_type.connect(wsEndpoint=browser_server.wsEndpoint)
-    page = await remote.newPage()
-    disconnected_future = asyncio.Future()
-    remote.once("disconnected", lambda: disconnected_future.set_result(None))
-    await asyncio.gather(browser_server.close(), disconnected_future)
-    assert remote.isConnected() is False
-    with pytest.raises(Error) as exc:
-        await page.evaluate('"1 + 1"')
-    assert "has been closed" in exc.value.message
-
-
-@pytest.mark.skip()
-async def test_browser_disconnect_should_reject_navigation_when_browser_closes(
-    browser_type, launch_arguments, server
-):
-    server.set_route("/one-style.css", lambda r: None)
-    browser_server = await browser_type.launchServer(**launch_arguments)
-    remote = await browser_type.connect(wsEndpoint=browser_server.wsEndpoint)
-    page = await remote.newPage()
-
-    async def handle_goto():
-        with pytest.raises(Error) as exc:
-            await page.goto(server.PREFIX + "/one-style.html", timeout=60000)
-        assert "Navigation failed because page was closed!" in exc.value.message
-
-    wait_for_request = asyncio.create_task(server.wait_for_request("/one-style.css"))
-    goto_assert = asyncio.create_task(handle_goto())
-    await wait_for_request
-    await remote.close()
-    await goto_assert
-    await browser_server.close()
-
-
-@pytest.mark.skip()
-async def test_browser_disconnect_should_reject_waitForSelector_when_browser_closes(
-    browser_type, launch_arguments, server
-):
-    server.set_route("/empty.html", lambda r: None)
-    browser_server = await browser_type.launchServer(**launch_arguments)
-    remote = await browser_type.connect(wsEndpoint=browser_server.wsEndpoint)
-    page = await remote.newPage()
-    wait_for_selector_future = asyncio.Future()
-
-    async def handle_wait_for_selector():
-        try:
-            await page.waitForSelector("div", state="attached", timeout=60000)
-        except Error as exc:
-            wait_for_selector_future.set_result(exc)
-
-    # Make sure the previous waitForSelector has time to make it to the browser before we disconnect.
-    asyncio.create_task(handle_wait_for_selector())
-    await asyncio.sleep(0)  # execute scheduled tasks, but don't await them
-    await page.waitForSelector("body", state="attached")
-
-    await remote.close()
-    error = await wait_for_selector_future
-    assert "Protocol error" in error.message
-    await browser_server.close()
-
-
-@pytest.mark.skip()
-async def test_browser_disconnect_should_throw_if_used_after_disconnect(
-    browser_type, launch_arguments
-):
-    browser_server = await browser_type.launchServer(**launch_arguments)
-    remote = await browser_type.connect(wsEndpoint=browser_server.wsEndpoint)
-    page = await remote.newPage()
-    await remote.close()
-    with pytest.raises(Error) as exc:
-        await page.evaluate('"1 + 1"')
-    assert "has been closed" in exc.value.message
-    await browser_server.close()
-
-
-@pytest.mark.skip()
-async def test_browser_disconnect_should_emit_close_events_on_pages_and_contexts(
-    browser_type, launch_arguments
-):
-    browser_server = await browser_type.launchServer(**launch_arguments)
-    remote = await browser_type.connect(wsEndpoint=browser_server.wsEndpoint)
-    context = await remote.newContext()
-    page = await context.newPage()
-    pages_closed = []
-    page.on("close", lambda: pages_closed.append(True))
-    context_close_fixture = asyncio.Future()
-    context.on("close", lambda: context_close_fixture.set_result(None))
-    await asyncio.gather(context_close_fixture, browser_server.close())
-    assert len(pages_closed) == 1
-
-
-@pytest.mark.skip()
-async def test_browser_close_should_terminate_network_waiters(
-    browser_type, launch_arguments, server
-):
-    browser_server = await browser_type.launchServer(**launch_arguments)
-    remote = await browser_type.connect(wsEndpoint=browser_server.wsEndpoint)
-    new_page = await remote.newPage()
-    wait_for_request_future = asyncio.Future()
-
-    async def handle_waitForRequest():
-        try:
-            await new_page.waitForRequest(server.EMPTY_PAGE)
-        except Error as exc:
-            wait_for_request_future.set_result(exc)
-
-    wait_for_response_future = asyncio.Future()
-
-    async def handle_waitForResponse():
-        try:
-            await new_page.waitForResponse(server.EMPTY_PAGE)
-        except Error as exc:
-            wait_for_response_future.set_result(exc)
-
-    asyncio.create_task(handle_waitForRequest())
-    asyncio.create_task(handle_waitForResponse())
-    await asyncio.sleep(0)  # execute scheduled tasks, but don't await them
-    results = await asyncio.gather(
-        wait_for_request_future,
-        wait_for_response_future,
-        browser_server.close(),
-    )
-    for i in range(2):
-        message = results[i].message
-        assert "Page closed" in message
-        assert "Timeout" not in message
-
-
 async def test_browser_close_should_fire_close_event_for_all_contexts(
     browser_type, launch_arguments
 ):
@@ -266,78 +122,3 @@ async def test_browser_close_should_be_callable_twice(browser_type, launch_argum
         browser.close(),
     )
     await browser.close()
-
-
-@pytest.mark.skip()
-async def test_browser_type_launch_server_should_work(browser_type, launch_arguments):
-    browser_server = await browser_type.launchServer(**launch_arguments)
-    browser = await browser_type.connect(wsEndpoint=browser_server.wsEndpoint)
-    browser_context = await browser.newContext()
-    assert len(browser_context.pages) == 0
-    assert browser_server.wsEndpoint
-    page = await browser_context.newPage()
-    assert await page.evaluate("11 * 11") == 121
-    await page.close()
-    await browser.close()
-    await browser_server.close()
-
-
-@pytest.mark.skip()
-async def test_browser_type_launch_server_should_fire_disconnected_when_closing_the_server(
-    browser_type, launch_arguments
-):
-    browser_server = await browser_type.launchServer(**launch_arguments)
-    browser = await browser_type.connect(wsEndpoint=browser_server.wsEndpoint)
-
-    disconnected_promise = asyncio.Future()
-    browser.once("disconnected", lambda: disconnected_promise.set_result(None))
-
-    closed_promise = asyncio.Future()
-    browser_server.on("close", lambda: closed_promise.set_result(None))
-
-    await browser_server.kill()
-    await asyncio.gather(
-        disconnected_promise,
-        closed_promise,
-    )
-
-
-@pytest.mark.skip()
-async def test_browser_type_launch_server_should_fire_close_event_during_kill(
-    browser_type, launch_arguments
-):
-    order = []
-    browser_server = await browser_type.launchServer(**launch_arguments)
-
-    closed_promise = asyncio.Future()
-    browser_server.on(
-        "close", lambda: (order.append("closed"), closed_promise.set_result(None))
-    )
-
-    async def kill_with_order():
-        await browser_server.kill()
-        order.append("killed")
-
-    await asyncio.gather(kill_with_order(), closed_promise)
-    assert order == ["closed", "killed"]
-
-
-@pytest.mark.skip()
-async def test_browser_type_connect_should_be_able_to_reconnect_to_a_browser(
-    browser_type, launch_arguments, server
-):
-    browser_server = await browser_type.launchServer(**launch_arguments)
-
-    browser = await browser_type.connect(wsEndpoint=browser_server.wsEndpoint)
-    browser_context = await browser.newContext()
-    page = await browser_context.newPage()
-    await page.goto(server.EMPTY_PAGE)
-    await browser.close()
-
-    browser = await browser_type.connect(wsEndpoint=browser_server.wsEndpoint)
-    browser_context = await browser.newContext()
-    page = await browser_context.newPage()
-    await page.goto(server.EMPTY_PAGE)
-    await browser.close()
-
-    await browser_server.close()