⚡️ 单元测试优化（错误修正，注入修正，concurrent，加速） (#904)

* 单元测试优化（错误修正，注入修正，concurrent，加速）

* 统一 `vitest.test` -> `vitest.it`

* #903

* 代码修正

Author: cyfung1031

package.json

@@ -7,7 +7,7 @@
   "private": true,
   "scripts": {
     "preinstall": "pnpm dlx only-allow pnpm",
-    "test": "vitest",
+    "test": "vitest --test-timeout=500 --no-coverage --isolate=false --reporter=verbose",
     "coverage": "vitest run --coverage",
     "build": "cross-env NODE_ENV=production rspack build",
     "dev": "cross-env NODE_ENV=development rspack",

packages/chrome-extension-mock/index.ts

@@ -26,7 +26,5 @@ const chromeMock = {
   userScripts: new MockUserScripts(),
   init() {},
 };
-// @ts-ignore
-global.chrome = chromeMock;
 
 export default chromeMock;

packages/chrome-extension-mock/runtime.ts

@@ -4,6 +4,7 @@ type Port = chrome.runtime.Port & {
 };
 
 export default class Runtime {
+  id = "kfjdomqetnlhbgxasrwzypcviueotmlr";
   connectListener: Array<(port: chrome.runtime.Port) => void> = [];
 
   messageListener: Array<(message: any) => void> = [];
@@ -64,8 +65,8 @@ export default class Runtime {
     return port;
   }
 
-  getURL(path: string) {
-    return `${window.location.href}${path}`;
+  getURL(_path: string) {
+    // implemented with vitest
   }
 
   sendMessage(message: any, callback?: (response: any) => void) {

packages/message/message_queue.test.ts

@@ -1,17 +1,6 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import { MessageQueue, MessageQueueGroup, type IMessageQueue } from "./message_queue";
 
-// Mock chrome.runtime
-global.chrome = {
-  runtime: {
-    onMessage: {
-      addListener: vi.fn(),
-    },
-    sendMessage: vi.fn(),
-    lastError: null,
-  },
-} as any;
-
 // Mock LoggerCore
 vi.mock("@App/app/logger/core", () => ({
   default: {
@@ -23,6 +12,8 @@ vi.mock("@App/app/logger/core", () => ({
   },
 }));
 
+const nextTick = () => Promise.resolve().then(() => {});
+
 describe("MessageQueueGroup", () => {
   let messageQueue: IMessageQueue;
 
@@ -36,55 +27,62 @@ describe("MessageQueueGroup", () => {
   });
 
   describe("基本功能测试", () => {
-    it("应该能够创建分组", () => {
-      const group = messageQueue.group("test");
+    it.concurrent("应该能够创建分组", () => {
+      const group = messageQueue.group("api-group");
       expect(group).toBeInstanceOf(MessageQueueGroup);
     });
 
-    it("应该能够在分组中订阅和发布消息", () => {
-      const group = messageQueue.group("api");
+    it.concurrent("应该能够在分组中订阅和发布消息", () => {
+      const group = messageQueue.group("api-sendBasic");
       const handler = vi.fn();
 
-      group.subscribe("user", handler);
-      group.emit("user", { id: 1, name: "test" });
+      group.subscribe("user1", handler);
+      group.emit("user1", { id: 1, name: "test" });
 
       expect(handler).toHaveBeenCalledWith({ id: 1, name: "test" });
     });
 
-    it("应该自动为分组名称添加斜杠", () => {
+    it.concurrent("应该自动为分组名称添加斜杠", () => {
       const group1 = messageQueue.group("group1");
       const group2 = messageQueue.group("group2/");
 
       const handler1 = vi.fn();
       const handler2 = vi.fn();
+      const handler3 = vi.fn();
+      const handler4 = vi.fn();
 
-      group1.subscribe("test", handler1);
-      group2.subscribe("test", handler2);
+      group1.subscribe("test1", handler1);
+      group2.subscribe("test1", handler2);
+      group1.subscribe("test2", handler3);
+      group2.subscribe("test2", handler4);
 
       // 直接通过 messageQueue 发布消息来验证主题名称
-      messageQueue.emit("group1/test", "message1");
-      messageQueue.emit("group2/test", "message2");
+      messageQueue.emit("group1/test1", "message1");
+      messageQueue.emit("group2/test1", "message2");
 
       expect(handler1).toHaveBeenCalledWith("message1");
       expect(handler2).toHaveBeenCalledWith("message2");
+
+      expect(handler3).not.toHaveBeenCalled();
+      expect(handler4).not.toHaveBeenCalled();
     });
 
-    it("应该能够创建嵌套分组", () => {
-      const apiGroup = messageQueue.group("api");
-      const userGroup = apiGroup.group("user");
+    it.concurrent("应该能够创建嵌套分组", () => {
+      const apiGroup = messageQueue.group("api-groupNested");
+      const userGroup = apiGroup.group("user2");
       const profileGroup = userGroup.group("profile");
 
       const handler = vi.fn();
-      profileGroup.subscribe("get", handler);
+      profileGroup.subscribe("get1", handler);
 
-      profileGroup.emit("get", { userId: 123 });
+      profileGroup.emit("get1", { userId: 123 });
 
       expect(handler).toHaveBeenCalledWith({ userId: 123 });
     });
   });
 
   describe("中间件功能测试", () => {
-    it("应该能够添加和执行中间件", async () => {
+    it.concurrent("应该能够添加和执行中间件", async () => {
       const middlewareOrder: string[] = [];
 
       const middleware = vi.fn((topic: string, message: any, next: () => void) => {
@@ -93,26 +91,26 @@ describe("MessageQueueGroup", () => {
         middlewareOrder.push("middleware-after");
       });
 
-      const group = messageQueue.group("api", middleware);
+      const group = messageQueue.group("api-middleware", middleware);
 
       const handler = vi.fn(() => {
-        middlewareOrder.push("handler");
+        middlewareOrder.push("handler-middle");
       });
 
-      group.subscribe("test", handler);
+      group.subscribe("good", handler);
 
       // 等待异步操作
-      group.emit("test", { data: "test" });
+      group.emit("good", { data: "bye" });
 
-      // 使用 setTimeout 确保异步操作完成
-      await new Promise((resolve) => setTimeout(resolve, 0));
+      await nextTick();
+      await nextTick();
 
-      expect(middlewareOrder).toEqual(["middleware-before", "handler", "middleware-after"]);
-      expect(middleware).toHaveBeenCalledWith("api/test", { data: "test" }, expect.any(Function));
-      expect(handler).toHaveBeenCalledWith({ data: "test" });
+      expect(middlewareOrder).toEqual(["middleware-before", "handler-middle", "middleware-after"]);
+      expect(middleware).toHaveBeenCalledWith("api-middleware/good", { data: "bye" }, expect.any(Function));
+      expect(handler).toHaveBeenCalledWith({ data: "bye" });
     });
 
-    it("应该能够使用 use 方法添加中间件", async () => {
+    it.concurrent("应该能够使用 use 方法添加中间件", async () => {
       const middlewareOrder: string[] = [];
 
       const middleware1 = vi.fn((topic: string, message: any, next: () => void) => {
@@ -127,27 +125,28 @@ describe("MessageQueueGroup", () => {
         middlewareOrder.push("middleware2-after");
       });
 
-      const group = messageQueue.group("api").use(middleware1).use(middleware2);
+      const group = messageQueue.group("group-08").use(middleware1).use(middleware2);
 
       const handler = vi.fn(() => {
-        middlewareOrder.push("handler");
+        middlewareOrder.push("handler-08");
       });
 
-      group.subscribe("test", handler);
-      group.emit("test", { data: "test" });
+      group.subscribe("test-08", handler);
+      group.emit("test-08", { data: "test-08" });
 
-      await new Promise((resolve) => setTimeout(resolve, 0));
+      await nextTick();
+      await nextTick();
 
       expect(middlewareOrder).toEqual([
         "middleware1-before",
         "middleware2-before",
-        "handler",
+        "handler-08",
         "middleware2-after",
         "middleware1-after",
       ]);
     });
 
-    it("子分组应该继承父分组的中间件", async () => {
+    it.concurrent("子分组应该继承父分组的中间件", async () => {
       const middlewareOrder: string[] = [];
 
       const parentMiddleware = vi.fn((topic: string, message: any, next: () => void) => {
@@ -164,108 +163,112 @@ describe("MessageQueueGroup", () => {
       const childGroup = parentGroup.group("child", childMiddleware);
 
       const handler = vi.fn(() => {
-        middlewareOrder.push("handler");
+        middlewareOrder.push("handler-09");
       });
 
-      childGroup.subscribe("test", handler);
-      childGroup.emit("test", { data: "test" });
+      childGroup.subscribe("test-09", handler);
+      childGroup.emit("test-09", { data: "test-09" });
 
-      await new Promise((resolve) => setTimeout(resolve, 0));
+      await nextTick();
+      await nextTick();
 
-      expect(middlewareOrder).toEqual(["parent-middleware", "child-middleware", "handler"]);
+      expect(middlewareOrder).toEqual(["parent-middleware", "child-middleware", "handler-09"]);
     });
 
-    it("应该支持异步中间件", async () => {
+    it.concurrent("应该支持异步中间件", async () => {
       const asyncMiddleware = vi.fn(async (topic: string, message: any, next: () => void) => {
-        await new Promise((resolve) => setTimeout(resolve, 10));
+        await nextTick();
         next();
       });
 
-      const group = messageQueue.group("api", asyncMiddleware);
+      const group = messageQueue.group("api-middlewareAsync", asyncMiddleware);
       const handler = vi.fn();
 
-      group.subscribe("test", handler);
-      group.emit("test", { data: "test" });
+      group.subscribe("test4", handler);
+      group.emit("test4", { data: "test4" });
 
       // 等待异步操作完成
-      await new Promise((resolve) => setTimeout(resolve, 20));
+      await nextTick();
+      await nextTick();
 
       expect(asyncMiddleware).toHaveBeenCalled();
-      expect(handler).toHaveBeenCalledWith({ data: "test" });
+      expect(handler).toHaveBeenCalledWith({ data: "test4" });
     });
   });
 
   describe("发布方法测试", () => {
-    it("publish 方法应该使用 chrome.runtime.sendMessage", () => {
-      const group = messageQueue.group("api");
+    it.concurrent("publish 方法应该使用 chrome.runtime.sendMessage", () => {
+      const group = messageQueue.group("api-sendChromeMessage");
 
-      group.publish("test", { data: "test" });
+      const sendSpy = vi.spyOn(chrome.runtime, "sendMessage");
+      group.publish("test-sendChromeMessage", { data: "test-sendChromeMessage" });
 
-      expect(chrome.runtime.sendMessage).toHaveBeenCalledWith({
-        msgQueue: "api/test",
-        data: { action: "message", message: { data: "test" } },
+      expect(sendSpy).toHaveBeenCalledWith({
+        msgQueue: "api-sendChromeMessage/test-sendChromeMessage",
+        data: { action: "message", message: { data: "test-sendChromeMessage" } },
       });
     });
 
-    it("emit 方法应该只在本地发布", () => {
-      const group = messageQueue.group("api");
+    it.concurrent("emit 方法应该只在本地发布", () => {
+      const group = messageQueue.group("api-emitLocal");
       const handler = vi.fn();
 
-      group.subscribe("test", handler);
-      group.emit("test", { data: "test" });
+      const sendSpy = vi.spyOn(chrome.runtime, "sendMessage");
+      group.subscribe("test-emitLocal", handler);
+      group.emit("test-emitLocal", { data: "test-emitLocal" });
 
-      expect(handler).toHaveBeenCalledWith({ data: "test" });
-      expect(chrome.runtime.sendMessage).not.toHaveBeenCalled();
+      expect(handler).toHaveBeenCalledWith({ data: "test-emitLocal" });
+      expect(sendSpy).not.toHaveBeenCalled();
     });
   });
 
   describe("取消订阅功能", () => {
-    it("应该能够取消订阅", () => {
-      const group = messageQueue.group("api");
+    it.concurrent("应该能够取消订阅", () => {
+      const group = messageQueue.group("api-unsubscribe");
       const handler = vi.fn();
 
-      const unsubscribe = group.subscribe("test", handler);
+      const unsubscribe = group.subscribe("test-unsubscribe", handler);
 
       // 发布消息，应该收到
-      group.emit("test", { data: "test1" });
+      group.emit("test-unsubscribe", { data: "test1" });
       expect(handler).toHaveBeenCalledWith({ data: "test1" });
 
       // 取消订阅
       unsubscribe();
 
       // 再次发布消息，不应该收到
-      group.emit("test", { data: "test2" });
+      group.emit("test-unsubscribe", { data: "test2" });
       expect(handler).toHaveBeenCalledTimes(1);
     });
   });
 
   describe("边界情况测试", () => {
-    it("没有中间件的分组应该正常工作", () => {
-      const group = messageQueue.group("api");
+    it.concurrent("没有中间件的分组应该正常工作", () => {
+      const group = messageQueue.group("api-groupNoMiddleware");
       const handler = vi.fn();
 
-      group.subscribe("test", handler);
-      group.emit("test", { data: "test" });
+      group.subscribe("test-groupNoMiddleware", handler);
+      group.emit("test-groupNoMiddleware", { data: "test-groupNoMiddleware" });
 
-      expect(handler).toHaveBeenCalledWith({ data: "test" });
+      expect(handler).toHaveBeenCalledWith({ data: "test-groupNoMiddleware" });
     });
 
-    it("应该能够处理复杂的数据类型", () => {
-      const group = messageQueue.group("api");
+    it.concurrent("应该能够处理复杂的数据类型", () => {
+      const group = messageQueue.group("api-complexPayload");
       const handler = vi.fn();
 
       const complexData = {
         array: [1, 2, 3],
         object: { nested: true },
         number: 42,
-        string: "test",
+        string: "test-complexPayload",
         boolean: true,
         null: null,
         undefined: undefined,
       };
 
-      group.subscribe("test", handler);
-      group.emit("test", complexData);
+      group.subscribe("test-complexPayload", handler);
+      group.emit("test-complexPayload", complexData);
 
       expect(handler).toHaveBeenCalledWith(complexData);
     });