Skip to content

armgit / peach

Public Imported from GitHub
0

Peach: Local-first video metadata scraper and media manager.

17.8 KB
Raw Blame
/* 管理区页头:骨架与路由树的换手、管理条的按下态与点击、面包屑左键走路由而带修饰键照链接走、回收站说明行
 * 先占位后落读数,同一页重画时读数那一格原地换字,以及它作为常驻组件(`RESIDENT_ROUTES['manage-header']`)在
 * 路由树里的行为:宿主就是 `[data-manage-header]`、骨架在首帧的同一个任务里换掉、句柄同步画完、抛错只卸组件。
 *
 * 指示线的滑动、标题居中与窄屏收档要量布局,由 e2e 在浏览器里走(`e2e/management-layout.test.ts`)。 */
import { act } from 'react';
import { createRoot } from 'react-dom/client';
import { afterEach, beforeAll, describe, expect, it, vi } from 'vitest';

import { manageHeaderSkeletonHtml, pressedManageKey, type ManageEntry, type ManageHeaderProps } from '../../src/manage-header';
import type { BatchDockApi, BatchDockHost } from '../../src/react/batch-dock/batch-dock-api';
import type { ManageHeaderApi, ManageHeaderHost } from '../../src/react/manage-header/manage-header-api';
import type { ShellActions } from '../../src/react/router/shell-actions';
import { click } from './render';

// 首次导入会编译路由表带进来的整棵页面子树,编译等待使用独立的有限窗口;之后每条用例重新装载只重跑模块。
const REACT_IMPORT_TIMEOUT_MS = 30_000;

type ActFlag = { IS_REACT_ACT_ENVIRONMENT?: boolean };

beforeAll(async () => { await import('../../src/react/router/router') }, REACT_IMPORT_TIMEOUT_MS);

/* 页签与面包屑的字形换成一层能当场决定抛不抛的包装:用例中途改 `glyph.broken`,就是「下一次绘制抛错」。 */
const glyph = vi.hoisted(() => ({ broken: false }));
vi.mock(import('../../src/react/settings-panel/icon'), async (importOriginal) => {
  const actual = await importOriginal();
  return {
    ...actual,
    Icon: (props: Parameters<typeof actual.Icon>[0]) => {
      if (glyph.broken) throw new Error('页头画不出来');
      return actual.Icon(props);
    },
  };
});

/* 常驻组件适配层直接读取同一包内的配置函数;测试只接本场景的句柄契约。 */
type ShellIslands = { connectApplication(next: (actions: ShellActions) => void): () => void;
  loadManageHeader(host: ManageHeaderHost): Promise<ManageHeaderApi>;
  manageHeaderApi(): ManageHeaderApi | null;
  loadBatchDock(host: BatchDockHost): Promise<BatchDockApi>;
};
const ISLANDS_MODULE = '../../src/react/application-residents';

async function load() {
  vi.resetModules();
  window.history.replaceState(null, '', '/');
  const [history, router, routes, islands] = await Promise.all([
    import('../../src/history'), import('../../src/react/router/router'), import('../../src/react/router/managed-routes'),
    import(/* @vite-ignore */ ISLANDS_MODULE) as Promise<ShellIslands>,
  ]);
  return { ...history, ...router, ...routes, islands };
}
type Loaded = Awaited<ReturnType<typeof load>>;

const unmounts: Array<() => void> = [];
afterEach(async () => {
  vi.useRealTimers();
  (globalThis as ActFlag).IS_REACT_ACT_ENVIRONMENT = true;
  for (const unmount of unmounts.splice(0)) await act(async () => { unmount() });
  document.body.innerHTML = '';
  glyph.broken = false;
  vi.unstubAllGlobals();
  vi.restoreAllMocks();
});

function shellActions(): ShellActions {
  return {
    openItem: vi.fn(), openEntity: vi.fn(), openTag: vi.fn(), openTasteSignal: vi.fn(), navigate: vi.fn(),
    openManage: vi.fn(), managePath: vi.fn(() => ''), openFollow: vi.fn(), receipt: vi.fn(), toast: vi.fn(),
    failure: vi.fn(), revealSource: vi.fn(async () => ''), reopenTutorial: vi.fn(async () => {}),
    routeReview: vi.fn(),
    routeFollowManage: vi.fn(), saveFollowPreference: vi.fn(), srcBadge: () => '', routeIndex: vi.fn(),
    savePeopleLayout: vi.fn(), exitSelectMode: vi.fn(), personAvatar: vi.fn(() => ({ html: '', face: '' })),
    authorAvatar: vi.fn(() => ''), showIndexTags: vi.fn(), openFollowAuthor: vi.fn(), openFollowTag: vi.fn(),
    openPlaylist: vi.fn(), canFlip: vi.fn(() => true),
    surfaceChanged: vi.fn(), clearSearch: vi.fn(), openImmerse: vi.fn(), openOverlay: vi.fn(), closeStage: vi.fn(), grid: {} as ShellActions['grid'],
  };
}

/** 壳启动时先画路由树(根的选项与 `mountApplication` 同一份);接上取数单独一步,用例可以把它往后放。 */
async function mountRouter(r: Loaded) {
  unmounts.push(r.islands.connectApplication(() => {}));
  const root = createRoot(document.createElement('div'), r.ROUTER_ROOT_OPTIONS);
  await act(async () => { root.render(<r.RouterRoot actions={shellActions()} />) });
  unmounts.push(() => root.unmount());
}
async function connect(r: Loaded) {
  await act(async () => { r.connectManagedRoutes(Promise.resolve(r.prefetchManagedRoute)) });
}

const SECTIONS: ManageEntry[] = [['stats', '统计', 'chart'], ['cleanup', '数据管理', 'database'], ['trash', '回收站', 'trash']];
const MENU = SECTIONS.filter(([key]) => key !== 'trash');

const props = (section: string, path: string, patch: Partial<ManageHeaderProps> = {}): ManageHeaderProps =>
  ({ section, path, sections: SECTIONS, menu: MENU, trash: null, ...patch });

/** 壳 `index.html` 里那个常驻宿主,壳启动时同步写进骨架。 */
function headerHost(first: ManageHeaderProps): ManageHeaderHost {
  const root = document.createElement('div');
  root.setAttribute('data-manage-header', '');
  document.body.append(root);
  root.innerHTML = manageHeaderSkeletonHtml(first);
  return { root, openManage: vi.fn(), openDataCleanup: vi.fn(), emptyTrash: vi.fn() };
}

/** 照壳的 `mountManageHeader` 接上:铺骨架、装载,拿到句柄就把手上那份推进去。 */
async function setup(first: ManageHeaderProps) {
  const r = await load();
  await mountRouter(r);
  await connect(r);
  const host = headerHost(first);
  let api!: ManageHeaderApi;
  await act(async () => { api = await r.islands.loadManageHeader(host) });
  const render = (next: ManageHeaderProps) => act(() => { api.render(next) });
  render(first);
  return { r, root: host.root, host, api, render };
}

/** 收下每一次上报;`console.error` 只静音,不数条数。 */
function watchReports() {
  const reported = vi.fn();
  vi.stubGlobal('reportError', reported);
  vi.spyOn(console, 'error').mockImplementation(() => {});
  return reported;
}

const title = (root: ParentNode) => root.querySelector('[data-manage-title]')?.textContent;

describe('换手', () => {
  it('预取未接上时宿主里是骨架、句柄为 null;画上之后句柄才交出,画出来的是同一份结构', async () => {
    const first = props('cleanup', '/junk-files');
    const skeleton = document.createElement('div');
    skeleton.innerHTML = manageHeaderSkeletonHtml(first);
    const r = await load();
    await mountRouter(r);
    const host = headerHost(first);
    const html = host.root.innerHTML;
    let loaded: Promise<ManageHeaderApi> | null = null;
    await act(async () => { loaded = r.islands.loadManageHeader(host) });
    expect(host.root.innerHTML, '路由树还没接上取数,骨架原样').toBe(html);
    expect(r.islands.manageHeaderApi(), '画上之前没有句柄,壳继续接骨架上的点击').toBeNull();

    await connect(r);
    let api: ManageHeaderApi | null = null;
    await act(async () => { api = await loaded });
    expect(r.islands.manageHeaderApi()).toBe(api);
    expect(r.managedEntry(host.root)?.path).toBe('manage-header');
    expect(host.root.childNodes.length, '骨架清掉了,首帧没有 props、画成空').toBe(0);

    await act(async () => { api!.render(first) });
    const shape = (node: ParentNode) => [...node.querySelectorAll('*')]
      .filter(el => !el.hasAttribute('data-pill-thumb'))
      .map((el) => [el.tagName, ...[...el.attributes].map((a) => a.name).filter((name) => name.startsWith('data-') || name.startsWith('aria-')).sort()].join(' '))
      .filter((line) => !line.startsWith('USE'));
    expect(shape(host.root)).toEqual(shape(skeleton));
    expect(host.root.querySelector('[data-pill-thumb]')).not.toBeNull();
    expect(title(host.root)).toBe('垃圾文件');
  });

  it('骨架与首帧在同一个任务里换掉:每个任务边界上宿主里要么是骨架、要么是画好的页头,宿主上不多包 .peach-react', async () => {
    const first = props('stats', '/stats');
    const r = await load();
    await mountRouter(r);
    await connect(r);
    const host = headerHost(first);
    const skeletonTitle = host.root.querySelector('[data-manage-title]');
    /* 不包 act:act 会把 flushSync 推到它结束时,看不出换手发生在哪一拍。 */
    (globalThis as ActFlag).IS_REACT_ACT_ENVIRONMENT = false;
    let done = false;
    void r.islands.loadManageHeader(host).then((api) => { api.render(first); done = true });
    const state = () => (host.root.contains(skeletonTitle) ? 'skeleton' : title(host.root) ? 'header' : 'empty');
    const seen: string[] = [];
    for (let turn = 0; turn < 200 && !done; turn += 1) {
      seen.push(state());
      await new Promise((resolve) => { setTimeout(resolve, 0) });
    }
    seen.push(state());
    expect(done).toBe(true);
    expect(seen).not.toContain('empty');
    expect(seen.at(-1)).toBe('header');
    expect(title(host.root)).toBe('统计');
    expect(host.root.querySelector(':scope > .peach-react')).toBeNull();
    expect(host.root.firstElementChild?.hasAttribute('data-manage-bar')).toBe(true);
  });

  it('骨架阶段的点击由壳的委托接,句柄交出之后归组件,一次点击只到一处', async () => {
    const r = await load();
    await mountRouter(r);
    const host = headerHost(props('stats', '/stats'));
    /* 壳 `mountManageHeader` 里那一段委托:句柄还没交出时才认。 */
    const delegated = vi.fn();
    host.root.addEventListener('click', (event) => {
      if (r.islands.manageHeaderApi()) return;
      const tab = (event.target as Element).closest<HTMLElement>('[data-manage]');
      if (tab) delegated(tab.dataset.manage);
    });
    let loaded: Promise<ManageHeaderApi> | null = null;
    await act(async () => { loaded = r.islands.loadManageHeader(host) });
    await click(host.root.querySelector('[data-manage="cleanup"]'));
    expect(delegated.mock.calls).toEqual([['cleanup']]);
    expect(host.openManage).not.toHaveBeenCalled();

    await connect(r);
    let api: ManageHeaderApi | null = null;
    await act(async () => { api = await loaded });
    act(() => { api!.render(props('cleanup', '/data-cleanup')) });
    await click(host.root.querySelector('[data-manage="stats"]'));
    expect(vi.mocked(host.openManage).mock.calls).toEqual([['stats']]);
    expect(delegated, '委托不再认').toHaveBeenCalledTimes(1);
  });

  it('离开管理区时整块清空,回来再画', async () => {
    const { root, render } = await setup(props('stats', '/stats'));
    render(props('', '/'));
    expect(root.childElementCount).toBe(0);
    render(props('cleanup', '/data-cleanup'));
    expect(title(root)).toBe('数据管理');
    expect(root.querySelector('[data-manage-title]')!.hasAttribute('data-compact')).toBe(true);
    expect(root.querySelector('[data-manage-crumb]')).toBeNull();
  });
});

describe('管理条与面包屑', () => {
  it('按下项跟着当前区走,点一项回到壳的 openManage', async () => {
    const { root, host, render } = await setup(props('stats', '/stats'));
    const pressed = () => [...root.querySelectorAll('[data-manage][aria-pressed="true"]')].map((node) => node.getAttribute('data-manage'));
    expect(pressed()).toEqual(['stats']);
    expect(root.querySelector('[data-manage="stats"]')!.getAttribute('aria-current')).toBe('page');
    render(props('cleanup', '/data-cleanup'));
    expect(pressed()).toEqual(['cleanup']);
    expect(root.querySelector('[data-manage="stats"]')!.hasAttribute('aria-current')).toBe(false);
    await click(root.querySelector('[data-manage="stats"]'));
    expect(host.openManage).toHaveBeenCalledWith('stats');
  });

  it('数据管理之下的子页按下「数据管理」,骨架与组件同一个判据;管理条上没有的区不按下任何一项', async () => {
    const first = props('trash', '/trash');
    const { root, render } = await setup(first);
    const pressed = () => [...root.querySelectorAll('[data-manage][aria-pressed="true"]')].map((node) => node.getAttribute('data-manage'));
    expect(pressed()).toEqual(['cleanup']);
    const skeleton = document.createElement('div');
    skeleton.innerHTML = manageHeaderSkeletonHtml(first);
    expect([...skeleton.querySelectorAll('[data-manage][aria-pressed="true"]')]
      .map((node) => node.getAttribute('data-manage'))).toEqual(pressed());
    render(props('cleanup', '/quality-goals'));
    expect(pressed()).toEqual(['cleanup']);
    render(props('stats', '/stats'));
    expect(pressed()).toEqual(['stats']);
    expect(pressedManageKey({ section: 'trash', path: '/somewhere', menu: MENU })).toBe('');
  });

  it('面包屑普通左键走路由,带修饰键或中键的点击照链接自己走', async () => {
    const { root, host } = await setup(props('cleanup', '/duplicates'));
    const link = root.querySelector<HTMLAnchorElement>('[data-manage-crumb] a')!;
    expect(link.getAttribute('href')).toBe('/data-cleanup');
    expect(root.querySelector('[data-manage-crumb] [aria-current="true"]')!.textContent).toBe('重复文件');
    const fire = (init: MouseEventInit) => {
      const event = new MouseEvent('click', { bubbles: true, cancelable: true, ...init });
      act(() => { link.dispatchEvent(event) });
      return event.defaultPrevented;
    };
    expect(fire({})).toBe(true);
    expect(host.openDataCleanup).toHaveBeenCalledTimes(1);
    expect([fire({ ctrlKey: true }), fire({ metaKey: true }), fire({ shiftKey: true }), fire({ button: 1 })])
      .toEqual([false, false, false, false]);
    expect(host.openDataCleanup).toHaveBeenCalledTimes(1);
  });
});

describe('回收站说明行', () => {
  it('读数到之前铺同形占位,读到以后落读数与清空键;说明行一直是同一个节点', async () => {
    const { root, host, render } = await setup(props('trash', '/trash'));
    const lede = root.querySelector('[data-manage-lede]')!;
    expect(lede.querySelectorAll('[data-trash-lede-skeleton]')).toHaveLength(2);
    expect(lede.querySelector('[data-lede-text]')).toBeNull();
    render(props('trash', '/trash', { trash: { total: 1234, shown: 8 } }));
    expect(root.querySelector('[data-manage-lede]')).toBe(lede);
    expect(lede.querySelector('[data-trash-lede-skeleton]')).toBeNull();
    expect(lede.querySelector('[data-lede-text]')!.textContent).toBe('1,234 个符合 · 显示 8');
    await click(lede.querySelector('[data-empty-trash]'));
    expect(host.emptyTrash).toHaveBeenCalledTimes(1);
    render(props('trash', '/trash', { trash: { total: 0, shown: 0 } }));
    expect(lede.querySelector('[data-empty-trash]')).toBeNull();
  });

  it('同一页重画:读数那一格沿用原节点,旧字淡出后换成新字,不回到占位', async () => {
    const { root, render } = await setup(props('trash', '/trash', { trash: { total: 20, shown: 8 } }));
    vi.useFakeTimers();
    const cell = root.querySelector<HTMLElement>('[data-lede-text]')!;
    render(props('trash', '/trash', { trash: { total: 20, shown: 16 } }));
    expect(root.querySelector('[data-lede-text]')).toBe(cell);
    expect(root.querySelector('[data-trash-lede-skeleton]')).toBeNull();
    expect(cell.classList.contains('leaving')).toBe(true);
    expect(cell.textContent).toBe('20 个符合 · 显示 8');
    act(() => { vi.advanceTimersByTime(400) });
    expect(cell.textContent).toBe('20 个符合 · 显示 16');
    expect(cell.classList.contains('leaving')).toBe(false);
  });
});

describe('常驻组件', () => {
  it('句柄 render 返回时标题已是新内容,不等下一次渲染', async () => {
    const { root, api } = await setup(props('stats', '/stats'));
    /* 不包 act:act 会把 flushSync 推到它结束时,看不出句柄自己同步没有。 */
    (globalThis as ActFlag).IS_REACT_ACT_ENVIRONMENT = false;
    api.render(props('cleanup', '/junk-files'));
    expect(title(root)).toBe('垃圾文件');
    api.render(props('trash', '/trash'));
    expect([title(root), root.querySelectorAll('[data-trash-lede-skeleton]').length]).toEqual(['回收站', 2]);
  });

  it('抛错只卸组件、宿主还在,批量条照画;之后句柄是空操作、不抛,这一面空到刷新为止,只报一次', async () => {
    const reported = watchReports();
    const { r, root, api, render } = await setup(props('stats', '/stats'));
    const dockRoot = document.createElement('div');
    dockRoot.setAttribute('data-batch-dock', '');
    document.body.append(dockRoot);
    let dock!: BatchDockApi;
    await act(async () => { dock = await r.islands.loadBatchDock({ root: dockRoot, run: vi.fn() }) });

    glyph.broken = true;
    render(props('cleanup', '/data-cleanup'));
    await act(async () => {});
    expect(reported).toHaveBeenCalledTimes(1);
    expect(reported).toHaveBeenCalledWith(expect.objectContaining({ message: '页头画不出来' }));
    expect(root.isConnected, '宿主是壳的节点,不撤').toBe(true);
    expect(root.childNodes.length, '组件卸掉了').toBe(0);
    expect(r.managedTaken(root)).toBe(false);
    expect(r.managedEntries().map((entry) => entry.path), '别的面照画').toEqual(['batch-dock']);
    await act(async () => { dock.render({ count: 2, context: 'catalog', junkDismissed: false }) });
    expect(dockRoot.querySelector('[data-selection-dock] [role="status"]')?.textContent).toBe('已选 2 项');

    /* 壳照旧每次换页都推一份:不抛、不重开、不再上报。 */
    for (const next of [props('stats', '/stats'), props('trash', '/trash')]) {
      await act(async () => { expect(() => api.render(next)).not.toThrow() });
    }
    expect(reported, '确定性抛错只报那一次').toHaveBeenCalledTimes(1);
    glyph.broken = false;
    render(props('stats', '/stats'));
    expect(root.childNodes.length, '空到刷新为止,不自愈').toBe(0);
  });
});