@marimo-team/islands 0.25.3-dev170 → 0.25.3-dev175

package/src/core/cells/__tests__/document.test.ts

@@ -29,7 +29,12 @@ import {
   type NotebookState,
   notebookReducer,
 } from "../cells";
-import { applyDocument, flushDocument, withDocumentSave } from "../document";
+import {
+  applyDocument,
+  flushDocument,
+  followDocument,
+  withDocumentSave,
+} from "../document";
 import { type CellId, SCRATCH_CELL_ID } from "../ids";
 
 vi.mock("../../rtc/state", async (importOriginal) => ({
@@ -102,9 +107,10 @@ describe("applyDocument", () => {
     expect(state.cellData[a]).toMatchObject({
       code: "a = 1",
       name: "_",
-      edited: false,
+      edited: true,
       lastCodeRun: null,
     });
+    expect(state.cellData[b].edited).toBe(false);
     expect(state.cellRuntime[a]).toBeDefined();
     expect(state.cellHandles[a]).toBeDefined();
     expect(state.cellData[SCRATCH_CELL_ID]).toBeDefined();
@@ -185,7 +191,7 @@ describe("applyDocument", () => {
     expect(next.cellData[a]).toMatchObject({
       name: "renamed",
       config: { hide_code: true },
-      edited: false,
+      edited: true,
     });
   });
 
@@ -277,45 +283,14 @@ describe("documentEditMiddleware", () => {
     store.set(activeDocumentModelAtom, null);
   });
 
-  it("creates a cell at the end without setting the order", () => {
-    actions.createNewCell({
-      cellId: c,
-      before: false,
-      code: "d = 1",
-      newCellId: d,
-    });
-
-    expect(calls.map((call) => call[0])).toEqual(["createCell"]);
-    expect(calls[0][1]).toMatchObject({ id: d, code: "d = 1" });
-  });
-
-  it("creates a cell elsewhere and sets the order", () => {
-    actions.createNewCell({ cellId: a, before: true, newCellId: d });
-
-    expect(calls.map((call) => call[0])).toEqual(["createCell", "setOrder"]);
-    expect(calls[1][1]).toEqual([d, a, b, c]);
-  });
-
-  it("deletes a cell", () => {
-    actions.deleteCell({ cellId: b });
-
-    expect(calls).toEqual([["deleteCell", b]]);
-  });
-
-  it("writes code, name, and config", () => {
+  it("writes code", () => {
     actions.updateCellCode({
       cellId: a,
       code: "a = 2",
       formattingChange: false,
     });
-    actions.updateCellName({ cellId: a, name: "first" });
-    actions.updateCellConfig({ cellId: a, config: { hide_code: true } });
 
-    expect(calls).toEqual([
-      ["setCode", a, "a = 2"],
-      ["setName", a, "first"],
-      ["updateConfig", a, { hide_code: true }],
-    ]);
+    expect(calls).toEqual([["setCode", a, "a = 2"]]);
   });
 
   it("sets the order when a cell moves", () => {
@@ -349,9 +324,14 @@ describe("documentEditMiddleware", () => {
     expect(calls).toEqual([["updateConfig", c, { column: null }]]);
   });
 
-  it("ignores the kernel's cells and runtime state", () => {
+  it("ignores the document and the kernel's run state", () => {
     actions.prepareForRun({ cellId: a });
-    actions.setCells([state.cellData[a]]);
+    actions.setLastRun({
+      lastCodeRun: { [a]: "a = 0" },
+      lastExecutionTime: {},
+    });
+    actions.resetCellRuntimes();
+    actions.reconcileDocument(documentOf([cell(a)]));
 
     expect(calls).toEqual([]);
   });
@@ -367,6 +347,30 @@ describe("documentEditMiddleware", () => {
   });
 });
 
+describe("followDocument", () => {
+  it("reconciles the document now and on each change, until aborted", () => {
+    const documentAtom = atom<EditableDocument | null>(null);
+    const reconcile = vi.fn();
+    const controller = new AbortController();
+
+    followDocument({
+      store,
+      model: { documentAtom },
+      reconcile,
+      signal: controller.signal,
+    });
+    expect(reconcile).not.toHaveBeenCalled();
+
+    const first = documentOf([cell(a)]);
+    store.set(documentAtom, first);
+    expect(reconcile).toHaveBeenCalledWith(first);
+
+    controller.abort();
+    store.set(documentAtom, documentOf([cell(b)]));
+    expect(reconcile).toHaveBeenCalledOnce();
+  });
+});
+
 describe("flushing before host commands", () => {
   const model = {
     syncStatusAtom: atom<DocumentSyncStatus>({ status: "idle" }),

package/src/core/cells/__tests__/notebook-outline.test.ts

@@ -4,6 +4,7 @@ import { createStore } from "jotai";
 import { describe, expect, it, vi } from "vitest";
 import { MockNotebook } from "@/__mocks__/notebook";
 import { cellId } from "@/__tests__/branded";
+import { CONFIG } from "@/core/notebook/document/__tests__/fixtures";
 import {
   createNotebookActions,
   notebookAtom,
@@ -84,7 +85,12 @@ describe("notebookOutline", () => {
       items: [...secondOutline.items, ...firstOutline.items],
     });
 
-    actions.deleteCell({ cellId: second });
+    actions.reconcileDocument({
+      order: [first],
+      cells: new Map([
+        [first, { id: first, code: "x = 1", name: "_", config: CONFIG }],
+      ]),
+    });
     expect(store.get(notebookOutline)).toEqual(firstOutline);
   });
 

package/src/core/cells/__tests__/outputs.test.tsx

@@ -2,116 +2,134 @@
 
 import { act, renderHook } from "@testing-library/react";
 import { createStore, Provider } from "jotai";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { MockNotebook } from "@/__mocks__/notebook";
-import { notebookAtom } from "@/core/cells/cells";
+import { afterEach, describe, expect, it } from "vitest";
+import { mockDocumentModel } from "@/__mocks__/document";
 import { CellId } from "@/core/cells/ids";
+import { DocumentProvider } from "@/core/notebook/document";
+import {
+  cell,
+  CONFIG,
+  document as documentOf,
+  withCells,
+} from "@/core/notebook/document/__tests__/fixtures";
 import { type AppMode, viewStateAtom } from "@/core/mode";
 import { useExpandedConsoleOutput, useExpandedOutput } from "../outputs";
 
-const saveCellConfig = vi.fn().mockResolvedValue(null);
+const stops: Array<() => void> = [];
 
-vi.mock("@/core/network/requests", () => ({
-  getRequestClient: () => ({ saveCellConfig }),
-}));
+afterEach(() => {
+  for (const stop of stops.splice(0)) {
+    stop();
+  }
+});
 
 function setup(opts: { mode: AppMode; expandOutput?: boolean }) {
   const cellId = CellId.create();
   const store = createStore();
-  store.set(
-    notebookAtom,
-    MockNotebook.notebookState({
-      cellData: {
-        [cellId]: { config: { expand_output: opts.expandOutput ?? false } },
+  const { model, stop } = mockDocumentModel(
+    store,
+    withCells(
+      documentOf(),
+      {
+        c1: null,
+        c2: null,
+        [cellId]: cell(cellId, "", {
+          config: { ...CONFIG, expand_output: opts.expandOutput ?? false },
+        }),
       },
-    }),
+      [cellId],
+    ),
   );
+  stops.push(stop);
   store.set(viewStateAtom, { mode: opts.mode, cellAnchor: null });
 
-  const { result } = renderHook(() => useExpandedOutput(cellId), {
-    wrapper: ({ children }) => <Provider store={store}>{children}</Provider>,
-  });
+  const wrapper = ({ children }: { children: React.ReactNode }) => (
+    <Provider store={store}>
+      <DocumentProvider model={model}>{children}</DocumentProvider>
+    </Provider>
+  );
+  const expanded = () =>
+    store.get(model.documentAtom)?.cells.get(cellId)?.config.expand_output;
 
-  return { cellId, store, result };
+  return { cellId, store, wrapper, expanded };
 }
 
-const configOf = (store: ReturnType<typeof createStore>, cellId: CellId) =>
-  store.get(notebookAtom).cellData[cellId].config;
-
 describe("useExpandedOutput", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
   it("reads the initial state from the cell's expand_output config", () => {
-    expect(setup({ mode: "edit" }).result.current[0]).toBe(false);
-    expect(setup({ mode: "edit", expandOutput: true }).result.current[0]).toBe(
-      true,
-    );
+    const collapsed = setup({ mode: "edit" });
+    expect(
+      renderHook(() => useExpandedOutput(collapsed.cellId), {
+        wrapper: collapsed.wrapper,
+      }).result.current[0],
+    ).toBe(false);
+
+    const expanded = setup({ mode: "edit", expandOutput: true });
+    expect(
+      renderHook(() => useExpandedOutput(expanded.cellId), {
+        wrapper: expanded.wrapper,
+      }).result.current[0],
+    ).toBe(true);
   });
 
   it("persists the toggle to the cell's config in edit mode", () => {
-    const { cellId, store, result } = setup({ mode: "edit" });
+    const { cellId, wrapper, expanded } = setup({ mode: "edit" });
+    const { result } = renderHook(() => useExpandedOutput(cellId), {
+      wrapper,
+    });
 
     act(() => result.current[1](true));
 
     expect(result.current[0]).toBe(true);
-    expect(configOf(store, cellId).expand_output).toBe(true);
-    expect(saveCellConfig).toHaveBeenCalledWith({
-      configs: { [cellId]: { expand_output: true } },
-    });
+    expect(expanded()).toBe(true);
   });
 
   it("collapses by clearing the config", () => {
-    const { cellId, store, result } = setup({
+    const { cellId, wrapper, expanded } = setup({
       mode: "edit",
       expandOutput: true,
     });
+    const { result } = renderHook(() => useExpandedOutput(cellId), {
+      wrapper,
+    });
 
     act(() => result.current[1](false));
 
     expect(result.current[0]).toBe(false);
-    expect(configOf(store, cellId).expand_output).toBe(false);
-    expect(saveCellConfig).toHaveBeenCalledWith({
-      configs: { [cellId]: { expand_output: false } },
-    });
+    expect(expanded()).toBe(false);
   });
 
   it("keeps the toggle in memory outside of edit mode", () => {
-    const { cellId, store, result } = setup({ mode: "read" });
+    const { cellId, wrapper, expanded } = setup({ mode: "read" });
+    const { result } = renderHook(() => useExpandedOutput(cellId), {
+      wrapper,
+    });
 
     act(() => result.current[1](true));
 
     expect(result.current[0]).toBe(true);
     // Cell configs are read-only outside of edit mode.
-    expect(configOf(store, cellId).expand_output).toBe(false);
-    expect(saveCellConfig).not.toHaveBeenCalled();
+    expect(expanded()).toBe(false);
   });
 
   it("still honors expand_output outside of edit mode", () => {
-    const { result } = setup({ mode: "read", expandOutput: true });
+    const { cellId, wrapper } = setup({ mode: "read", expandOutput: true });
+    const { result } = renderHook(() => useExpandedOutput(cellId), {
+      wrapper,
+    });
     expect(result.current[0]).toBe(true);
   });
 
   // `expand_output` covers the cell's output area only. Console output is
   // clamped independently and stays an in-memory, per-session toggle.
   it("does not touch the config when console output is expanded", () => {
-    const cellId = CellId.create();
-    const store = createStore();
-    store.set(
-      notebookAtom,
-      MockNotebook.notebookState({ cellData: { [cellId]: {} } }),
-    );
-    store.set(viewStateAtom, { mode: "edit", cellAnchor: null });
-
+    const { cellId, wrapper, expanded } = setup({ mode: "edit" });
     const { result } = renderHook(() => useExpandedConsoleOutput(cellId), {
-      wrapper: ({ children }) => <Provider store={store}>{children}</Provider>,
+      wrapper,
     });
 
     act(() => result.current[1](true));
 
     expect(result.current[0]).toBe(true);
-    expect(configOf(store, cellId).expand_output).toBe(false);
-    expect(saveCellConfig).not.toHaveBeenCalled();
+    expect(expanded()).toBe(false);
   });
 });