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.4 KB
Raw Blame
/**
 * slack-hook-protocol 阶段 19(Telegram 行为配置)测试:
 *   1. provider.behavior.get/set/state 构造 -> 序列化 -> 解析 round-trip
 *   2. 选择器校验: provider 只认 telegram、bindingId 非空必填(不接受 scopeId 替代)
 *   3. set: 三个全局字段的 `enum | null` patch 三态(不动 / 显式 override / 显式
 *      清除), 各自取值校验, 以及"至少一个实际 patch"的空 set 拒收(null 也算
 *      一次真实改动)
 *   4. state: 三个全局字段收敛为必填非空枚举(从不是 patch、从不是 null)、
 *      groupActivation 的形状/取值校验与累积可表达性, 以及 bound=false -> 默认值 + 空
 *      groupActivation 的字段联动(parse 强制)
 *   5. 能力标识常量 provider-behavior-v1
 *   6. DEFAULT_TELEGRAM_BEHAVIOR 与个人版桌面客户端出厂默认对齐
 */

import { describe, it, expect } from 'vitest';

import {
  DEFAULT_TELEGRAM_BEHAVIOR,
  HOOK_FEATURE_PROVIDER_BEHAVIOR,
  PROVIDER_BEHAVIOR_PROVIDERS,
  TELEGRAM_EMOJI_REACTIONS,
  TELEGRAM_GROUP_ACTIVATION_ALWAYS,
  TELEGRAM_REPLY_QUOTE_DM,
  TELEGRAM_REPLY_QUOTE_GROUP,
  makeProviderBehaviorGet,
  makeProviderBehaviorSet,
  makeProviderBehaviorState,
  parseHookMessage,
  serializeHookMessage,
  type HookMessage,
  type ProviderBehaviorGetPayload,
  type ProviderBehaviorSetPayload,
  type ProviderBehaviorStatePayload,
} from '../index';

function roundTrip(message: HookMessage): HookMessage {
  const parsed = parseHookMessage(serializeHookMessage(message));
  expect(parsed.ok, parsed.ok ? '' : parsed.error).toBe(true);
  if (!parsed.ok) throw new Error('unreachable');
  expect(parsed.message).toEqual(message);
  return parsed.message;
}

function expectReject(mutated: unknown, keyword: string): void {
  const parsed = parseHookMessage(mutated);
  expect(parsed.ok).toBe(false);
  if (parsed.ok) throw new Error('unreachable');
  expect(parsed.error).toContain(keyword);
}

const BINDING_ID = 'binding-tg-1';
const CHAT_ID = '-1001234567890';

const GET: ProviderBehaviorGetPayload = {
  requestId: 'behavior-req-1',
  provider: 'telegram',
  bindingId: BINDING_ID,
};

const SET_GLOBAL_ONLY: ProviderBehaviorSetPayload = {
  requestId: 'behavior-req-2',
  provider: 'telegram',
  bindingId: BINDING_ID,
  emojiReactions: 'minimal',
  replyQuoteDm: 'first',
  replyQuoteGroup: 'all',
};

const SET_GROUP_ACTIVATION_ONLY: ProviderBehaviorSetPayload = {
  requestId: 'behavior-req-3',
  provider: 'telegram',
  bindingId: BINDING_ID,
  groupActivation: { chatId: CHAT_ID, value: TELEGRAM_GROUP_ACTIVATION_ALWAYS },
};

const SET_GROUP_ACTIVATION_CLEAR: ProviderBehaviorSetPayload = {
  requestId: 'behavior-req-4',
  provider: 'telegram',
  bindingId: BINDING_ID,
  groupActivation: { chatId: CHAT_ID, value: null },
};

const SET_COMBINED: ProviderBehaviorSetPayload = {
  requestId: 'behavior-req-5',
  provider: 'telegram',
  bindingId: BINDING_ID,
  emojiReactions: 'expressive',
  replyQuoteDm: 'off',
  replyQuoteGroup: 'first',
  groupActivation: { chatId: CHAT_ID, value: TELEGRAM_GROUP_ACTIVATION_ALWAYS },
};

// 三个全局字段的 null = 显式清除 override(回落版本默认), 与 undefined(不动)
// 是不同的三态第三态。
const SET_GLOBAL_ALL_NULL: ProviderBehaviorSetPayload = {
  requestId: 'behavior-req-6',
  provider: 'telegram',
  bindingId: BINDING_ID,
  emojiReactions: null,
  replyQuoteDm: null,
  replyQuoteGroup: null,
};

const SET_SINGLE_NULL_ONLY: ProviderBehaviorSetPayload = {
  requestId: 'behavior-req-7',
  provider: 'telegram',
  bindingId: BINDING_ID,
  emojiReactions: null,
};

const SET_NULL_PLUS_GROUP_ACTIVATION: ProviderBehaviorSetPayload = {
  requestId: 'behavior-req-8',
  provider: 'telegram',
  bindingId: BINDING_ID,
  replyQuoteGroup: null,
  groupActivation: { chatId: CHAT_ID, value: TELEGRAM_GROUP_ACTIVATION_ALWAYS },
};

const STATE_BOUND_NON_DEFAULT: ProviderBehaviorStatePayload = {
  provider: 'telegram',
  bindingId: BINDING_ID,
  replyTo: 'behavior-req-5',
  bound: true,
  emojiReactions: 'expressive',
  replyQuoteDm: 'first',
  replyQuoteGroup: 'all',
  groupActivation: { [CHAT_ID]: TELEGRAM_GROUP_ACTIVATION_ALWAYS },
};

const STATE_BOUND_DEFAULT: ProviderBehaviorStatePayload = {
  provider: 'telegram',
  bindingId: BINDING_ID,
  replyTo: null,
  bound: true,
  ...DEFAULT_TELEGRAM_BEHAVIOR,
  groupActivation: {},
};

const STATE_UNBOUND: ProviderBehaviorStatePayload = {
  provider: 'telegram',
  bindingId: BINDING_ID,
  replyTo: null,
  bound: false,
  ...DEFAULT_TELEGRAM_BEHAVIOR,
  groupActivation: {},
};

describe('provider.behavior(阶段 19)', () => {
  it('能力标识常量', () => {
    expect(HOOK_FEATURE_PROVIDER_BEHAVIOR).toBe('provider-behavior-v1');
  });

  it('导出的 provider/behavior 枚举表在运行时不可变', () => {
    expect(Object.isFrozen(PROVIDER_BEHAVIOR_PROVIDERS)).toBe(true);
    expect(Object.isFrozen(TELEGRAM_EMOJI_REACTIONS)).toBe(true);
    expect(Object.isFrozen(TELEGRAM_REPLY_QUOTE_DM)).toBe(true);
    expect(Object.isFrozen(TELEGRAM_REPLY_QUOTE_GROUP)).toBe(true);
  });

  it('DEFAULT_TELEGRAM_BEHAVIOR 与个人版桌面客户端出厂默认对齐', () => {
    expect(DEFAULT_TELEGRAM_BEHAVIOR).toEqual({
      emojiReactions: 'minimal',
      replyQuoteDm: 'off',
      replyQuoteGroup: 'first',
    });
    expect(Object.isFrozen(DEFAULT_TELEGRAM_BEHAVIOR)).toBe(true);
    expect(() => {
      (DEFAULT_TELEGRAM_BEHAVIOR as { emojiReactions: string }).emojiReactions = 'off';
    }).toThrow(TypeError);
  });

  it('round-trip: get', () => {
    roundTrip(makeProviderBehaviorGet(GET));
  });

  it('round-trip: set(全局字段 / groupActivation 单独 / 混合 / 清除)', () => {
    roundTrip(makeProviderBehaviorSet(SET_GLOBAL_ONLY));
    roundTrip(makeProviderBehaviorSet(SET_GROUP_ACTIVATION_ONLY));
    roundTrip(makeProviderBehaviorSet(SET_GROUP_ACTIVATION_CLEAR));
    roundTrip(makeProviderBehaviorSet(SET_COMBINED));
  });

  it('round-trip: set 全局字段的显式 null(清除 override, 与 undefined 不同)', () => {
    roundTrip(makeProviderBehaviorSet(SET_GLOBAL_ALL_NULL));
    // 只 clear 一个字段、其余不动, 仍算一次实际 patch, 不会被当空 set 拒收。
    roundTrip(makeProviderBehaviorSet(SET_SINGLE_NULL_ONLY));
    // null 清除与 groupActivation patch 可同帧组合。
    roundTrip(makeProviderBehaviorSet(SET_NULL_PLUS_GROUP_ACTIVATION));
  });

  it('round-trip: state(bound 非默认 / bound 默认 / 未绑定)', () => {
    roundTrip(makeProviderBehaviorState(STATE_BOUND_NON_DEFAULT));
    roundTrip(makeProviderBehaviorState(STATE_BOUND_DEFAULT));
    roundTrip(makeProviderBehaviorState(STATE_UNBOUND));
  });

  it('选择器校验: bindingId 必须非空字符串, 不接受缺省或 scopeId 替代', () => {
    const get = makeProviderBehaviorGet(GET);
    expectReject({ ...get, payload: { ...GET, bindingId: '' } }, 'provider.behavior.get.bindingId');
    const missingBindingId: Record<string, unknown> = { ...GET };
    delete missingBindingId.bindingId;
    expectReject({ ...get, payload: missingBindingId }, 'provider.behavior.get.bindingId');
    // scopeId 不是这个 selector 认识的字段: 加了也不能替代 bindingId。
    expectReject(
      {
        ...get,
        payload: { requestId: GET.requestId, provider: GET.provider, scopeId: 'bot-1' },
      },
      'provider.behavior.get.bindingId',
    );
  });

  it('选择器校验: provider 只认 telegram(get/set/state 三帧都拒收非法值)', () => {
    const get = makeProviderBehaviorGet(GET);
    expectReject(
      { ...get, payload: { ...GET, provider: 'slack' } },
      'provider.behavior.get.provider',
    );
    const set = makeProviderBehaviorSet(SET_GLOBAL_ONLY);
    expectReject(
      { ...set, payload: { ...SET_GLOBAL_ONLY, provider: 'x' } },
      'provider.behavior.set.provider',
    );
    const state = makeProviderBehaviorState(STATE_BOUND_DEFAULT);
    expectReject(
      { ...state, payload: { ...STATE_BOUND_DEFAULT, provider: 'discord' } },
      'provider.behavior.state.provider',
    );
  });

  it('set: 三个全局字段各自校验非法取值(必须是已知枚举或 null, 二者之外都拒收)', () => {
    const set = makeProviderBehaviorSet(SET_GLOBAL_ONLY);
    expectReject(
      { ...set, payload: { ...SET_GLOBAL_ONLY, emojiReactions: 'loud' } },
      'provider.behavior.set.emojiReactions',
    );
    expectReject(
      { ...set, payload: { ...SET_GLOBAL_ONLY, replyQuoteDm: 'always' } },
      'provider.behavior.set.replyQuoteDm',
    );
    expectReject(
      { ...set, payload: { ...SET_GLOBAL_ONLY, replyQuoteGroup: 'some' } },
      'provider.behavior.set.replyQuoteGroup',
    );
    // 非字符串、非 null 的其它类型同样拒收(不能借道混入任意值)。
    expectReject(
      { ...set, payload: { ...SET_GLOBAL_ONLY, emojiReactions: 0 } },
      'provider.behavior.set.emojiReactions',
    );
  });

  it('set: groupActivation patch 的 chatId / value 校验', () => {
    const set = makeProviderBehaviorSet(SET_GROUP_ACTIVATION_ONLY);
    expectReject(
      {
        ...set,
        payload: {
          ...SET_GROUP_ACTIVATION_ONLY,
          groupActivation: { chatId: 'not-a-number', value: TELEGRAM_GROUP_ACTIVATION_ALWAYS },
        },
      },
      'provider.behavior.set.groupActivation.chatId',
    );
    for (const chatId of ['0', '123', '-0', '-001', '-4503599627370496']) {
      expectReject(
        {
          ...set,
          payload: {
            ...SET_GROUP_ACTIVATION_ONLY,
            groupActivation: { chatId, value: TELEGRAM_GROUP_ACTIVATION_ALWAYS },
          },
        },
        'provider.behavior.set.groupActivation.chatId',
      );
    }
    expectReject(
      {
        ...set,
        payload: {
          ...SET_GROUP_ACTIVATION_ONLY,
          groupActivation: { chatId: '', value: TELEGRAM_GROUP_ACTIVATION_ALWAYS },
        },
      },
      'provider.behavior.set.groupActivation.chatId',
    );
    expectReject(
      {
        ...set,
        payload: {
          ...SET_GROUP_ACTIVATION_ONLY,
          groupActivation: { chatId: '1'.repeat(33), value: TELEGRAM_GROUP_ACTIVATION_ALWAYS },
        },
      },
      'provider.behavior.set.groupActivation.chatId',
    );
    expectReject(
      {
        ...set,
        payload: {
          ...SET_GROUP_ACTIVATION_ONLY,
          groupActivation: { chatId: CHAT_ID, value: 'mention' },
        },
      },
      'provider.behavior.set.groupActivation.value',
    );
    expectReject(
      {
        ...set,
        payload: { ...SET_GROUP_ACTIVATION_ONLY, groupActivation: 'not-an-object' },
      },
      'provider.behavior.set.groupActivation',
    );
  });

  it('set: 空 patch(既无全局字段也无 groupActivation)拒收', () => {
    const set = makeProviderBehaviorSet(SET_GLOBAL_ONLY);
    const empty: Record<string, unknown> = {
      requestId: SET_GLOBAL_ONLY.requestId,
      provider: SET_GLOBAL_ONLY.provider,
      bindingId: SET_GLOBAL_ONLY.bindingId,
    };
    expectReject({ ...set, payload: empty }, 'at least one behavior field');
  });

  it('set: requestId 必须非空字符串', () => {
    const set = makeProviderBehaviorSet(SET_GLOBAL_ONLY);
    expectReject(
      { ...set, payload: { ...SET_GLOBAL_ONLY, requestId: '' } },
      'provider.behavior.set.requestId',
    );
  });

  it('state: 三个全局字段必须是完整(非 patch)非空枚举值 —— 不接受 undefined 也不接受 null', () => {
    const state = makeProviderBehaviorState(STATE_BOUND_DEFAULT);
    expectReject(
      { ...state, payload: { ...STATE_BOUND_DEFAULT, emojiReactions: undefined } },
      'provider.behavior.state.emojiReactions',
    );
    // 与 set 不同: state 是已解析的有效值快照, null(patch 语义里的"清除")在这里
    // 没有意义 —— 必须已经解析成某个具体的默认或 override 枚举值。
    expectReject(
      { ...state, payload: { ...STATE_BOUND_DEFAULT, emojiReactions: null } },
      'provider.behavior.state.emojiReactions',
    );
    expectReject(
      { ...state, payload: { ...STATE_BOUND_DEFAULT, replyQuoteDm: 'loud' } },
      'provider.behavior.state.replyQuoteDm',
    );
    expectReject(
      { ...state, payload: { ...STATE_BOUND_DEFAULT, replyQuoteGroup: 'lots' } },
      'provider.behavior.state.replyQuoteGroup',
    );
  });

  it('state: groupActivation 形状、键值校验与累积可表达性', () => {
    const state = makeProviderBehaviorState(STATE_BOUND_NON_DEFAULT);
    expectReject(
      { ...state, payload: { ...STATE_BOUND_NON_DEFAULT, groupActivation: 'not-an-object' } },
      'provider.behavior.state.groupActivation must be an object',
    );
    expectReject(
      {
        ...state,
        payload: {
          ...STATE_BOUND_NON_DEFAULT,
          groupActivation: { 'not-a-chat-id': TELEGRAM_GROUP_ACTIVATION_ALWAYS },
        },
      },
      'provider.behavior.state.groupActivation key must be a canonical negative Telegram group chat id',
    );
    expectReject(
      {
        ...state,
        payload: {
          ...STATE_BOUND_NON_DEFAULT,
          groupActivation: { '001': TELEGRAM_GROUP_ACTIVATION_ALWAYS },
        },
      },
      'provider.behavior.state.groupActivation key must be a canonical negative Telegram group chat id',
    );
    expectReject(
      {
        ...state,
        payload: { ...STATE_BOUND_NON_DEFAULT, groupActivation: { [CHAT_ID]: 'mention' } },
      },
      `must be '${TELEGRAM_GROUP_ACTIVATION_ALWAYS}'`,
    );
    const accumulated: Record<string, typeof TELEGRAM_GROUP_ACTIVATION_ALWAYS> = Object.fromEntries(
      Array.from({ length: 501 }, (_, i) => [`-${i + 1}`, TELEGRAM_GROUP_ACTIVATION_ALWAYS]),
    );
    roundTrip(
      makeProviderBehaviorState({ ...STATE_BOUND_NON_DEFAULT, groupActivation: accumulated }),
    );
  });

  it('字段联动(parse 强制): bound=false 必须收敛为默认行为与空 groupActivation', () => {
    const nonDefaultState = makeProviderBehaviorState(STATE_BOUND_NON_DEFAULT);
    expectReject(
      { ...nonDefaultState, payload: { ...STATE_BOUND_NON_DEFAULT, bound: false } },
      'must report the default behavior when bound is false',
    );

    const defaultState = makeProviderBehaviorState(STATE_BOUND_DEFAULT);
    expectReject(
      {
        ...defaultState,
        payload: {
          ...STATE_BOUND_DEFAULT,
          bound: false,
          groupActivation: { [CHAT_ID]: TELEGRAM_GROUP_ACTIVATION_ALWAYS },
        },
      },
      'groupActivation must be empty when bound is false',
    );

    // 反过来: bound=false 且已是默认值 + 空 map 的合法快照必须放行(已在上面的
    // round-trip 用例覆盖 STATE_UNBOUND, 这里不重复)。
  });
});