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。

10.1 KB
Raw Blame
import { describe, expect, it } from 'vitest';
import {
  buildDeviceListPresentation,
  deviceAccessState,
  deviceDisplayName,
  isControllableDevice,
  platformLabel,
  toDeviceListItem,
  toDeviceListItems,
  type DeviceListDeviceLike,
  visibleDeviceListItems,
} from '../deviceList.js';

function device(patch: Partial<DeviceListDeviceLike> = {}): DeviceListDeviceLike {
  return {
    deviceId: 'dev-1',
    name: 'Mac',
    platform: 'darwin',
    lastSeenAt: '2026-01-01T00:00:00.000Z',
    online: true,
    busy: false,
    remoteControlEnabled: true,
    isSelf: false,
    ...patch,
  };
}

describe('shared device list presentation model', () => {
  it('requires online, remoteControlEnabled and not self', () => {
    expect(isControllableDevice(device())).toBe(true);
    expect(isControllableDevice(device({ busy: true }))).toBe(true);
    expect(isControllableDevice(device({ online: false }))).toBe(false);
    expect(isControllableDevice(device({ remoteControlEnabled: false }))).toBe(false);
    expect(isControllableDevice(device({ isSelf: true }))).toBe(false);
    expect(isControllableDevice(device({ platform: 'ios' }))).toBe(false);
    expect(isControllableDevice(device({ platform: 'android' }))).toBe(false);
  });

  it('uses user-facing platform labels', () => {
    expect(platformLabel('darwin')).toBe('macOS');
    expect(platformLabel('win32')).toBe('Windows');
    expect(platformLabel('linux')).toBe('Linux');
    expect(platformLabel('ios')).toBe('iOS');
    expect(platformLabel('android')).toBe('Android');
    expect(platformLabel(null)).toBe('Unknown');
  });

  it('maps device access states without treating busy as unavailable', () => {
    expect(deviceAccessState(device())).toBe('ready');
    expect(deviceAccessState(device({ busy: true }))).toBe('busy');
    expect(deviceAccessState(device({ deviceId: 'revoked' }), new Set(['revoked']))).toBe('access_revoked');
    expect(deviceAccessState(device({ online: false }))).toBe('offline');
    expect(deviceAccessState(device({ online: false, remoteControlEnabled: false }))).toBe('offline');
    expect(deviceAccessState(device({ remoteControlEnabled: false }))).toBe('remote_disabled');
    expect(deviceAccessState(device({ isSelf: true }))).toBe('self');
  });

  // Regression: the singular projection must reuse controllability so ready mobile clients cannot be opened.
  // Minimal unit inputs: online, remote-enabled iOS/Android; desktop ready/busy retain their existing projection.
  it('keeps ready mobile clients closed while preserving desktop ready and busy projections', () => {
    expect(toDeviceListItem(device({ platform: 'ios' }))).toMatchObject({ state: 'ready', canOpen: false });
    expect(toDeviceListItem(device({ platform: 'android' }))).toMatchObject({ state: 'ready', canOpen: false });
    expect(toDeviceListItem(device())).toMatchObject({ state: 'ready', canOpen: true });
    expect(toDeviceListItem(device({ busy: true }))).toMatchObject({ state: 'busy', canOpen: true });
  });

  it('omits the current mobile device and other mobile clients while keeping unavailable peers with actionable details', () => {
    const now = new Date('2026-01-01T00:10:00.000Z').getTime();
    const items = toDeviceListItems([
      device({ deviceId: 'self', isSelf: true }),
      device({ deviceId: 'phone', platform: 'ios' }),
      device({ deviceId: 'tablet', platform: 'android' }),
      device({ deviceId: 'disabled', name: 'Charlie', remoteControlEnabled: false }),
      device({ deviceId: 'busy', name: 'Alpha', busy: true }),
      device({ deviceId: 'revoked', name: 'Delta' }),
      device({ deviceId: 'offline', name: 'Echo', online: false, lastSeenAt: '2026-01-01T00:00:00.000Z' }),
      device({ deviceId: 'ready', name: 'Beta' }),
    ], now, new Set(['revoked']));

    expect(items.map((item) => [item.device.deviceId, item.state, item.canOpen])).toEqual([
      ['busy', 'busy', true],
      ['ready', 'ready', true],
      ['disabled', 'remote_disabled', false],
      ['revoked', 'access_revoked', false],
      ['offline', 'offline', false],
    ]);
    expect(items.find((item) => item.device.deviceId === 'ready')?.statusDetail).toBe('已允许远程控制');
    expect(items.find((item) => item.device.deviceId === 'busy')?.statusDetail).toBe('电脑端正在处理任务');
    expect(items.find((item) => item.device.deviceId === 'revoked')?.statusDetail).toContain('恢复');
    expect(items.find((item) => item.device.deviceId === 'disabled')?.statusDetail).toContain('打开允许远程控制');
    expect(items.find((item) => item.device.deviceId === 'offline')?.statusDetail).toContain('10 分钟前在线');
  });

  it('defaults the visible list to controllable devices while keeping unavailable diagnostics behind a toggle', () => {
    const items = toDeviceListItems([
      device({ deviceId: 'disabled', name: 'A disabled', remoteControlEnabled: false }),
      device({ deviceId: 'busy', name: 'B busy', busy: true }),
      device({ deviceId: 'offline', name: 'C offline', online: false }),
      device({ deviceId: 'ready', name: 'D ready' }),
    ]);

    expect(visibleDeviceListItems(items, false)).toMatchObject({
      availableCount: 2,
      hiddenUnavailableCount: 2,
      unavailableCount: 2,
    });
    expect(visibleDeviceListItems(items, false).visibleItems.map((item) => item.device.deviceId)).toEqual([
      'busy',
      'ready',
    ]);
    expect(visibleDeviceListItems(items, true).visibleItems.map((item) => item.device.deviceId)).toEqual([
      'busy',
      'ready',
      'disabled',
      'offline',
    ]);
  });

  it('shows unavailable devices by default when there is no controllable peer', () => {
    const items = toDeviceListItems([
      device({ deviceId: 'disabled', remoteControlEnabled: false }),
      device({ deviceId: 'offline', online: false }),
    ]);

    const visibility = visibleDeviceListItems(items, false);
    expect(visibility.availableCount).toBe(0);
    expect(visibility.hiddenUnavailableCount).toBe(0);
    expect(visibility.visibleItems.map((item) => item.device.deviceId)).toEqual(['disabled', 'offline']);
  });

  it('sorts same-bucket devices by stable identity instead of lastSeenAt or caller order', () => {
    const items = toDeviceListItems([
      device({ deviceId: 'second', name: 'Beta', lastSeenAt: '2026-01-01T00:00:00.000Z' }),
      device({ deviceId: 'first', name: 'Alpha', lastSeenAt: '2026-01-01T00:10:00.000Z' }),
    ]);

    expect(items.map((item) => item.device.deviceId)).toEqual(['first', 'second']);
  });

  it('keeps bucket order stable when ready and busy states change', () => {
    const readyBusy = toDeviceListItems([
      device({ deviceId: 'beta', name: 'Beta', busy: false }),
      device({ deviceId: 'alpha', name: 'Alpha', busy: true }),
    ]);
    const busyReady = toDeviceListItems([
      device({ deviceId: 'beta', name: 'Beta', busy: true }),
      device({ deviceId: 'alpha', name: 'Alpha', busy: false }),
    ]);

    expect(readyBusy.map((item) => [item.device.deviceId, item.state])).toEqual([
      ['alpha', 'busy'],
      ['beta', 'ready'],
    ]);
    expect(busyReady.map((item) => [item.device.deviceId, item.state])).toEqual([
      ['alpha', 'ready'],
      ['beta', 'busy'],
    ]);
  });

  it('keeps available devices before unavailable devices while sorting within each bucket by stable identity', () => {
    const items = toDeviceListItems([
      device({ deviceId: 'unavailable-a', name: 'A unavailable', online: false }),
      device({ deviceId: 'available-b', name: 'B available' }),
      device({ deviceId: 'unavailable-c', name: 'C unavailable', remoteControlEnabled: false }),
      device({ deviceId: 'available-d', name: 'D available', busy: true }),
    ]);

    expect(items.map((item) => [item.device.deviceId, item.canOpen])).toEqual([
      ['available-b', true],
      ['available-d', true],
      ['unavailable-a', false],
      ['unavailable-c', false],
    ]);
  });

  it('builds header, filter, toggle, and empty-state copy from the same visibility model', () => {
    const hiddenUnavailable = buildDeviceListPresentation({
      availableCount: 2,
      hiddenUnavailableCount: 3,
      unavailableCount: 3,
    }, false);
    expect(hiddenUnavailable).toMatchObject({
      headerSubtitle: '2 台电脑可控制',
      filterTitle: '可控制设备',
      filterMeta: '2 台可进入 · 3 台需处理',
      toggleAccessibilityLabel: '显示不可用电脑',
      toggleLabel: '不可用 3',
    });

    const shownUnavailable = buildDeviceListPresentation({
      availableCount: 2,
      hiddenUnavailableCount: 0,
      unavailableCount: 3,
    }, true);
    expect(shownUnavailable).toMatchObject({
      toggleAccessibilityLabel: '隐藏不可用电脑',
      toggleLabel: '只看可用',
    });

    const empty = buildDeviceListPresentation({
      availableCount: 0,
      hiddenUnavailableCount: 0,
      unavailableCount: 0,
    }, false);
    expect(empty.headerSubtitle).toBe('等待电脑端上线');
    expect(empty.filterMeta).toBe('等待电脑端上线');
    expect(empty.toggleLabel).toBeNull();
    expect(empty.emptyTitle).toBe('还没有可显示的电脑');
  });
});

// Regression: full device fingerprints crowded teammate/project labels, including cached ID-as-name values.
describe('device display names', () => {
  it('recovers missing or cached ID names from the roster, otherwise uses localized copy', () => {
    const id = 'eb2ad08b24c63a9e818609e29057ca8d1a4';
    expect(deviceDisplayName(id, id, '未命名设备', [{ deviceId: id, name: ' Mac Studio ' }])).toBe('Mac Studio');
    expect(deviceDisplayName(id, ' ', '未命名设备')).toBe('未命名设备');
    expect(deviceDisplayName(id, id, '未命名设备')).toBe('未命名设备');
  });
  it('uses deterministic ordinals for distinct duplicate hosts without changing routing identities', () => {
    const devices = [{ deviceId: 'b', name: 'Studio' }, { deviceId: 'a', name: ' studio ' }];
    expect(deviceDisplayName('b', 'Studio', 'Computer', devices)).toBe('Studio (2)');
    expect(deviceDisplayName('b', 'Studio', 'Computer', [...devices].reverse())).toBe('Studio (2)');
    expect(deviceDisplayName('b', 'Studio', 'Computer', [devices[0], devices[0]])).toBe('Studio');
    expect(devices.map((device) => device.deviceId)).toEqual(['b', 'a']);
  });
});