bingocode 1.0.26 → 1.0.28

package/adapters/common/__tests__/ws-bridge.test.ts

@@ -1,177 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'bun:test'
-import { WsBridge } from '../ws-bridge.js'
-import { WebSocketServer, type WebSocket as WsServerSocket } from 'ws'
-
-describe('WsBridge', () => {
-  let bridge: WsBridge
-
-  beforeEach(() => {
-    bridge = new WsBridge('ws://127.0.0.1:19999', 'test')
-  })
-
-  afterEach(() => {
-    bridge.destroy()
-  })
-
-  it('connectSession connects with provided sessionId', () => {
-    const result = bridge.connectSession('chat-1', 'my-uuid-session-id')
-    expect(result).toBe(true)
-    expect(bridge.hasSession('chat-1')).toBe(true)
-  })
-
-  it('connectSession for different chatIds creates separate sessions', () => {
-    bridge.connectSession('chat-1', 'uuid-1')
-    bridge.connectSession('chat-2', 'uuid-2')
-    expect(bridge.hasSession('chat-1')).toBe(true)
-    expect(bridge.hasSession('chat-2')).toBe(true)
-  })
-
-  it('resetSession removes the session', () => {
-    bridge.connectSession('chat-reset', 'uuid-reset')
-    bridge.resetSession('chat-reset')
-    expect(bridge.hasSession('chat-reset')).toBe(false)
-  })
-
-  it('sendUserMessage returns false when no open connection', () => {
-    bridge.connectSession('chat-offline', 'uuid-offline')
-    expect(bridge.sendUserMessage('chat-offline', 'hello')).toBe(false)
-  })
-
-  it('sendPermissionResponse returns false when no open connection', () => {
-    bridge.connectSession('chat-perm', 'uuid-perm')
-    expect(bridge.sendPermissionResponse('chat-perm', 'req-1', true)).toBe(false)
-  })
-
-  it('sendStopGeneration returns false when no open connection', () => {
-    bridge.connectSession('chat-stop', 'uuid-stop')
-    expect(bridge.sendStopGeneration('chat-stop')).toBe(false)
-  })
-
-  it('destroy cleans up all sessions', () => {
-    bridge.connectSession('a', 'uuid-a')
-    bridge.connectSession('b', 'uuid-b')
-    bridge.destroy()
-    expect(bridge.hasSession('a')).toBe(false)
-    expect(bridge.hasSession('b')).toBe(false)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Integration: per-chat handler serialization
-//
-// Reproduces the feishu text→tool→text race: a slow handler on msg 1 must
-// complete BEFORE msg 2's handler starts, otherwise msg 2 reads the stale
-// state msg 1's continuation is about to clear.
-// ---------------------------------------------------------------------------
-
-describe('WsBridge: handler serialization', () => {
-  let server: WebSocketServer
-  let port: number
-  let connections: WsServerSocket[]
-  let serverUrl: string
-
-  beforeEach(async () => {
-    connections = []
-    // port 0 → let the OS pick a free one
-    server = new WebSocketServer({ port: 0 })
-    server.on('connection', (ws) => {
-      connections.push(ws)
-    })
-    await new Promise<void>((resolve) => server.on('listening', () => resolve()))
-    port = (server.address() as { port: number }).port
-    serverUrl = `ws://127.0.0.1:${port}`
-  })
-
-  afterEach(async () => {
-    // Forcibly kill any server-side sockets (not graceful close) so
-    // WebSocketServer.close() doesn't wait for client FIN.
-    for (const ws of connections) {
-      try { ws.terminate() } catch {}
-    }
-    await new Promise<void>((resolve) => {
-      const t = setTimeout(() => resolve(), 500) // hard cap
-      server.close(() => {
-        clearTimeout(t)
-        resolve()
-      })
-    })
-  })
-
-  it('processes handler calls in strict FIFO order per chatId', async () => {
-    const bridge = new WsBridge(serverUrl, 'test')
-    const events: string[] = []
-
-    // The handler simulates an async side effect that takes varying time.
-    // If handlers ran concurrently, fast msgs could finish before slow ones,
-    // producing an out-of-order `events` array.
-    bridge.onServerMessage('chat-1', async (msg: any) => {
-      const tag = msg.tag as string
-      const delay = msg.delay as number
-      events.push(`start:${tag}`)
-      await new Promise((r) => setTimeout(r, delay))
-      events.push(`end:${tag}`)
-    })
-
-    bridge.connectSession('chat-1', 'sess-1')
-    const ok = await bridge.waitForOpen('chat-1')
-    expect(ok).toBe(true)
-    expect(connections.length).toBe(1)
-    const serverWs = connections[0]!
-
-    // Blast three messages back-to-back. msg1 is slow, msg2/msg3 are fast.
-    // With serialization: start:1, end:1, start:2, end:2, start:3, end:3
-    // Without serialization: start:1, start:2, start:3, end:2, end:3, end:1
-    serverWs.send(JSON.stringify({ tag: '1', delay: 40 }))
-    serverWs.send(JSON.stringify({ tag: '2', delay: 5 }))
-    serverWs.send(JSON.stringify({ tag: '3', delay: 5 }))
-
-    // Wait long enough for all three handlers to run serially
-    await new Promise((r) => setTimeout(r, 200))
-
-    expect(events).toEqual([
-      'start:1', 'end:1',
-      'start:2', 'end:2',
-      'start:3', 'end:3',
-    ])
-
-    bridge.destroy()
-  })
-
-  it('handler error does not break the chain (subsequent messages still run)', async () => {
-    const bridge = new WsBridge(serverUrl, 'test')
-    const events: string[] = []
-
-    bridge.onServerMessage('chat-err', async (msg: any) => {
-      if (msg.throw) {
-        events.push('throwing')
-        throw new Error('boom')
-      }
-      events.push(`ok:${msg.tag}`)
-    })
-
-    bridge.connectSession('chat-err', 'sess-err')
-    await bridge.waitForOpen('chat-err')
-    const serverWs = connections[0]!
-
-    serverWs.send(JSON.stringify({ throw: true }))
-    serverWs.send(JSON.stringify({ tag: 'after' }))
-
-    await new Promise((r) => setTimeout(r, 80))
-
-    expect(events).toEqual(['throwing', 'ok:after'])
-
-    bridge.destroy()
-  })
-
-  it('resetSession clears the handler chain', async () => {
-    const bridge = new WsBridge(serverUrl, 'test')
-    bridge.onServerMessage('chat-reset', () => {})
-    bridge.connectSession('chat-reset', 'sess-reset')
-    await bridge.waitForOpen('chat-reset')
-
-    bridge.resetSession('chat-reset')
-    expect(bridge.hasSession('chat-reset')).toBe(false)
-
-    bridge.destroy()
-  })
-})

package/adapters/common/attachment/__tests__/attachment-limits.test.ts

@@ -1,52 +0,0 @@
-import { describe, it, expect } from 'bun:test'
-import {
-  checkAttachmentLimit,
-  IMAGE_MAX_BYTES,
-  FILE_MAX_BYTES,
-  IMAGE_MIME_WHITELIST,
-} from '../attachment-limits.js'
-
-describe('checkAttachmentLimit', () => {
-  it('accepts a 1 MB PNG image', () => {
-    const result = checkAttachmentLimit('image', 1024 * 1024, 'image/png')
-    expect(result.ok).toBe(true)
-  })
-
-  it('rejects an 11 MB image as too_large', () => {
-    const result = checkAttachmentLimit('image', 11 * 1024 * 1024, 'image/png')
-    expect(result.ok).toBe(false)
-    if (!result.ok) {
-      expect(result.reason).toBe('too_large')
-      expect(result.hint).toContain('10')
-    }
-  })
-
-  it('rejects an unsupported image mime', () => {
-    const result = checkAttachmentLimit('image', 500_000, 'image/svg+xml')
-    expect(result.ok).toBe(false)
-    if (!result.ok) expect(result.reason).toBe('unsupported_mime')
-  })
-
-  it('rejects image/heic (not supported by Claude API)', () => {
-    const result = checkAttachmentLimit('image', 500_000, 'image/heic')
-    expect(result.ok).toBe(false)
-    if (!result.ok) expect(result.reason).toBe('unsupported_mime')
-  })
-
-  it('accepts a 10 MB PDF file', () => {
-    const result = checkAttachmentLimit('file', 10 * 1024 * 1024, 'application/pdf')
-    expect(result.ok).toBe(true)
-  })
-
-  it('rejects a 31 MB file as too_large', () => {
-    const result = checkAttachmentLimit('file', 31 * 1024 * 1024, 'application/pdf')
-    expect(result.ok).toBe(false)
-    if (!result.ok) expect(result.reason).toBe('too_large')
-  })
-
-  it('exposes the limits as exports', () => {
-    expect(IMAGE_MAX_BYTES).toBe(10 * 1024 * 1024)
-    expect(FILE_MAX_BYTES).toBe(30 * 1024 * 1024)
-    expect(IMAGE_MIME_WHITELIST).toContain('image/png')
-  })
-})

package/adapters/common/attachment/__tests__/attachment-store.test.ts

@@ -1,108 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'bun:test'
-import * as fs from 'node:fs/promises'
-import * as fsSync from 'node:fs'
-import * as path from 'node:path'
-import * as os from 'node:os'
-import { AttachmentStore } from '../attachment-store.js'
-
-let tmpRoot: string
-
-beforeEach(async () => {
-  tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'att-store-test-'))
-})
-
-afterEach(async () => {
-  await fs.rm(tmpRoot, { recursive: true, force: true })
-})
-
-describe('AttachmentStore', () => {
-  it('writes a buffer and returns the absolute path', async () => {
-    const store = new AttachmentStore({ root: tmpRoot, retentionMs: 60_000 })
-    const target = store.resolvePath('feishu', 'sess-1', 'hello.png')
-    const written = await store.write(target, Buffer.from('PNGDATA'))
-    expect(path.isAbsolute(written)).toBe(true)
-    const content = await fs.readFile(written)
-    expect(content.toString()).toBe('PNGDATA')
-  })
-
-  it('writes under {root}/{platform}/{sessionId}/', async () => {
-    const store = new AttachmentStore({ root: tmpRoot, retentionMs: 60_000 })
-    const target = store.resolvePath('telegram', 'sess-42', 'foo.pdf')
-    expect(target).toContain(path.join('telegram', 'sess-42'))
-    expect(target.endsWith('foo.pdf')).toBe(true)
-  })
-
-  it('sanitizes unsafe filenames (strips path separators and ..)', async () => {
-    const store = new AttachmentStore({ root: tmpRoot, retentionMs: 60_000 })
-    const target = store.resolvePath('feishu', 'sess-1', '../../etc/passwd')
-    // The resulting target must still live inside the store root.
-    const root = path.resolve(tmpRoot)
-    expect(path.resolve(target).startsWith(root)).toBe(true)
-    expect(path.basename(target)).not.toContain('..')
-    expect(path.basename(target)).not.toContain('/')
-  })
-
-  it('collapses name collisions by prefixing timestamps', async () => {
-    const store = new AttachmentStore({ root: tmpRoot, retentionMs: 60_000 })
-    const a = store.resolvePath('feishu', 'sess-1', 'image.png')
-    await store.write(a, Buffer.from('first'))
-    const b = store.resolvePath('feishu', 'sess-1', 'image.png')
-    expect(b).not.toBe(a)
-    await store.write(b, Buffer.from('second'))
-    const contentB = await fs.readFile(b)
-    expect(contentB.toString()).toBe('second')
-  })
-
-  it('gc() removes files older than retentionMs and reports counts', async () => {
-    const store = new AttachmentStore({ root: tmpRoot, retentionMs: 50 })
-    const target = store.resolvePath('feishu', 'sess-1', 'stale.png')
-    await store.write(target, Buffer.from('STALE'))
-    // Age the file manually
-    const past = new Date(Date.now() - 10_000)
-    await fs.utimes(target, past, past)
-    const result = await store.gc()
-    expect(result.removed).toBe(1)
-    expect(result.bytes).toBe(5)
-    await expect(fs.access(target)).rejects.toThrow()
-  })
-
-  it('gc() keeps fresh files', async () => {
-    const store = new AttachmentStore({ root: tmpRoot, retentionMs: 60_000 })
-    const target = store.resolvePath('feishu', 'sess-1', 'fresh.png')
-    await store.write(target, Buffer.from('FRESH'))
-    const result = await store.gc()
-    expect(result.removed).toBe(0)
-    await fs.access(target)
-  })
-
-  it('resolvePath under heavy collision pressure returns unique paths', () => {
-    const store = new AttachmentStore({ root: tmpRoot, retentionMs: 60_000 })
-    // First create a file so subsequent resolves hit the collision branch
-    const a = store.resolvePath('feishu', 'sess-1', 'race.png')
-    fsSync.writeFileSync(a, 'first')
-    // Collect 50 resolved paths in a tight loop — none should clash
-    const seen = new Set<string>()
-    for (let i = 0; i < 50; i++) {
-      seen.add(store.resolvePath('feishu', 'sess-1', 'race.png'))
-    }
-    expect(seen.size).toBe(50)
-    for (const p of seen) {
-      expect(p).not.toBe(a)
-    }
-  })
-
-  it('gc() cleans orphan .part files after a short grace period', async () => {
-    const store = new AttachmentStore({ root: tmpRoot, retentionMs: 10_000, orphanGraceMs: 50 })
-    // Simulate a crashed write — leave a .part tmp file behind
-    const dir = path.join(tmpRoot, 'feishu', 'sess-1')
-    await fs.mkdir(dir, { recursive: true })
-    const orphan = path.join(dir, 'image.png.1234.5678.part')
-    await fs.writeFile(orphan, 'ORPHAN')
-    // Age the orphan so gc considers it stale
-    const past = new Date(Date.now() - 1000)
-    await fs.utimes(orphan, past, past)
-    const result = await store.gc()
-    expect(result.removed).toBeGreaterThanOrEqual(1)
-    await expect(fs.access(orphan)).rejects.toThrow()
-  })
-})

package/adapters/common/attachment/__tests__/image-block-watcher.test.ts

@@ -1,115 +0,0 @@
-import { describe, it, expect } from 'bun:test'
-import { ImageBlockWatcher } from '../image-block-watcher.js'
-
-describe('ImageBlockWatcher', () => {
-  it('extracts a markdown image with http URL', () => {
-    const w = new ImageBlockWatcher()
-    const out = w.feed('Here is ![alt](https://example.com/foo.png) an image.')
-    expect(out.length).toBe(1)
-    const source = out[0]!.source
-    expect(source.kind).toBe('url')
-    if (source.kind === 'url') {
-      expect(source.url).toBe('https://example.com/foo.png')
-    }
-    expect(out[0]!.alt).toBe('alt')
-  })
-
-  it('extracts a markdown image with absolute local path', () => {
-    const w = new ImageBlockWatcher()
-    const out = w.feed('![cat](/tmp/cat.jpg)')
-    expect(out.length).toBe(1)
-    const source = out[0]!.source
-    expect(source.kind).toBe('path')
-    if (source.kind === 'path') {
-      expect(source.path).toBe('/tmp/cat.jpg')
-    }
-  })
-
-  it('extracts a markdown image with file:// URL as path', () => {
-    const w = new ImageBlockWatcher()
-    const out = w.feed('![x](file:///var/img/x.png)')
-    const source = out[0]!.source
-    expect(source.kind).toBe('path')
-    if (source.kind === 'path') expect(source.path).toBe('/var/img/x.png')
-  })
-
-  it('extracts a data URI as base64', () => {
-    const w = new ImageBlockWatcher()
-    const out = w.feed('![inline](data:image/png;base64,AAAA)')
-    const source = out[0]!.source
-    expect(source.kind).toBe('base64')
-    if (source.kind === 'base64') {
-      expect(source.mime).toBe('image/png')
-      expect(source.data).toBe('AAAA')
-    }
-  })
-
-  it('deduplicates the same image across multiple feeds', () => {
-    const w = new ImageBlockWatcher()
-    const a = w.feed('![](https://x/y.png)')
-    const b = w.feed(' repeated ![](https://x/y.png) again')
-    expect(a.length).toBe(1)
-    expect(b.length).toBe(0)
-  })
-
-  it('handles images split across feed boundaries', () => {
-    const w = new ImageBlockWatcher()
-    const a = w.feed('a ![al')
-    const b = w.feed('t](/tmp/x.png) b')
-    expect(a.length).toBe(0)
-    expect(b.length).toBe(1)
-    const source = b[0]!.source
-    expect(source.kind).toBe('path')
-    if (source.kind === 'path') expect(source.path).toBe('/tmp/x.png')
-  })
-
-  it('skips non-image markdown links', () => {
-    const w = new ImageBlockWatcher()
-    const out = w.feed('See [docs](https://example.com).')
-    expect(out.length).toBe(0)
-  })
-
-  it('drain() returns all accumulated uploads', () => {
-    const w = new ImageBlockWatcher()
-    w.feed('![a](/tmp/a.png)')
-    w.feed(' and ![b](/tmp/b.png)')
-    const all = w.drain()
-    expect(all.length).toBe(2)
-  })
-
-  it('reset() clears buffer, seen set, and accumulated list', () => {
-    const w = new ImageBlockWatcher()
-    w.feed('![a](/tmp/a.png)')
-    w.reset()
-    // After reset, drain() is empty
-    expect(w.drain().length).toBe(0)
-    // And re-feeding the same image yields a fresh emit (dedup state cleared)
-    const out = w.feed('![a](/tmp/a.png)')
-    expect(out.length).toBe(1)
-  })
-
-  it('skips relative paths (cannot be resolved safely)', () => {
-    const w = new ImageBlockWatcher()
-    const out = w.feed('![rel](relative/path.png) and ![ok](/tmp/ok.png)')
-    expect(out.length).toBe(1)
-    const source = out[0]!.source
-    expect(source.kind).toBe('path')
-    if (source.kind === 'path') expect(source.path).toBe('/tmp/ok.png')
-  })
-
-  it('extracts multiple images from a single feed chunk in order', () => {
-    const w = new ImageBlockWatcher()
-    const out = w.feed('![a](/tmp/a.png) ![b](https://x/b.png) ![c](data:image/png;base64,QQ==)')
-    expect(out.length).toBe(3)
-    expect(out[0]!.source.kind).toBe('path')
-    expect(out[1]!.source.kind).toBe('url')
-    expect(out[2]!.source.kind).toBe('base64')
-  })
-
-  it('rejects malformed data URI (not base64)', () => {
-    const w = new ImageBlockWatcher()
-    const out = w.feed('![bad](data:image/png,ABC)')
-    // Not in `;base64,` form → classify returns null → skipped
-    expect(out.length).toBe(0)
-  })
-})

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)
-  })
-})