Playwright并行测试：如何实现聊天室测试的相互隔离？

问题描述 #

在测试类聊天应用时，你尝试通过预定义聊天室列表+内存Map分配资源，但Playwright并行测试会启动独立Worker进程，每个进程都有独立的chatroomsInUse实例，导致所有并行测试都会抢占同一个聊天室，无法实现隔离。你的现有代码如下：

const chatRooms = [1, 2, 3]
const chatroomsInUse = new Map<number, boolean>(chatRooms.map(i => ([i, false])))
async function runInUnusedChatroom(test: (chatroom: number) => void) {
    for (let room of chatRooms) {
        const inUse = chatroomsInUse.get(room);
        if (!inUse) {
            chatroomsInUse.set(room, true)
            try {
                await test(room)
                return
            } finally {
                chatroomsInUse.set(room, false)
            }
        }
    }
    throw new Error("Unable to find available chatroom")
}

test("A simple test", async () => {
  await runInUnusedChatroom(room => {
    // This test will run in chatroom 1
  })
})

test("Another test", async () => {
  await runInUnusedChatroom(room => {
    // This test will also run in chatroom 1... but I expect it to run in chatroom 2 when I run in parallel.
  })
})

你考虑在Web服务器中实现空闲聊天室分配接口加锁机制，想了解是否有更优方案。

可行解决方案 #

1. 动态生成专属聊天室（推荐） #

放弃预定义聊天室，让每个测试创建自己的唯一聊天室，测试结束后销毁，从根源避免资源竞争：

test("专属聊天室测试", async ({ page }) => {
  // 用测试信息+时间戳生成唯一ID，确保并行测试不重复
  const uniqueRoomId = `test-room-${test.info().title.replace(/\W+/g, "-")}-${Date.now()}`;
  
  // 调用后端接口创建聊天室
  await page.request.post("/api/chatrooms", {
    data: { id: uniqueRoomId, name: "测试专属聊天室" }
  });

  try {
    // 执行测试逻辑
    await page.goto(`/chat/${uniqueRoomId}`);
    // ...发送消息、验证接收等测试步骤
  } finally {
    // 测试完成后清理资源
    await page.request.delete(`/api/chatrooms/${uniqueRoomId}`);
  }
});

这种方案完全隔离每个测试的环境，不需要额外的锁机制，是并行测试的最优实践。

2. 本地文件共享锁 #

如果必须使用预定义聊天室，可以用本地文件作为跨Worker的共享状态存储：

import { writeFile, readFile, access, constants } from "fs/promises";
import { join } from "path";

// 定义锁文件路径
const lockFilePath = join(process.cwd(), "chatroom-lock.json");

async function acquireChatroom(): Promise<number> {
  // 初始化锁文件（如果不存在）
  let lockState: Record<number, boolean>;
  try {
    await access(lockFilePath, constants.F_OK);
    const content = await readFile(lockFilePath, "utf-8");
    lockState = JSON.parse(content);
  } catch {
    lockState = { 1: false, 2: false, 3: false };
  }

  // 查找可用聊天室
  for (const [roomIdStr, inUse] of Object.entries(lockState)) {
    const roomId = parseInt(roomIdStr);
    if (!inUse) {
      lockState[roomId] = true;
      await writeFile(lockFilePath, JSON.stringify(lockState), "utf-8");
      return roomId;
    }
  }
  throw new Error("无可用聊天室");
}

async function releaseChatroom(roomId: number): Promise<void> {
  const content = await readFile(lockFilePath, "utf-8");
  const lockState = JSON.parse(content);
  lockState[roomId] = false;
  await writeFile(lockFilePath, JSON.stringify(lockState), "utf-8");
}

// 测试中使用
test("并行测试示例", async () => {
  const roomId = await acquireChatroom();
  try {
    // 测试逻辑：使用roomId进行操作
  } finally {
    await releaseChatroom(roomId);
  }
});

注意：基础文件锁可能存在竞态条件，可使用proper-lockfile等第三方库实现更可靠的文件排他锁，避免多个Worker同时修改锁文件。

3. 服务器端资源分配接口（你提到的方案） #

在后端实现一套资源分配接口，集中管理聊天室的占用状态：

• GET /api/chatrooms/available：返回一个未被占用的聊天室ID，并标记为占用
• POST /api/chatrooms/:id/release：释放指定聊天室的占用状态

测试中通过调用这两个接口获取和释放资源，适合多机器分布式测试场景，但需要额外开发后端逻辑。

方案对比 #

优先推荐动态生成聊天室的方案，这是Playwright并行测试的标准隔离方式。

内容的提问来源于stack exchange，提问作者Malcolm Crum