feat: Repr for classes (#581)

kumaraditya303 · web-flow · commit 1b27a4c92aaa · 2021-03-23T07:52:52.000-07:00
diff --git a/playwright/_impl/_browser.py b/playwright/_impl/_browser.py
@@ -51,6 +51,9 @@ def __init__(
         self._contexts: List[BrowserContext] = []
         self._channel.on("close", lambda _: self._on_close())
 
+    def __repr__(self) -> str:
+        return f"<Browser type={self._browser_type} version={self.version}>"
+
     def _on_close(self) -> None:
         self._is_connected = False
         self.emit(Browser.Events.Disconnected)
diff --git a/playwright/_impl/_browser_context.py b/playwright/_impl/_browser_context.py
@@ -75,6 +75,9 @@ def __init__(
             ),
         )
 
+    def __repr__(self) -> str:
+        return f"<BrowserContext browser={self.browser}>"
+
     def _on_page(self, page: Page) -> None:
         page._set_browser_context(self)
         self._pages.append(page)
diff --git a/playwright/_impl/_browser_type.py b/playwright/_impl/_browser_type.py
@@ -38,6 +38,9 @@ def __init__(
     ) -> None:
         super().__init__(parent, type, guid, initializer)
 
+    def __repr__(self) -> str:
+        return f"<BrowserType name={self.name} executable_path={self.executable_path}>"
+
     @property
     def name(self) -> str:
         return self._initializer["name"]
diff --git a/playwright/_impl/_console_message.py b/playwright/_impl/_console_message.py
@@ -25,6 +25,9 @@ def __init__(
     ) -> None:
         super().__init__(parent, type, guid, initializer)
 
+    def __repr__(self) -> str:
+        return f"<ConsoleMessage type={self.type} text={self.text}>"
+
     def __str__(self) -> str:
         return self.text
 
diff --git a/playwright/_impl/_dialog.py b/playwright/_impl/_dialog.py
@@ -24,6 +24,9 @@ def __init__(
     ) -> None:
         super().__init__(parent, type, guid, initializer)
 
+    def __repr__(self) -> str:
+        return f"<Dialog type={self.type} message={self.message} default_value={self.default_value}>"
+
     @property
     def type(self) -> str:
         return self._initializer["type"]
diff --git a/playwright/_impl/_download.py b/playwright/_impl/_download.py
@@ -26,6 +26,9 @@ def __init__(
     ) -> None:
         super().__init__(parent, type, guid, initializer)
 
+    def __repr__(self) -> str:
+        return f"<Download url={self.url!r} suggested_filename={self.suggested_filename!r}>"
+
     @property
     def url(self) -> str:
         return self._initializer["url"]
diff --git a/playwright/_impl/_file_chooser.py b/playwright/_impl/_file_chooser.py
@@ -35,6 +35,9 @@ def __init__(
         self._element_handle = element_handle
         self._is_multiple = is_multiple
 
+    def __repr__(self) -> str:
+        return f"<FileChooser page={self._page} element={self._element_handle}>"
+
     @property
     def page(self) -> "Page":
         return self._page
diff --git a/playwright/_impl/_frame.py b/playwright/_impl/_frame.py
@@ -81,6 +81,9 @@ def __init__(
             lambda params: self._on_frame_navigated(params),
         )
 
+    def __repr__(self) -> str:
+        return f"<Frame name={self.name} url={self.url!r}>"
+
     def _on_load_state(
         self, add: DocumentLoadState = None, remove: DocumentLoadState = None
     ) -> None:
diff --git a/playwright/_impl/_impl_to_api_mapping.py b/playwright/_impl/_impl_to_api_mapping.py
@@ -26,6 +26,9 @@ class ImplWrapper:
     def __init__(self, impl_obj: Any) -> None:
         self._impl_obj = impl_obj
 
+    def __repr__(self) -> str:
+        return self._impl_obj.__repr__()
+
 
 class ImplToApiMapping:
     def __init__(self) -> None:
diff --git a/playwright/_impl/_js_handle.py b/playwright/_impl/_js_handle.py
@@ -36,6 +36,9 @@ def __init__(
             "previewUpdated", lambda params: self._on_preview_updated(params["preview"])
         )
 
+    def __repr__(self) -> str:
+        return f"<JSHandle preview={self._preview}>"
+
     def __str__(self) -> str:
         return self._preview
 
diff --git a/playwright/_impl/_network.py b/playwright/_impl/_network.py
@@ -60,6 +60,9 @@ def __init__(
         }
         self._headers: Dict[str, str] = parse_headers(self._initializer["headers"])
 
+    def __repr__(self) -> str:
+        return f"<Request url={self.url!r} method={self.method!r}>"
+
     @property
     def url(self) -> str:
         return self._initializer["url"]
@@ -136,6 +139,9 @@ def __init__(
     ) -> None:
         super().__init__(parent, type, guid, initializer)
 
+    def __repr__(self) -> str:
+        return f"<Route request={self.request}>"
+
     @property
     def request(self) -> Request:
         return from_channel(self._initializer["request"])
@@ -218,6 +224,9 @@ def __init__(
         self._request._timing["responseStart"] = timing["responseStart"]
         self._request._headers = parse_headers(self._initializer["requestHeaders"])
 
+    def __repr__(self) -> str:
+        return f"<Response url={self.url!r} request={self.request}>"
+
     @property
     def url(self) -> str:
         return self._initializer["url"]
@@ -290,6 +299,9 @@ def __init__(
         )
         self._channel.on("close", lambda params: self._on_close())
 
+    def __repr__(self) -> str:
+        return f"<WebSocket url={self.url!r}>"
+
     @property
     def url(self) -> str:
         return self._initializer["url"]
diff --git a/playwright/_impl/_page.py b/playwright/_impl/_page.py
@@ -224,6 +224,9 @@ def __init__(
             "worker", lambda params: self._on_worker(from_channel(params["worker"]))
         )
 
+    def __repr__(self) -> str:
+        return f"<Page url={self.url!r}>"
+
     def _set_browser_context(self, context: "BrowserContext") -> None:
         self._browser_context = context
         self._timeout_settings = TimeoutSettings(context._timeout_settings)
@@ -883,6 +886,9 @@ def __init__(
         self._page: Optional[Page] = None
         self._context: Optional["BrowserContext"] = None
 
+    def __repr__(self) -> str:
+        return f"<Worker url={self.url!r}>"
+
     def _on_close(self) -> None:
         if self._page:
             self._page._workers.remove(self)
diff --git a/playwright/_impl/_video.py b/playwright/_impl/_video.py
@@ -41,3 +41,6 @@ def _set_relative_path(self, relative_path: str) -> None:
                 )
             )
         )
+
+    def __repr__(self) -> str:
+        return f"<Video page={self._page}>"
diff --git a/tests/async/test_download.py b/tests/async/test_download.py
@@ -55,6 +55,10 @@ async def test_should_report_downloads_with_accept_downloads_false(page: Page, s
     download = await download_info.value
     assert download.url == f"{server.PREFIX}/downloadWithFilename"
     assert download.suggested_filename == "file.txt"
+    assert (
+        repr(download)
+        == f"<Download url={download.url!r} suggested_filename={download.suggested_filename!r}>"
+    )
     error: Optional[Error] = None
     try:
         await download.path()
diff --git a/tests/async/test_input.py b/tests/async/test_input.py
@@ -76,6 +76,10 @@ async def test_should_emit_event(page: Page):
     await page.click("input")
     file_chooser = await fc_done
     assert file_chooser
+    assert (
+        repr(file_chooser)
+        == f"<FileChooser page={file_chooser.page} element={file_chooser.element}>"
+    )
 
 
 async def test_should_work_when_file_input_is_attached_to_dom(page: Page):
diff --git a/tests/async/test_jshandle.py b/tests/async/test_jshandle.py
@@ -16,12 +16,15 @@
 import math
 from datetime import datetime
 
-from playwright.async_api import Error
+from playwright.async_api import Error, Page
 
 
-async def test_jshandle_evaluate_work(page):
+async def test_jshandle_evaluate_work(page: Page):
     window_handle = await page.evaluate_handle("window")
     assert window_handle
+    assert (
+        repr(window_handle) == f"<JSHandle preview={window_handle._impl_obj._preview}>"
+    )
 
 
 async def test_jshandle_evaluate_accept_object_handle_as_argument(page):
diff --git a/tests/async/test_network.py b/tests/async/test_network.py
@@ -14,17 +14,18 @@
 
 import asyncio
 import json
-from asyncio.futures import Future
+from asyncio import Future
 from typing import Dict, List, cast
 
 import pytest
 
-from playwright.async_api import Error, Page, Request, Response
+from playwright.async_api import Error, Page, Request, Response, Route
 
 
 async def test_request_fulfill(page, server):
-    async def handle_request(route, request):
+    async def handle_request(route: Route, request: Request):
         assert route.request == request
+        assert repr(route) == f"<Route request={route.request}>"
         assert "empty.html" in request.url
         assert request.headers["user-agent"]
         assert request.method == "GET"
@@ -33,6 +34,9 @@ async def handle_request(route, request):
         assert request.resource_type == "document"
         assert request.frame == page.main_frame
         assert request.frame.url == "about:blank"
+        assert (
+            repr(request) == f"<Request url={request.url!r} method={request.method!r}>"
+        )
         await route.fulfill(body="Text")
 
     await page.route(
@@ -41,7 +45,11 @@ async def handle_request(route, request):
     )
 
     response = await page.goto(server.EMPTY_PAGE)
+
     assert response.ok
+    assert (
+        repr(response) == f"<Response url={response.url!r} request={response.request}>"
+    )
     assert await response.text() == "Text"
 
 
diff --git a/tests/async/test_websocket.py b/tests/async/test_websocket.py
@@ -46,6 +46,7 @@ async def test_should_emit_close_events(page, ws_server):
         )
     ws = await ws_info.value
     assert ws.url == f"ws://localhost:{ws_server.PORT}/ws"
+    assert repr(ws) == f"<WebSocket url={ws.url!r}>"
     if not ws.is_closed():
         await ws.wait_for_event("close")
     assert ws.is_closed()
diff --git a/tests/async/test_worker.py b/tests/async/test_worker.py
@@ -20,11 +20,12 @@
 from playwright.async_api import Error, Page, Worker
 
 
-async def test_workers_page_workers(page, server):
+async def test_workers_page_workers(page: Page, server):
     async with page.expect_worker() as worker_info:
         await page.goto(server.PREFIX + "/worker/worker.html")
     worker = await worker_info.value
     assert "worker.js" in worker.url
+    assert repr(worker) == f"<Worker url={worker.url!r}>"
 
     assert (
         await worker.evaluate('() => self["workerFunction"]()')
diff --git a/tests/sync/test_sync.py b/tests/sync/test_sync.py
@@ -16,7 +16,15 @@
 
 import pytest
 
-from playwright.sync_api import Browser, Error, Page, TimeoutError, sync_playwright
+from playwright.sync_api import (
+    Browser,
+    BrowserContext,
+    Dialog,
+    Error,
+    Page,
+    TimeoutError,
+    sync_playwright,
+)
 
 
 def test_sync_query_selector(page):
@@ -31,6 +39,58 @@ def test_sync_query_selector(page):
     )
 
 
+def test_page_repr(page):
+    page.goto("https://example.com")
+    assert repr(page) == f"<Page url={page.url!r}>"
+
+
+def test_frame_repr(page: Page):
+    page.goto("https://example.com")
+    assert (
+        repr(page.main_frame)
+        == f"<Frame name={page.main_frame.name} url={page.main_frame.url!r}>"
+    )
+
+
+def test_browser_context_repr(context: BrowserContext):
+    assert repr(context) == f"<BrowserContext browser={context.browser}>"
+
+
+def test_browser_repr(browser: Browser):
+    assert (
+        repr(browser)
+        == f"<Browser type={browser._impl_obj._browser_type} version={browser.version}>"
+    )
+
+
+def test_browser_type_repr(browser: Browser):
+    browser_type = browser._impl_obj._browser_type
+    assert (
+        repr(browser_type)
+        == f"<BrowserType name={browser_type.name} executable_path={browser_type.executable_path}>"
+    )
+
+
+def test_dialog_repr(page: Page, server):
+    def on_dialog(dialog: Dialog):
+        dialog.accept()
+        assert (
+            repr(dialog)
+            == f"<Dialog type={dialog.type} message={dialog.message} default_value={dialog.default_value}>"
+        )
+
+    page.on("dialog", on_dialog)
+    page.evaluate("alert('yo')")
+
+
+def test_console_repr(page: Page, server):
+    messages = []
+    page.on("console", lambda m: messages.append(m))
+    page.evaluate('() => console.log("Hello world")')
+    message = messages[0]
+    assert repr(message) == f"<ConsoleMessage type={message.type} text={message.text}>"
+
+
 def test_sync_click(page):
     page.set_content(
         """
diff --git a/tests/sync/test_video.py b/tests/sync/test_video.py
@@ -21,6 +21,7 @@ def test_should_expose_video_path(browser, tmpdir, server):
     )
     page.goto(server.PREFIX + "/grid.html")
     path = page.video.path()
+    assert repr(page.video) == f"<Video page={page}>"
     assert str(tmpdir) in str(path)
     page.context.close()
 

Original file line number	Diff line number	Diff line change
`@@ -75,6 +75,9 @@ def __init__(`
`75`	`75`	`),`
`76`	`76`	`)`
`77`	`77`
	`78`	`+ def __repr__(self) -> str:`
	`79`	`+ return f"<BrowserContext browser={self.browser}>"`
	`80`	`+`
`78`	`81`	`def _on_page(self, page: Page) -> None:`
`79`	`82`	`page._set_browser_context(self)`
`80`	`83`	`self._pages.append(page)`
Original file line number	Diff line number	Diff line change
`@@ -81,6 +81,9 @@ def __init__(`
`81`	`81`	`lambda params: self._on_frame_navigated(params),`
`82`	`82`	`)`
`83`	`83`
	`84`	`+ def __repr__(self) -> str:`
	`85`	`+ return f"<Frame name={self.name} url={self.url!r}>"`
	`86`	`+`
`84`	`87`	`def _on_load_state(`
`85`	`88`	`self, add: DocumentLoadState = None, remove: DocumentLoadState = None`
`86`	`89`	`) -> None:`
Original file line number	Diff line number	Diff line change
`@@ -36,6 +36,9 @@ def __init__(`
`36`	`36`	`"previewUpdated", lambda params: self._on_preview_updated(params["preview"])`
`37`	`37`	`)`
`38`	`38`
	`39`	`+ def __repr__(self) -> str:`
	`40`	`+ return f"<JSHandle preview={self._preview}>"`
	`41`	`+`
`39`	`42`	`def __str__(self) -> str:`
`40`	`43`	`return self._preview`
`41`	`44`