@mzzsfy/dsh-usage-dash 0.1.0

package/test/pricing-parity.test.mjs

@@ -0,0 +1,231 @@
+// 双实现同源 parity 测试:client.js 顶层定价镜像函数与宿主 src/pricing.js 同输入同输出
+// 向量表驱动:同一批向量喂双侧,deepEqual 双侧结果并对期望值断言
+// client.js 为非模块 script(bundle 求值形态,禁 import/export),整源求值后按顶层声明名收集
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { dirname, join } from 'node:path'
+
+import {
+  matchPrice as hostMatchPrice,
+  costOf as hostCostOf,
+  conditionMatches as hostConditionMatches,
+  UNIT_PER_MILLION as hostUnitPerMillion,
+  CURRENCIES as hostCurrencies,
+  CONDITION_KINDS as hostConditionKinds,
+  TOKENS_PER_MILLION as hostTokensPerMillion,
+} from '../src/pricing.js'
+
+const CLIENT_SOURCE = readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'src', 'client.js'), 'utf8')
+const DECLARATION_NAMES = [
+  ...new Set(
+    [...CLIENT_SOURCE.matchAll(/^(?:const|function|let) ([A-Za-z_$][\w$]*)/gm)].map((match) => match[1])
+  ),
+]
+const core = new Function(`${CLIENT_SOURCE}\nreturn { ${DECLARATION_NAMES.join(', ')} }`)()
+
+const {
+  matchPrice: clientMatchPrice,
+  costOf: clientCostOf,
+  conditionMatches: clientConditionMatches,
+  UNIT_PER_MILLION: clientUnitPerMillion,
+  CURRENCIES: clientCurrencies,
+  CONDITION_KINDS: clientConditionKinds,
+  TOKENS_PER_MILLION: clientTokensPerMillion,
+} = core
+
+// 本地时区固定时刻(2026-03-15 为周日):同一 Date 实例喂双侧
+const SUNDAY_0930 = [2026, 2, 15, 9, 30]
+const SUNDAY_1800 = [2026, 2, 15, 18, 0]
+const SUNDAY_0900 = [2026, 2, 15, 9, 0]
+const SUNDAY_2330 = [2026, 2, 15, 23, 30]
+const SUNDAY_0300 = [2026, 2, 15, 3, 0]
+const SUNDAY_1200 = [2026, 2, 15, 12, 0]
+const MON_JAN15 = [2026, 0, 15, 12, 0]
+const MON_JAN16 = [2026, 0, 16, 12, 0]
+const MON_JAN26 = [2026, 0, 26, 12, 0]
+const MON_JAN03 = [2026, 0, 3, 12, 0]
+const FEB_30_ROLLS_TO_MAR02 = [2026, 1, 30, 12, 0]
+
+const CONDITION_VECTORS = [
+  { name: 'dailyWindow from<to 命中', condition: { kind: 'dailyWindow', from: '09:00', to: '18:00' }, date: SUNDAY_0930, expected: true },
+  { name: 'dailyWindow 含头不含尾', condition: { kind: 'dailyWindow', from: '09:00', to: '18:00' }, date: SUNDAY_1800, expected: false },
+  { name: 'dailyWindow 含头', condition: { kind: 'dailyWindow', from: '09:00', to: '18:00' }, date: SUNDAY_0900, expected: true },
+  { name: 'dailyWindow 跨午夜夜段命中', condition: { kind: 'dailyWindow', from: '22:00', to: '06:00' }, date: SUNDAY_2330, expected: true },
+  { name: 'dailyWindow 跨午夜凌晨命中', condition: { kind: 'dailyWindow', from: '22:00', to: '06:00' }, date: SUNDAY_0300, expected: true },
+  { name: 'dailyWindow 跨午夜日间不命中', condition: { kind: 'dailyWindow', from: '22:00', to: '06:00' }, date: SUNDAY_1200, expected: false },
+  { name: 'dailyWindow from===to 全天', condition: { kind: 'dailyWindow', from: '00:00', to: '00:00' }, date: SUNDAY_1200, expected: true },
+  { name: 'dailyWindow 非法格式', condition: { kind: 'dailyWindow', from: 'abc', to: '06:00' }, date: SUNDAY_1200, expected: false },
+  { name: 'weekdays 命中周日', condition: { kind: 'weekdays', days: [0] }, date: SUNDAY_0930, expected: true },
+  { name: 'weekdays 空 days 不成立', condition: { kind: 'weekdays', days: [] }, date: SUNDAY_0930, expected: false },
+  { name: 'weekdays 未命中', condition: { kind: 'weekdays', days: [1] }, date: SUNDAY_0930, expected: false },
+  { name: 'weekdays days 非数组', condition: { kind: 'weekdays', days: 'x' }, date: SUNDAY_0930, expected: false },
+  { name: 'monthDays 双闭含端', condition: { kind: 'monthDays', from: 1, to: 15 }, date: MON_JAN15, expected: true },
+  { name: 'monthDays 界外', condition: { kind: 'monthDays', from: 1, to: 15 }, date: MON_JAN16, expected: false },
+  { name: 'monthDays 环绕起点命中', condition: { kind: 'monthDays', from: 26, to: 5 }, date: MON_JAN26, expected: true },
+  { name: 'monthDays 环绕中段不命中', condition: { kind: 'monthDays', from: 26, to: 5 }, date: MON_JAN15, expected: false },
+  { name: 'monthDays 环绕终点命中', condition: { kind: 'monthDays', from: 26, to: 5 }, date: MON_JAN03, expected: true },
+  { name: 'monthDays 非整数不成立', condition: { kind: 'monthDays', from: 1.5, to: 5 }, date: MON_JAN15, expected: false },
+  { name: 'dateRange 命中', condition: { kind: 'dateRange', from: '2026-01-01', to: '2026-01-31' }, date: MON_JAN15, expected: true },
+  { name: 'dateRange 倒序不成立', condition: { kind: 'dateRange', from: '2026-01-31', to: '2026-01-01' }, date: MON_JAN15, expected: false },
+  { name: 'dateRange 非零填充不成立', condition: { kind: 'dateRange', from: '2026-1-1', to: '2026-1-31' }, date: MON_JAN15, expected: false },
+  { name: 'dateRange 2 月 30 号滚月后不命中', condition: { kind: 'dateRange', from: '2026-02-01', to: '2026-02-28' }, date: FEB_30_ROLLS_TO_MAR02, expected: false },
+  { name: '未知 kind 不成立', condition: { kind: 'hourly', days: [0] }, date: SUNDAY_0930, expected: false },
+  { name: '非法 Date 不成立', condition: { kind: 'weekdays', days: [0] }, date: null, expected: false },
+  { name: 'condition 形状残缺不成立', condition: null, date: SUNDAY_0930, expected: false },
+]
+
+const priceOf = (input) => ({ input, output: 0, cacheRead: 0, cacheWrite: 0 })
+const ruleOf = (model, input, conditions = []) => ({ model, currency: '¥', price: priceOf(input), conditions })
+
+const MATCH_SUNDAY_1000 = [2026, 2, 15, 10, 0]
+
+const MATCH_VECTORS = [
+  {
+    name: '精确命中按数组序取首个',
+    rules: [ruleOf('a', 1), ruleOf('b', 2)], model: 'b', date: MATCH_SUNDAY_1000, expected: priceOf(2),
+  },
+  {
+    name: '同 model 多条取数组序第一条',
+    rules: [ruleOf('a', 1), ruleOf('a', 3)], model: 'a', date: MATCH_SUNDAY_1000, expected: priceOf(1),
+  },
+  {
+    name: '无精确回落通配',
+    rules: [ruleOf('*', 5)], model: 'zzz', date: MATCH_SUNDAY_1000, expected: priceOf(5),
+  },
+  {
+    name: '精确优先于通配',
+    rules: [ruleOf('*', 5), ruleOf('a', 1)], model: 'a', date: MATCH_SUNDAY_1000, expected: priceOf(1),
+  },
+  {
+    name: '多条件 AND 全过命中',
+    rules: [ruleOf('a', 1, [{ kind: 'weekdays', days: [0] }, { kind: 'dailyWindow', from: '00:00', to: '23:59' }])],
+    model: 'a', date: MATCH_SUNDAY_1000, expected: priceOf(1),
+  },
+  {
+    name: '一条件不过跳至下一条规则',
+    rules: [ruleOf('a', 1, [{ kind: 'weekdays', days: [1] }]), ruleOf('a', 2, [])],
+    model: 'a', date: MATCH_SUNDAY_1000, expected: priceOf(2),
+  },
+  {
+    name: '缺 conditions 形状残缺跳过',
+    rules: [{ model: 'a', currency: '¥', price: priceOf(1) }],
+    model: 'a', date: MATCH_SUNDAY_1000, expected: null,
+  },
+  {
+    name: '缺 price 形状残缺跳过',
+    rules: [{ model: 'a', currency: '¥', conditions: [] }],
+    model: 'a', date: MATCH_SUNDAY_1000, expected: null,
+  },
+  {
+    name: 'unit 非 perMillion 跳过',
+    rules: [{ ...ruleOf('a', 1), unit: 'perThousand' }],
+    model: 'a', date: MATCH_SUNDAY_1000, expected: null,
+  },
+  {
+    name: 'unit 缺省视为 perMillion 命中',
+    rules: [ruleOf('a', 1)],
+    model: 'a', date: MATCH_SUNDAY_1000, expected: priceOf(1),
+  },
+  {
+    name: 'rules 非数组为 null',
+    rules: 'nope', model: 'a', date: MATCH_SUNDAY_1000, expected: null,
+  },
+  {
+    name: 'model 非字符串为 null',
+    rules: [ruleOf('a', 1)], model: 7, date: MATCH_SUNDAY_1000, expected: null,
+  },
+  {
+    name: '非法时间戳为 null',
+    rules: [ruleOf('a', 1)], model: 'a', date: null, expected: null,
+  },
+  {
+    name: '条件不满足且无通配为 null',
+    rules: [ruleOf('a', 1, [{ kind: 'weekdays', days: [1] }])],
+    model: 'a', date: MATCH_SUNDAY_1000, expected: null,
+  },
+]
+
+const MILLION = 1000 * 1000
+const COST_VECTORS = [
+  {
+    name: '四桶全带求和',
+    price: { input: 1, output: 2, cacheRead: 3, cacheWrite: 4 },
+    buckets: { inputTokens: MILLION, outputTokens: MILLION, cacheReadTokens: MILLION, cacheWriteTokens: MILLION },
+    expected: 10,
+  },
+  {
+    name: '缺桶按 0',
+    price: { input: 1, output: 2, cacheRead: 3, cacheWrite: 4 },
+    buckets: { inputTokens: MILLION },
+    expected: 1,
+  },
+  {
+    name: '非有限 token 按 0',
+    price: { input: 1, output: 2, cacheRead: 3, cacheWrite: 4 },
+    buckets: { inputTokens: Number.NaN, outputTokens: MILLION, cacheReadTokens: Number.POSITIVE_INFINITY, cacheWriteTokens: 0 },
+    expected: 2,
+  },
+  {
+    name: '非有限单价按 0',
+    price: { input: 1, output: Number.POSITIVE_INFINITY, cacheRead: Number.NaN, cacheWrite: 4 },
+    buckets: { inputTokens: MILLION, outputTokens: MILLION, cacheReadTokens: MILLION, cacheWriteTokens: 0 },
+    expected: 1,
+  },
+  {
+    name: '零价为 0',
+    price: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    buckets: { inputTokens: MILLION, outputTokens: MILLION, cacheReadTokens: MILLION, cacheWriteTokens: MILLION },
+    expected: 0,
+  },
+  {
+    name: '原始浮点不圆整',
+    price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 },
+    buckets: { inputTokens: 3 },
+    expected: 3 / MILLION,
+  },
+]
+
+test('镜像常量与宿主逐项一致', () => {
+  assert.equal(clientUnitPerMillion, hostUnitPerMillion)
+  assert.deepEqual(clientCurrencies, hostCurrencies)
+  assert.deepEqual(clientConditionKinds, hostConditionKinds)
+  assert.equal(clientTokensPerMillion, hostTokensPerMillion)
+})
+
+// 向量总量下限锁定:S14 要求 ≥25 组,防止后续裁剪 quietly 缩水
+const VECTOR_TOTAL = CONDITION_VECTORS.length + MATCH_VECTORS.length + COST_VECTORS.length
+
+test('parity 向量总量不低于 25 组', () => {
+  assert.ok(VECTOR_TOTAL >= 25, `向量总量 ${VECTOR_TOTAL} 不足 25`)
+})
+
+test(`conditionMatches 双侧一致(${CONDITION_VECTORS.length} 向量)`, () => {
+  for (const vector of CONDITION_VECTORS) {
+    const date = vector.date ? new Date(...vector.date) : new Date(Number.NaN)
+    const host = hostConditionMatches(vector.condition, date)
+    const client = clientConditionMatches(vector.condition, date)
+    assert.deepEqual(client, host, vector.name)
+    assert.equal(host, vector.expected, vector.name)
+  }
+})
+
+test(`matchPrice 双侧一致(${MATCH_VECTORS.length} 向量)`, () => {
+  for (const vector of MATCH_VECTORS) {
+    const date = vector.date ? new Date(...vector.date) : new Date(Number.NaN)
+    const host = hostMatchPrice(vector.rules, vector.model, date)
+    const client = clientMatchPrice(vector.rules, vector.model, date)
+    assert.deepEqual(client, host, vector.name)
+    assert.deepEqual(host, vector.expected, vector.name)
+  }
+})
+
+test(`costOf 双侧一致(${COST_VECTORS.length} 向量)`, () => {
+  for (const vector of COST_VECTORS) {
+    const host = hostCostOf(vector.price, vector.buckets)
+    const client = clientCostOf(vector.price, vector.buckets)
+    assert.deepEqual(client, host, vector.name)
+    assert.deepEqual(host, vector.expected, vector.name)
+  }
+})

package/test/pricing.test.mjs

@@ -0,0 +1,285 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  CURRENCIES,
+  CONDITION_KINDS,
+  TOKENS_PER_MILLION,
+  UNIT_PER_MILLION,
+  conditionMatches,
+  costOf,
+  matchPrice,
+} from '../src/pricing.js'
+
+// 锚定日期一律本地时区构造,期望只依赖本地分量,与运行机时区无关
+const SUNDAY = new Date(2026, 8, 6)
+const MONDAY = new Date(2026, 8, 7)
+const SATURDAY = new Date(2026, 8, 12)
+
+const localTime = (day, hour, minute = 0) => new Date(2026, 8, day, hour, minute)
+
+const makeRule = (overrides = {}) => ({
+  model: '*',
+  unit: UNIT_PER_MILLION,
+  currency: '¥',
+  price: { input: 1, output: 2, cacheRead: 0.5, cacheWrite: 1 },
+  conditions: [],
+  ...overrides,
+})
+
+// 浮点比较容差
+const EPSILON = 1e-9
+
+test('常量为文档定值', () => {
+  assert.equal(UNIT_PER_MILLION, 'perMillion')
+  assert.deepEqual(CURRENCIES, ['¥', '$'])
+  assert.deepEqual(CONDITION_KINDS, ['dailyWindow', 'weekdays', 'monthDays', 'dateRange'])
+  assert.equal(TOKENS_PER_MILLION, 1000 * 1000)
+})
+
+test('锚定日期星期与本地分量自检', () => {
+  // Given 本地构造的锚定日期 When 读本地分量 Then 与写死期望一致,防锚点拍脑袋
+  assert.equal(SUNDAY.getDay(), 0)
+  assert.equal(MONDAY.getDay(), 1)
+  assert.equal(SATURDAY.getDay(), 6)
+  assert.equal(localTime(6, 23, 30).getHours(), 23)
+  assert.equal(localTime(6, 23, 30).getMinutes(), 30)
+})
+
+test('无条件规则恒命中', () => {
+  // Given conditions 空数组规则 When 匹配其模型 Then 返回该规则 price
+  const target = makeRule({ model: 'a/b' })
+  assert.deepEqual(matchPrice([target], 'a/b', SUNDAY), target.price)
+})
+
+test('精确模型优先于通配规则', () => {
+  // Given 精确规则与 '*' 规则并存 When 匹配 Then 取精确规则 price
+  const exact = makeRule({ model: 'a/b', price: { input: 5 } })
+  const wildcard = makeRule({ model: '*', price: { input: 1 } })
+  assert.deepEqual(matchPrice([wildcard, exact], 'a/b', SUNDAY), exact.price)
+})
+
+test('精确子集按数组序取首个命中', () => {
+  // Given 两条同模型无条件规则 When 匹配 Then 取数组序第一
+  const first = makeRule({ model: 'a/b', price: { input: 1 } })
+  const second = makeRule({ model: 'a/b', price: { input: 2 } })
+  assert.deepEqual(matchPrice([first, second], 'a/b', SUNDAY), first.price)
+})
+
+test('精确子集全不命中回落通配子集', () => {
+  // Given 精确规则条件不满足、'*' 规则无条件 When 匹配 Then 回落 '*' 而非 null
+  const exact = makeRule({ model: 'a/b', conditions: [{ kind: 'weekdays', days: [1] }] })
+  const wildcard = makeRule({ model: '*', price: { input: 3 } })
+  assert.deepEqual(matchPrice([exact, wildcard], 'a/b', SUNDAY), wildcard.price)
+})
+
+test('通配子集按数组序取首个命中', () => {
+  // Given 首条 '*' 条件满足、次条无条件 When 匹配 Then 取首条
+  const first = makeRule({ model: '*', conditions: [{ kind: 'weekdays', days: [0] }], price: { input: 1 } })
+  const second = makeRule({ model: '*', price: { input: 2 } })
+  assert.deepEqual(matchPrice([first, second], 'a/b', SUNDAY), first.price)
+})
+
+test('无精确子集直接查通配子集', () => {
+  // Given 仅 '*' 规则 When 匹配未列出模型 Then 命中通配
+  const wildcard = makeRule({ model: '*', price: { input: 4 } })
+  assert.deepEqual(matchPrice([wildcard], 'other/c', SUNDAY), wildcard.price)
+})
+
+test('两子集全不命中返回 null 计 unpriced', () => {
+  // Given 仅一条精确规则且条件不满足 When 匹配本模型与陌生模型 Then 均为 null
+  const rules = [makeRule({ model: 'a/b', conditions: [{ kind: 'weekdays', days: [1] }] })]
+  assert.equal(matchPrice(rules, 'a/b', SUNDAY), null)
+  assert.equal(matchPrice(rules, 'x/y', SUNDAY), null)
+})
+
+test('多条件 AND 一过一不过整规则不命中', () => {
+  // Given 周日 + 10:00~12:00 两条件 When 周日 09:00 与 11:00 Then 前者 null 后者命中
+  const target = makeRule({
+    model: 'a/b',
+    conditions: [
+      { kind: 'weekdays', days: [0] },
+      { kind: 'dailyWindow', from: '10:00', to: '12:00' },
+    ],
+  })
+  assert.equal(matchPrice([target], 'a/b', localTime(6, 9)), null)
+  assert.deepEqual(matchPrice([target], 'a/b', localTime(6, 11)), target.price)
+})
+
+test('规则形状残缺跳过不崩溃', () => {
+  // Given 缺 model/缺 price/非法 unit/缺 conditions 的规则在前 When 匹配 Then 跳过并命中合法规则
+  const good = makeRule({ model: 'a/b' })
+  const rules = [
+    { unit: UNIT_PER_MILLION, price: { input: 9 }, conditions: [] },
+    { model: 'a/b', conditions: [] },
+    makeRule({ model: 'a/b', unit: 'perKilo' }),
+    makeRule({ model: 'a/b', conditions: undefined }),
+    good,
+  ]
+  assert.deepEqual(matchPrice(rules, 'a/b', SUNDAY), good.price)
+})
+
+test('rules 非数组或 timestamp 非法返回 null', () => {
+  // Given 非法入参 When matchPrice Then 返回 null 不抛错
+  assert.equal(matchPrice([], 'a/b', SUNDAY), null)
+  assert.equal(matchPrice(undefined, 'a/b', SUNDAY), null)
+  assert.equal(matchPrice([makeRule()], 'a/b', Number.NaN), null)
+})
+
+test('dailyWindow from<to 含头不含尾', () => {
+  // Given 10:00~12:00 When 逐时刻判定 Then 10:00 与 11:59 命中,09:59 与 12:00 不命中
+  const condition = { kind: 'dailyWindow', from: '10:00', to: '12:00' }
+  assert.equal(conditionMatches(condition, localTime(6, 10)), true)
+  assert.equal(conditionMatches(condition, localTime(6, 11, 59)), true)
+  assert.equal(conditionMatches(condition, localTime(6, 9, 59)), false)
+  assert.equal(conditionMatches(condition, localTime(6, 12)), false)
+})
+
+test('dailyWindow 跨午夜窗口按本地分量命中', () => {
+  // Given 22:00~02:00 When 本地 23:30 与次日 01:00 Then 命中;本地正午不命中
+  const condition = { kind: 'dailyWindow', from: '22:00', to: '02:00' }
+  assert.equal(conditionMatches(condition, localTime(6, 23, 30)), true)
+  assert.equal(conditionMatches(condition, new Date(2026, 8, 7, 1)), true)
+  assert.equal(conditionMatches(condition, localTime(6, 12)), false)
+})
+
+test('dailyWindow from===to 全天生效', () => {
+  // Given 10:00~10:00 When 判定 00:00/10:00/23:59 Then 全部命中
+  const condition = { kind: 'dailyWindow', from: '10:00', to: '10:00' }
+  assert.equal(conditionMatches(condition, localTime(6, 0)), true)
+  assert.equal(conditionMatches(condition, localTime(6, 10)), true)
+  assert.equal(conditionMatches(condition, localTime(6, 23, 59)), true)
+})
+
+test('dailyWindow 分钟级评估', () => {
+  // Given 10:05~10:10 When 判定 10:05/10:09/10:10 Then 前两者命中
+  const condition = { kind: 'dailyWindow', from: '10:05', to: '10:10' }
+  assert.equal(conditionMatches(condition, localTime(6, 10, 5)), true)
+  assert.equal(conditionMatches(condition, localTime(6, 10, 9)), true)
+  assert.equal(conditionMatches(condition, localTime(6, 10, 10)), false)
+})
+
+test('weekdays 集合按 getDay 命中', () => {
+  // Given days [0,6] When 判定锚定周日/周六/周一 Then 前两者命中
+  const weekend = { kind: 'weekdays', days: [0, 6] }
+  assert.equal(conditionMatches(weekend, SUNDAY), true)
+  assert.equal(conditionMatches(weekend, SATURDAY), true)
+  assert.equal(conditionMatches(weekend, MONDAY), false)
+})
+
+test('weekdays 空数组条件不成立', () => {
+  assert.equal(conditionMatches({ kind: 'weekdays', days: [] }, SUNDAY), false)
+})
+
+test('monthDays 正向段双闭含单日', () => {
+  // Given 1~15 When 判定 1/15/16 号 Then 双闭;Given 5~5 When 判定 5/6 号 Then 单日
+  const span = { kind: 'monthDays', from: 1, to: 15 }
+  assert.equal(conditionMatches(span, new Date(2026, 8, 1)), true)
+  assert.equal(conditionMatches(span, new Date(2026, 8, 15)), true)
+  assert.equal(conditionMatches(span, new Date(2026, 8, 16)), false)
+  const single = { kind: 'monthDays', from: 5, to: 5 }
+  assert.equal(conditionMatches(single, new Date(2026, 8, 5)), true)
+  assert.equal(conditionMatches(single, new Date(2026, 8, 6)), false)
+})
+
+test('monthDays 单日 31 号在 2 月自然不触发', () => {
+  // Given 31~31 When 判定 1 月 31 号与 2 月末 Then 前者命中;2 月无 31 号,该月任意日不命中
+  const condition = { kind: 'monthDays', from: 31, to: 31 }
+  assert.equal(conditionMatches(condition, new Date(2026, 0, 31)), true)
+  assert.equal(conditionMatches(condition, new Date(2026, 1, 28)), false)
+})
+
+test('monthDays 26~25 跨月环绕覆盖全月', () => {
+  // Given 26~25 账单周期 When 判定 26/31/1/25/15 号 Then 26..31 并 1..25 覆盖全月,含 15
+  const condition = { kind: 'monthDays', from: 26, to: 25 }
+  assert.equal(conditionMatches(condition, new Date(2026, 0, 26)), true)
+  assert.equal(conditionMatches(condition, new Date(2026, 0, 31)), true)
+  assert.equal(conditionMatches(condition, new Date(2026, 1, 1)), true)
+  assert.equal(conditionMatches(condition, new Date(2026, 1, 25)), true)
+  assert.equal(conditionMatches(condition, new Date(2026, 0, 15)), true)
+})
+
+test('monthDays 27~10 环绕存在不命中间隙', () => {
+  // Given 27~10 When 判定 27/31/1/10 与 15/26 号 Then 前四命中,间隙内不命中
+  const condition = { kind: 'monthDays', from: 27, to: 10 }
+  assert.equal(conditionMatches(condition, new Date(2026, 0, 27)), true)
+  assert.equal(conditionMatches(condition, new Date(2026, 0, 31)), true)
+  assert.equal(conditionMatches(condition, new Date(2026, 1, 1)), true)
+  assert.equal(conditionMatches(condition, new Date(2026, 1, 10)), true)
+  assert.equal(conditionMatches(condition, new Date(2026, 0, 15)), false)
+  assert.equal(conditionMatches(condition, new Date(2026, 0, 26)), false)
+})
+
+test('dateRange 双闭区间', () => {
+  // Given 2026-01-01~2026-01-31 When 判定首末日与界外 Then 端点命中,两侧不命中
+  const condition = { kind: 'dateRange', from: '2026-01-01', to: '2026-01-31' }
+  assert.equal(conditionMatches(condition, new Date(2026, 0, 1)), true)
+  assert.equal(conditionMatches(condition, new Date(2026, 0, 15)), true)
+  assert.equal(conditionMatches(condition, new Date(2026, 0, 31)), true)
+  assert.equal(conditionMatches(condition, new Date(2025, 11, 31)), false)
+  assert.equal(conditionMatches(condition, new Date(2026, 1, 1)), false)
+})
+
+test('dateRange 倒序属配置错误不成立', () => {
+  const condition = { kind: 'dateRange', from: '2026-02-01', to: '2026-01-01' }
+  assert.equal(conditionMatches(condition, new Date(2026, 0, 15)), false)
+})
+
+test('未知 kind 与非法日期不成立', () => {
+  // Given 未知 kind/null 条件/非法 Date When conditionMatches Then 均不成立不抛错
+  assert.equal(conditionMatches({ kind: 'lunarPhase' }, SUNDAY), false)
+  assert.equal(conditionMatches(null, SUNDAY), false)
+  assert.equal(conditionMatches({ kind: 'weekdays', days: [0] }, new Date(Number.NaN)), false)
+})
+
+test('同值 Date 与毫秒数结果一致', () => {
+  // Given 命中与不命中规则各一 When 分别传 Date 与 getTime() Then 两次结果一致
+  const hit = makeRule({ model: 'a/b', conditions: [{ kind: 'weekdays', days: [0] }] })
+  const miss = makeRule({ model: 'a/b', conditions: [{ kind: 'weekdays', days: [1] }] })
+  const stamp = localTime(6, 10, 30)
+  assert.deepEqual(matchPrice([hit], 'a/b', stamp), matchPrice([hit], 'a/b', stamp.getTime()))
+  assert.deepEqual(matchPrice([miss], 'a/b', stamp), matchPrice([miss], 'a/b', stamp.getTime()))
+})
+
+test('四桶计价混合 token 算术', () => {
+  // Given 四桶单价与部分桶 token When costOf Then Σ(桶token×单价)/百万
+  const price = { input: 2, output: 6, cacheRead: 0.5, cacheWrite: 1 }
+  const buckets = {
+    inputTokens: TOKENS_PER_MILLION,
+    outputTokens: TOKENS_PER_MILLION / 2,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+  }
+  assert.ok(Math.abs(costOf(price, buckets) - 5) < EPSILON)
+})
+
+test('四桶全非零按权重求和', () => {
+  // Given 四桶单价 1/2/3/4 且各桶百万 token When costOf Then 权重和 10
+  const price = { input: 1, output: 2, cacheRead: 3, cacheWrite: 4 }
+  const buckets = {
+    inputTokens: TOKENS_PER_MILLION,
+    outputTokens: TOKENS_PER_MILLION,
+    cacheReadTokens: TOKENS_PER_MILLION,
+    cacheWriteTokens: TOKENS_PER_MILLION,
+  }
+  assert.ok(Math.abs(costOf(price, buckets) - (1 + 2 + 3 + 4)) < EPSILON)
+})
+
+test('全零 token 费用为 0', () => {
+  const buckets = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 }
+  assert.equal(costOf({ input: 2, output: 6, cacheRead: 0.5, cacheWrite: 1 }, buckets), 0)
+})
+
+test('缺桶或价格字段按 0 计', () => {
+  // Given buckets 缺部分桶、price 只配部分单价 When costOf Then 只计两侧齐备的桶
+  assert.ok(Math.abs(costOf({ input: 2 }, { inputTokens: TOKENS_PER_MILLION, outputTokens: TOKENS_PER_MILLION / 2 }) - 2) < EPSILON)
+  assert.equal(costOf({ input: 2 }, {}), 0)
+  assert.equal(costOf({}, { inputTokens: TOKENS_PER_MILLION }), 0)
+})
+
+test('费用保留原始浮点不圆整', () => {
+  // Given 0.1+0.2 类单价 When costOf Then 得原始浮点和,不 toFixed 圆整
+  const price = { input: 0.1, output: 0.2 }
+  const buckets = { inputTokens: TOKENS_PER_MILLION, outputTokens: TOKENS_PER_MILLION }
+  assert.ok(Math.abs(costOf(price, buckets) - 0.3) < EPSILON)
+})