@koishi-ce/plugin-market 1.1.2 → 1.1.4

package/src/__tests__/provider.test.ts

@@ -0,0 +1,276 @@
+// 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(
+	"../node/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 dependencies = await app
+			.get("console.services.dependencies")
+			?.get();
+		expect(
+			dependencies?.["koishi-plugin-demo"]?.request,
+		).toBeTruthy();
+		expect(
+			dependencies?.["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(
+		"搜索接口失败时 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"];
+	});
+});

package/src/__tests__/retry.test.ts

@@ -0,0 +1,169 @@
+// 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 net from "node:net";
+import type { Plugin } from "@koishi-ce/koishi";
+import {
+	App,
+	FakeConsole,
+	FakeLoader,
+	flakyIndexHits,
+	http,
+	itQuiet,
+	market,
+	memory,
+	registryServer,
+	setFlakyIndexHits,
+	setFlakyIndexMisses,
+	setSlowIndexHits,
+	slowIndexHits,
+	startApp,
+	stopApp,
+	type TestApp,
+} from "./helpers.ts";
+
+beforeAll(startApp);
+afterAll(stopApp);
+
+describe("镜像索引瞬态重试", () => {
+	/** 搭建配了 search.endpoint 的独立宿主（镜像索引经本测试桩提供）。 */
+	async function createMirrorApp(search: {
+		endpoint: string;
+		timeout?: number;
+	}) {
+		const mirror = new App();
+		// 类型层转型缘由见 helpers 的 app.plugin(memory) 注释
+		mirror.plugin(
+			memory as unknown as Plugin.Object<TestApp>,
+		);
+		mirror.plugin(http);
+		mirror.plugin(
+			FakeConsole as unknown as Plugin.Constructor<TestApp>,
+		);
+		mirror.plugin(FakeLoader);
+		mirror.plugin(market, {
+			registry: {
+				endpoint: `http://127.0.0.1:${registryServer.port}/`,
+			},
+			search,
+		});
+		await mirror.start();
+		return mirror;
+	}
+
+	it("镜像索引部署窗口 404 经退避重试后恢复", async () => {
+		setFlakyIndexHits(0);
+		setFlakyIndexMisses(2);
+		const mirror = await createMirrorApp({
+			endpoint: `http://127.0.0.1:${registryServer.port}/flaky-index`,
+		});
+		const svc = mirror.get("console.services.market");
+		// start(true) 内部 await prepare：前两次 404，退避重试后第三次成功
+		await svc?.start(true);
+		expect(flakyIndexHits).toBeGreaterThanOrEqual(3);
+		const payload = await svc?.get();
+		expect(Object.keys(payload?.data ?? {})).toEqual([
+			"koishi-plugin-demo",
+		]);
+		expect(payload?.total).toBe(1);
+		await mirror.stop();
+	}, 10000);
+
+	itQuiet(
+		"镜像索引持续超时经重试后优雅失败",
+		async () => {
+			setSlowIndexHits(0);
+			const mirror = await createMirrorApp({
+				endpoint: `http://127.0.0.1:${registryServer.port}/slow-index`,
+				timeout: 50,
+			});
+			const svc = mirror.get("console.services.market");
+			// 每次尝试 50ms 即超时，退避 1s + 2s 后仍失败；重试确实发生
+			await svc?.start(true);
+			expect(slowIndexHits).toBeGreaterThanOrEqual(3);
+			// start 末尾的 refresh 会再触发一轮 collect，等待其失败落地
+			await new Promise((resolve) =>
+				setTimeout(resolve, 3600),
+			);
+			const error = svc?.["_error" as keyof typeof svc];
+			expect(error).toBeDefined();
+			await mirror.stop();
+		},
+		15000,
+	);
+
+	// 裸 TCP 桩：前 planned 次请求收到请求头后直接销毁连接（复现
+	// 证书验证失败 / 连接重置等 fetch 网络层瞬态错误），随后回正常索引
+	function startFlakyTcpServer(planned: number) {
+		let hits = 0;
+		const server = net.createServer((socket) => {
+			socket.on("data", () => {
+				hits++;
+				if (hits <= planned) {
+					socket.destroy();
+					return;
+				}
+				const body = JSON.stringify({
+					version: "4",
+					objects: [
+						{
+							package: {
+								name: "koishi-plugin-demo",
+								version: "2.0.0",
+								date: "2024-06-01T00:00:00Z",
+								keywords: ["koishi", "plugin"],
+							},
+						},
+					],
+				});
+				socket.end(
+					`HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: ${body.length}\r\nConnection: close\r\n\r\n${body}`,
+				);
+			});
+		});
+		return new Promise<{
+			port: number;
+			hits: () => number;
+			close: () => void;
+		}>((resolve) => {
+			server.listen(0, "127.0.0.1", () => {
+				const { port } =
+					server.address() as net.AddressInfo;
+				resolve({
+					port,
+					hits: () => hits,
+					close: () => {
+						server.close();
+					},
+				});
+			});
+		});
+	}
+
+	it("网络层瞬态错误（连接重置）经退避重试后恢复", async () => {
+		const stub = await startFlakyTcpServer(2);
+		const mirror = await createMirrorApp({
+			endpoint: `http://127.0.0.1:${stub.port}/`,
+		});
+		const svc = mirror.get("console.services.market");
+		// 前两次连接被重置（fetch 抛 TypeError，plugin-http 包装为无 code
+		// 无 response 的 HTTP.Error），退避重试后第三次成功
+		await svc?.start(true);
+		expect(stub.hits()).toBeGreaterThanOrEqual(3);
+		const payload = await svc?.get();
+		expect(Object.keys(payload?.data ?? {})).toEqual([
+			"koishi-plugin-demo",
+		]);
+		expect(payload?.total).toBe(1);
+		await mirror.stop();
+		stub.close();
+	}, 10000);
+});