bingocode 1.0.40 → 1.1.42

package/adapters/feishu/__tests__/card-errors.test.ts

@@ -1,194 +0,0 @@
-/**
- * card-errors 单元测试
- */
-
-import { describe, it, expect } from 'bun:test'
-import {
-  CARD_ERROR,
-  CARD_CONTENT_SUB_ERROR,
-  extractLarkApiCode,
-  extractSubCode,
-  parseCardApiError,
-  isCardRateLimitError,
-  isCardTableLimitError,
-} from '../card-errors.js'
-
-describe('extractLarkApiCode', () => {
-  it('从 err.code 直接提取', () => {
-    expect(extractLarkApiCode({ code: 230020 })).toBe(230020)
-  })
-
-  it('从 err.data.code 提取', () => {
-    expect(extractLarkApiCode({ data: { code: 230099 } })).toBe(230099)
-  })
-
-  it('从 err.response.data.code 提取（Axios 风格）', () => {
-    expect(extractLarkApiCode({ response: { data: { code: 99991672 } } })).toBe(99991672)
-  })
-
-  it('数字字符串被强制转成 number', () => {
-    expect(extractLarkApiCode({ code: '230020' })).toBe(230020)
-  })
-
-  it('三层结构优先级: err.code > err.data.code > err.response.data.code', () => {
-    const err = {
-      code: 1,
-      data: { code: 2 },
-      response: { data: { code: 3 } },
-    }
-    expect(extractLarkApiCode(err)).toBe(1)
-  })
-
-  it('none → undefined', () => {
-    expect(extractLarkApiCode({})).toBeUndefined()
-    expect(extractLarkApiCode(null)).toBeUndefined()
-    expect(extractLarkApiCode(undefined)).toBeUndefined()
-    expect(extractLarkApiCode('just a string')).toBeUndefined()
-    expect(extractLarkApiCode(new Error('plain'))).toBeUndefined()
-  })
-
-  it('非有限数字被忽略', () => {
-    expect(extractLarkApiCode({ code: NaN })).toBeUndefined()
-    expect(extractLarkApiCode({ code: 'not-a-number' })).toBeUndefined()
-  })
-})
-
-describe('extractSubCode', () => {
-  it('识别标准的 ErrCode: 11310', () => {
-    const msg = 'Failed to create card content, ext=ErrCode: 11310; ErrMsg: card table number over limit'
-    expect(extractSubCode(msg)).toBe(11310)
-  })
-
-  it('无 ErrCode 时返回 null', () => {
-    expect(extractSubCode('random error message')).toBeNull()
-    expect(extractSubCode('')).toBeNull()
-  })
-
-  it('ErrCode 大小写容错（冒号后多空格）', () => {
-    expect(extractSubCode('ErrCode:  42')).toBe(42)
-  })
-})
-
-describe('parseCardApiError', () => {
-  it('从 SDK 风格错误提取完整结构', () => {
-    const err = { code: 230099, msg: 'ErrCode: 11310; ErrMsg: card table number over limit' }
-    const parsed = parseCardApiError(err)
-    expect(parsed).toEqual({
-      code: 230099,
-      subCode: 11310,
-      errMsg: 'ErrCode: 11310; ErrMsg: card table number over limit',
-    })
-  })
-
-  it('从 Axios 风格错误（response.data.msg）提取', () => {
-    const err = {
-      response: {
-        data: {
-          code: 230020,
-          msg: 'rate limited',
-        },
-      },
-    }
-    const parsed = parseCardApiError(err)
-    expect(parsed?.code).toBe(230020)
-    expect(parsed?.errMsg).toBe('rate limited')
-    expect(parsed?.subCode).toBeNull()
-  })
-
-  it('无 code 时返回 null', () => {
-    expect(parseCardApiError({})).toBeNull()
-    expect(parseCardApiError(null)).toBeNull()
-    expect(parseCardApiError('string')).toBeNull()
-  })
-
-  it('有 code 无 msg 时 errMsg 为空字符串', () => {
-    const parsed = parseCardApiError({ code: 230020 })
-    expect(parsed).toEqual({ code: 230020, subCode: null, errMsg: '' })
-  })
-
-  it('fallback 到 err.message', () => {
-    const err = Object.assign(new Error('fallback text'), { code: 230099 })
-    const parsed = parseCardApiError(err)
-    expect(parsed?.errMsg).toBe('fallback text')
-  })
-})
-
-describe('isCardRateLimitError', () => {
-  it('识别 230020', () => {
-    expect(isCardRateLimitError({ code: 230020 })).toBe(true)
-  })
-
-  it('识别 Axios 风格 230020', () => {
-    expect(isCardRateLimitError({ response: { data: { code: 230020 } } })).toBe(true)
-  })
-
-  it('不匹配其他 code', () => {
-    expect(isCardRateLimitError({ code: 230099 })).toBe(false)
-    expect(isCardRateLimitError({ code: 99991672 })).toBe(false)
-  })
-
-  it('非错误对象返回 false', () => {
-    expect(isCardRateLimitError(null)).toBe(false)
-    expect(isCardRateLimitError({})).toBe(false)
-    expect(isCardRateLimitError(new Error('random'))).toBe(false)
-  })
-})
-
-describe('isCardTableLimitError', () => {
-  const validMsg = 'Failed to create card content, ext=ErrCode: 11310; ErrMsg: card table number over limit; ErrorValue: table; '
-
-  it('严格三条件匹配: code=230099 + subCode=11310 + msg 含 table number over limit', () => {
-    const err = { code: CARD_ERROR.CARD_CONTENT_FAILED, msg: validMsg }
-    expect(isCardTableLimitError(err)).toBe(true)
-  })
-
-  it('从 Axios 风格的 response.data 匹配', () => {
-    const err = {
-      response: {
-        data: {
-          code: 230099,
-          msg: validMsg,
-        },
-      },
-    }
-    expect(isCardTableLimitError(err)).toBe(true)
-  })
-
-  it('230099 + 11310 但没有 "table number over limit" 字样 → false（其它元素超限）', () => {
-    const err = {
-      code: CARD_ERROR.CARD_CONTENT_FAILED,
-      msg: 'ErrCode: 11310; ErrMsg: some other element limit; ',
-    }
-    expect(isCardTableLimitError(err)).toBe(false)
-  })
-
-  it('code 不是 230099 → false', () => {
-    const err = { code: 230020, msg: validMsg }
-    expect(isCardTableLimitError(err)).toBe(false)
-  })
-
-  it('没有 subCode → false', () => {
-    const err = { code: 230099, msg: 'card table number over limit (no ErrCode)' }
-    expect(isCardTableLimitError(err)).toBe(false)
-  })
-
-  it('不区分 "table number" 的大小写', () => {
-    const err = {
-      code: 230099,
-      msg: 'ErrCode: 11310; ErrMsg: CARD TABLE NUMBER OVER LIMIT; ',
-    }
-    expect(isCardTableLimitError(err)).toBe(true)
-  })
-})
-
-describe('常量值', () => {
-  it('CARD_ERROR.RATE_LIMITED === 230020', () => {
-    expect(CARD_ERROR.RATE_LIMITED).toBe(230020)
-  })
-  it('CARD_ERROR.CARD_CONTENT_FAILED === 230099', () => {
-    expect(CARD_ERROR.CARD_CONTENT_FAILED).toBe(230099)
-  })
-  it('CARD_CONTENT_SUB_ERROR.ELEMENT_LIMIT === 11310', () => {
-    expect(CARD_CONTENT_SUB_ERROR.ELEMENT_LIMIT).toBe(11310)
-  })
-})

package/adapters/feishu/__tests__/cardkit.test.ts

@@ -1,295 +0,0 @@
-/**
- * cardkit.ts 单元测试
- *
- * 不调用真实的 Lark API —— 用 mock client 捕获调用参数，验证:
- * - 每个函数构造的 payload 结构
- * - 非零 code 响应抛出 CardKitApiError（可被 card-errors 识别）
- * - 缺失关键字段时抛错
- * - sequence 正确传递
- */
-
-import { describe, it, expect } from 'bun:test'
-import {
-  createCardEntity,
-  sendCardAsMessage,
-  streamCardContent,
-  setCardStreamingMode,
-  updateCardKitCard,
-  CardKitApiError,
-  STREAMING_ELEMENT_ID,
-} from '../cardkit.js'
-import { isCardRateLimitError, isCardTableLimitError } from '../card-errors.js'
-
-// ---------------------------------------------------------------------------
-// Mock client factory
-// ---------------------------------------------------------------------------
-
-type MockCall = { api: string; args: any }
-
-function makeMockClient(responses: Record<string, any>) {
-  const calls: MockCall[] = []
-  const recorder = (api: string, resp: any) => async (args: any) => {
-    calls.push({ api, args })
-    if (typeof resp === 'function') {
-      return resp(args)
-    }
-    return resp
-  }
-  const client: any = {
-    cardkit: {
-      v1: {
-        card: {
-          create: recorder('cardkit.v1.card.create', responses['card.create']),
-          settings: recorder('cardkit.v1.card.settings', responses['card.settings']),
-          update: recorder('cardkit.v1.card.update', responses['card.update']),
-        },
-        cardElement: {
-          content: recorder(
-            'cardkit.v1.cardElement.content',
-            responses['cardElement.content'],
-          ),
-        },
-      },
-    },
-    im: {
-      message: {
-        create: recorder('im.message.create', responses['im.message.create']),
-        reply: recorder('im.message.reply', responses['im.message.reply']),
-      },
-    },
-  }
-  return { client, calls }
-}
-
-// ---------------------------------------------------------------------------
-// createCardEntity
-// ---------------------------------------------------------------------------
-
-describe('createCardEntity', () => {
-  it('构造 card_json payload 并返回 card_id', async () => {
-    const { client, calls } = makeMockClient({
-      'card.create': {
-        code: 0,
-        data: { card_id: 'ck_abc_123' },
-      },
-    })
-    const card = { schema: '2.0', body: { elements: [] } }
-    const id = await createCardEntity(client, card)
-
-    expect(id).toBe('ck_abc_123')
-    expect(calls.length).toBe(1)
-    expect(calls[0]!.api).toBe('cardkit.v1.card.create')
-    expect(calls[0]!.args.data.type).toBe('card_json')
-    // data.data 应当是 card 的 JSON 字符串
-    expect(calls[0]!.args.data.data).toBe(JSON.stringify(card))
-  })
-
-  it('兼容顶层 card_id（某些 SDK 包装层）', async () => {
-    const { client } = makeMockClient({
-      'card.create': { code: 0, card_id: 'top_level_id' },
-    })
-    const id = await createCardEntity(client, {})
-    expect(id).toBe('top_level_id')
-  })
-
-  it('non-zero code 抛 CardKitApiError', async () => {
-    const { client } = makeMockClient({
-      'card.create': { code: 230099, msg: 'something failed' },
-    })
-    await expect(createCardEntity(client, {})).rejects.toThrow(CardKitApiError)
-  })
-
-  it('code=0 但缺 card_id 抛错', async () => {
-    const { client } = makeMockClient({
-      'card.create': { code: 0, data: {} },
-    })
-    await expect(createCardEntity(client, {})).rejects.toThrow(/missing card_id/)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// sendCardAsMessage
-// ---------------------------------------------------------------------------
-
-describe('sendCardAsMessage', () => {
-  it('无 replyTo: 走 im.message.create 使用 chat_id', async () => {
-    const { client, calls } = makeMockClient({
-      'im.message.create': { data: { message_id: 'om_new_msg_1' } },
-    })
-    const mid = await sendCardAsMessage(client, 'oc_chat_123', 'ck_id_xyz')
-    expect(mid).toBe('om_new_msg_1')
-    expect(calls.length).toBe(1)
-    expect(calls[0]!.api).toBe('im.message.create')
-    expect(calls[0]!.args.params.receive_id_type).toBe('chat_id')
-    expect(calls[0]!.args.data.receive_id).toBe('oc_chat_123')
-    expect(calls[0]!.args.data.msg_type).toBe('interactive')
-    // content 格式: {"type":"card","data":{"card_id":"xxx"}}
-    const parsed = JSON.parse(calls[0]!.args.data.content)
-    expect(parsed).toEqual({ type: 'card', data: { card_id: 'ck_id_xyz' } })
-  })
-
-  it('有 replyTo: 走 im.message.reply', async () => {
-    const { client, calls } = makeMockClient({
-      'im.message.reply': { data: { message_id: 'om_reply_1' } },
-    })
-    const mid = await sendCardAsMessage(client, 'oc_chat_123', 'ck_id_xyz', 'om_parent')
-    expect(mid).toBe('om_reply_1')
-    expect(calls.length).toBe(1)
-    expect(calls[0]!.api).toBe('im.message.reply')
-    expect(calls[0]!.args.path.message_id).toBe('om_parent')
-    const parsed = JSON.parse(calls[0]!.args.data.content)
-    expect(parsed.data.card_id).toBe('ck_id_xyz')
-  })
-
-  it('缺 message_id 抛错', async () => {
-    const { client } = makeMockClient({
-      'im.message.create': { data: {} },
-    })
-    await expect(sendCardAsMessage(client, 'c', 'ck')).rejects.toThrow(
-      /missing message_id/,
-    )
-  })
-})
-
-// ---------------------------------------------------------------------------
-// streamCardContent
-// ---------------------------------------------------------------------------
-
-describe('streamCardContent', () => {
-  it('构造 content + sequence payload，path 包含 card_id + element_id', async () => {
-    const { client, calls } = makeMockClient({
-      'cardElement.content': { code: 0 },
-    })
-    await streamCardContent(client, 'ck_abc', STREAMING_ELEMENT_ID, 'hello', 42)
-
-    expect(calls.length).toBe(1)
-    expect(calls[0]!.api).toBe('cardkit.v1.cardElement.content')
-    expect(calls[0]!.args.data).toEqual({ content: 'hello', sequence: 42 })
-    expect(calls[0]!.args.path).toEqual({
-      card_id: 'ck_abc',
-      element_id: STREAMING_ELEMENT_ID,
-    })
-  })
-
-  it('STREAMING_ELEMENT_ID 常量 = "streaming_content"', () => {
-    expect(STREAMING_ELEMENT_ID).toBe('streaming_content')
-  })
-
-  it('230020 响应可被 isCardRateLimitError 识别', async () => {
-    const { client } = makeMockClient({
-      'cardElement.content': { code: 230020, msg: 'rate limited' },
-    })
-    try {
-      await streamCardContent(client, 'ck', 'el', 'x', 1)
-      expect('should have thrown').toBe('but did not')
-    } catch (err) {
-      expect(err).toBeInstanceOf(CardKitApiError)
-      expect(isCardRateLimitError(err)).toBe(true)
-    }
-  })
-
-  it('230099 + table limit msg 可被 isCardTableLimitError 识别', async () => {
-    const { client } = makeMockClient({
-      'cardElement.content': {
-        code: 230099,
-        msg: 'Failed to create card content, ext=ErrCode: 11310; ErrMsg: card table number over limit; ErrorValue: table; ',
-      },
-    })
-    try {
-      await streamCardContent(client, 'ck', 'el', 'x', 1)
-      expect('should have thrown').toBe('but did not')
-    } catch (err) {
-      expect(err).toBeInstanceOf(CardKitApiError)
-      expect(isCardTableLimitError(err)).toBe(true)
-    }
-  })
-})
-
-// ---------------------------------------------------------------------------
-// setCardStreamingMode
-// ---------------------------------------------------------------------------
-
-describe('setCardStreamingMode', () => {
-  it('streaming_mode=false + sequence 正确传递', async () => {
-    const { client, calls } = makeMockClient({
-      'card.settings': { code: 0 },
-    })
-    await setCardStreamingMode(client, 'ck_xxx', false, 99)
-
-    expect(calls.length).toBe(1)
-    expect(calls[0]!.api).toBe('cardkit.v1.card.settings')
-    expect(calls[0]!.args.path).toEqual({ card_id: 'ck_xxx' })
-    expect(calls[0]!.args.data.sequence).toBe(99)
-    // settings 是 JSON 字符串
-    const settings = JSON.parse(calls[0]!.args.data.settings)
-    expect(settings).toEqual({ streaming_mode: false })
-  })
-
-  it('streaming_mode=true 也能工作', async () => {
-    const { client, calls } = makeMockClient({
-      'card.settings': { code: 0 },
-    })
-    await setCardStreamingMode(client, 'ck', true, 1)
-    const settings = JSON.parse(calls[0]!.args.data.settings)
-    expect(settings).toEqual({ streaming_mode: true })
-  })
-})
-
-// ---------------------------------------------------------------------------
-// updateCardKitCard
-// ---------------------------------------------------------------------------
-
-describe('updateCardKitCard', () => {
-  it('把 card 包装成 card_json payload + sequence', async () => {
-    const { client, calls } = makeMockClient({
-      'card.update': { code: 0 },
-    })
-    const card = { schema: '2.0', body: { elements: [{ tag: 'markdown', content: 'done' }] } }
-    await updateCardKitCard(client, 'ck_final', card, 100)
-
-    expect(calls.length).toBe(1)
-    expect(calls[0]!.api).toBe('cardkit.v1.card.update')
-    expect(calls[0]!.args.path).toEqual({ card_id: 'ck_final' })
-    expect(calls[0]!.args.data.sequence).toBe(100)
-    expect(calls[0]!.args.data.card.type).toBe('card_json')
-    expect(calls[0]!.args.data.card.data).toBe(JSON.stringify(card))
-  })
-
-  it('非零 code 抛 CardKitApiError', async () => {
-    const { client } = makeMockClient({
-      'card.update': { code: -1, msg: 'bad card' },
-    })
-    await expect(updateCardKitCard(client, 'ck', {}, 1)).rejects.toThrow(CardKitApiError)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// CardKitApiError
-// ---------------------------------------------------------------------------
-
-describe('CardKitApiError', () => {
-  it('携带 code 和 msg，可被 parseCardApiError 识别', () => {
-    const err = new CardKitApiError({
-      api: 'card.update',
-      code: 230020,
-      msg: 'rate limited',
-      context: 'seq=5',
-    })
-    expect(err.code).toBe(230020)
-    expect(err.msg).toBe('rate limited')
-    expect(err.name).toBe('CardKitApiError')
-    expect(isCardRateLimitError(err)).toBe(true)
-  })
-
-  it('消息包含 api 名和 context', () => {
-    const err = new CardKitApiError({
-      api: 'cardElement.content',
-      code: 230099,
-      msg: 'oops',
-      context: 'seq=3 len=100',
-    })
-    expect(err.message).toContain('cardElement.content')
-    expect(err.message).toContain('230099')
-    expect(err.message).toContain('seq=3 len=100')
-  })
-})

package/adapters/feishu/__tests__/extract-payload.test.ts

@@ -1,77 +0,0 @@
-import { describe, it, expect } from 'bun:test'
-import { extractInboundPayload } from '../extract-payload.js'
-
-describe('extractInboundPayload', () => {
-  it('pulls text out of a text message', () => {
-    const result = extractInboundPayload(
-      JSON.stringify({ text: 'hello world' }),
-      'text',
-    )
-    expect(result.text).toBe('hello world')
-    expect(result.pendingDownloads).toEqual([])
-  })
-
-  it('pulls text out of a post (rich text) message', () => {
-    const content = JSON.stringify({
-      zh_cn: {
-        content: [[{ tag: 'text', text: 'hi ' }, { tag: 'text', text: 'there' }]],
-      },
-    })
-    const result = extractInboundPayload(content, 'post')
-    expect(result.text).toBe('hi there')
-    expect(result.pendingDownloads).toEqual([])
-  })
-
-  it('identifies an image message as a pending image download', () => {
-    const content = JSON.stringify({ image_key: 'img_key_abc' })
-    const result = extractInboundPayload(content, 'image')
-    expect(result.text).toBe('')
-    expect(result.pendingDownloads).toEqual([
-      { kind: 'image', fileKey: 'img_key_abc' },
-    ])
-  })
-
-  it('identifies a file message as a pending file download with file_name', () => {
-    const content = JSON.stringify({
-      file_key: 'file_key_xyz',
-      file_name: 'spec.pdf',
-    })
-    const result = extractInboundPayload(content, 'file')
-    expect(result.pendingDownloads).toEqual([
-      { kind: 'file', fileKey: 'file_key_xyz', fileName: 'spec.pdf' },
-    ])
-  })
-
-  it('identifies file_archive the same way as file', () => {
-    const content = JSON.stringify({ file_key: 'fk1', file_name: 'x.zip' })
-    const result = extractInboundPayload(content, 'file_archive')
-    expect(result.pendingDownloads).toEqual([
-      { kind: 'file', fileKey: 'fk1', fileName: 'x.zip' },
-    ])
-  })
-
-  it('extracts img + file elements from a post message', () => {
-    const content = JSON.stringify({
-      zh_cn: {
-        content: [
-          [{ tag: 'text', text: 'look: ' }],
-          [{ tag: 'img', image_key: 'img_post_1' }],
-          [{ tag: 'text', text: ' and ' }],
-          [{ tag: 'file', file_key: 'file_post_1', file_name: 'note.txt' }],
-        ],
-      },
-    })
-    const result = extractInboundPayload(content, 'post')
-    expect(result.text).toBe('look:  and ')
-    expect(result.pendingDownloads).toEqual([
-      { kind: 'image', fileKey: 'img_post_1' },
-      { kind: 'file', fileKey: 'file_post_1', fileName: 'note.txt' },
-    ])
-  })
-
-  it('returns empty on malformed JSON', () => {
-    const result = extractInboundPayload('not json', 'text')
-    expect(result.text).toBe('')
-    expect(result.pendingDownloads).toEqual([])
-  })
-})