test(e2e): run a notebook cell through the labview, isolate the work dir

Adds an env-backed e2e that drives the labview WebContentsView: open a
notebook, run 1 + 1, assert the output renders. The point is the Electron
glue, not JupyterLab, so it stays at 1 + 1 (a kernel running over the
websocket Electron's net stack carries) rather than testing Python
packages. The cell handling mirrors what Galata does (textbox role +
pressSequentially, the status-bar kernel-ready check) instead of guessing
selectors, and the kernel picker is accepted only if it appears.

Also closes a gap the env-backed tests already meant to cover: new
sessions now get defaultWorkingDirectory set to the per-launch temp dir,
so notebooks the test creates land there and are cleaned up with it
rather than in the real home (on macOS HOME alone doesn't move the
session cwd).

I validated this locally against a clean jupyterlab venv: the cell test
passes repeatedly (~22s) and the home directory stays empty before and
after. jupyterlab already pulls ipykernel, so the venv has a python3
kernel without installing one separately, which I confirmed with a
jupyterlab-only venv (kernelspec lists python3).

Author: notluquis

.github/workflows/e2e.yml

@@ -81,6 +81,8 @@ jobs:
           ver=$(awk '$1=="-" && $2=="jupyterlab" {print $3}' env_installer/jlab_server.yaml)
           [[ "$ver" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]] || { echo "unexpected jupyterlab pin '$ver' in jlab_server.yaml (want exact x.y.z)"; exit 1; }
           python3 -m venv "$RUNNER_TEMP/jlab-venv"
+          # jupyterlab pulls in ipykernel, so the venv already has a python3
+          # kernel for the cell-run test; no need to install it separately.
           "$RUNNER_TEMP/jlab-venv/bin/pip" install --quiet "jupyterlab==$ver"
           echo "JLAB_TEST_PYTHON_PATH=$RUNNER_TEMP/jlab-venv/bin/python" >> "$GITHUB_ENV"
       # xvfb is Linux-only; on macOS the runner has a real display, so run the

test/e2e/helpers.ts

@@ -62,9 +62,16 @@ export async function launchApp(opts?: {
         ]
       })
     );
+    // Point new sessions at the temp jupyter dir so notebooks the test creates
+    // (New notebook) land there and get removed with it, instead of the real
+    // home. On macOS the spawned server's cwd follows this setting; HOME alone
+    // does not move it because Electron resolves home via NSHomeDirectory.
     writeFileSync(
       join(userDataDir, 'settings.json'),
-      JSON.stringify({ pythonPath: opts.pythonPath })
+      JSON.stringify({
+        pythonPath: opts.pythonPath,
+        defaultWorkingDirectory: jupyterDir
+      })
     );
   }
   try {

test/e2e/python-env.test.ts

@@ -34,3 +34,59 @@ test('with a seeded Python env, New notebook opens the labview', async () => {
     cleanup(userDataDir, jupyterDir);
   }
 });
+
+// The point of this one is the Electron glue, not JupyterLab: a notebook cell
+// evaluated through the labview WebContentsView exercises the whole embedded
+// chain (server boots, the kernel connects over the websocket Electron's net
+// stack carries, output renders back in the view). 1 + 1 is enough; testing
+// numpy here would be testing Python, not Electron.
+test('a notebook cell runs through the Electron labview', async () => {
+  test.skip(!pythonPath, NEEDS_PYTHON);
+  test.setTimeout(180000);
+  const { app, userDataDir, jupyterDir } = await launchApp({ pythonPath });
+  try {
+    const welcome = await pageByTitle(app, /welcome/i);
+    const newNotebook = welcome.locator('#new-notebook-link');
+    await expect(newNotebook).not.toHaveClass(/disabled/, { timeout: 20000 });
+    await newNotebook.click();
+
+    const lab = await pageByUrl(app, LAB_URL);
+    // With the seeded env the notebook usually picks the kernel on its own, but
+    // a kernel picker can still appear; accept it if it does, don't block if not.
+    await lab
+      .locator('.jp-Dialog button.jp-mod-accept')
+      .click({ timeout: 15000 })
+      .catch(() => undefined);
+
+    // Wait for the kernel to finish connecting before running anything, using
+    // Galata's readiness check (the status bar stops showing connecting states)
+    // rather than a fixed delay.
+    await lab.waitForFunction(
+      () => {
+        const text =
+          document.querySelector('#jp-main-statusbar')?.textContent ?? '';
+        return !['Connecting', 'Initializing', 'Starting'].some(s =>
+          text.includes(s)
+        );
+      },
+      { timeout: 90000 }
+    );
+
+    // Drive the active notebook's first cell the way Galata does: target the
+    // editor by its textbox role, replace its content, then run with Shift+Enter.
+    const cell = lab
+      .locator('.jp-NotebookPanel:not(.lm-mod-hidden) .jp-Notebook .jp-Cell')
+      .first();
+    const editor = cell.getByRole('textbox');
+    await editor.click();
+    await editor.press('Control+A');
+    await editor.pressSequentially('1 + 1');
+    await lab.keyboard.press('Shift+Enter');
+
+    const output = cell.locator('.jp-OutputArea-output').first();
+    await expect(output).toContainText('2', { timeout: 90000 });
+  } finally {
+    await app.close();
+    cleanup(userDataDir, jupyterDir);
+  }
+});