Testing

# Run all Rust tests
cargo test

# Run all TypeScript tests
pnpm test:run

# All tests
cargo test

# Specific package
cargo test -p notebook
cargo test -p runtimed

# Specific test
cargo test test_find_pyproject

# With output
cargo test -- --nocapture

# Run tests in parallel (default)
cargo test

# Run tests serially
cargo test -- --test-threads=1

# Run all tests
pnpm test:run

# Watch mode (re-run on changes)
pnpm test

# Specific test file
pnpm test:run src/components/Cell.test.tsx

# Run a single fixture test
./e2e/dev.sh test-fixture \
  crates/notebook/fixtures/audit-test/1-vanilla.ipynb \
  e2e/specs/vanilla-startup.spec.js

# Run all fixture tests (fresh app per test)
./e2e/dev.sh test-fixtures

# Run all tests in Docker
pnpm test:e2e:docker

# Interactive debugging shell
docker compose --profile dev run --rm tauri-e2e-shell

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_dependencies() {
        let deps = vec!["pandas".to_string(), "numpy".to_string()];
        let result = parse_dependencies(&deps);
        assert!(result.is_ok());
    }

    #[tokio::test]
    async fn test_async_function() {
        let result = fetch_data().await;
        assert!(result.is_ok());
    }
}

import { describe, it, expect } from 'vitest';
import { render, screen } from '@testing-library/react';
import { Cell } from './Cell';

describe('Cell', () => {
  it('renders code cell', () => {
    render(<Cell type="code" />);
    expect(screen.getByRole('textbox')).toBeInTheDocument();
  });
});

/**
 * E2E Test: Cell Execution (Regular)
 * 
 * Tests basic cell execution flow.
 */
import { browser, expect } from "@wdio/globals";
import { waitForKernelReady, setupCodeCell, typeSlowly } from "../helpers.js";

describe("Cell Execution", () => {
  before(async () => {
    await waitForKernelReady();
  });

  it("should execute a code cell", async () => {
    const cell = await setupCodeCell();
    await typeSlowly('print("hello")');
    await browser.keys(["Shift", "Enter"]);

    await browser.waitUntil(async () => {
      const output = await $('[data-slot="ansi-stream-output"]');
      return output.isExisting();
    }, { timeout: 30000 });

    const text = await $('[data-slot="ansi-stream-output"]').getText();
    expect(text).toContain("hello");
  });
});

/**
 * E2E Test: UV Inline Dependencies (Fixture)
 * 
 * Tests UV inline dependency resolution and installation.
 * 
 * Requires: NOTEBOOK_PATH=crates/notebook/fixtures/audit-test/2-uv-inline.ipynb
 */
import { browser, expect } from "@wdio/globals";
import { waitForAppReady, approveTrustDialog } from "../helpers.js";

describe("UV Inline Dependencies", () => {
  before(async () => {
    await waitForAppReady();
  });

  it("should show trust dialog for inline deps", async () => {
    const dialog = await $('[data-testid="trust-dialog"]');
    await dialog.waitForExist({ timeout: 5000 });
    expect(await dialog.isDisplayed()).toBe(true);
  });

  it("should install deps after approval", async () => {
    await approveTrustDialog();
    
    await browser.waitUntil(async () => {
      const status = await getKernelStatus();
      return status === "idle";
    }, { timeout: 120000 });
  });
});

import {
  waitForAppReady,
  waitForKernelReady,
  executeFirstCell,
  waitForCellOutput,
  typeSlowly,
  setupCodeCell,
} from "../helpers.js";

<button
  onClick={handleClick}
  data-testid="my-feature-button"
>
  Click me
</button>

// BAD — returns broken element reference
const button = await $("button*=Code");
await button.click(); // "Malformed type for elementId parameter"

// GOOD — use data-testid
const button = await $('[data-testid="add-code-cell-button"]');
await button.click();

async function evalInIframe(code, timeout = 10000) {
  await browser.execute((code) => {
    window.__iframeEvalResult = undefined;
    window.__iframeEvalDone = false;

    window.addEventListener("message", function handler(event) {
      if (event.data?.type === "eval_result") {
        window.__iframeEvalResult = event.data.payload;
        window.__iframeEvalDone = true;
        window.removeEventListener("message", handler);
      }
    });

    const iframe = document.querySelector('iframe[title="Isolated output frame"]');
    iframe?.contentWindow?.postMessage(
      { type: "eval", payload: { code } }, "*"
    );
  }, code);

  await browser.waitUntil(
    async () => await browser.execute(() => window.__iframeEvalDone === true),
    { timeout }
  );

  return await browser.execute(() => window.__iframeEvalResult);
}

// BAD — 404 in wry
const result = await browser.executeAsync((done) => {
  setTimeout(() => done("value"), 100);
});

// GOOD — polling pattern
await browser.execute(() => {
  window.__myResult = undefined;
  setTimeout(() => { window.__myResult = "value"; }, 100);
});
await browser.waitUntil(
  async () => await browser.execute(() => window.__myResult !== undefined),
  { timeout: 5000 }
);
const result = await browser.execute(() => window.__myResult);

// BAD — fragile: daemon may have already set theme
it("should start with system theme", async () => {
  const theme = await getThemeSetting();
  expect(theme).toBe("system"); // fails if daemon set it to "dark"
});

// GOOD — tests the observable effect of an action
it("should apply dark class when clicking Dark", async () => {
  // Click Dark (regardless of initial state)
  await browser.execute(() => {
    const buttons = document.querySelectorAll('[data-testid="settings-theme-group"] button');
    for (const btn of buttons) {
      if (btn.textContent?.includes("Dark")) {
        btn.click();
        break;
      }
    }
  });

  // Assert the observable DOM effect
  await browser.waitUntil(async () => {
    return await browser.execute(() =>
      document.documentElement.classList.contains("dark")
    );
  });
});

import { typeSlowly, setupCodeCell } from "../helpers.js";

const cell = await setupCodeCell();
await typeSlowly('print("hello")');
await browser.keys(["Shift", "Enter"]);

console.log("Step completed:", someValue);

console.log("Title:", await browser.getTitle());
const html = await browser.getPageSource();

const result = await browser.execute(() => {
  return document.querySelector('[data-cell-type]')?.outerHTML;
});

await browser.pause(5000);

# Quick JS evaluation
./e2e/dev.sh exec 'return document.title'

# Check if WebDriver is up
./e2e/dev.sh status

./e2e/dev.sh build       # Fast: recompiles Rust only
./e2e/dev.sh build-full  # Full: rebuilds frontend + Rust

# Terminal 1
./e2e/dev.sh start

# Terminal 2
./e2e/dev.sh test