@koishi-ce/plugin-market 1.1.3 → 1.2.0

package/src/node/__tests__/helpers.ts

@@ -0,0 +1,380 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2019-present Shigma and Koishijs contributors.
+// Copyright (c) 2026-present Koishi-CE contributors.
+
+import { expect, it, mock } from "bun:test";
+import {
+	mkdtempSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import memory from "@koishi-ce/plugin-database-memory";
+
+/**
+ * market 插件测试：
+ * - 子进程（bun 安装）经 mock.module 拦截 installer/proc.ts（spawnBun 封装），不落盘不联网安装；
+ * - registry 网络请求由进程内 Bun.serve 提供（registry 协议的最小 JSON）；
+ * - 宿主环境（loader / cwd）使用 FakeLoader 与临时目录 + chdir，
+ *   Installer 的 override 写盘只会作用于临时 package.json。
+ */
+
+/** 已发生的子进程调用（参数列表）。 */
+export const spawnCalls: string[][] = [];
+/** 控制下一次子进程的退出码与触发事件。 */
+let nextExitCode = 0;
+let nextSpawnError = false;
+
+/** let 绑定无法跨模块直接赋值，用例经以下 setter 控制子进程桩。 */
+export function setNextExitCode(code: number) {
+	nextExitCode = code;
+}
+
+export function setNextSpawnError(flag: boolean) {
+	nextSpawnError = flag;
+}
+
+const spawnBunMock = (_args: string[], _cwd: string) => {
+	spawnCalls.push(_args);
+	return {
+		on(event: string, cb: (code?: number) => void) {
+			if (nextSpawnError) {
+				if (event === "error") setImmediate(() => cb());
+			} else if (event === "exit") {
+				setImmediate(() => cb(nextExitCode));
+			}
+			return this;
+		},
+		stderr: {
+			on(event: string, cb: (data: Buffer) => void) {
+				// 同步派发：异步派发会晚于用例的日志静默窗口，导致转发告警漏出刷屏
+				if (event === "data")
+					cb(Buffer.from("stderr line\n"));
+				return this;
+			},
+		},
+		stdout: {
+			on(event: string, cb: (data: Buffer) => void) {
+				if (event === "data")
+					cb(Buffer.from("stdout line\n"));
+				return this;
+			},
+		},
+	};
+};
+
+// 注册须先于下方动态 import 被测模块；bun test --isolate 下各测试文件
+// 独立实例化本模块，mock 随之按文件各自生效
+mock.module("../installer/proc.ts", () => ({
+	spawnBun: spawnBunMock,
+}));
+
+import type { Entry } from "@koishi-ce/console";
+// 均为 type-only 导入：编译期擦除，不干扰 mock.module 先于插件加载的时序
+import type { Plugin } from "@koishi-ce/koishi";
+
+const { Console } = await import("@koishi-ce/console");
+const { App, Logger, Service } = await import(
+	"@koishi-ce/koishi"
+);
+const http = (await import("@koishi-ce/plugin-http"))
+	.default;
+const market = await import("../index.ts");
+const mockPlugin = (await import("@koishi-ce/plugin-mock"))
+	.default;
+// 加载包入口占位文件（纯 re-export，无独立逻辑），保证 src 全量被加载
+await import("../../index.ts");
+
+// 供各主题测试文件复用的共享构建块（App / http / Logger / market / memory）
+export { App, http, Logger, market, memory };
+
+/** 控制台服务桩：仅实现入口登记所需的最小面。 */
+export class FakeConsole extends Console {
+	protected resolveEntry(
+		_files: Entry.Files,
+		_key: string,
+	): string[] {
+		return [];
+	}
+}
+
+/** loader 服务桩（immediate Service）：writable 可写、envData 供重启消息断言。 */
+export class FakeLoader extends Service {
+	writable = true;
+	envData: Record<string, unknown> = { message: null };
+	paths() {
+		return ["group:entry", "plugins"];
+	}
+	fullReload() {}
+	constructor(
+		ctx: ConstructorParameters<typeof Service>[0],
+	) {
+		super(ctx, "loader", true);
+	}
+}
+
+/** registry 协议最小 JSON 服务（Bun.serve，随机端口）。 */
+export const registryData: {
+	[key: string]: {
+		versions: Record<
+			string,
+			{
+				version: string;
+				peerDependencies?: Record<string, string>;
+				deprecated?: boolean;
+			}
+		>;
+		time?: Record<string, string>;
+	};
+} = {};
+
+/** 搜索接口响应（/-/v1/search，collect 阶段消费）。初始给空结果，避免启动期空转 404。 */
+let searchResponse: {
+	objects: unknown[];
+	total: number;
+} | null = {
+	objects: [],
+	total: 0,
+};
+
+/** 用例经本 setter 切换搜索接口响应（let 绑定无法跨模块直接赋值）。 */
+export function setSearchResponse(
+	value: typeof searchResponse,
+) {
+	searchResponse = value;
+}
+
+/** flaky-index 镜像索引桩：已发生的请求计数与计划内的 404 次数。 */
+export let flakyIndexHits = 0;
+let flakyIndexMisses = 0;
+/** slow-index 慢响应桩：已发生的请求计数。 */
+export let slowIndexHits = 0;
+
+/** 计数导出为 live binding 供用例断言读取；写回仍须经以下 setter
+ *  （let 绑定无法跨模块直接赋值）。 */
+export function setFlakyIndexHits(hits: number) {
+	flakyIndexHits = hits;
+}
+
+export function setFlakyIndexMisses(misses: number) {
+	flakyIndexMisses = misses;
+}
+
+export function setSlowIndexHits(hits: number) {
+	slowIndexHits = hits;
+}
+
+/** 声明预期触发 market 域告警（404 / 限流等桩失败路径）的用例：执行期间静默该域。 */
+export const itQuiet = (
+	name: string,
+	fn: () => Promise<void> | void,
+	timeout?: number,
+) =>
+	it(
+		name,
+		async () => {
+			const levels = Logger.levels as Record<
+				string,
+				number
+			>;
+			levels["market"] = 0;
+			try {
+				await fn();
+			} finally {
+				delete levels["market"];
+			}
+		},
+		timeout,
+	);
+
+// 预置一个兼容插件包：最新版 2.0.0，旧版 1.0.0 均声明 koishi ^4 peer
+registryData["koishi-plugin-demo"] = {
+	versions: {
+		"1.0.0": {
+			version: "1.0.0",
+			peerDependencies: { koishi: "^4.17.0" },
+		},
+		"2.0.0": {
+			version: "2.0.0",
+			peerDependencies: { koishi: "^4.17.0" },
+		},
+	},
+	time: {
+		"1.0.0": "2024-01-01T00:00:00Z",
+		"2.0.0": "2024-06-01T00:00:00Z",
+	},
+};
+// 预置一个未安装的插件包（plugin.install 安装路径使用）
+registryData["koishi-plugin-newpkg"] = {
+	versions: {
+		"1.0.0": {
+			version: "1.0.0",
+			peerDependencies: { koishi: "^4.17.0" },
+		},
+	},
+	time: { "1.0.0": "2024-01-01T00:00:00Z" },
+};
+// 预置初始清单里三个非插件依赖的远端条目：Installer.refresh() 每轮都会对全部
+// 清单依赖发起 registry 查询，缺桩会让每个用例都刷 404 告警
+registryData["koishi"] = {
+	versions: { "4.18.0": { version: "4.18.0" } },
+	time: { "4.18.0": "2024-01-01T00:00:00Z" },
+};
+registryData["market-alias"] = {
+	versions: { "1.0.0": { version: "1.0.0" } },
+	time: { "1.0.0": "2024-01-01T00:00:00Z" },
+};
+registryData["bad-range"] = {
+	versions: { "1.0.0": { version: "1.0.0" } },
+	time: { "1.0.0": "2024-01-01T00:00:00Z" },
+};
+
+/** 临时宿主目录的初始依赖清单（每次重建时原样写入 package.json）。 */
+const initialDependencies = {
+	// 护栏：workspace 声明不可被覆盖或删除
+	koishi: "workspace:*",
+	// 护栏：npm:@koishi-ce alias 同样受保护
+	"market-alias": "npm:@koishi-ce/anything@^1.0.0",
+	// 普通依赖：可解析远端最新版
+	"koishi-plugin-demo": "^1.0.0",
+	// 非法 semver 区间：应标记 invalid
+	"bad-range": "not-a-version",
+};
+
+/** 模块加载时的原始 cwd，stopApp 还原用。 */
+const originalCwd = process.cwd();
+
+// App 经动态 import 取值为 const，实例类型由构造器派生供 Plugin.Constructor 泛型使用
+export type TestApp = InstanceType<typeof App>;
+
+/** 临时宿主目录（Installer 的 cwd 与 override 写盘目标）。 */
+export let tmp: string;
+export let registryServer: Bun.Server<undefined>;
+export let app: TestApp;
+export let client: ReturnType<TestApp["mock"]["client"]>;
+
+/**
+ * 全量重建临时宿主与配套桩（fetch 闭包仍读上方模块级 let 桩状态）。
+ * 裸跑（bun test 无 --isolate）时多测试文件共享本模块单例，stopApp
+ * 清理后由下一次 startApp 全量重建，避免对已停机实例二次 start。
+ */
+function rebuild() {
+	tmp = mkdtempSync(join(tmpdir(), "market-test-"));
+	writeFileSync(
+		join(tmp, "package.json"),
+		JSON.stringify(
+			{
+				name: "market-host",
+				dependencies: initialDependencies,
+			},
+			null,
+			"\t",
+		),
+	);
+	process.chdir(tmp);
+	// registry 协议最小 JSON 服务（Bun.serve，随机端口）
+	registryServer = Bun.serve({
+		port: 0,
+		hostname: "127.0.0.1",
+		async fetch(request) {
+			const url = new URL(request.url);
+			if (url.pathname.startsWith("/-/v1/search")) {
+				if (!searchResponse) {
+					return new Response("not found", {
+						status: 404,
+					});
+				}
+				return Response.json(searchResponse);
+			}
+			// 模拟镜像索引的部署窗口：前 flakyIndexMisses 次 404，随后返回完整索引
+			if (url.pathname === "/flaky-index") {
+				if (flakyIndexHits++ < flakyIndexMisses) {
+					return new Response("not found", {
+						status: 404,
+					});
+				}
+				return Response.json({
+					version: "4",
+					objects: [
+						{
+							package: {
+								name: "koishi-plugin-demo",
+								version: "2.0.0",
+								date: "2024-06-01T00:00:00Z",
+								keywords: ["koishi", "plugin"],
+							},
+						},
+					],
+				});
+			}
+			// 模拟镜像索引挂起：延迟超过用例配置的 timeout，驱动超时重试路径
+			if (url.pathname === "/slow-index") {
+				slowIndexHits++;
+				await new Promise((resolve) =>
+					setTimeout(resolve, 300),
+				);
+				return Response.json({ version: "4", objects: [] });
+			}
+			// 模拟 registry 限流：恒定 429 + 极短的 Retry-After，驱动重试后失败
+			if (
+				url.pathname.includes("koishi-plugin-ratelimited")
+			) {
+				return new Response("rate limited", {
+					status: 429,
+					headers: { "Retry-After": "0.01" },
+				});
+			}
+			const name = decodeURIComponent(
+				url.pathname.slice(1),
+			);
+			const data = registryData[name];
+			if (!data) {
+				return new Response("not found", { status: 404 });
+			}
+			return Response.json(data);
+		},
+	});
+	app = new App();
+	// MemoryDriver 的 Schema Config 推导在 TS7 增量编译下重载解析失败
+	// （全量编译不报，删 buildinfo 后消失），参照 FakeConsole 先例做
+	// 类型层转型绕开推导；Plugin.Object<App> 形态见 actions 测试先例
+	app.plugin(memory as unknown as Plugin.Object<TestApp>);
+	app.plugin(http);
+	// Console 基类的 static inject 是 cordis 3 旧形态，与 Plugin.Constructor 期待类型不兼容，仅做类型层转型
+	app.plugin(
+		FakeConsole as unknown as Plugin.Constructor<TestApp>,
+	);
+	app.plugin(FakeLoader);
+	app.plugin(market, {
+		registry: {
+			endpoint: `http://127.0.0.1:${registryServer.port}/`,
+		},
+	});
+	app.plugin(mockPlugin);
+	client = app.mock.client("123");
+}
+
+/** 各主题测试文件的 beforeAll 钩子体：启动宿主并触发延迟服务实例化。 */
+export async function startApp() {
+	rebuild();
+	await app.start();
+	await app.mock.initUser("123", 4);
+	// 触发 installer 等延迟服务的实例化
+	expect(app.installer).toBeDefined();
+}
+
+/**
+ * 各主题测试文件的 afterAll 钩子体：停机、还原 cwd、清理临时目录与
+ * registry 桩。停机前先冲刷 MarketProvider 的节流广播（窗口 500ms）：
+ * 悬挂的 flushData 若在 console 服务析构后才触发，裸跑（无 --isolate）
+ * 多文件形态下会在下一文件的执行窗口炸出 ctx.console undefined 的
+ * unhandled error（isolate 形态每文件独立进程环境则不可见）。
+ */
+export async function stopApp() {
+	await Bun.sleep(600);
+	await app.stop();
+	process.chdir(originalCwd);
+	rmSync(tmp, { recursive: true, force: true });
+	registryServer.stop(true);
+}

package/src/node/__tests__/provider.test.ts

@@ -0,0 +1,340 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2019-present Shigma and Koishijs contributors.
+// Copyright (c) 2026-present Koishi-CE contributors.
+
+import {
+	afterAll,
+	beforeAll,
+	describe,
+	expect,
+	it,
+} from "bun:test";
+import { rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { RemotePackage } from "@koishi-ce/registry";
+import {
+	App,
+	app,
+	http,
+	itQuiet,
+	registryServer,
+	setSearchResponse,
+	startApp,
+	stopApp,
+	tmp,
+} from "./helpers.ts";
+
+const { default: Installer } = await import(
+	"../installer/index.ts"
+);
+
+beforeAll(startApp);
+afterAll(stopApp);
+
+describe("market 插件", () => {
+	it("注册三个数据服务与浏览器监听器", () => {
+		expect(
+			app.get("console.services.market"),
+		).toBeDefined();
+		expect(
+			app.get("console.services.dependencies"),
+		).toBeDefined();
+		expect(
+			app.get("console.services.registry"),
+		).toBeDefined();
+		expect(
+			app.console.listeners["market/install"],
+		).toBeDefined();
+		expect(
+			app.console.listeners["market/registry"],
+		).toBeDefined();
+	});
+
+	it("resolveName 解析插件短名的候选全名", () => {
+		const installer = app.installer;
+		expect(
+			installer.resolveName("@koishijs/plugin-echo"),
+		).toEqual(["@koishijs/plugin-echo"]);
+		expect(
+			installer.resolveName("koishi-plugin-echo"),
+		).toEqual(["koishi-plugin-echo"]);
+		expect(installer.resolveName("@scope/echo")).toEqual([
+			"@scope/koishi-plugin-echo",
+		]);
+		expect(installer.resolveName("echo")).toEqual([
+			"@koishijs/plugin-echo",
+			"koishi-plugin-echo",
+		]);
+	});
+
+	it("getDeps 汇总本地依赖并带出远端最新版", async () => {
+		const deps = await app.installer.getDeps();
+		// 语义化区间去除前缀符号
+		expect(deps["koishi-plugin-demo"]?.request).toBe(
+			"1.0.0",
+		);
+		// 远端最新版（本地 registry 预置 2.0.0）
+		expect(deps["koishi-plugin-demo"]?.latest).toBe(
+			"2.0.0",
+		);
+		// 非法 semver 标记 invalid
+		expect(deps["bad-range"]?.invalid).toBe(true);
+	});
+
+	itQuiet(
+		"findVersion 返回首个存在的候选包版本",
+		async () => {
+			const found = await app.installer.findVersion([
+				"@koishijs/plugin-none",
+				"koishi-plugin-demo",
+			]);
+			expect(found).toEqual({
+				"koishi-plugin-demo": "2.0.0",
+			});
+			// 全部不存在时返回 undefined
+			expect(
+				await app.installer.findVersion([
+					"@koishijs/plugin-none",
+				]),
+			).toBeUndefined();
+		},
+	);
+
+	itQuiet("getPackage 拉取失败时回退为空表", async () => {
+		const versions = await app.installer.getPackage(
+			"koishi-plugin-missing",
+		);
+		expect(versions).toEqual({});
+	});
+
+	it("setPackage 写入缓存并触发节流广播", async () => {
+		app.installer.setPackage("koishi-plugin-demo", [
+			{
+				version: "3.0.0",
+				peerDependencies: { koishi: "^4.17.0" },
+				// RemotePackage 的其余元数据字段与本断言无关，最小载荷经 unknown 二段式断言
+			} as unknown as RemotePackage,
+		]);
+		expect(
+			Object.keys(
+				app.installer.fullCache["koishi-plugin-demo"] ?? {},
+			),
+		).toEqual(["3.0.0"]);
+		// 等待节流窗口
+		await new Promise((resolve) =>
+			setTimeout(resolve, 600),
+		);
+	});
+});
+
+describe("registry 配置探测", () => {
+	it("无显式 endpoint 时按 npmrc / 环境变量探测", async () => {
+		// 环境变量优先：npm_config_registry 指向本地服务
+		process.env["npm_config_registry"] =
+			`http://127.0.0.1:${registryServer.port}/`;
+		const app2 = new App();
+		app2.plugin(http);
+		app2.plugin(Installer, {});
+		await app2.start();
+		expect(app2.installer.endpoint).toBe(
+			`http://127.0.0.1:${registryServer.port}/`,
+		);
+		await app2.stop();
+
+		// 环境变量缺失时回落到项目 .npmrc（含不合法行与合法 registry 行）
+		delete process.env["npm_config_registry"];
+		writeFileSync(
+			join(tmp, ".npmrc"),
+			"not-a-registry-line\nregistry=http://registry.example.npm/\n",
+		);
+		const app3 = new App();
+		app3.plugin(http);
+		app3.plugin(Installer, {});
+		await app3.start();
+		expect(app3.installer.endpoint).toBe(
+			"http://registry.example.npm/",
+		);
+		await app3.stop();
+		rmSync(join(tmp, ".npmrc"), { force: true });
+	});
+});
+
+describe("MarketProvider 市场数据服务", () => {
+	it("collect 经搜索接口收集并逐包分析填充缓存", async () => {
+		const svc = app.get("console.services.market");
+		expect(svc).toBeDefined();
+		// 提供搜索结果：一个插件条目 + 一个被忽略条目
+		setSearchResponse({
+			objects: [
+				{
+					package: {
+						name: "koishi-plugin-demo",
+						version: "1.0.0",
+						date: "2024-01-01T00:00:00Z",
+						keywords: ["koishi", "plugin", "Tool"],
+					},
+				},
+				{
+					package: {
+						name: "not-a-plugin",
+						date: "2024-01-01T00:00:00Z",
+					},
+				},
+			],
+			total: 1,
+		});
+		// start(true) 强制刷新市场数据（重新 collect）
+		await svc?.start(true);
+		// 等待节流窗口与逐包分析完成
+		await new Promise((resolve) =>
+			setTimeout(resolve, 700),
+		);
+		const payload = await svc?.get();
+		expect(payload).toBeDefined();
+		// 非 plugin 条目被剔除，只保留 demo
+		expect(Object.keys(payload?.data ?? {})).toEqual([
+			"koishi-plugin-demo",
+		]);
+		expect(payload?.total).toBe(1);
+		expect(payload?.failed).toBe(0);
+		expect(payload?.registry).toBe(
+			`http://127.0.0.1:${registryServer.port}/`,
+		);
+	});
+
+	it("依赖服务两拍推送:快照先行、元数据完成后填充", async () => {
+		const service = app.get(
+			"console.services.dependencies",
+		);
+		expect(service).toBeDefined();
+		const first = await service?.get();
+		// 第一拍:本地快照先行,元数据尚在拉取
+		expect(
+			first?.["koishi-plugin-demo"]?.request,
+		).toBeTruthy();
+		// 等元数据拉取完成(本地 registry 桩,秒级内):条目就地填充
+		await new Promise((resolve) =>
+			setTimeout(resolve, 800),
+		);
+		expect(first?.["koishi-plugin-demo"]?.latest).toBe(
+			"2.0.0",
+		);
+		expect(
+			first?.["koishi-plugin-demo"]?.fetching,
+		).toBeUndefined();
+		// 第二拍 get() 复用上一轮结果,不再拉取
+		const second = await service?.get();
+		expect(second?.["koishi-plugin-demo"]?.latest).toBe(
+			"2.0.0",
+		);
+
+		const registry = await app
+			.get("console.services.registry")
+			?.get();
+		expect(
+			Object.keys(registry?.["koishi-plugin-demo"] ?? {}),
+		).toContain("2.0.0");
+	});
+
+	itQuiet(
+		"registry 无此包的条目两拍后标记 not-found 负缓存",
+		async () => {
+			// 向宿主清单添加一个 registry 桩里不存在的依赖
+			const manifestPath = join(tmp, "package.json");
+			const manifest = JSON.parse(
+				await Bun.file(manifestPath).text(),
+			) as {
+				dependencies: Record<string, string>;
+			};
+			manifest.dependencies["koishi-plugin-ghost"] =
+				"^1.0.0";
+			await Bun.write(
+				manifestPath,
+				JSON.stringify(manifest, null, "\t"),
+			);
+			try {
+				const service = app.get(
+					"console.services.dependencies",
+				);
+				const snapshot = await service?.get();
+				expect(
+					snapshot?.["koishi-plugin-ghost"]?.request,
+				).toBe("1.0.0");
+				await new Promise((resolve) =>
+					setTimeout(resolve, 800),
+				);
+				expect(
+					snapshot?.["koishi-plugin-ghost"]?.error,
+				).toBe("not-found");
+				// 404 负缓存:重建快照仍标记 not-found 且不再拉取
+				const again = await service?.get();
+				expect(again?.["koishi-plugin-ghost"]?.error).toBe(
+					"not-found",
+				);
+				expect(
+					again?.["koishi-plugin-ghost"]?.fetching,
+				).toBeUndefined();
+			} finally {
+				delete manifest.dependencies["koishi-plugin-ghost"];
+				await Bun.write(
+					manifestPath,
+					JSON.stringify(manifest, null, "\t"),
+				);
+			}
+		},
+		15000,
+	);
+
+	itQuiet(
+		"搜索接口失败时 get 返回空数据与错误标记",
+		async () => {
+			const svc = app.get("console.services.market");
+			setSearchResponse(null);
+			// 强制重扫：collect 失败置 _error，get 返回空 payload
+			await svc?.start(true);
+			const payload = await svc?.get();
+			expect(payload).toEqual({
+				data: {},
+				failed: 0,
+				total: 0,
+				progress: 0,
+			});
+			setSearchResponse({
+				objects: [],
+				total: 0,
+			});
+		},
+	);
+
+	it("控制台连接事件在数据过期时触发刷新", async () => {
+		const svc = app.get("console.services.market");
+		expect(svc).toBeDefined();
+		// 伪造一个在线客户端，使连接事件通过在线检查（broadcast 需可用的 socket）
+		const fakeClient = {
+			id: "conn-1",
+			socket: { send() {} },
+		};
+		(app.console.clients as Record<string, unknown>)[
+			"conn-1"
+		] = fakeClient;
+		// 刚刷新过：12 小时窗口内直接返回，不重新收集
+		const timestamp = svc?.[
+			"_timestamp" as keyof typeof svc
+		] as number;
+		// console/connection 载荷声明为 Client，桩对象仅含在线检查所需的最小面，类型层断言穿透
+		app.emit("console/connection", fakeClient as never);
+		expect(
+			svc?.["_timestamp" as keyof typeof svc] as number,
+		).toBe(timestamp);
+		// 将时间戳回拨到窗口外，连接事件重新触发 start（异步监听，稍等）
+		(svc as Record<string, unknown>)["_timestamp"] = 0;
+		app.emit("console/connection", fakeClient as never);
+		await new Promise((resolve) => setTimeout(resolve, 20));
+		expect(
+			(svc as Record<string, unknown>)[
+				"_timestamp"
+			] as number,
+		).toBeGreaterThan(0);
+		delete app.console.clients["conn-1"];
+	});
+});