rootandClaude Opus 5.5
0088c1c9e7
- 迁移 0077 新表 site_failure_sample:类型(parse_error / challenge)、请求类型、脱敏 URL、状态码、
关键响应头、错误文案、命中规则、脱敏页面开头(≤ 64 KB);样本几十 KB,不放进每条请求都读的 site.config
- 适配器 onFailureSample 回调接到 runtime.siteAdapter,异步写入并删到最近 5 份,写失败只记日志
- GET /sites/{id}/failure-samples(不带正文)与 /failure-samples/{sampleId}(带正文)
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_01Cxwgnn2pbzQ7rXv3rq7fei
448 lines
16 KiB
TypeScript
448 lines
16 KiB
TypeScript
import { readFileSync } from "node:fs";
|
||
import { Kysely, PostgresDialect, sql } from "kysely";
|
||
import { NO_MIGRATIONS } from "kysely/migration";
|
||
import pg from "pg";
|
||
import { afterAll, beforeAll, describe, expect, it } from "vitest";
|
||
import { formatWithBiome, generateTypesSource, TYPES_FILE } from "../scripts/gen-types-lib.ts";
|
||
import { createMigrator, type DB, migrateToLatest } from "../src/index.ts";
|
||
|
||
// 对真实 PG(默认开发库 55433)跑迁移往返;每次测试用独立 schema,互不干扰且不碰 public。
|
||
// 无数据库环境可设 UMT_SKIP_DB_TESTS=1 跳过(CI 默认要求数据库可用)。
|
||
const url = process.env.DATABASE_URL ?? "postgres://umt:umt@localhost:55433/umt";
|
||
const skip = process.env.UMT_SKIP_DB_TESTS === "1";
|
||
const schema = `umt_test_${process.pid}_${Date.now().toString(36)}`;
|
||
|
||
const EXPECTED_TABLES = [
|
||
// 底座(0001/0002)
|
||
"settings",
|
||
"api_key",
|
||
"audit_event",
|
||
"outbox_event",
|
||
"secret",
|
||
// 实例
|
||
"library_root",
|
||
"downloader_instance",
|
||
"media_server_instance",
|
||
"path_mapping",
|
||
// 内容 / 身份
|
||
"media_entity",
|
||
"content_unit",
|
||
"title_alias",
|
||
"external_identity",
|
||
"identity_revision",
|
||
// 来源
|
||
"site",
|
||
"site_account",
|
||
"feed_source",
|
||
"source_release",
|
||
"observation",
|
||
// 文件
|
||
"media_asset",
|
||
"asset_unit_coverage",
|
||
"asset_location",
|
||
"path_binding",
|
||
// 规则
|
||
"policy_revision",
|
||
"subscription",
|
||
"acquisition_slot",
|
||
"preference_tag",
|
||
"preference_suppression",
|
||
// 执行
|
||
"task",
|
||
"acquisition_plan",
|
||
"download_task",
|
||
"asset_operation",
|
||
// 人工/AI
|
||
"agent_run",
|
||
"artifact",
|
||
"decision",
|
||
"approval",
|
||
"automation_grant",
|
||
// 运维 / 整理
|
||
"reconcile_run",
|
||
"server_mapping",
|
||
"organization_record",
|
||
"organize_source_snapshot",
|
||
"organization_file_result",
|
||
// tasks 包自有表(0013)与 agent 事件(0014)
|
||
"tasks_run_meta",
|
||
"tasks_fact",
|
||
"tasks_op_ledger",
|
||
"agent_run_event",
|
||
// W2-B 来源/身份/元数据(0018–0020)
|
||
"site_snapshot",
|
||
"identity_candidate",
|
||
"resolution_attempt",
|
||
"identity_redirect",
|
||
"metadata_field",
|
||
"field_override",
|
||
// META-1 元数据补全记录(0049)
|
||
"metadata_enrichment",
|
||
// W2-D Agent 装配(0021)
|
||
"capability_invocation",
|
||
"agent_run_message",
|
||
// 登录门禁(0015)与 SSE 多进程总线(0016)
|
||
"admin_user",
|
||
"admin_session",
|
||
"login_attempt",
|
||
"sse_event",
|
||
// W4-C 浏览器实体(0023)
|
||
"browser_provider",
|
||
"browser_session",
|
||
"browser_tab",
|
||
"browser_control_lease",
|
||
// W5-A 文件管理回收站(0024)
|
||
"trash_item",
|
||
// W5-C 订阅增强(0025)
|
||
"slot_deferral",
|
||
"slot_unit",
|
||
"subscription_history",
|
||
// W7-A Pi 上游(0027)
|
||
"pi_upstream",
|
||
// W7-C 定时任务注册表(0028)
|
||
"scheduled_job",
|
||
"scheduled_job_run",
|
||
// W9-A 站点用户数据(0031)
|
||
"site_user_data",
|
||
// W9-C 命名模板版本(0032)
|
||
"naming_template_version",
|
||
// W9-D 规则组(0033)
|
||
"rule_group",
|
||
"rule_atom",
|
||
// W9-I 进程心跳(0034)
|
||
"process_heartbeat",
|
||
"process_heartbeat_sample",
|
||
// AG-1 MCP 服务端配置(0039)
|
||
"mcp_server_config",
|
||
// C1-B 恢复码 / Passkey / WebAuthn 挑战(0037)
|
||
"admin_recovery_code",
|
||
"admin_passkey",
|
||
"webauthn_challenge",
|
||
// C2-A 跨进程站点限流(0041)
|
||
"rate_limit_bucket",
|
||
// C2-A PG 短期缓存(0042,UNLOGGED)
|
||
"kv_cache",
|
||
// 站点请求计数(0046,按小时聚合)
|
||
"site_request_count",
|
||
// SCR-2 刮削记录(0058,替代 0057 media_scrape)
|
||
"scrape_record",
|
||
// 补字幕写入历史(0064)
|
||
"subtitle_write",
|
||
// 集数映射规则(0066)
|
||
"episode_mapping_rule",
|
||
// 站点请求失败留样(0077)
|
||
"site_failure_sample",
|
||
].sort();
|
||
|
||
/** 不走 entityTable() 的表:追加型/引擎自有表,没有 uuid id + created_at/updated_at 三件套 */
|
||
const NON_ENTITY_TABLES = [
|
||
"organize_source_snapshot",
|
||
"settings",
|
||
"audit_event",
|
||
"outbox_event",
|
||
"tasks_run_meta",
|
||
"tasks_fact",
|
||
"tasks_op_ledger",
|
||
"agent_run_event",
|
||
"login_attempt",
|
||
"sse_event",
|
||
// 稳定 key 作主键 / 只追加的运行历史
|
||
"scheduled_job",
|
||
"scheduled_job_run",
|
||
// 进程心跳:instance_id 主键 / 只追加的采样
|
||
"process_heartbeat",
|
||
"process_heartbeat_sample",
|
||
// 补字幕写入历史:只有 created_at / undone_at
|
||
"subtitle_write",
|
||
// 单行配置(id = 1)
|
||
"mcp_server_config",
|
||
// 一次性凭据:只记创建 / 用掉的时间
|
||
"admin_recovery_code",
|
||
"webauthn_challenge",
|
||
// 限流桶:key 主键,只有 updated_at
|
||
"rate_limit_bucket",
|
||
// 缓存:(region, key) 主键
|
||
"kv_cache",
|
||
// 站点请求计数:(site_id, hour) 主键
|
||
"site_request_count",
|
||
// 失败留样:只追加,只有 created_at
|
||
"site_failure_sample",
|
||
];
|
||
|
||
describe.skipIf(skip)("schema migrations (real PG)", () => {
|
||
let admin: Kysely<unknown>;
|
||
let db: Kysely<DB>;
|
||
|
||
beforeAll(async () => {
|
||
admin = new Kysely({ dialect: new PostgresDialect({ pool: new pg.Pool({ connectionString: url, max: 1 }) }) });
|
||
await sql.raw(`create schema ${schema}`).execute(admin);
|
||
db = new Kysely<DB>({
|
||
dialect: new PostgresDialect({
|
||
pool: new pg.Pool({ connectionString: url, max: 2, options: `-c search_path=${schema},public` }),
|
||
}),
|
||
});
|
||
await migrateToLatest(db, { migrationTableSchema: schema });
|
||
});
|
||
|
||
afterAll(async () => {
|
||
await db?.destroy();
|
||
await sql.raw(`drop schema if exists ${schema} cascade`).execute(admin);
|
||
await admin?.destroy();
|
||
});
|
||
|
||
const tables = async () =>
|
||
(
|
||
await sql<{ t: string }>`select table_name as t from information_schema.tables
|
||
where table_schema = current_schema() and table_type = 'BASE TABLE' and table_name not like 'kysely_%'
|
||
order by 1`.execute(db)
|
||
).rows.map((r) => r.t);
|
||
|
||
it("建齐任务书 §3.1-2 全部表", async () => {
|
||
expect(await tables()).toEqual(EXPECTED_TABLES);
|
||
});
|
||
|
||
it("src/types.ts 与迁移结果一致(无漂移)", async () => {
|
||
const generated = formatWithBiome(await generateTypesSource(db));
|
||
expect(generated).toBe(readFileSync(TYPES_FILE, "utf8"));
|
||
});
|
||
|
||
it("新实体表都有 uuid 主键默认值与 created_at/updated_at", async () => {
|
||
const rows = (
|
||
await sql<{ table_name: string; column_name: string; column_default: string | null }>`
|
||
select table_name, column_name, column_default from information_schema.columns
|
||
where table_schema = current_schema() and column_name in ('id', 'created_at', 'updated_at')`.execute(db)
|
||
).rows;
|
||
for (const t of EXPECTED_TABLES.filter((x) => !NON_ENTITY_TABLES.includes(x))) {
|
||
const cols = rows.filter((r) => r.table_name === t);
|
||
expect(cols.map((c) => c.column_name).sort(), t).toEqual(["created_at", "id", "updated_at"]);
|
||
expect(cols.find((c) => c.column_name === "id")?.column_default, t).toBe("gen_random_uuid()");
|
||
}
|
||
});
|
||
|
||
it("updated_at 触发器与 CHECK 状态约束", async () => {
|
||
const e = await db
|
||
.insertInto("media_entity")
|
||
.values({ kind: "movie", title: "沙丘2", year: 2024 })
|
||
.returningAll()
|
||
.executeTakeFirstOrThrow();
|
||
await sql`select pg_sleep(0.01)`.execute(db);
|
||
const u = await db
|
||
.updateTable("media_entity")
|
||
.set({ title: "沙丘:第二部" })
|
||
.where("id", "=", e.id)
|
||
.returningAll()
|
||
.executeTakeFirstOrThrow();
|
||
expect(u.updated_at.getTime()).toBeGreaterThanOrEqual(e.updated_at.getTime());
|
||
await expect(
|
||
sql`insert into acquisition_slot (media_entity_id, name, status) values (${e.id}, 'x', 'bogus')`.execute(db),
|
||
).rejects.toThrow(/check constraint/);
|
||
});
|
||
|
||
it("external_identity:accepted 唯一,候选可并存", async () => {
|
||
const [a, b] = await db
|
||
.insertInto("media_entity")
|
||
.values([
|
||
{ kind: "movie", title: "A" },
|
||
{ kind: "movie", title: "B" },
|
||
])
|
||
.returning("id")
|
||
.execute();
|
||
const base = { provider: "tmdb", entity_type: "movie" as const, external_id: "693134" };
|
||
await db
|
||
.insertInto("external_identity")
|
||
.values([
|
||
{ ...base, media_entity_id: a!.id, status: "proposed" },
|
||
{ ...base, media_entity_id: b!.id, status: "proposed" },
|
||
{ ...base, media_entity_id: a!.id, status: "accepted" },
|
||
{ ...base, entity_type: "tv", media_entity_id: b!.id, status: "accepted" },
|
||
])
|
||
.execute();
|
||
await expect(
|
||
db
|
||
.insertInto("external_identity")
|
||
.values({ ...base, media_entity_id: b!.id, status: "accepted" })
|
||
.execute(),
|
||
).rejects.toThrow(/external_identity_accepted_key/);
|
||
});
|
||
|
||
it("source_release / observation / download_task / Slot 预留 唯一约束", async () => {
|
||
const site = await db
|
||
.insertInto("site")
|
||
.values({ key: "audiences", name: "观众", adapter: "nexusphp", base_url: "https://example.invalid" })
|
||
.returning("id")
|
||
.executeTakeFirstOrThrow();
|
||
const rel = await db
|
||
.insertInto("source_release")
|
||
.values({ site_id: site.id, site_release_id: "123", title: "Dune.Part.Two.2024.2160p" })
|
||
.returning("id")
|
||
.executeTakeFirstOrThrow();
|
||
await expect(
|
||
db.insertInto("source_release").values({ site_id: site.id, site_release_id: "123", title: "dup" }).execute(),
|
||
).rejects.toThrow(/source_release_site_release_key/);
|
||
|
||
const feed = await db
|
||
.insertInto("feed_source")
|
||
.values({ site_id: site.id, name: "电影", url_display: "https://example.invalid/rss?passkey=[REDACTED]" })
|
||
.returning("id")
|
||
.executeTakeFirstOrThrow();
|
||
const obs = { feed_id: feed.id, guid: "g1", content_digest: "d1", title: "t" };
|
||
await db.insertInto("observation").values(obs).execute();
|
||
await expect(db.insertInto("observation").values(obs).execute()).rejects.toThrow(/observation_feed_guid_key/);
|
||
|
||
const qb = await db
|
||
.insertInto("downloader_instance")
|
||
.values({ name: "qb1", base_url: "http://qb.invalid" })
|
||
.returning("id")
|
||
.executeTakeFirstOrThrow();
|
||
const dt = { instance_id: qb.id, torrent_hash: "a".repeat(40), name: "x" };
|
||
await db.insertInto("download_task").values(dt).execute();
|
||
await expect(db.insertInto("download_task").values(dt).execute()).rejects.toThrow(
|
||
/download_task_instance_hash_key/,
|
||
);
|
||
|
||
const ent = await db
|
||
.insertInto("media_entity")
|
||
.values({ kind: "movie", title: "C" })
|
||
.returning("id")
|
||
.executeTakeFirstOrThrow();
|
||
const slot = await db
|
||
.insertInto("acquisition_slot")
|
||
.values({ media_entity_id: ent.id, name: "archival" })
|
||
.returning("id")
|
||
.executeTakeFirstOrThrow();
|
||
await expect(
|
||
db.insertInto("acquisition_slot").values({ media_entity_id: ent.id, name: "archival" }).execute(),
|
||
).rejects.toThrow(/acquisition_slot_target_key/);
|
||
const plan = (k: string) => ({
|
||
slot_id: slot.id,
|
||
source_release_id: rel.id,
|
||
status: "reserved" as const,
|
||
payload_hash: "h",
|
||
idempotency_key: k,
|
||
});
|
||
await db.insertInto("acquisition_plan").values(plan("k1")).execute();
|
||
// 0025 起剧集 Slot 允许多个单元不相交的在途计划(服务端在 Slot 行锁内按单元校验);幂等键仍唯一
|
||
await db.insertInto("acquisition_plan").values(plan("k2")).execute();
|
||
await expect(db.insertInto("acquisition_plan").values(plan("k2")).execute()).rejects.toThrow(
|
||
/acquisition_plan_idempotency_key/,
|
||
);
|
||
});
|
||
|
||
it("path_binding:同作品同季只能有一个 active 绑定", async () => {
|
||
const root = await db
|
||
.insertInto("library_root")
|
||
.values({ name: "movies", local_path: "/media/movies" })
|
||
.returning("id")
|
||
.executeTakeFirstOrThrow();
|
||
const ent = await db
|
||
.insertInto("media_entity")
|
||
.values({ kind: "series", title: "S" })
|
||
.returning("id")
|
||
.executeTakeFirstOrThrow();
|
||
const b = { media_entity_id: ent.id, library_root_id: root.id, binding_kind: "entity" as const };
|
||
await db
|
||
.insertInto("path_binding")
|
||
.values({ ...b, relative_path: "S (2023)" })
|
||
.execute();
|
||
await expect(
|
||
db
|
||
.insertInto("path_binding")
|
||
.values({ ...b, relative_path: "S2 (2023)" })
|
||
.execute(),
|
||
).rejects.toThrow(/path_binding_active_key/);
|
||
await db
|
||
.insertInto("path_binding")
|
||
.values({ ...b, relative_path: "S2 (2023)", status: "conflict" })
|
||
.execute();
|
||
});
|
||
|
||
it("organization_record.change_seq 随更新与文件明细变化递增", async () => {
|
||
const rec = await db
|
||
.insertInto("organization_record")
|
||
.values({ trigger: "auto", actor_type: "system", action: "copy" })
|
||
.returningAll()
|
||
.executeTakeFirstOrThrow();
|
||
const upd = await db
|
||
.updateTable("organization_record")
|
||
.set({ status: "running" })
|
||
.where("id", "=", rec.id)
|
||
.returning("change_seq")
|
||
.executeTakeFirstOrThrow();
|
||
expect(upd.change_seq).toBeGreaterThan(rec.change_seq);
|
||
await db
|
||
.insertInto("organization_file_result")
|
||
.values({ organization_record_id: rec.id, mode: "copy", source_path: "/downloads/a.mkv" })
|
||
.execute();
|
||
const after = await db
|
||
.selectFrom("organization_record")
|
||
.select("change_seq")
|
||
.where("id", "=", rec.id)
|
||
.executeTakeFirstOrThrow();
|
||
expect(after.change_seq).toBeGreaterThan(upd.change_seq);
|
||
expect(typeof after.change_seq).toBe("number");
|
||
});
|
||
|
||
it("title_alias 上有 gin trgm 索引,可模糊召回", async () => {
|
||
const ent = await db
|
||
.insertInto("media_entity")
|
||
.values({ kind: "series", title: "最后生还者" })
|
||
.returning("id")
|
||
.executeTakeFirstOrThrow();
|
||
await db
|
||
.insertInto("title_alias")
|
||
.values({ media_entity_id: ent.id, alias: "The Last of Us", normalized: "the last of us", source: "tmdb" })
|
||
.execute();
|
||
const hit = await sql<{ id: string }>`select media_entity_id as id from title_alias
|
||
where normalized % ${"last of us"}`.execute(db);
|
||
expect(hit.rows.map((r) => r.id)).toContain(ent.id);
|
||
});
|
||
|
||
it("agent_run_event:(run_id, seq) 唯一,删 run 级联删事件", async () => {
|
||
const run = await db
|
||
.insertInto("agent_run")
|
||
.values({ trigger: "user", goal: "g" })
|
||
.returning("id")
|
||
.executeTakeFirstOrThrow();
|
||
const ev = { run_id: run.id, seq: 0, type: "run_started" as const, payload: JSON.stringify({ goal: "g" }) };
|
||
await db.insertInto("agent_run_event").values(ev).execute();
|
||
await expect(db.insertInto("agent_run_event").values(ev).execute()).rejects.toThrow(/agent_run_event_pkey/);
|
||
await expect(
|
||
sql`insert into agent_run_event (run_id, seq, type) values (${run.id}, 1, 'bogus')`.execute(db),
|
||
).rejects.toThrow(/check constraint/);
|
||
await db.deleteFrom("agent_run").where("id", "=", run.id).execute();
|
||
const left = await db.selectFrom("agent_run_event").select("seq").where("run_id", "=", run.id).execute();
|
||
expect(left).toEqual([]);
|
||
});
|
||
|
||
it("迁移可完整 down 再 up(往返)", async () => {
|
||
const migrator = createMigrator(db, { migrationTableSchema: schema });
|
||
const down = await migrator.migrateTo(NO_MIGRATIONS);
|
||
expect(down.error).toBeUndefined();
|
||
expect(await tables()).toEqual([]);
|
||
const up = await migrator.migrateToLatest();
|
||
expect(up.error).toBeUndefined();
|
||
expect(await tables()).toEqual(EXPECTED_TABLES);
|
||
}, 60_000);
|
||
|
||
it("迁移器只内省目标 schema:别处同时建删 schema 不影响(并行测试共用库)", async () => {
|
||
const migrator = createMigrator(db, { migrationTableSchema: schema });
|
||
let stop = false;
|
||
const churn = (async () => {
|
||
for (let i = 0; !stop && i < 200; i++) {
|
||
const tmp = `${schema}_churn_${i}`;
|
||
await sql.raw(`create schema ${tmp}; create table ${tmp}.t (id serial primary key)`).execute(admin);
|
||
await sql.raw(`drop schema ${tmp} cascade`).execute(admin);
|
||
}
|
||
})();
|
||
try {
|
||
for (let i = 0; i < 20; i++) {
|
||
const r = await migrator.migrateToLatest();
|
||
expect(r.error).toBeUndefined();
|
||
}
|
||
} finally {
|
||
stop = true;
|
||
await churn;
|
||
}
|
||
}, 60_000);
|
||
});
|