SY-3549: Automate Workspaces QA (#1979)

* Automate Workspaces QA
* Extend workspaces client to handle file imports
* Add workspace/pages for import
* Reorganize tests

Author: sy-nico

.github/PULL_REQUEST_TEMPLATE/rc.md

@@ -426,25 +426,14 @@ I can successfully:
 
 I can successfully:
 
-- [ ] View the correct version in the bottom navbar.
 - [ ] Verify that the auto-update functionality works correctly.
 
 ### Workspaces
 
 I can successfully:
 
 - [ ] Import a workspace by drag and dropping from a directory.
-
-- **Resources Toolbar**
-  - **Context Menu**
-    - [ ] Export a workspace.
-    - [ ] Import a line plot.
-    - [ ] Import a schematic.
-    - [ ] Import a log.
-    - [ ] Import a table.
 - [ ] Open a workspace from a link.
-- **Search and Command Palette**
-  - [ ] Import a workspace.
 - [ ] Create a workspace in a previous version of Synnax, add visualizations, and open it in the release candidate.
 
 ## Driver

integration/console/layout.py

@@ -299,6 +299,20 @@ def close_left_toolbar(self) -> None:
 
         nav_drawer.wait_for(state="hidden", timeout=5000)
 
+    def get_version(self) -> str:
+        """Get the version string displayed in the navbar badge.
+
+        Returns:
+            The version string (e.g., "v0.51.0").
+        """
+        navbar_end = self.page.locator(
+            ".pluto-navbar__content.pluto--end[data-tauri-drag-region]"
+        )
+        navbar_end.wait_for(state="visible", timeout=15000)
+        version_badge = navbar_end.locator("button").first
+        version_badge.wait_for(state="visible", timeout=5000)
+        return version_badge.inner_text().strip()
+
     def fill_input_field(self, input_label: str, value: str) -> None:
         """Fill an input field by label."""
         input_field = (

integration/console/plot.py

@@ -274,19 +274,22 @@ def get_line_thickness(self) -> int:
         stroke_input = line_item.locator("input").nth(1)
         return int(stroke_input.input_value())
 
-    def get_line_label(self) -> str:
-        """Get the label for the first line from the Lines tab.
+    def get_line_labels(self) -> list[str]:
+        """Get labels for all lines from the Lines tab.
 
         Returns:
-            The current line label
+            List of line label strings.
         """
         self.notifications.close_all()
+        self.layout.show_visualization_toolbar()
         self.page.locator("#lines").click(timeout=5000)
 
         lines_container = self.page.locator(".console-line-plot__toolbar-lines")
-        line_item = lines_container.locator(".pluto-list__item").first
-        label_input = line_item.locator("input").first
-        return label_input.input_value()
+        line_items = lines_container.locator(".pluto-list__item")
+        count = line_items.count()
+        return [
+            line_items.nth(i).locator("input").first.input_value() for i in range(count)
+        ]
 
     def drag_channel_to_canvas(
         self, channel_name: str, channels: ChannelClient

integration/console/schematic/schematic.py

@@ -465,6 +465,10 @@ def get_properties(self) -> SchematicProperties:
             "show_control_legend": show_control_legend,
         }
 
+    def get_symbol_count(self) -> int:
+        """Get the number of symbol nodes on the schematic pane."""
+        return self.page.locator(".react-flow__node").count()
+
     @property
     def control_legend_visible(self) -> bool:
         """Check if the control state legend is visible."""

integration/console/schematic/symbol_editor.py

@@ -77,6 +77,7 @@ def upload_svg(self, svg_path: str) -> None:
             for word in name_without_ext.replace("_", " ").replace("-", " ").split()
         )
 
+        # SY-3670
         self.page.evaluate(
             """([svgContent, properName]) => {
                 // Access React fiber to call FileDrop's onContentsChange prop directly

integration/console/table.py

@@ -13,6 +13,8 @@
 from console.layout import LayoutClient
 from console.page import ConsolePage
 
+DATA_ROW_SELECTOR = ".pluto-table__row:not(.pluto-table__col-resizer)"
+
 
 class Table(ConsolePage):
     """Table page management interface"""
@@ -57,18 +59,42 @@ def get_cell_channel(self, row: int = 0, col: int = 0) -> str:
         Returns:
             The channel name or empty string if not set
         """
-        self.layout.get_tab(self.page_name).click()
-        self._click_cell(row, col)
-        self.layout.show_visualization_toolbar()
+        self._select_cell(row, col)
         self.page.get_by_text("Telemetry").click()
         channel_btn = (
             self.page.locator("text=Input Channel")
             .locator("..")
             .locator("button")
             .first
         )
-        channel_text = channel_btn.inner_text().strip()
-        return channel_text
+        return channel_btn.inner_text().strip()
+
+    def get_cell_text(self, row: int = 0, col: int = 0) -> str:
+        """Get the text content of a text cell.
+
+        Args:
+            row: Row index (0-based)
+            col: Column index (0-based)
+
+        Returns:
+            The text value of the cell
+        """
+        self._select_cell(row, col)
+        text_input = self.page.locator("text=Text").locator("..").locator("input").first
+        return text_input.input_value().strip()
+
+    def has_text(self, text: str, row: int = 0, col: int = 0) -> bool:
+        """Check if a text cell contains the given text.
+
+        Args:
+            text: Text to check for
+            row: Row index (0-based)
+            col: Column index (0-based)
+
+        Returns:
+            True if the cell text matches
+        """
+        return self.get_cell_text(row, col) == text
 
     def has_channel(self, channel_name: str, row: int = 0, col: int = 0) -> bool:
         """Check if a channel is shown in a cell.
@@ -83,13 +109,27 @@ def has_channel(self, channel_name: str, row: int = 0, col: int = 0) -> bool:
         """
         return channel_name in self.get_cell_channel(row, col)
 
+    def _select_cell(self, row: int, col: int) -> None:
+        """Focus the tab, click a cell, and open the visualization toolbar."""
+        self.layout.get_tab(self.page_name).click()
+        self._click_cell(row, col)
+        self.layout.show_visualization_toolbar()
+
     def _click_cell(self, row: int, col: int) -> None:
         """Click on a specific cell in the table."""
         cells = self.page.locator(".pluto-table__cell")
-        cell_index = row * self._get_column_count() + col
+        cell_index = row * self.get_column_count() + col
         cells.nth(cell_index).click()
 
-    def _get_column_count(self) -> int:
-        """Get the number of columns in the table."""
-        first_row = self.page.locator(".pluto-table__row").first
-        return first_row.locator(".pluto-table__cell").count()
+    def get_row_count(self) -> int:
+        """Get the number of data rows in the table (excludes the column resizer row)."""
+        self.page.locator(DATA_ROW_SELECTOR).first.wait_for(
+            state="visible", timeout=5000
+        )
+        return self.page.locator(DATA_ROW_SELECTOR).count()
+
+    def get_column_count(self) -> int:
+        """Get the number of data columns in the table (excludes the row resizer cell)."""
+        data_row = self.page.locator(DATA_ROW_SELECTOR).first
+        data_row.wait_for(state="visible", timeout=5000)
+        return data_row.locator(".pluto-table__cell").count()

integration/console/workspace.py

@@ -35,6 +35,31 @@
 
 T = TypeVar("T", bound="ConsolePage")
 
+# SY-3670 — Shared JS snippet that walks the React fiber tree from #root
+# to find the Redux store. Used by import_page and export_workspace as a
+# browser-mode workaround for features that normally rely on Tauri APIs.
+_FIND_REDUX_STORE_JS = """
+const rootEl = document.getElementById('root');
+if (!rootEl) throw new Error('Root element not found');
+const containerKey = Object.keys(rootEl).find(
+    k => k.startsWith('__reactContainer$')
+);
+if (!containerKey) throw new Error('React container not found');
+let store = null;
+const stack = [rootEl[containerKey]];
+while (stack.length > 0) {
+    const fiber = stack.pop();
+    if (!fiber) continue;
+    if (fiber.memoizedProps?.store?.dispatch) {
+        store = fiber.memoizedProps.store;
+        break;
+    }
+    if (fiber.child) stack.push(fiber.child);
+    if (fiber.sibling) stack.push(fiber.sibling);
+}
+if (!store) throw new Error('Redux store not found');
+"""
+
 
 class WorkspaceClient:
     """Workspace management for Console UI automation."""
@@ -449,6 +474,180 @@ def export_page(self, name: str) -> dict[str, Any]:
             result: dict[str, Any] = json.load(f)
             return result
 
+    def _evaluate_with_redux(self, js_body: str, args: Any = None) -> Any:
+        """Execute JS with the Redux store available as ``store``.
+
+        # SY-3670 — Uses React fiber walking to locate the Redux store
+        # from the React root. This is a browser-mode workaround for
+        # features that normally rely on Tauri APIs.
+
+        Args:
+            js_body: JS code to execute. ``store`` and ``args`` are in scope.
+            args: Optional arguments forwarded to the JS function.
+        """
+        js = "(args) => {" + _FIND_REDUX_STORE_JS + js_body + "}"
+        return self.layout.page.evaluate(js, args)
+
+    def import_page(self, json_path: str, name: str) -> None:
+        """Import a page from a JSON file via direct JS injection.
+
+        Since the console uses Tauri's native file dialog for imports
+        (unavailable in browser mode), this method bypasses the dialog
+        by reading the JSON file and dispatching Redux actions directly.
+
+        # SY-3670 will address this issue.
+
+        Args:
+            json_path: Path to the JSON file to import.
+            name: Display name for the imported page tab.
+        """
+        with open(json_path, "r") as f:
+            data: dict[str, Any] = json.load(f)
+
+        resource_type = data.get("type")
+        if resource_type is None:
+            raise ValueError(f"JSON file missing 'type' field: {json_path}")
+
+        type_config: dict[str, dict[str, str]] = {
+            "lineplot": {"slice": "line", "icon": "Visualize"},
+            "schematic": {"slice": "schematic", "icon": "Schematic"},
+            "log": {"slice": "log", "icon": "Log"},
+            "table": {"slice": "table", "icon": "Table"},
+        }
+
+        config = type_config.get(resource_type)
+        if config is None:
+            raise ValueError(f"Unsupported resource type: {resource_type}")
+
+        self._evaluate_with_redux(
+            """
+            const [data, name, sliceName, icon] = args;
+            const key = crypto.randomUUID();
+            store.dispatch({
+                type: sliceName + '/create',
+                payload: { ...data, key }
+            });
+            store.dispatch({
+                type: 'layout/place',
+                payload: {
+                    key, name,
+                    location: 'mosaic',
+                    type: data.type,
+                    icon,
+                    windowKey: 'main',
+                }
+            });
+            """,
+            [data, name, config["slice"], config["icon"]],
+        )
+
+        self.layout.get_tab(name).wait_for(state="visible", timeout=10000)
+
+    def import_workspace(self, name: str, data: dict[str, Any]) -> None:
+        """Import a workspace via command palette with JS injection fallback.
+
+        Triggers "Import a workspace" from the command palette. Since the
+        console uses Tauri's native directory dialog (unavailable in browser
+        mode), the actual import falls back to dispatching Redux actions
+        via JS injection.
+
+        # SY-3670 will address the browser-mode limitation.
+
+        Args:
+            name: Name for the imported workspace.
+            data: Export data dict with 'layout' and 'components' keys
+                  (as returned by export_workspace).
+        """
+        self.layout.command_palette("Import a workspace")
+
+        sliceMap: dict[str, str] = {
+            "lineplot": "line",
+            "schematic": "schematic",
+            "log": "log",
+            "table": "table",
+        }
+
+        self._evaluate_with_redux(
+            """
+            const [name, layoutData, components, sliceMap] = args;
+            const wsKey = crypto.randomUUID();
+            store.dispatch({
+                type: 'workspace/setActive',
+                payload: { key: wsKey, name, layout: layoutData },
+            });
+            store.dispatch({
+                type: 'layout/setWorkspace',
+                payload: { slice: layoutData, keepNav: false },
+            });
+            for (const [key, component] of Object.entries(components)) {
+                const sliceName = sliceMap[component.type];
+                if (!sliceName) continue;
+                store.dispatch({
+                    type: sliceName + '/create',
+                    payload: { ...component, key },
+                });
+            }
+            """,
+            [name, data["layout"], data["components"], sliceMap],
+        )
+
+        self.layout.page.get_by_role("button").filter(has_text=name).wait_for(
+            state="visible", timeout=10000
+        )
+
+    def export_workspace(self, name: str) -> dict[str, Any]:
+        """Export a workspace via context menu with JS injection fallback.
+
+        Opens the context menu on the workspace and clicks Export. Since the
+        console uses Tauri's native directory dialog and file system APIs
+        (unavailable in browser mode), the actual data extraction falls back
+        to reading Redux state via JS injection.
+
+        # SY-3670 will address the browser-mode limitation.
+
+        Args:
+            name: Name of the workspace to export.
+
+        Returns:
+            Dict with 'layout' (the layout state) and 'components'
+            (dict of component key -> exported state with type field).
+        """
+        self.layout.show_resource_toolbar("workspace")
+        workspace_item = self.get_item(name)
+        workspace_item.wait_for(state="visible", timeout=5000)
+        self.ctx_menu.action(workspace_item, "Export")
+        self.notifications.close_all()
+
+        result: dict[str, Any] = self._evaluate_with_redux("""
+            const state = store.getState();
+            const layoutState = state.layout;
+            const sliceMap = {
+                lineplot: { slice: 'line', collection: 'plots' },
+                schematic: { slice: 'schematic', collection: 'schematics' },
+                log: { slice: 'log', collection: 'logs' },
+                table: { slice: 'table', collection: 'tables' },
+            };
+            const components = {};
+            const layouts = {};
+            for (const [key, layout] of Object.entries(layoutState.layouts)) {
+                if (layout.excludeFromWorkspace || layout.location === 'modal')
+                    continue;
+                layouts[key] = layout;
+                const mapping = sliceMap[layout.type];
+                if (!mapping) continue;
+                const cs = state[mapping.slice]?.[mapping.collection]?.[key];
+                if (cs) components[key] = { ...cs, type: layout.type };
+            }
+            return { layout: { ...layoutState, layouts }, components };
+            """)
+
+        save_path = get_results_path(f"{name}_export.json")
+        with open(save_path, "w") as f:
+            json.dump(result, f, indent=2)
+
+        self.layout.close_left_toolbar()
+        return result
+
     def snapshot_page_to_active_range(self, name: str, range_name: str) -> None:
         """Snapshot a page to the active range via context menu.