@mpcore/test 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 ice breaker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,41 @@
+# @mpcore/test
+
+面向微信小程序编译产物的 runner 无关测试 API。它模拟微信宿主和逻辑 WXML 树，不创建浏览器 DOM。
+
+```ts
+const project = createTestProject({
+  artifact: { projectPath: '/path/to/project' },
+  host: createWxMock({
+    request: { url: '/api/count', response: { data: { count: 1 } } },
+  }),
+})
+
+const result = await project.renderComponent('components/counter/index', {
+  properties: { value: 1 },
+  slots: { default: '<text>计数器</text>' },
+})
+
+await result.user.tap(result.screen.getByRole('button', { name: '增加' }))
+```
+
+查询支持 text、role、test id、attribute、`within()` 及 `get/query/find/getAll/findAll` 变体，并保留 `$` / `$$` 选择器逃生口。`tap/input/change/blur/trigger` 会等待同步更新和 microtask 稳定后刷新逻辑树。
+
+未匹配的网络 mock 会抛错；未捕获运行时异常和 `console.error` 默认令测试失败。可通过 `diagnostics()` 断言 warning，负向 console 测试可显式设置 `failOnConsoleError: false`。
+
+`@mpcore/test` 为真实微信小程序编译产物提供页面和组件单测环境。它模拟微信宿主与逻辑 WXML 树，不提供浏览器 `document` 或 CSS layout。
+
+```ts
+import { artifactFromProject, createTestProject } from '@mpcore/test'
+
+const project = createTestProject({
+  artifact: artifactFromProject(process.cwd()),
+})
+
+const { screen, user } = await project.renderPage('/pages/index/index')
+await user.tap(screen.getByRole('button', { name: '增加' }))
+expect(screen.getByText('2')).toBeDefined()
+
+await project.close()
+```
+
+组件测试通过内存宿主页挂载构建后的组件，不会修改小程序产物。

package/dist/index.d.mts

@@ -0,0 +1,159 @@
+import { HeadlessSession, HeadlessTestingLogicalNode, HeadlessTestingPageHandle, HeadlessTestingPageSnapshot, HeadlessWxActionSheetMockDefinition, HeadlessWxDownloadFileMockDefinition, HeadlessWxModalMockDefinition, HeadlessWxRequestMockDefinition, HeadlessWxUploadFileMockDefinition, PlatformAdapter, RuntimeDiagnosticEntry, wechat } from "@mpcore/simulator";
+//#region src/screen/helpers.d.ts
+type TextMatcher = string | RegExp;
+interface RoleQueryOptions {
+  name?: TextMatcher;
+}
+//#endregion
+//#region src/screen/index.d.ts
+declare class MiniProgramNode {
+  private readonly owner;
+  readonly nodeId: string;
+  constructor(owner: MiniProgramScreen, nodeId: string);
+  private get current();
+  get attributes(): {
+    [x: string]: string;
+  };
+  get dataset(): {
+    [k: string]: string;
+  };
+  get isConnected(): boolean;
+  get role(): string | undefined;
+  get tagName(): string | undefined;
+  get textContent(): string;
+  getAttribute(name: string): string;
+}
+declare class MiniProgramScreen {
+  private readonly page;
+  private currentSnapshot;
+  private readonly rootNodeId?;
+  constructor(page: HeadlessTestingPageHandle, snapshot: HeadlessTestingPageSnapshot, rootNodeId?: string);
+  private get root();
+  private allElements;
+  private wrap;
+  private requireOne;
+  private findOne;
+  private findAll;
+  hasNode(nodeId: string): boolean;
+  resolveNode(nodeId: string): HeadlessTestingLogicalNode;
+  refresh(): Promise<void>;
+  within(node: MiniProgramNode): MiniProgramScreen;
+  queryAllByText(matcher: TextMatcher): MiniProgramNode[];
+  queryByText(matcher: TextMatcher): MiniProgramNode;
+  getAllByText(matcher: TextMatcher): MiniProgramNode[];
+  getByText(matcher: TextMatcher): MiniProgramNode;
+  findByText(matcher: TextMatcher, timeout?: number): Promise<MiniProgramNode>;
+  findAllByText(matcher: TextMatcher, timeout?: number): Promise<MiniProgramNode[]>;
+  queryAllByRole(role: string, options?: RoleQueryOptions): MiniProgramNode[];
+  queryByRole(role: string, options?: RoleQueryOptions): MiniProgramNode;
+  getAllByRole(role: string, options?: RoleQueryOptions): MiniProgramNode[];
+  getByRole(role: string, options?: RoleQueryOptions): MiniProgramNode;
+  findByRole(role: string, options?: RoleQueryOptions, timeout?: number): Promise<MiniProgramNode>;
+  findAllByRole(role: string, options?: RoleQueryOptions, timeout?: number): Promise<MiniProgramNode[]>;
+  queryAllByTestId(testId: string): MiniProgramNode[];
+  queryByTestId(testId: string): MiniProgramNode;
+  getAllByTestId(testId: string): MiniProgramNode[];
+  getByTestId(testId: string): MiniProgramNode;
+  findByTestId(testId: string, timeout?: number): Promise<MiniProgramNode>;
+  findAllByTestId(testId: string, timeout?: number): Promise<MiniProgramNode[]>;
+  queryAllByAttribute(name: string, value?: TextMatcher): MiniProgramNode[];
+  queryByAttribute(name: string, value?: TextMatcher): MiniProgramNode;
+  getAllByAttribute(name: string, value?: TextMatcher): MiniProgramNode[];
+  getByAttribute(name: string, value?: TextMatcher): MiniProgramNode;
+  findByAttribute(name: string, value?: TextMatcher, timeout?: number): Promise<MiniProgramNode>;
+  findAllByAttribute(name: string, value?: TextMatcher, timeout?: number): Promise<MiniProgramNode[]>;
+  $(selector: string): Promise<import("@mpcore/simulator").HeadlessTestingNodeHandle | null>;
+  $$(selector: string): Promise<import("@mpcore/simulator").HeadlessTestingNodeHandle[]>;
+}
+//#endregion
+//#region src/user.d.ts
+declare class MiniProgramUser {
+  private readonly page;
+  private readonly screen;
+  private readonly settle;
+  constructor(page: HeadlessTestingPageHandle, screen: MiniProgramScreen, settle: () => Promise<void>);
+  private nodeHandle;
+  private finish;
+  tap(node: MiniProgramNode, event?: Record<string, any>): Promise<void>;
+  input(node: MiniProgramNode, value: string, event?: Record<string, any>): Promise<void>;
+  change(node: MiniProgramNode, value: string, event?: Record<string, any>): Promise<void>;
+  blur(node: MiniProgramNode, value?: string, event?: Record<string, any>): Promise<void>;
+  trigger(node: MiniProgramNode, eventName: string, event?: Record<string, any>): Promise<void>;
+}
+//#endregion
+//#region src/types.d.ts
+interface MiniProgramArtifact {
+  appConfigPath?: string;
+  miniprogramRootPath?: string;
+  projectPath: string;
+}
+interface WxHostMock {
+  actionSheet?: HeadlessWxActionSheetMockDefinition | HeadlessWxActionSheetMockDefinition[];
+  downloadFile?: HeadlessWxDownloadFileMockDefinition | HeadlessWxDownloadFileMockDefinition[];
+  modal?: HeadlessWxModalMockDefinition | HeadlessWxModalMockDefinition[];
+  request?: HeadlessWxRequestMockDefinition | HeadlessWxRequestMockDefinition[];
+  uploadFile?: HeadlessWxUploadFileMockDefinition | HeadlessWxUploadFileMockDefinition[];
+}
+interface CreateTestProjectOptions {
+  artifact: MiniProgramArtifact;
+  failOnConsoleError?: boolean;
+  host?: WxHostMock;
+  platform?: PlatformAdapter;
+}
+interface RenderComponentOptions {
+  on?: Record<string, (detail: unknown, event: Record<string, any>) => void>;
+  properties?: Record<string, unknown>;
+  slots?: Record<string, string>;
+}
+interface MiniProgramRenderResult {
+  close: () => Promise<void>;
+  diagnostics: () => RuntimeDiagnosticEntry[];
+  emitted: (eventName: string) => unknown[];
+  page: HeadlessTestingPageHandle;
+  screen: MiniProgramScreen;
+  user: MiniProgramUser;
+}
+interface MiniProgramEmissionSource {
+  emitted: (eventName: string) => unknown[];
+}
+interface MiniProgramMatcherResult {
+  message: () => string;
+  pass: boolean;
+}
+type MiniProgramNodeLike = MiniProgramNode;
+//#endregion
+//#region src/host.d.ts
+declare function createWxMock(definition?: WxHostMock): WxHostMock;
+declare function applyWxMock(session: HeadlessSession, definition?: WxHostMock): void;
+//#endregion
+//#region src/matchers.d.ts
+declare function toBeInTheMiniProgram(node: MiniProgramNode): MiniProgramMatcherResult;
+declare function toHaveTextContent(node: MiniProgramNode, expected: string | RegExp): MiniProgramMatcherResult;
+declare function toHaveEmitted(source: MiniProgramEmissionSource, eventName: string, expected?: unknown): MiniProgramMatcherResult;
+declare function toHaveAttribute(node: MiniProgramNode, name: string, expected?: string): MiniProgramMatcherResult;
+declare function toHaveDataset(node: MiniProgramNode, expected: Record<string, unknown>): MiniProgramMatcherResult;
+declare const mpcoreMatchers: {
+  toBeInTheMiniProgram: typeof toBeInTheMiniProgram;
+  toHaveAttribute: typeof toHaveAttribute;
+  toHaveDataset: typeof toHaveDataset;
+  toHaveEmitted: typeof toHaveEmitted;
+  toHaveTextContent: typeof toHaveTextContent;
+};
+//#endregion
+//#region src/project.d.ts
+declare class MiniProgramTestProject {
+  private readonly options;
+  private readonly baseProject;
+  private readonly renders;
+  constructor(options: CreateTestProjectOptions);
+  private render;
+  renderPage(route: string): Promise<MiniProgramRenderResult>;
+  renderComponent(componentPath: string, options?: RenderComponentOptions): Promise<MiniProgramRenderResult>;
+  close(): Promise<void>;
+}
+declare function artifactFromProject(projectPath: string): {
+  projectPath: string;
+};
+declare function createTestProject(options: CreateTestProjectOptions): MiniProgramTestProject;
+//#endregion
+export { CreateTestProjectOptions, MiniProgramArtifact, MiniProgramEmissionSource, MiniProgramMatcherResult, MiniProgramNode, MiniProgramNodeLike, MiniProgramRenderResult, MiniProgramScreen, MiniProgramTestProject, MiniProgramUser, RenderComponentOptions, type RoleQueryOptions, type TextMatcher, WxHostMock, applyWxMock, artifactFromProject, createTestProject, createWxMock, mpcoreMatchers, toBeInTheMiniProgram, toHaveAttribute, toHaveDataset, toHaveEmitted, toHaveTextContent, wechat };

package/dist/index.mjs

@@ -0,0 +1,478 @@
+import path from "node:path";
+import { HeadlessTestingPageHandle, createArtifactProject, createHeadlessSession, createMemoryArtifactSource, createOverlayArtifactSource, createProjectDescriptor, loadProject, wechat, wechat as wechat$1 } from "@mpcore/simulator";
+//#region src/host.ts
+function asList(value) {
+	if (!value) return [];
+	return Array.isArray(value) ? value : [value];
+}
+function createWxMock(definition = {}) {
+	return definition;
+}
+function applyWxMock(session, definition = {}) {
+	asList(definition.actionSheet).forEach((item) => session.mockActionSheet(item));
+	asList(definition.downloadFile).forEach((item) => session.mockDownloadFile(item));
+	asList(definition.modal).forEach((item) => session.mockModal(item));
+	asList(definition.request).forEach((item) => session.mockRequest(item));
+	asList(definition.uploadFile).forEach((item) => session.mockUploadFile(item));
+}
+//#endregion
+//#region src/matchers.ts
+function toBeInTheMiniProgram(node) {
+	const pass = node?.isConnected === true;
+	return {
+		message: () => pass ? "Expected node not to be present in the mini-program tree." : "Expected node to be present in the mini-program tree.",
+		pass
+	};
+}
+function toHaveTextContent(node, expected) {
+	const actual = node.textContent;
+	if (expected instanceof RegExp) expected.lastIndex = 0;
+	return {
+		message: () => `Expected mini-program node text ${JSON.stringify(actual)} to match ${String(expected)}.`,
+		pass: typeof expected === "string" ? actual.includes(expected) : expected.test(actual)
+	};
+}
+function toHaveEmitted(source, eventName, expected) {
+	const emissions = source.emitted(eventName);
+	return {
+		message: () => `Expected mini-program event ${eventName} to be emitted${expected === void 0 ? "" : ` with ${JSON.stringify(expected)}`}, received ${JSON.stringify(emissions)}.`,
+		pass: expected === void 0 ? emissions.length > 0 : emissions.some((value) => JSON.stringify(value) === JSON.stringify(expected))
+	};
+}
+function toHaveAttribute(node, name, expected) {
+	const actual = node.getAttribute(name);
+	return {
+		message: () => `Expected mini-program node attribute ${name} to be ${JSON.stringify(expected)}, received ${JSON.stringify(actual)}.`,
+		pass: expected === void 0 ? actual !== void 0 : actual === expected
+	};
+}
+function toHaveDataset(node, expected) {
+	const actual = node.dataset;
+	return {
+		message: () => `Expected mini-program node dataset ${JSON.stringify(actual)} to equal ${JSON.stringify(expected)}.`,
+		pass: JSON.stringify(actual) === JSON.stringify(expected)
+	};
+}
+const mpcoreMatchers = {
+	toBeInTheMiniProgram,
+	toHaveAttribute,
+	toHaveDataset,
+	toHaveEmitted,
+	toHaveTextContent
+};
+//#endregion
+//#region src/screen/helpers.ts
+function matchesText(value, matcher) {
+	if (typeof matcher === "string") return value === matcher;
+	matcher.lastIndex = 0;
+	return matcher.test(value);
+}
+function implicitRole(node) {
+	const explicit = node.attrs.role ?? node.attrs["aria-role"];
+	if (explicit) return explicit;
+	if (node.tag === "button") return "button";
+	if (node.tag === "textarea") return "textbox";
+	if (node.tag === "input") {
+		const type = node.attrs.type ?? "text";
+		if (type === "checkbox") return "checkbox";
+		if (type === "radio") return "radio";
+		return "textbox";
+	}
+	if (node.tag === "image") return "img";
+}
+function accessibleName(node) {
+	return node.attrs["aria-label"] ?? node.attrs.placeholder ?? node.attrs.alt ?? node.text.trim();
+}
+function collectElements(root, result = []) {
+	if (root.type === "element") result.push(root);
+	root.children.forEach((child) => collectElements(child, result));
+	return result;
+}
+function findNodeById(root, nodeId) {
+	if (root.nodeId === nodeId) return root;
+	for (const child of root.children) {
+		const match = findNodeById(child, nodeId);
+		if (match) return match;
+	}
+}
+//#endregion
+//#region src/screen/index.ts
+var MiniProgramNode = class {
+	owner;
+	nodeId;
+	constructor(owner, nodeId) {
+		this.owner = owner;
+		this.nodeId = nodeId;
+	}
+	get current() {
+		return this.owner.resolveNode(this.nodeId);
+	}
+	get attributes() {
+		return { ...this.current.attrs };
+	}
+	get dataset() {
+		return Object.fromEntries(Object.entries(this.current.attrs).filter(([key]) => key.startsWith("data-")).map(([key, value]) => [key.slice(5).replace(/-([a-z])/g, (_match, char) => char.toUpperCase()), value]));
+	}
+	get isConnected() {
+		return this.owner.hasNode(this.nodeId);
+	}
+	get role() {
+		return implicitRole(this.current);
+	}
+	get tagName() {
+		return this.current.tag;
+	}
+	get textContent() {
+		return this.current.text;
+	}
+	getAttribute(name) {
+		return this.current.attrs[name];
+	}
+};
+var MiniProgramScreen = class MiniProgramScreen {
+	page;
+	currentSnapshot;
+	rootNodeId;
+	constructor(page, snapshot, rootNodeId) {
+		this.page = page;
+		this.currentSnapshot = snapshot;
+		this.rootNodeId = rootNodeId;
+	}
+	get root() {
+		this.page.assertActive();
+		if (!this.rootNodeId) return this.currentSnapshot.root;
+		const root = findNodeById(this.currentSnapshot.root, this.rootNodeId);
+		if (!root) throw new Error("The within() root is no longer present in the mini-program tree.");
+		return root;
+	}
+	allElements() {
+		return collectElements(this.root).filter((node) => Boolean(node.nodeId));
+	}
+	wrap(nodes) {
+		return nodes.map((node) => new MiniProgramNode(this, node.nodeId));
+	}
+	requireOne(nodes, label) {
+		if (nodes.length === 0) throw new Error(`Unable to find ${label} in the mini-program tree.\n\n${this.currentSnapshot.wxml}`);
+		if (nodes.length > 1) throw new Error(`Found multiple ${label} nodes in the mini-program tree.`);
+		return nodes[0];
+	}
+	async findOne(query, label, timeout = 1e3) {
+		const deadline = Date.now() + timeout;
+		while (true) {
+			const node = query();
+			if (node) return node;
+			if (Date.now() >= deadline) throw new Error(`Timed out waiting for ${label} in the mini-program tree.`);
+			await new Promise((resolve) => setTimeout(resolve, 10));
+			await this.refresh();
+		}
+	}
+	async findAll(query, label, timeout = 1e3) {
+		const deadline = Date.now() + timeout;
+		while (true) {
+			const nodes = query();
+			if (nodes.length > 0) return nodes;
+			if (Date.now() >= deadline) throw new Error(`Timed out waiting for ${label} in the mini-program tree.`);
+			await new Promise((resolve) => setTimeout(resolve, 10));
+			await this.refresh();
+		}
+	}
+	hasNode(nodeId) {
+		return Boolean(findNodeById(this.currentSnapshot.root, nodeId));
+	}
+	resolveNode(nodeId) {
+		const node = findNodeById(this.currentSnapshot.root, nodeId);
+		if (!node) throw new Error("The mini-program node is no longer present in the rendered tree.");
+		return node;
+	}
+	async refresh() {
+		this.currentSnapshot = await this.page.snapshot();
+	}
+	within(node) {
+		return new MiniProgramScreen(this.page, this.currentSnapshot, node.nodeId);
+	}
+	queryAllByText(matcher) {
+		const matches = this.allElements().filter((node) => {
+			if (!matchesText(node.text.trim(), matcher)) return false;
+			return !node.children.some((child) => child.type === "element" && matchesText(child.text.trim(), matcher));
+		});
+		return this.wrap(matches);
+	}
+	queryByText(matcher) {
+		const matches = this.queryAllByText(matcher);
+		if (matches.length > 1) throw new Error(`Found multiple text ${String(matcher)} nodes in the mini-program tree.`);
+		return matches[0] ?? null;
+	}
+	getAllByText(matcher) {
+		const matches = this.queryAllByText(matcher);
+		if (matches.length === 0) throw new Error(`Unable to find text ${String(matcher)} in the mini-program tree.`);
+		return matches;
+	}
+	getByText(matcher) {
+		return this.requireOne(this.queryAllByText(matcher), `text ${String(matcher)}`);
+	}
+	findByText(matcher, timeout) {
+		return this.findOne(() => this.queryByText(matcher), `text ${String(matcher)}`, timeout);
+	}
+	findAllByText(matcher, timeout) {
+		return this.findAll(() => this.queryAllByText(matcher), `text ${String(matcher)}`, timeout);
+	}
+	queryAllByRole(role, options = {}) {
+		return this.wrap(this.allElements().filter((node) => {
+			if (implicitRole(node) !== role) return false;
+			return options.name == null || matchesText(accessibleName(node), options.name);
+		}));
+	}
+	queryByRole(role, options = {}) {
+		const matches = this.queryAllByRole(role, options);
+		if (matches.length > 1) throw new Error(`Found multiple role ${role} nodes in the mini-program tree.`);
+		return matches[0] ?? null;
+	}
+	getAllByRole(role, options = {}) {
+		const matches = this.queryAllByRole(role, options);
+		if (matches.length === 0) throw new Error(`Unable to find role ${role} in the mini-program tree.`);
+		return matches;
+	}
+	getByRole(role, options = {}) {
+		return this.requireOne(this.queryAllByRole(role, options), `role ${role}`);
+	}
+	findByRole(role, options = {}, timeout) {
+		return this.findOne(() => this.queryByRole(role, options), `role ${role}`, timeout);
+	}
+	findAllByRole(role, options = {}, timeout) {
+		return this.findAll(() => this.queryAllByRole(role, options), `role ${role}`, timeout);
+	}
+	queryAllByTestId(testId) {
+		return this.queryAllByAttribute("data-testid", testId);
+	}
+	queryByTestId(testId) {
+		return this.queryByAttribute("data-testid", testId);
+	}
+	getAllByTestId(testId) {
+		return this.getAllByAttribute("data-testid", testId);
+	}
+	getByTestId(testId) {
+		return this.getByAttribute("data-testid", testId);
+	}
+	findByTestId(testId, timeout) {
+		return this.findOne(() => this.queryByTestId(testId), `test id ${testId}`, timeout);
+	}
+	findAllByTestId(testId, timeout) {
+		return this.findAll(() => this.queryAllByTestId(testId), `test id ${testId}`, timeout);
+	}
+	queryAllByAttribute(name, value) {
+		return this.wrap(this.allElements().filter((node) => {
+			const attribute = node.attrs[name];
+			return attribute != null && (value == null || matchesText(attribute, value));
+		}));
+	}
+	queryByAttribute(name, value) {
+		const matches = this.queryAllByAttribute(name, value);
+		if (matches.length > 1) throw new Error(`Found multiple attribute ${name} nodes in the mini-program tree.`);
+		return matches[0] ?? null;
+	}
+	getAllByAttribute(name, value) {
+		const matches = this.queryAllByAttribute(name, value);
+		if (matches.length === 0) throw new Error(`Unable to find attribute ${name} in the mini-program tree.`);
+		return matches;
+	}
+	getByAttribute(name, value) {
+		return this.requireOne(this.queryAllByAttribute(name, value), `attribute ${name}`);
+	}
+	findByAttribute(name, value, timeout) {
+		return this.findOne(() => this.queryByAttribute(name, value), `attribute ${name}`, timeout);
+	}
+	findAllByAttribute(name, value, timeout) {
+		return this.findAll(() => this.queryAllByAttribute(name, value), `attribute ${name}`, timeout);
+	}
+	async $(selector) {
+		return await this.page.$(selector);
+	}
+	async $$(selector) {
+		return await this.page.$$(selector);
+	}
+};
+//#endregion
+//#region src/user.ts
+var MiniProgramUser = class {
+	page;
+	screen;
+	settle;
+	constructor(page, screen, settle) {
+		this.page = page;
+		this.screen = screen;
+		this.settle = settle;
+	}
+	async nodeHandle(node) {
+		const handle = await this.page.$(`[data-sim-node="${node.nodeId}"]`);
+		if (!handle) throw new Error("The mini-program node is no longer available for interaction.");
+		return handle;
+	}
+	async finish() {
+		await this.settle();
+		await this.screen.refresh();
+	}
+	async tap(node, event = {}) {
+		await (await this.nodeHandle(node)).tap(event);
+		await this.finish();
+	}
+	async input(node, value, event = {}) {
+		await (await this.nodeHandle(node)).input(value, event);
+		await this.finish();
+	}
+	async change(node, value, event = {}) {
+		await (await this.nodeHandle(node)).change(value, event);
+		await this.finish();
+	}
+	async blur(node, value, event = {}) {
+		await (await this.nodeHandle(node)).blur(value, event);
+		await this.finish();
+	}
+	async trigger(node, eventName, event = {}) {
+		await (await this.nodeHandle(node)).trigger(eventName, event);
+		await this.finish();
+	}
+};
+//#endregion
+//#region src/project.ts
+const COMPONENT_HOST_ROUTE = "__mpcore__/component-host/index";
+function normalizeComponentPath(componentPath) {
+	return componentPath.trim().replace(/^\/+/, "").replace(/\.(?:js|json|wxml)$/, "");
+}
+function serializeProperties(properties) {
+	try {
+		return JSON.stringify(properties).replaceAll("<", "\\u003c");
+	} catch (error) {
+		throw new TypeError("Component properties must be serializable.", { cause: error });
+	}
+}
+function createSlotMarkup(slots) {
+	return Object.entries(slots).map(([name, content]) => {
+		return name === "default" ? content : `<block slot="${name}">${content}</block>`;
+	}).join("");
+}
+function createComponentHostProject(project, componentPath, options) {
+	const root = project.miniprogramRootPath;
+	const eventEntries = Object.keys(options.on ?? {}).map((eventName, index) => ({
+		eventName,
+		methodName: `__mpcoreEvent${index}`
+	}));
+	const eventMethods = eventEntries.map(({ eventName, methodName }) => {
+		return `${methodName}(event) { globalThis.__mpcoreRecordEvent(${JSON.stringify(eventName)}, event?.detail, event) }`;
+	}).join(",\n");
+	const propertyBindings = Object.keys(options.properties ?? {}).map((key) => `${key}="{{__mpcoreProperties.${key}}}"`).join(" ");
+	const eventBindings = eventEntries.map(({ eventName, methodName }) => `bind:${eventName}="${methodName}"`).join(" ");
+	const hostRoot = path.resolve(root, COMPONENT_HOST_ROUTE);
+	const overlay = createMemoryArtifactSource([
+		[path.resolve(root, "app.json"), JSON.stringify({ pages: [COMPONENT_HOST_ROUTE] })],
+		[path.resolve(root, "app.js"), "App({})\n"],
+		[`${hostRoot}.json`, JSON.stringify({ usingComponents: { "mpcore-subject": `/${normalizeComponentPath(componentPath)}` } })],
+		[`${hostRoot}.js`, `Page({
+  data: { __mpcoreProperties: ${serializeProperties(options.properties ?? {})} },
+  ${eventMethods}
+})\n`],
+		[`${hostRoot}.wxml`, `<mpcore-subject id="mpcore-subject" ${propertyBindings} ${eventBindings}>${createSlotMarkup(options.slots ?? {})}</mpcore-subject>`]
+	]);
+	return createProjectDescriptor({
+		appConfig: { pages: [COMPONENT_HOST_ROUTE] },
+		appConfigPath: path.resolve(root, "app.json"),
+		artifactSource: createOverlayArtifactSource(overlay, project.artifactSource),
+		miniprogramRoot: project.miniprogramRoot,
+		miniprogramRootPath: root,
+		projectConfigFiles: project.projectConfigFiles,
+		projectPath: project.projectPath
+	});
+}
+function formatDiagnostic(entry) {
+	return entry.args.map((arg) => {
+		if (arg && typeof arg === "object" && "message" in arg && typeof arg.message === "string") return "stack" in arg && typeof arg.stack === "string" ? arg.stack : arg.message;
+		return typeof arg === "string" ? arg : JSON.stringify(arg);
+	}).join(" ");
+}
+var MiniProgramTestProject = class {
+	options;
+	baseProject;
+	renders = /* @__PURE__ */ new Set();
+	constructor(options) {
+		this.options = options;
+		if (options.platform && options.platform.name !== "wechat") throw new Error(`Unsupported mini-program test platform: ${options.platform.name}`);
+		this.baseProject = options.artifact.miniprogramRootPath ? createArtifactProject({
+			appConfigPath: options.artifact.appConfigPath,
+			miniprogramRootPath: options.artifact.miniprogramRootPath,
+			projectPath: options.artifact.projectPath
+		}) : loadProject(options.artifact.projectPath);
+	}
+	async render(project, route, on = {}) {
+		const eventLog = /* @__PURE__ */ new Map();
+		const session = createHeadlessSession({
+			globals: { __mpcoreRecordEvent(eventName, detail, event) {
+				const entries = eventLog.get(eventName) ?? [];
+				entries.push(detail);
+				eventLog.set(eventName, entries);
+				on?.[eventName]?.(detail, event);
+			} },
+			project,
+			strictHostMocks: true
+		});
+		applyWxMock(session, this.options.host);
+		const page = new HeadlessTestingPageHandle(project, session.reLaunch(route), session);
+		const screen = new MiniProgramScreen(page, await page.snapshot());
+		const assertDiagnostics = () => {
+			const errors = session.getDiagnostics().filter((entry) => {
+				return entry.level === "exception" || entry.level === "error" && this.options.failOnConsoleError !== false;
+			});
+			if (errors.length > 0) throw new Error(`Mini-program runtime reported errors:\n${errors.map(formatDiagnostic).join("\n")}`);
+		};
+		const settle = async () => {
+			await Promise.resolve();
+			await Promise.resolve();
+			assertDiagnostics();
+		};
+		const user = new MiniProgramUser(page, screen, settle);
+		let closed = false;
+		const result = {
+			close: async () => {
+				if (closed) return;
+				closed = true;
+				session.close();
+				this.renders.delete(result);
+				assertDiagnostics();
+			},
+			diagnostics: () => session.getDiagnostics(),
+			emitted: (eventName) => [...eventLog.get(eventName) ?? []],
+			page,
+			screen,
+			user
+		};
+		this.renders.add(result);
+		await settle();
+		return result;
+	}
+	async renderPage(route) {
+		return await this.render(this.baseProject, route);
+	}
+	async renderComponent(componentPath, options = {}) {
+		const project = createComponentHostProject(this.baseProject, componentPath, options);
+		return await this.render(project, `/${COMPONENT_HOST_ROUTE}`, options.on);
+	}
+	async close() {
+		let firstError;
+		for (const render of this.renders) try {
+			await render.close();
+		} catch (error) {
+			firstError ??= error;
+		}
+		this.renders.clear();
+		if (firstError) throw firstError;
+	}
+};
+function artifactFromProject(projectPath) {
+	return { projectPath };
+}
+function createTestProject(options) {
+	return new MiniProgramTestProject({
+		...options,
+		platform: options.platform ?? wechat$1()
+	});
+}
+//#endregion
+export { MiniProgramNode, MiniProgramScreen, MiniProgramTestProject, MiniProgramUser, applyWxMock, artifactFromProject, createTestProject, createWxMock, mpcoreMatchers, toBeInTheMiniProgram, toHaveAttribute, toHaveDataset, toHaveEmitted, toHaveTextContent, wechat };

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@mpcore/test",
+  "type": "module",
+  "version": "0.0.0",
+  "description": "Testing Library-style utilities for compiled WeChat mini-program artifacts",
+  "author": "ice breaker <1324318532@qq.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/weapp-vite/weapp-vite.git",
+    "directory": "mpcore/packages/test"
+  },
+  "bugs": {
+    "url": "https://github.com/weapp-vite/weapp-vite/issues"
+  },
+  "keywords": [
+    "mpcore",
+    "weapp",
+    "mini-program",
+    "testing",
+    "vitest"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "README.md",
+    "dist"
+  ],
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "dependencies": {
+    "@mpcore/simulator": "0.2.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "scripts": {
+    "dev": "tsdown -w",
+    "build": "tsdown",
+    "test": "vitest run",
+    "test:dev": "vitest",
+    "test:types": "pnpm build && tsd",
+    "typecheck": "tsc --noEmit"
+  }
+}