Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

14.1 KB
Raw Blame
// @vitest-environment jsdom
import { readFileSync } from 'node:fs';
import { createRequire } from 'node:module';
import { resolve } from 'node:path';
import * as jsxRuntime from 'react/jsx-runtime';
import { act, Children, createContext, forwardRef, Fragment, isValidElement, useContext, useRef, useState, type ReactElement, type ReactNode } from 'react';
import { createRoot } from 'react-dom/client';
import ts from 'typescript';
import { expect, it, vi } from 'vitest';
import { getRemoteSessionPreviewCollapse, toRemoteSessionListItem } from '@cindy/maker-shared/session-list';
import { buildHomeProjectChildOffsets, resolveHomeProjectChildAnchor, resolveHomeProjectChildWindow, shouldWindowHomeProjectChildren } from '@/session/homeProjectChildWindow';

// Exercise the production child renderer without importing the entire native
// navigation stack. Anchor math is covered separately; native measurement needs
// an on-device scroll check.
const source = ts.createSourceFile('HomeSurface.tsx', readFileSync(resolve(process.cwd(), 'src/session/HomeSurface.tsx'), 'utf8'),
  ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
const declaration = source.statements.find((node): node is ts.FunctionDeclaration => ts.isFunctionDeclaration(node)
  && node.name?.text === 'AutomationGroupChildren')!;
const compiled = ts.transpileModule(declaration.getText(source), {
  compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.CommonJS, jsx: ts.JsxEmit.ReactJSX },
}).outputText;

// Unit regression for #7083: the native drag callback must transfer only its
// small payload, not the project's task/history tree. Existing window tests
// count mounted rows but never exercise Babel's actual worklet closure.
it('keeps task data out of the project drag worklet while preserving drag actions', () => {
  const projectRow = source.statements.find((node): node is ts.FunctionDeclaration => ts.isFunctionDeclaration(node)
    && node.name?.text === 'ProjectRow')!;
  let gesture!: ts.VariableDeclaration;
  function visit(node: ts.Node) {
    if (ts.isVariableDeclaration(node) && node.name.getText(source) === 'dragGesture') gesture = node;
    ts.forEachChild(node, visit);
  }
  visit(projectRow);
  const require = createRequire(import.meta.url);
  const { transformSync } = require('@babel/core');
  const code = transformSync(`function build(project, onDragStart, onDragMove, onDragEnd) {
    const kind = 'project', displayTitle = project.title;
    return ${gesture.initializer!.getText(source)};
  }`, {
    filename: __filename, babelrc: false, configFile: false,
    plugins: [require.resolve('react-native-worklets/plugin')],
  }).code;
  const callbacks: Record<string, ((event?: unknown) => void) & { __closure?: object }> = {};
  const pan: Record<string, (...args: any[]) => unknown> = {};
  for (const method of ['activateAfterLongPress', 'activeOffsetY', 'failOffsetX', 'onStart', 'onUpdate', 'onFinalize']) {
    pan[method] = (value: any) => {
      if (method.startsWith('on')) callbacks[method] = value;
      return pan;
    };
  }
  const build = new Function('Gesture', 'useMemo', 'runOnJS', `${code}; return build;`)(
    { Pan: () => pan }, (factory: () => unknown) => factory(), (callback: unknown) => callback,
  );
  const start = vi.fn(), move = vi.fn(), finish = vi.fn();
  const project = { key: 'project', title: 'Project', sessionCount: 1,
    get sessions(): never { throw new Error('task data crossed into a gesture worklet'); } };
  build(project, start, move, finish);
  // Serializable conversion enumerates captured objects, including their
  // nested fields. A single sentinel task collection catches the old transfer.
  const visited = new Set<object>();
  function inspect(value: unknown) {
    if (!value || typeof value !== 'object' || visited.has(value)) return;
    visited.add(value);
    Object.values(value).forEach(inspect);
  }
  expect(() => Object.values(callbacks).forEach(callback => inspect(callback.__closure))).not.toThrow();
  callbacks.onStart({ absoluteY: 140 });
  callbacks.onUpdate({ absoluteY: 160 });
  callbacks.onFinalize();
  expect(start).toHaveBeenCalledWith({ absoluteY: 140, count: 1, key: 'project', title: 'Project' });
  expect(move).toHaveBeenCalledWith(160);
  expect(finish).toHaveBeenCalledOnce();
});

function renderChildren(count: number, anchor: number, old = false) {
  const now = Date.now();
  const items = Array.from({ length: count }, (_, i) => toRemoteSessionListItem({
    id: `s${i}`, title: `Run ${i}`, status: 'active', agentKind: 'codex', model: 'model', workingDir: '/repo',
    createdAt: new Date(now - (old ? 30 * 86400000 : 1000)).toISOString(),
    updatedAt: new Date(now - (old ? 30 * 86400000 : 1000)).toISOString(),
  }, now));
  const onOpenSession = vi.fn();
  const dependencies = {
    exports: {},
    require: () => jsxRuntime,
    useThemedStyles: () => ({}), makeStyles: () => ({}), useTheme: () => ({ colors: {} }),
    useTranslation: () => ({ t: () => '' }), useRemoteHomeStatusVersion: () => 0,
    getRemoteSessionPreviewCollapse, PROJECT_PREVIEW_LIMIT: 5,
    remoteSessionStore: { isSessionRunning: () => false },
    useContext: () => ({ scrollY: { value: 0 }, viewportHeight: 800 }), HomeListViewportContext: {},
    useAnimatedRef: () => ({}), useSharedValue: (value: number) => ({ value }), useState: () => [anchor, () => {}],
    buildHomeProjectChildOffsets, estimateHomeSessionRowHeight: () => 60,
    useHomeRowDisplay: () => ({ taskInfoFields: ['time'], viewMode: 'list' }),
    shouldWindowHomeProjectChildren, resolveHomeProjectChildWindow,
    PROJECT_CHILD_WINDOW_THRESHOLD: 20, PROJECT_CHILD_WINDOW_OVERSCAN: 4, PROJECT_CHILD_WINDOW_SIZE: 15,
    Reanimated: { View: 'animated-view' }, View: 'view', HomeProjectWindowAnchorTracker: 'tracker',
    HomeSessionRow: 'row', SwipeableSessionRow: 'swipe', Fragment,
    Pressable: 'button', Text: 'text', ChevronRight: 'chevron', iconSize: {}, iconStroke: {},
  };
  const render = new Function(...Object.keys(dependencies), `${compiled}; return AutomationGroupChildren;`)(...Object.values(dependencies));
  const tree = render({ group: { key: 'group', items, sessionCount: count }, testID: 'fixture',
    onOpenSession, onOpenGroup: () => {}, inBlock: true, swipe: { registry: {}, onArchive: vi.fn() } });
  const elements: ReactElement<Record<string, any>>[] = [];
  function visit(node: ReactNode) {
    Children.forEach(node, child => {
      if (!isValidElement(child)) return;
      const element = child as ReactElement<Record<string, any>>;
      elements.push(element); visit(element.props.children);
    });
  }
  visit(tree);
  return { elements, onOpenSession };
}

it('bounds 200 recent runs before layout, while scrolling, and when reversing to the beginning', () => {
  for (const anchor of [-1, 0, 4, 96, 196, 96, 0]) {
    const { elements, onOpenSession } = renderChildren(200, anchor);
    const rows = elements.filter(node => node.type === 'row');
    expect(rows.length).toBeLessThanOrEqual(23);
    expect(rows.length).toBe(anchor < 0 ? 0 : anchor === 196 ? 15 : 23);
    const spacerHeight = elements.filter(node => node.type === 'view').reduce((sum, node) => sum + (node.props.style?.height ?? 0), 0);
    expect(spacerHeight + rows.length * 60).toBe(200 * 60);
    if (anchor < 0) continue;
    const first = rows[0];
    first.props.onOpenSession(first.props.item);
    expect(onOpenSession).toHaveBeenCalledWith(first.props.item);
    if (anchor === 0) expect(first.props.item.session.id).toBe('s0');
    if (anchor === 196) {
      expect(rows.at(-1)!.props.item.session.id).toBe('s199');
      expect(rows.at(-1)!.props.hideDivider).toBe(true);
    }
  }
});

// PR #6298 review: retained expanded groups must not multiply initial native
// mounts (23 groups x 23 rows). Unit tier, actual production child renderer;
// earlier coverage allowed every unmeasured group to mount a full window.
it('does not eagerly mount runs for multiple unmeasured expanded groups', () => {
  const rows = Array.from({ length: 23 }, () => renderChildren(23, -1).elements)
    .flat().filter(node => node.type === 'row');
  expect(rows).toHaveLength(0);
});

it('preserves small previews and the view-all action for old runs', () => {
  expect(renderChildren(5, -1).elements.filter(node => node.type === 'row')).toHaveLength(5);
  const { elements } = renderChildren(200, -1, true);
  expect(elements.filter(node => node.type === 'row')).toHaveLength(5);
  expect(elements.filter(node => node.type === 'button')).toHaveLength(1);
});

it('connects native layout and scroll measurements through the real tracker to rendered rows', () => {
  Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true });
  const tracker = source.statements.find((node): node is ts.FunctionDeclaration => ts.isFunctionDeclaration(node)
    && node.name?.text === 'HomeProjectWindowAnchorTracker')!;
  const trackerCode = ts.transpileModule(tracker.getText(source), {
    compilerOptions: { target: ts.ScriptTarget.ES2022 },
  }).outputText;
  let prepare!: () => number | null;
  let react!: (next: number | null, previous: number | null) => void;
  let onLayout!: () => void;
  let pageY: number | null = 200;
  let scrollOffset = 0;
  const readScroll = vi.fn(() => scrollOffset);
  const scrollY = { get value() { return readScroll(); } };
  const Viewport = createContext<{ scrollY: { readonly value: number }; viewportHeight: number } | null>(null);
  const container = document.createElement('div');
  const NativeView = forwardRef<HTMLDivElement, { children?: ReactNode; onLayout(): void; testID: string }>(
    function NativeView({ children, onLayout: callback, testID }, ref) {
      onLayout = callback;
      return <div ref={ref} data-testid={testID}>{children}</div>;
    },
  );
  const measure = vi.fn((ref: { current: HTMLElement | null }) => {
    expect(ref.current).toBe(container.querySelector('[data-testid="fixture.automationGroupChildren"]'));
    return pageY === null ? null : { pageY };
  });
  const dependencies = {
    exports: {}, require: () => jsxRuntime,
    useThemedStyles: () => ({}), makeStyles: () => ({}), useTheme: () => ({ colors: {} }),
    useTranslation: () => ({ t: () => '' }), useRemoteHomeStatusVersion: () => 0,
    getRemoteSessionPreviewCollapse, PROJECT_PREVIEW_LIMIT: 5,
    remoteSessionStore: { isSessionRunning: () => false },
    useContext, HomeListViewportContext: Viewport, useState,
    useAnimatedRef: () => useRef(null), useSharedValue: (value: number) => useRef({ value }).current,
    useAnimatedReaction: (p: typeof prepare, r: typeof react) => { prepare = p; react = r; },
    measure, runOnJS: (callback: unknown) => callback,
    buildHomeProjectChildOffsets, estimateHomeSessionRowHeight: () => 60,
    useHomeRowDisplay: () => ({ taskInfoFields: ['time'], viewMode: 'list' }),
    shouldWindowHomeProjectChildren, resolveHomeProjectChildWindow, resolveHomeProjectChildAnchor,
    PROJECT_CHILD_WINDOW_THRESHOLD: 20, PROJECT_CHILD_WINDOW_OVERSCAN: 4,
    PROJECT_CHILD_WINDOW_SIZE: 15, PROJECT_CHILD_WINDOW_SHIFT: 4,
    Reanimated: { View: NativeView }, View: ({ style }: { style: { height: number } }) => <div data-spacer={style.height} />,
    HomeSessionRow: ({ item, onOpenSession }: { item: ReturnType<typeof toRemoteSessionListItem>; onOpenSession(item: unknown): void }) =>
      <button data-row={item.session.id} onClick={() => onOpenSession(item)}>{item.title}</button>,
    Fragment,
  };
  // Both production functions execute; only the native measurement/worklet bridge is simulated.
  const Group = new Function(...Object.keys(dependencies), `${compiled}\n${trackerCode}\nreturn AutomationGroupChildren;`)(...Object.values(dependencies));
  const now = Date.now();
  const items = Array.from({ length: 200 }, (_, i) => toRemoteSessionListItem({
    id: `s${i}`, title: `Run ${i}`, status: 'active', agentKind: 'codex', model: 'model', workingDir: '/repo',
    createdAt: new Date(now).toISOString(), updatedAt: new Date(now).toISOString(),
  }, now));
  const open = vi.fn();
  const root = createRoot(container);
  const rows = () => [...container.querySelectorAll<HTMLButtonElement>('[data-row]')];
  let previous: number | null = null;
  function frame(nextPageY: number | null, offset: number) {
    pageY = nextPageY; scrollOffset = offset; readScroll.mockClear();
    act(() => { const next = prepare(); react(next, previous); previous = next; });
    expect(readScroll).toHaveBeenCalled();
    expect(rows().length).toBeLessThanOrEqual(23);
  }
  try {
    act(() => root.render(<Viewport.Provider value={{ scrollY, viewportHeight: 800 }}>
      <Group group={{ key: 'group', items, sessionCount: 200 }} testID="fixture" onOpenSession={open} />
    </Viewport.Provider>));
    frame(2400, 0);
    expect(measure).not.toHaveBeenCalled();
    expect(rows()).toHaveLength(0);
    act(() => onLayout());
    frame(2400, 0);
    expect(rows()).toHaveLength(0);
    frame(1200, 1200); // Preload one viewport before actually becoming visible.
    expect(rows()).toHaveLength(23);
    expect(rows()[0].dataset.row).toBe('s0');
    frame(200, 2200);
    expect(rows()[0].dataset.row).toBe('s0');
    frame(-6000, 6200);
    expect(rows()[0].dataset.row).toBe('s96');
    act(() => rows()[0].click());
    expect(open).toHaveBeenLastCalledWith(items[96]);
    frame(null, 6500); // A transient native measurement failure must not blank the list.
    expect(rows()[0].dataset.row).toBe('s96');
    frame(-11800, 12000);
    expect(rows().at(-1)?.dataset.row).toBe('s199');
    frame(-12000, 12200);
    // Leaving the viewport must not discard the last bounded window: a
    // reverse scroll can reveal it before the JS update is delivered.
    expect(rows().at(-1)?.dataset.row).toBe('s199');
    frame(-13000, 13200); // Far outside the preload band: release nested rows.
    expect(rows()).toHaveLength(0);
    frame(-12400, 12600); // Preload the tail before it re-enters on reversal.
    expect(rows().at(-1)?.dataset.row).toBe('s199');
    frame(-11800, 12000);
    expect(rows().at(-1)?.dataset.row).toBe('s199');
    frame(200, 0);
    expect(rows()[0].dataset.row).toBe('s0');
    const spacers = [...container.querySelectorAll<HTMLElement>('[data-spacer]')]
      .reduce((sum, node) => sum + Number(node.dataset.spacer), 0);
    expect(spacers + rows().length * 60).toBe(12000);
  } finally { act(() => root.unmount()); }
});