feat: cleaning up type definitions for testing files

Author: gvwilson

dash/testing/browser.py

@@ -4,10 +4,7 @@
 import time
 import logging
 import warnings
-from typing import List
-
 import percy
-import percy.errors  # to satisfy type checking
 import requests
 
 from selenium import webdriver
@@ -105,7 +102,7 @@ def __exit__(self, exc_type, exc_val, traceback):
                 logger.info("percy finalize relies on CI job")
         except WebDriverException:
             logger.exception("webdriver quit was not successful")
-        except percy.errors.Error:
+        except percy.errors.Error:  # type: ignore[reportAttributeAccessIssue]
             logger.exception("percy runner failed to finalize properly")
 
     def visit_and_snapshot(
@@ -118,7 +115,7 @@ def visit_and_snapshot(
         stay_on_page=False,
         widths=None,
     ):
-        path = resource_path.lstrip("/")  # moved before 'try' to satisfy type checking
+        path = resource_path.lstrip("/")
         try:
             if path != resource_path:
                 logger.warning("we stripped the left '/' in resource_path")
@@ -240,16 +237,16 @@ def take_snapshot(self, name):
 
         self.driver.save_screenshot(f"{target}/{name}_{self.session_id}.png")
 
-    def find_element(self, locator, attribute="CSS_SELECTOR"):
-        """find_element returns the first found element by the attribute `locator`
+    def find_element(self, selector, attribute="CSS_SELECTOR"):
+        """find_element returns the first found element by the attribute `selector`
         shortcut to `driver.find_element(By.CSS_SELECTOR, ...)`.
         args:
         - attribute: the attribute type to search for, aligns with the Selenium
             API's `By` class. default "CSS_SELECTOR"
             valid values: "CSS_SELECTOR", "ID", "NAME", "TAG_NAME",
             "CLASS_NAME", "LINK_TEXT", "PARTIAL_LINK_TEXT", "XPATH"
         """
-        return self.driver.find_element(getattr(By, attribute.upper()), locator)
+        return self.driver.find_element(getattr(By, attribute.upper()), selector)
 
     def find_elements(self, selector, attribute="CSS_SELECTOR"):
         """find_elements returns a list of all elements matching the attribute
@@ -288,7 +285,6 @@ def _wait_for(self, method, timeout, msg):
                 message = msg(self.driver)
             else:
                 message = msg
-            assert isinstance(message, str)  # to satisfy type checking
             raise TimeoutException(message) from err
 
     def wait_for_element(self, selector, timeout=None):
@@ -408,7 +404,7 @@ def wait_for_page(self, url=None, timeout=10):
             )
         except TimeoutException as exc:
             logger.exception("dash server is not loaded within %s seconds", timeout)
-            logs = "\n".join((str(log) for log in self.get_logs()))
+            logs = "\n".join((str(log) for log in self.get_logs()))  # type: ignore[reportOptionalIterable]
             logger.debug(logs)
             html = self.find_element("body").get_property("innerHTML")
             raise DashAppLoadingError(
@@ -502,17 +498,16 @@ def _get_chrome(self):
         options.add_argument("--disable-gpu")
         options.add_argument("--remote-debugging-port=9222")
 
-        assert isinstance(self._remote_url, str)  # to satisfy type checking
         chrome = (
-            webdriver.Remote(command_executor=self._remote_url, options=options)
+            webdriver.Remote(command_executor=self._remote_url, options=options)  # type: ignore[reportAttributeAccessIssue]
             if self._remote
             else webdriver.Chrome(options=options)
         )
 
         # https://bugs.chromium.org/p/chromium/issues/detail?id=696481
         if self._headless:
             # pylint: disable=protected-access
-            chrome.command_executor._commands["send_command"] = (  # type: ignore[reportAttributeAccessIssue]
+            chrome.command_executor._commands["send_command"] = (  # type: ignore[reportArgumentType]
                 "POST",
                 "/session/$sessionId/chromium/send_command",
             )
@@ -605,7 +600,7 @@ def click_at_coord_fractions(self, elem_or_selector, fx, fy):
             elem, elem.size["width"] * fx, elem.size["height"] * fy
         ).click().perform()
 
-    def get_logs(self) -> List:
+    def get_logs(self):
         """Return a list of `SEVERE` level logs after last reset time stamps
         (default to 0, resettable by `reset_log_timestamp`.
 
@@ -617,8 +612,8 @@ def get_logs(self) -> List:
                 for entry in self.driver.get_log("browser")
                 if entry["timestamp"] > self._last_ts
             ]
-        warnings.warn("get_logs always returns '[]' with webdrivers other than Chrome")
-        return []
+        warnings.warn("get_logs always return None with webdrivers other than Chrome")
+        return None
 
     def reset_log_timestamp(self):
         """reset_log_timestamp only work with chrome webdriver."""

dash/testing/dash_page.py

@@ -1,94 +1,47 @@
-from typing import Any, Dict, List, Optional, Protocol, cast, runtime_checkable
+# type: ignore[reportAttributeAccessIssue]
+# Ignore attribute access issues when type checking because mixin
+# class depends on other class lineage to supply things. We could use
+# a protocol definition here instead…
 
 from bs4 import BeautifulSoup
 
-# directive needed because protocol classes are so brief
-# pylint: disable=too-few-public-methods
-
-
-@runtime_checkable
-class WebElement(Protocol):
-    """Protocol for WebElement-like objects with get_attribute."""
-
-    def get_attribute(self, name: str) -> str:
-        ...
-
-
-@runtime_checkable
-class WebDriver(Protocol):
-    """Protocol for WebDriver-like objects with execute_script."""
-
-    def execute_script(self, script: str, *args: Any) -> Any:
-        ...
-
 
 class DashPageMixin:
-    """Mixin class for Dash page with DOM access methods.
-
-    This mixin is intended to be used with a class that provides:
-    1. A 'driver' attribute with execute_script method
-    2. A 'find_element' method that returns elements with get_attribute method
-
-    The mixin provides properties like dash_entry_locator and methods to
-    interact with the Dash application's DOM and state.
-    """
-
-    driver: WebDriver  # Expected to be provided by the parent class
-
-    def find_element(self, locator: str) -> WebElement:
-        """Find an element by locator.
-
-        This is expected to be implemented by the parent class.
-        """
-        raise NotImplementedError(
-            "find_element must be implemented by the parent class"
+    def _get_dash_dom_by_attribute(self, attr):
+        return BeautifulSoup(
+            self.find_element(self.dash_entry_locator).get_attribute(attr), "lxml"
         )
 
     @property
-    def dash_entry_locator(self) -> str:
-        """CSS selector for Dash app entry point."""
-        return "#react-entry-point"
-
-    @property
-    def devtools_error_count_locator(self) -> str:
-        """CSS selector for devtools error count."""
+    def devtools_error_count_locator(self):
         return ".test-devtools-error-count"
 
-    def _get_dash_dom_by_attribute(self, attr: str) -> BeautifulSoup:
-        """Get BeautifulSoup representation of element's attribute."""
-        element = self.find_element(self.dash_entry_locator)
-        return BeautifulSoup(element.get_attribute(attr), "lxml")
+    @property
+    def dash_entry_locator(self):
+        return "#react-entry-point"
 
     @property
-    def dash_outerhtml_dom(self) -> BeautifulSoup:
-        """Get BeautifulSoup representation of outerHTML."""
+    def dash_outerhtml_dom(self):
         return self._get_dash_dom_by_attribute("outerHTML")
 
     @property
-    def dash_innerhtml_dom(self) -> BeautifulSoup:
-        """Get BeautifulSoup representation of innerHTML."""
+    def dash_innerhtml_dom(self):
         return self._get_dash_dom_by_attribute("innerHTML")
 
     @property
-    def redux_state_paths(self) -> Dict[str, Any]:
-        """Get Redux state paths."""
-        return cast(
-            dict[str, Any],
-            self.driver.execute_script(
-                """
+    def redux_state_paths(self):
+        return self.driver.execute_script(
+            """
             var p = window.store.getState().paths;
             return {strs: p.strs, objs: p.objs}
             """
-            ),
         )
 
     @property
-    def redux_state_rqs(self) -> List[Dict[str, Any]]:
-        """Get Redux state request queue."""
-        return cast(
-            list[dict[str, Any]],
-            self.driver.execute_script(
-                """
+    def redux_state_rqs(self):
+        return self.driver.execute_script(
+            """
+
             // Check for legacy `pendingCallbacks` store prop (compatibility for Dash matrix testing)
             var pendingCallbacks = window.store.getState().pendingCallbacks;
             if (pendingCallbacks) {
@@ -108,62 +61,39 @@ def redux_state_rqs(self) -> List[Dict[str, Any]]:
 
             return Array.prototype.concat.apply([], Object.values(callbacksState));
             """
-            ),
         )
 
     @property
-    def redux_state_is_loading(self) -> bool:
-        """Check if Redux state is loading."""
-        return cast(
-            bool,
-            self.driver.execute_script(
-                """
+    def redux_state_is_loading(self):
+        return self.driver.execute_script(
+            """
             return window.store.getState().isLoading;
             """
-            ),
         )
 
     @property
-    def window_store(self) -> Optional[Any]:
-        """Get window.store object."""
+    def window_store(self):
         return self.driver.execute_script("return window.store")
 
-    def _wait_for_callbacks(self) -> bool:
-        """Check if callbacks are complete."""
-        # Access properties directly
-        window_store = self.window_store
-        redux_state_rqs = self.redux_state_rqs
-        return (not window_store) or (redux_state_rqs == [])
-
-    def get_local_storage(self, store_id: str = "local") -> Optional[Dict[str, Any]]:
-        """Get item from localStorage."""
-        return cast(
-            Optional[dict[str, Any]],
-            self.driver.execute_script(
-                f"return JSON.parse(window.localStorage.getItem('{store_id}'));"
-            ),
+    def _wait_for_callbacks(self):
+        return (not self.window_store) or self.redux_state_rqs == []
+
+    def get_local_storage(self, store_id="local"):
+        return self.driver.execute_script(
+            f"return JSON.parse(window.localStorage.getItem('{store_id}'));"
         )
 
-    def get_session_storage(
-        self, session_id: str = "session"
-    ) -> Optional[Dict[str, Any]]:
-        """Get item from sessionStorage."""
-        return cast(
-            Optional[dict[str, Any]],
-            self.driver.execute_script(
-                f"return JSON.parse(window.sessionStorage.getItem('{session_id}'));"
-            ),
+    def get_session_storage(self, session_id="session"):
+        return self.driver.execute_script(
+            f"return JSON.parse(window.sessionStorage.getItem('{session_id}'));"
         )
 
-    def clear_local_storage(self) -> None:
-        """Clear localStorage."""
+    def clear_local_storage(self):
         self.driver.execute_script("window.localStorage.clear()")
 
-    def clear_session_storage(self) -> None:
-        """Clear sessionStorage."""
+    def clear_session_storage(self):
         self.driver.execute_script("window.sessionStorage.clear()")
 
-    def clear_storage(self) -> None:
-        """Clear both localStorage and sessionStorage."""
+    def clear_storage(self):
         self.clear_local_storage()
         self.clear_session_storage()