Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

34.9 KB
Raw Blame
import { create } from "@bufbuild/protobuf";
import { act } from "react";
import { createRoot, type Root } from "react-dom/client";
import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
import {
  SavedQuerySchema,
  type SavedQuery,
} from "@/types/proto-es/v1/saved_query_service_pb";
import {
  storageKeySqlEditorSavedQueryFilter,
  storageKeySqlEditorSavedQueryFolder,
} from "@/utils";

type AppState = {
  currentUser: { email: string; workspace: string };
  savedQueriesByKey: Record<string, SavedQuery>;
  isSaaSMode: () => boolean;
  getSavedQueryByName: (name: string) => SavedQuery | undefined;
  patchSavedQueryFolderInCache: ReturnType<typeof vi.fn>;
  searchSavedQueryFolders: ReturnType<typeof vi.fn>;
  fetchSavedQueryList: ReturnType<typeof vi.fn>;
  updateSavedQueryStar: ReturnType<typeof vi.fn>;
  moveMySavedQueries: ReturnType<typeof vi.fn>;
  patchSavedQuery: ReturnType<typeof vi.fn>;
};

const mocks = vi.hoisted(() => {
  let appState: AppState;
  const isSavedQueryWritableV1 = vi.fn();
  const appSubscribers = new Set<(state: AppState, prev: AppState) => void>();
  const keyForSavedQuery = (name: string) => `${name.split("/").pop()}:FULL`;

  const setSavedQueries = (savedQueries: SavedQuery[]) => {
    const prev = {
      ...appState,
      savedQueriesByKey: appState.savedQueriesByKey,
    };
    appState = {
      ...appState,
      savedQueriesByKey: {
        ...appState.savedQueriesByKey,
        ...Object.fromEntries(
          savedQueries.map((savedQuery) => [
            keyForSavedQuery(savedQuery.name),
            savedQuery,
          ])
        ),
      },
    };
    for (const subscriber of appSubscribers) {
      subscriber(appState, prev);
    }
  };

  return {
    getAppState: () => appState,
    isSavedQueryWritableV1,
    resetAppState: () => {
      appSubscribers.clear();
      appState = {
        currentUser: {
          email: "[email protected]",
          workspace: "workspaces/default",
        },
        savedQueriesByKey: {},
        isSaaSMode: () => false,
        getSavedQueryByName: (name: string) =>
          appState.savedQueriesByKey[keyForSavedQuery(name)],
        searchSavedQueryFolders: vi.fn(async () => []),
        fetchSavedQueryList: vi.fn(async (_project, _filter, _params) => {
          const savedQuery = create(SavedQuerySchema, {
            name: "projects/proj1/savedQueries/1",
            project: "projects/proj1",
            creator: "users/[email protected]",
            title: "Existing saved query",
          });
          setSavedQueries([savedQuery]);
          return { savedQueries: [savedQuery], nextPageToken: "next-page" };
        }),
        updateSavedQueryStar: vi.fn(),
        moveMySavedQueries: vi.fn(async () => 0),
        patchSavedQuery: vi.fn(async () => undefined),
        patchSavedQueryFolderInCache: vi.fn(),
      };
    },
    addSavedQueries: setSavedQueries,
    useAppStore: {
      getState: () => appState,
      subscribe: (subscriber: (state: AppState, prev: AppState) => void) => {
        appSubscribers.add(subscriber);
        return () => appSubscribers.delete(subscriber);
      },
    },
    getSQLEditorTabsState: vi.fn(() => ({
      currentTabId: "",
      openTmpTabList: [],
      tabsById: new Map(),
    })),
    subscribeSQLEditorEditorState: vi.fn(),
    subscribeSQLEditorTabsState: vi.fn(),
  };
});

vi.mock("@/lib/i18n", () => ({
  default: { t: (key: string) => key },
}));

vi.mock("@/stores/app", () => ({
  useAppStore: mocks.useAppStore,
}));

// The real predicate reads registration bridges the mocked store never
// installs, so it is stubbed; the default (set in beforeEach) mirrors its
// creator arm.
vi.mock("@/utils", async (importOriginal) => ({
  ...(await importOriginal<typeof import("@/utils")>()),
  isSavedQueryWritableV1: mocks.isSavedQueryWritableV1,
}));

vi.mock("@/modules/sql-editor/store/editor", () => ({
  getSQLEditorEditorState: () => ({ project: "projects/proj1" }),
  subscribeSQLEditorEditorState: mocks.subscribeSQLEditorEditorState,
  useSQLEditorEditorStore: vi.fn(),
}));

vi.mock("@/modules/sql-editor/store/tab", () => ({
  getSQLEditorTabsState: mocks.getSQLEditorTabsState,
  subscribeSQLEditorTabsState: mocks.subscribeSQLEditorTabsState,
  useSQLEditorTabsStore: vi.fn(),
}));

describe("sheet context", () => {
  let root: Root;
  let container: HTMLDivElement;

  beforeEach(() => {
    vi.useFakeTimers();
    mocks.resetAppState();
    mocks.isSavedQueryWritableV1.mockImplementation(
      (sheet: SavedQuery) => sheet.creator === "users/[email protected]"
    );
    window.localStorage.clear();
    container = document.createElement("div");
    document.body.appendChild(container);
  });

  afterEach(() => {
    root?.unmount();
    container.remove();
    vi.useRealTimers();
    vi.resetModules();
  });

  test("adds newly created saved queries to the initialized paged my view", async () => {
    const { provideSheetContext, useSheetContextByView } = await import(
      "./context"
    );
    let viewContext: ReturnType<typeof useSheetContextByView> | undefined;

    const Probe = () => {
      provideSheetContext();
      viewContext = useSheetContextByView("my");
      return (
        <div>
          {viewContext.sheetTree.children.map((child) => child.label).join(",")}
        </div>
      );
    };

    root = createRoot(container);
    await act(async () => {
      root.render(<Probe />);
    });

    await act(async () => {
      await viewContext!.fetchSheetList();
    });

    expect(container.textContent).toContain("Existing saved query");
    expect(viewContext!.sheetTree.children.map((child) => child.label)).toContain(
      "common.load-more"
    );
    expect(viewContext!.folderTree.children.map((child) => child.label)).not.toContain(
      "common.load-more"
    );

    mocks.addSavedQueries([
      create(SavedQuerySchema, {
        name: "projects/proj1/savedQueries/2",
        project: "projects/proj1",
        creator: "users/[email protected]",
        title: "Created saved query",
      }),
    ]);
    await act(async () => {
      vi.runAllTimers();
    });

    expect(container.textContent).toContain("Created saved query");
  });

  test("does not restore saved query filter from localStorage", async () => {
    window.localStorage.setItem(
      storageKeySqlEditorSavedQueryFilter(
        "",
        "projects/proj1",
        "[email protected]"
      ),
      JSON.stringify({
        keyword: "payroll",
        showMine: true,
        showShared: false,
        showDraft: true,
        onlyShowStarred: true,
      })
    );

    const { provideSheetContext, useSheetContext } = await import("./context");
    let sheetContext: ReturnType<typeof useSheetContext> | undefined;

    const Probe = () => {
      provideSheetContext();
      sheetContext = useSheetContext();
      return null;
    };

    root = createRoot(container);
    await act(async () => {
      root.render(<Probe />);
    });

    expect(sheetContext!.filter).toEqual({
      keyword: "",
      showMine: true,
      showShared: true,
      showDraft: true,
      onlyShowStarred: false,
    });
  });

  test("does not persist saved query filter to localStorage", async () => {
    const key = storageKeySqlEditorSavedQueryFilter(
      "",
      "projects/proj1",
      "[email protected]"
    );

    const { provideSheetContext, useSheetContext } = await import("./context");
    let sheetContext: ReturnType<typeof useSheetContext> | undefined;

    const Probe = () => {
      provideSheetContext();
      sheetContext = useSheetContext();
      return null;
    };

    root = createRoot(container);
    await act(async () => {
      root.render(<Probe />);
    });

    act(() => {
      sheetContext!.setFilter({
        ...sheetContext!.filter,
        keyword: "payroll",
        onlyShowStarred: true,
      });
    });

    expect(window.localStorage.getItem(key)).toBeNull();
  });

  test("uses a collision-free key for load-more rows", async () => {
    mocks.getAppState().searchSavedQueryFolders.mockResolvedValueOnce([
      "__load-more",
    ]);

    const { provideSheetContext, useSheetContextByView } = await import(
      "./context"
    );
    let viewContext: ReturnType<typeof useSheetContextByView> | undefined;

    const Probe = () => {
      provideSheetContext();
      viewContext = useSheetContextByView("my");
      return null;
    };

    root = createRoot(container);
    await act(async () => {
      root.render(<Probe />);
    });

    await act(async () => {
      await viewContext!.fetchSheetList();
    });

    const keys = viewContext!.sheetTree.children.map((child) => child.key);
    expect(keys).toContain("/my/__load-more");
    expect(keys).toContain("__savedQuery_load_more__:/my");
  });

  test("loads caller saved query folders before the root saved query page", async () => {
    mocks
      .getAppState()
      .searchSavedQueryFolders.mockResolvedValueOnce(["alpha", "alpha/beta"]);
    mocks.getAppState().fetchSavedQueryList.mockImplementationOnce(async () => ({
      savedQueries: [],
      nextPageToken: "",
    }));

    const { provideSheetContext, useSheetContextByView } = await import(
      "./context"
    );
    let viewContext: ReturnType<typeof useSheetContextByView> | undefined;

    const Probe = () => {
      provideSheetContext();
      viewContext = useSheetContextByView("my");
      return (
        <div>
          {viewContext.sheetTree.children.map((child) => child.label).join(",")}
        </div>
      );
    };

    root = createRoot(container);
    await act(async () => {
      root.render(<Probe />);
    });
    await act(async () => {
      await viewContext!.fetchSheetList();
    });

    expect(mocks.getAppState().searchSavedQueryFolders).toHaveBeenCalledWith(
      "projects/proj1",
      'creator == "users/[email protected]"'
    );
    expect(mocks.getAppState().fetchSavedQueryList).toHaveBeenCalledWith(
      "projects/proj1",
      'creator == "users/[email protected]" && folder == ""',
      expect.objectContaining({ pageToken: "" })
    );
    expect(container.textContent).toContain("alpha");
    expect(container.textContent).not.toContain("shared");
  });

  test("builds the shared folder tree from the server, not the row cache", async () => {
    // Regression: deriving shared folders from cached rows found nothing on a
    // cold cache, because the root page only fetches unfiled rows -- so every
    // foldered shared saved query was unreachable.
    mocks
      .getAppState()
      .searchSavedQueryFolders.mockResolvedValueOnce(["theirs", "theirs/deep"]);
    mocks.getAppState().fetchSavedQueryList.mockImplementationOnce(async () => ({
      savedQueries: [],
      nextPageToken: "",
    }));

    const { provideSheetContext, useSheetContextByView } = await import(
      "./context"
    );
    let viewContext: ReturnType<typeof useSheetContextByView> | undefined;

    const Probe = () => {
      provideSheetContext();
      viewContext = useSheetContextByView("shared");
      return (
        <div>
          {viewContext.sheetTree.children.map((child) => child.label).join(",")}
        </div>
      );
    };

    root = createRoot(container);
    await act(async () => {
      root.render(<Probe />);
    });
    await act(async () => {
      await viewContext!.fetchSheetList();
    });

    // Shared is "reached through a binding", not "somebody else created it":
    // the latter also matches saved queries an admin can read but nobody
    // shared with them.
    expect(mocks.getAppState().searchSavedQueryFolders).toHaveBeenCalledWith(
      "projects/proj1",
      "shared == true"
    );
    expect(container.textContent).toContain("theirs");
  });

  test("merges persisted empty folders with backend folders", async () => {
    window.localStorage.setItem(
      storageKeySqlEditorSavedQueryFolder(
        "",
        "projects/proj1",
        "shared",
        "[email protected]"
      ),
      JSON.stringify(["/shared/alpha", "/shared/local-empty"])
    );
    mocks.getAppState().fetchSavedQueryList.mockImplementationOnce(async () => ({
      savedQueries: [],
      nextPageToken: "",
    }));

    const { provideSheetContext, useSheetContextByView } = await import(
      "./context"
    );
    let viewContext: ReturnType<typeof useSheetContextByView> | undefined;

    const Probe = () => {
      provideSheetContext();
      viewContext = useSheetContextByView("shared");
      return (
        <div>
          {viewContext.sheetTree.children.map((child) => child.label).join(",")}
        </div>
      );
    };

    root = createRoot(container);
    await act(async () => {
      root.render(<Probe />);
    });
    await act(async () => {
      await viewContext!.fetchSheetList();
    });

    expect(container.textContent).toContain("alpha");
    expect(container.textContent).toContain("local-empty");
  });

  test("persists locally created empty folders", async () => {
    const { provideSheetContext, useSheetContextByView } = await import(
      "./context"
    );
    let viewContext: ReturnType<typeof useSheetContextByView> | undefined;

    const Probe = () => {
      provideSheetContext();
      viewContext = useSheetContextByView("my");
      return null;
    };

    root = createRoot(container);
    await act(async () => {
      root.render(<Probe />);
    });

    act(() => {
      viewContext!.folderContext.addFolder("/my/local-empty");
    });

    expect(
      JSON.parse(
        window.localStorage.getItem(
          storageKeySqlEditorSavedQueryFolder(
            "",
            "projects/proj1",
            "my",
            "[email protected]"
          )
        ) ?? "[]"
      )
    ).toEqual(["/my/local-empty"]);
  });

  test("uses server-side keyword and starred filters when fetching saved queries", async () => {
    const { provideSheetContext, useSheetContext, useSheetContextByView } =
      await import("./context");
    let sheetContext: ReturnType<typeof useSheetContext> | undefined;
    let viewContext: ReturnType<typeof useSheetContextByView> | undefined;

    const Probe = () => {
      provideSheetContext();
      sheetContext = useSheetContext();
      viewContext = useSheetContextByView("my");
      return null;
    };

    root = createRoot(container);
    await act(async () => {
      root.render(<Probe />);
    });
    await act(async () => {
      await viewContext!.fetchSheetList();
    });
    mocks.getAppState().fetchSavedQueryList.mockClear();

    act(() => {
      sheetContext!.setFilter({
        ...sheetContext!.filter,
        keyword: "Payroll",
        onlyShowStarred: true,
      });
    });
    await act(async () => {
      await vi.runAllTimersAsync();
    });

    expect(mocks.getAppState().fetchSavedQueryList).toHaveBeenLastCalledWith(
      "projects/proj1",
      'creator == "users/[email protected]" && folder == "" && title.contains("payroll") && starred == true',
      expect.objectContaining({ pageToken: "" })
    );

    mocks.getAppState().fetchSavedQueryList.mockClear();
    await act(async () => {
      await viewContext!.fetchNextPage();
    });

    expect(mocks.getAppState().fetchSavedQueryList).toHaveBeenLastCalledWith(
      "projects/proj1",
      'creator == "users/[email protected]" && folder == "" && title.contains("payroll") && starred == true',
      expect.objectContaining({ pageToken: "next-page" })
    );
  });

  test("keeps backend-known folders visible when starred filter is active", async () => {
    mocks
      .getAppState()
      .searchSavedQueryFolders.mockResolvedValue(["alpha"]);
    mocks.getAppState().fetchSavedQueryList.mockResolvedValue({
      savedQueries: [],
      nextPageToken: "",
    });

    const { provideSheetContext, useSheetContext, useSheetContextByView } =
      await import("./context");
    let sheetContext: ReturnType<typeof useSheetContext> | undefined;
    let viewContext: ReturnType<typeof useSheetContextByView> | undefined;

    const Probe = () => {
      provideSheetContext();
      sheetContext = useSheetContext();
      viewContext = useSheetContextByView("my");
      return (
        <div>
          {viewContext.sheetTree.children.map((child) => child.label).join(",")}
        </div>
      );
    };

    root = createRoot(container);
    await act(async () => {
      root.render(<Probe />);
    });
    await act(async () => {
      await viewContext!.fetchSheetList();
    });
    mocks.getAppState().fetchSavedQueryList.mockClear();

    act(() => {
      sheetContext!.setFilter({
        ...sheetContext!.filter,
        onlyShowStarred: true,
      });
    });
    await act(async () => {
      await vi.runAllTimersAsync();
    });

    expect(mocks.getAppState().fetchSavedQueryList).toHaveBeenLastCalledWith(
      "projects/proj1",
      'creator == "users/[email protected]" && folder == "" && starred == true',
      expect.objectContaining({ pageToken: "" })
    );
    expect(container.textContent).toContain("alpha");
  });

  test("fetches saved query descendants for a folder without replacing the paged view", async () => {
    const { provideSheetContext, useSheetContextByView } = await import(
      "./context"
    );
    let viewContext: ReturnType<typeof useSheetContextByView> | undefined;

    const Probe = () => {
      provideSheetContext();
      viewContext = useSheetContextByView("my");
      return (
        <div>
          {viewContext.sheetTree.children.map((child) => child.label).join(",")}
        </div>
      );
    };

    root = createRoot(container);
    await act(async () => {
      root.render(<Probe />);
    });
    await act(async () => {
      await viewContext!.fetchSheetList();
    });

    mocks.getAppState().fetchSavedQueryList.mockImplementationOnce(async () => {
      const savedQuery = create(SavedQuerySchema, {
          name: "projects/proj1/savedQueries/3",
          project: "projects/proj1",
          creator: "users/[email protected]",
          title: "Folder saved query",
          folder: "alpha",
        });
      mocks.addSavedQueries([savedQuery]);
      return {
        savedQueries: [savedQuery],
        nextPageToken: "",
      };
    });

    await act(async () => {
      await viewContext!.fetchSavedQueriesByFolder("/my/alpha");
    });

    expect(mocks.getAppState().fetchSavedQueryList).toHaveBeenLastCalledWith(
      "projects/proj1",
      'creator == "users/[email protected]" && folder == "alpha"',
      expect.objectContaining({ pageToken: "" })
    );
    expect(container.textContent).toContain("Existing saved query");
    expect(container.textContent).toContain("alpha");
  });

  test("fetches the next page for a folder without using the root page token", async () => {
    const { provideSheetContext, useSheetContextByView } = await import(
      "./context"
    );
    let viewContext: ReturnType<typeof useSheetContextByView> | undefined;

    const Probe = () => {
      provideSheetContext();
      viewContext = useSheetContextByView("my");
      return null;
    };

    root = createRoot(container);
    await act(async () => {
      root.render(<Probe />);
    });
    await act(async () => {
      await viewContext!.fetchSheetList();
    });

    mocks.getAppState().fetchSavedQueryList.mockImplementationOnce(async () => {
      const savedQuery = create(SavedQuerySchema, {
        name: "projects/proj1/savedQueries/3",
        project: "projects/proj1",
        creator: "users/[email protected]",
        title: "Folder saved query",
        folder: "alpha",
      });
      mocks.addSavedQueries([savedQuery]);
      return {
        savedQueries: [savedQuery],
        nextPageToken: "folder-next",
      };
    });
    await act(async () => {
      await viewContext!.fetchSavedQueriesByFolder("/my/alpha");
    });

    const alpha = viewContext!.sheetTree.children.find(
      (child) => child.key === "/my/alpha"
    );
    expect(alpha?.children.map((child) => child.label)).toContain(
      "common.load-more"
    );

    mocks.getAppState().fetchSavedQueryList.mockImplementationOnce(async () => ({
      savedQueries: [],
      nextPageToken: "",
    }));
    await act(async () => {
      await viewContext!.fetchNextPage("/my/alpha");
    });

    expect(mocks.getAppState().fetchSavedQueryList).toHaveBeenLastCalledWith(
      "projects/proj1",
      'creator == "users/[email protected]" && folder == "alpha"',
      expect.objectContaining({ pageToken: "folder-next" })
    );
  });

  test("appends newly fetched saved query pages without frontend reordering", async () => {
    const firstSavedQuery = create(SavedQuerySchema, {
      name: "projects/proj1/savedQueries/first",
      project: "projects/proj1",
      creator: "users/[email protected]",
      title: "Zeta saved query",
    });
    mocks.getAppState().fetchSavedQueryList.mockImplementationOnce(async () => {
      mocks.addSavedQueries([firstSavedQuery]);
      return {
        savedQueries: [firstSavedQuery],
        nextPageToken: "next-page",
      };
    });

    const { provideSheetContext, useSheetContextByView } = await import(
      "./context"
    );
    let viewContext: ReturnType<typeof useSheetContextByView> | undefined;

    const Probe = () => {
      provideSheetContext();
      viewContext = useSheetContextByView("my");
      return null;
    };

    root = createRoot(container);
    await act(async () => {
      root.render(<Probe />);
    });
    await act(async () => {
      await viewContext!.fetchSheetList();
    });

    const secondSavedQuery = create(SavedQuerySchema, {
      name: "projects/proj1/savedQueries/second",
      project: "projects/proj1",
      creator: "users/[email protected]",
      title: "Alpha saved query",
    });
    mocks.getAppState().fetchSavedQueryList.mockImplementationOnce(async () => {
      mocks.addSavedQueries([secondSavedQuery]);
      return {
        savedQueries: [secondSavedQuery],
        nextPageToken: "",
      };
    });
    await act(async () => {
      await viewContext!.fetchNextPage();
    });

    expect(
      viewContext!.sheetTree.children
        .filter((child) => child.savedQuery)
        .map((child) => child.label)
    ).toEqual(["Zeta saved query", "Alpha saved query"]);
  });

  test("keeps folder and descendant load-more state after renaming a folder", async () => {
    const { provideSheetContext, useSheetContextByView } = await import(
      "./context"
    );
    let viewContext: ReturnType<typeof useSheetContextByView> | undefined;

    const Probe = () => {
      provideSheetContext();
      viewContext = useSheetContextByView("my");
      return null;
    };

    root = createRoot(container);
    await act(async () => {
      root.render(<Probe />);
    });
    await act(async () => {
      await viewContext!.fetchSheetList();
    });

    mocks.getAppState().fetchSavedQueryList.mockImplementationOnce(async () => {
      const savedQuery = create(SavedQuerySchema, {
        name: "projects/proj1/savedQueries/3",
        project: "projects/proj1",
        creator: "users/[email protected]",
        title: "Folder saved query",
        folder: "alpha",
      });
      mocks.addSavedQueries([savedQuery]);
      return {
        savedQueries: [savedQuery],
        nextPageToken: "folder-next",
      };
    });
    await act(async () => {
      await viewContext!.fetchSavedQueriesByFolder("/my/alpha");
    });

    expect(viewContext!.hasMoreForFolder("/my/alpha")).toBe(true);

    mocks.getAppState().fetchSavedQueryList.mockImplementationOnce(async () => {
      const savedQuery = create(SavedQuerySchema, {
        name: "projects/proj1/savedQueries/4",
        project: "projects/proj1",
        creator: "users/[email protected]",
        title: "Child folder saved query",
        folder: "alpha/child",
      });
      mocks.addSavedQueries([savedQuery]);
      return {
        savedQueries: [savedQuery],
        nextPageToken: "child-folder-next",
      };
    });
    await act(async () => {
      await viewContext!.fetchSavedQueriesByFolder("/my/alpha/child");
    });

    expect(viewContext!.hasMoreForFolder("/my/alpha/child")).toBe(true);

    act(() => {
      viewContext!.folderContext.moveFolder("/my/alpha", "/my/beta");
      viewContext!.rebuildTree();
    });

    expect(viewContext!.hasMoreForFolder("/my/beta")).toBe(true);
    expect(viewContext!.hasMoreForFolder("/my/beta/child")).toBe(true);
    expect(viewContext!.hasMoreForFolder("/my/alpha/child")).toBe(false);
  });

  test("invalidates folder pagination state when merging folders", async () => {
    const { provideSheetContext, useSheetContextByView } = await import(
      "./context"
    );
    let viewContext: ReturnType<typeof useSheetContextByView> | undefined;

    const Probe = () => {
      provideSheetContext();
      viewContext = useSheetContextByView("my");
      return null;
    };

    root = createRoot(container);
    await act(async () => {
      root.render(<Probe />);
    });
    await act(async () => {
      await viewContext!.fetchSheetList();
    });

    viewContext!.folderContext.addFolder("/my/beta");

    mocks.getAppState().fetchSavedQueryList.mockImplementationOnce(async () => {
      const savedQuery = create(SavedQuerySchema, {
        name: "projects/proj1/savedQueries/3",
        project: "projects/proj1",
        creator: "users/[email protected]",
        title: "Alpha saved query",
        folder: "alpha",
      });
      mocks.addSavedQueries([savedQuery]);
      return {
        savedQueries: [savedQuery],
        nextPageToken: "alpha-next",
      };
    });
    await act(async () => {
      await viewContext!.fetchSavedQueriesByFolder("/my/alpha");
    });

    expect(viewContext!.hasMoreForFolder("/my/alpha")).toBe(true);

    act(() => {
      viewContext!.folderContext.moveFolder("/my/alpha", "/my/beta");
      viewContext!.rebuildTree();
    });

    expect(viewContext!.hasMoreForFolder("/my/beta")).toBe(false);
    expect(viewContext!.hasMoreForFolder("/my/alpha")).toBe(false);
  });

  test("invalidates affected page tokens after moving saved queries", async () => {
    const { provideSheetContext, useSheetContext, useSheetContextByView } =
      await import("./context");
    let sheetContext: ReturnType<typeof useSheetContext> | undefined;
    let viewContext: ReturnType<typeof useSheetContextByView> | undefined;

    const Probe = () => {
      provideSheetContext();
      sheetContext = useSheetContext();
      viewContext = useSheetContextByView("my");
      return null;
    };

    root = createRoot(container);
    await act(async () => {
      root.render(<Probe />);
    });
    await act(async () => {
      await viewContext!.fetchSheetList();
    });

    mocks.getAppState().fetchSavedQueryList.mockImplementationOnce(async () => {
      const savedQuery = create(SavedQuerySchema, {
        name: "projects/proj1/savedQueries/3",
        project: "projects/proj1",
        creator: "users/[email protected]",
        title: "Folder saved query",
        folder: "alpha",
      });
      mocks.addSavedQueries([savedQuery]);
      return {
        savedQueries: [savedQuery],
        nextPageToken: "folder-next",
      };
    });
    await act(async () => {
      await viewContext!.fetchSavedQueriesByFolder("/my/alpha");
    });

    expect(viewContext!.hasMore).toBe(true);
    expect(viewContext!.hasMoreForFolder("/my/alpha")).toBe(true);

    await act(async () => {
      await sheetContext!.batchUpdateSavedQueryFolders([
        { name: "projects/proj1/savedQueries/1", folders: ["alpha"] },
      ]);
    });

    expect(viewContext!.hasMore).toBe(false);
    expect(viewContext!.hasMoreForFolder("/my/alpha")).toBe(false);
  });

  test("batch updates saved query folders via UpdateSavedQuery per row", async () => {
    const { provideSheetContext, useSheetContext } = await import("./context");
    let sheetContext: ReturnType<typeof useSheetContext> | undefined;

    const Probe = () => {
      provideSheetContext();
      sheetContext = useSheetContext();
      return null;
    };

    root = createRoot(container);
    await act(async () => {
      root.render(<Probe />);
    });

    // Re-filing patches the cached row, so the rows must be in the cache and
    // writable by the caller (the default stub passes creator rows).
    mocks.addSavedQueries([
      create(SavedQuerySchema, {
        name: "projects/proj1/savedQueries/1",
        project: "projects/proj1",
        creator: "users/[email protected]",
        title: "one",
      }),
      create(SavedQuerySchema, {
        name: "projects/proj1/savedQueries/2",
        project: "projects/proj1",
        creator: "users/[email protected]",
        title: "two",
      }),
    ]);

    await act(async () => {
      await sheetContext!.batchUpdateSavedQueryFolders([
        { name: "projects/proj1/savedQueries/1", folders: ["target"] },
        { name: "projects/proj1/savedQueries/2", folders: ["target"] },
      ]);
    });

    expect(mocks.getAppState().moveMySavedQueries).not.toHaveBeenCalled();
    expect(mocks.getAppState().patchSavedQuery).toHaveBeenCalledTimes(2);
    expect(mocks.getAppState().patchSavedQuery).toHaveBeenCalledWith(
      expect.objectContaining({
        name: "projects/proj1/savedQueries/1",
        folder: "target",
      }),
      ["folder"]
    );
    expect(mocks.getAppState().patchSavedQuery).toHaveBeenCalledWith(
      expect.objectContaining({
        name: "projects/proj1/savedQueries/2",
        folder: "target",
      }),
      ["folder"]
    );
    // Both cache views are re-filed per row so the tree rebuild does not snap
    // the rows back to the old folder.
    expect(
      mocks.getAppState().patchSavedQueryFolderInCache
    ).toHaveBeenCalledWith(["projects/proj1/savedQueries/1"], "target");
    expect(
      mocks.getAppState().patchSavedQueryFolderInCache
    ).toHaveBeenCalledWith(["projects/proj1/savedQueries/2"], "target");
  });

  test("re-files shared rows the caller can update and skips the rest", async () => {
    const { provideSheetContext, useSheetContext } = await import("./context");
    let sheetContext: ReturnType<typeof useSheetContext> | undefined;

    const Probe = () => {
      provideSheetContext();
      sheetContext = useSheetContext();
      return null;
    };

    root = createRoot(container);
    await act(async () => {
      root.render(<Probe />);
    });

    // The server lets an EDITOR grantee (or a project-level update grant)
    // re-file somebody else's saved query — folder is an ordinary update
    // field — so the move keys off writability, not ownership.
    mocks.addSavedQueries([
      create(SavedQuerySchema, {
        name: "projects/proj1/savedQueries/editable-shared",
        project: "projects/proj1",
        creator: "users/[email protected]",
        title: "editable",
      }),
      create(SavedQuerySchema, {
        name: "projects/proj1/savedQueries/readonly-shared",
        project: "projects/proj1",
        creator: "users/[email protected]",
        title: "read-only",
      }),
    ]);
    mocks.isSavedQueryWritableV1.mockImplementation(
      (sheet: SavedQuery) =>
        sheet.name === "projects/proj1/savedQueries/editable-shared"
    );

    await act(async () => {
      await sheetContext!.batchUpdateSavedQueryFolders([
        {
          name: "projects/proj1/savedQueries/editable-shared",
          folders: ["target"],
        },
        {
          name: "projects/proj1/savedQueries/readonly-shared",
          folders: ["target"],
        },
      ]);
    });

    expect(mocks.getAppState().patchSavedQuery).toHaveBeenCalledTimes(1);
    expect(mocks.getAppState().patchSavedQuery).toHaveBeenCalledWith(
      expect.objectContaining({
        name: "projects/proj1/savedQueries/editable-shared",
        folder: "target",
      }),
      ["folder"]
    );
    expect(
      mocks.getAppState().patchSavedQueryFolderInCache
    ).toHaveBeenCalledWith(
      ["projects/proj1/savedQueries/editable-shared"],
      "target"
    );
    expect(
      mocks.getAppState().patchSavedQueryFolderInCache
    ).not.toHaveBeenCalledWith(
      ["projects/proj1/savedQueries/readonly-shared"],
      "target"
    );
  });

  test("moves cached rows that the starred filter hides", async () => {
    // Regression: the server moves every row in the folder (the batch filter
    // drops display filters), so patching only the visible rows left the
    // hidden ones under their old folder once the starred filter cleared.
    const starred = create(SavedQuerySchema, {
      name: "projects/proj1/savedQueries/starred",
      project: "projects/proj1",
      creator: "users/[email protected]",
      title: "Starred",
      folder: "old",
      starred: true,
    });
    const unstarred = create(SavedQuerySchema, {
      name: "projects/proj1/savedQueries/unstarred",
      project: "projects/proj1",
      creator: "users/[email protected]",
      title: "Unstarred",
      folder: "old",
      starred: false,
    });
    mocks.getAppState().fetchSavedQueryList.mockImplementationOnce(async () => {
      mocks.addSavedQueries([starred, unstarred]);
      return { savedQueries: [starred, unstarred], nextPageToken: "" };
    });

    const { provideSheetContext, useSheetContext, useSheetContextByView } =
      await import("./context");
    let sheetContext: ReturnType<typeof useSheetContext> | undefined;
    let viewContext: ReturnType<typeof useSheetContextByView> | undefined;

    const Probe = () => {
      provideSheetContext();
      sheetContext = useSheetContext();
      viewContext = useSheetContextByView("my");
      return null;
    };

    root = createRoot(container);
    await act(async () => {
      root.render(<Probe />);
    });
    await act(async () => {
      await viewContext!.fetchSheetList();
    });
    act(() => {
      sheetContext!.setFilter({
        ...sheetContext!.filter,
        onlyShowStarred: true,
      });
    });

    await act(async () => {
      await sheetContext!.batchUpdateSavedQueryFolderPaths("my", [
        { sourceFolder: ["old"], targetFolder: ["new"] },
      ]);
    });

    expect(
      mocks.getAppState().patchSavedQueryFolderInCache
    ).toHaveBeenCalledWith([starred.name, unstarred.name], "new");
  });

  test("batch updates saved query folder paths without display filters", async () => {
    const { provideSheetContext, useSheetContext } = await import("./context");
    let sheetContext: ReturnType<typeof useSheetContext> | undefined;

    const Probe = () => {
      provideSheetContext();
      sheetContext = useSheetContext();
      return null;
    };

    root = createRoot(container);
    await act(async () => {
      root.render(<Probe />);
    });
    act(() => {
      sheetContext!.setFilter({
        ...sheetContext!.filter,
        keyword: "Payroll",
        onlyShowStarred: true,
      });
    });

    await act(async () => {
      await sheetContext!.batchUpdateSavedQueryFolderPaths("my", [
        { sourceFolder: ["old"], targetFolder: ["new"] },
        { sourceFolder: ["old", "child"], targetFolder: ["new", "child"] },
      ]);
    });

    // The server moves descendants with the folder, so only the top-level move
    // is sent -- "old/child" would otherwise be rewritten twice.
    expect(mocks.getAppState().moveMySavedQueries).toHaveBeenCalledTimes(1);
    expect(mocks.getAppState().moveMySavedQueries).toHaveBeenCalledWith(
      "projects/proj1",
      { sourceFolder: "old", targetFolder: "new" }
    );
  });
});