@esengine/server 1.1.4 → 1.2.0

package/dist/testing/index.js

@@ -0,0 +1,629 @@
+import { onMessage, createServer, Room } from '../chunk-7C6JZO4O.js';
+import { __name, __publicField } from '../chunk-T626JPC7.js';
+import WebSocket from 'ws';
+import { json } from '@esengine/rpc/codec';
+
+var PacketType = {
+  ApiRequest: 0,
+  ApiResponse: 1,
+  ApiError: 2,
+  Message: 3
+};
+var _TestClient = class _TestClient {
+  constructor(port, options = {}) {
+    __publicField(this, "_port");
+    __publicField(this, "_codec");
+    __publicField(this, "_timeout");
+    __publicField(this, "_connectTimeout");
+    __publicField(this, "_ws", null);
+    __publicField(this, "_callIdCounter", 0);
+    __publicField(this, "_connected", false);
+    __publicField(this, "_currentRoomId", null);
+    __publicField(this, "_currentPlayerId", null);
+    __publicField(this, "_pendingCalls", /* @__PURE__ */ new Map());
+    __publicField(this, "_msgHandlers", /* @__PURE__ */ new Map());
+    __publicField(this, "_receivedMessages", []);
+    this._port = port;
+    this._codec = options.codec ?? json();
+    this._timeout = options.timeout ?? 5e3;
+    this._connectTimeout = options.connectTimeout ?? 5e3;
+  }
+  // ========================================================================
+  // Properties | 属性
+  // ========================================================================
+  /**
+   * @zh 是否已连接
+   * @en Whether connected
+   */
+  get isConnected() {
+    return this._connected;
+  }
+  /**
+   * @zh 当前房间 ID
+   * @en Current room ID
+   */
+  get roomId() {
+    return this._currentRoomId;
+  }
+  /**
+   * @zh 当前玩家 ID
+   * @en Current player ID
+   */
+  get playerId() {
+    return this._currentPlayerId;
+  }
+  /**
+   * @zh 收到的所有消息
+   * @en All received messages
+   */
+  get receivedMessages() {
+    return this._receivedMessages;
+  }
+  // ========================================================================
+  // Connection | 连接管理
+  // ========================================================================
+  /**
+   * @zh 连接到服务器
+   * @en Connect to server
+   */
+  connect() {
+    return new Promise((resolve, reject) => {
+      const url = `ws://localhost:${this._port}`;
+      this._ws = new WebSocket(url);
+      const timeout = setTimeout(() => {
+        this._ws?.close();
+        reject(new Error(`Connection timeout after ${this._connectTimeout}ms`));
+      }, this._connectTimeout);
+      this._ws.on("open", () => {
+        clearTimeout(timeout);
+        this._connected = true;
+        resolve(this);
+      });
+      this._ws.on("close", () => {
+        this._connected = false;
+        this._rejectAllPending("Connection closed");
+      });
+      this._ws.on("error", (err) => {
+        clearTimeout(timeout);
+        if (!this._connected) {
+          reject(err);
+        }
+      });
+      this._ws.on("message", (data) => {
+        this._handleMessage(data);
+      });
+    });
+  }
+  /**
+   * @zh 断开连接
+   * @en Disconnect from server
+   */
+  async disconnect() {
+    return new Promise((resolve) => {
+      if (!this._ws || this._ws.readyState === WebSocket.CLOSED) {
+        resolve();
+        return;
+      }
+      this._ws.once("close", () => {
+        this._connected = false;
+        this._ws = null;
+        resolve();
+      });
+      this._ws.close();
+    });
+  }
+  // ========================================================================
+  // Room Operations | 房间操作
+  // ========================================================================
+  /**
+   * @zh 加入房间
+   * @en Join a room
+   */
+  async joinRoom(roomType, options) {
+    const result = await this.call("JoinRoom", {
+      roomType,
+      options
+    });
+    this._currentRoomId = result.roomId;
+    this._currentPlayerId = result.playerId;
+    return result;
+  }
+  /**
+   * @zh 通过 ID 加入房间
+   * @en Join a room by ID
+   */
+  async joinRoomById(roomId) {
+    const result = await this.call("JoinRoom", {
+      roomId
+    });
+    this._currentRoomId = result.roomId;
+    this._currentPlayerId = result.playerId;
+    return result;
+  }
+  /**
+   * @zh 离开房间
+   * @en Leave room
+   */
+  async leaveRoom() {
+    await this.call("LeaveRoom", {});
+    this._currentRoomId = null;
+    this._currentPlayerId = null;
+  }
+  /**
+   * @zh 发送消息到房间
+   * @en Send message to room
+   */
+  sendToRoom(type, data) {
+    this.send("RoomMessage", {
+      type,
+      data
+    });
+  }
+  // ========================================================================
+  // API Calls | API 调用
+  // ========================================================================
+  /**
+   * @zh 调用 API
+   * @en Call API
+   */
+  call(name, input) {
+    return new Promise((resolve, reject) => {
+      if (!this._connected || !this._ws) {
+        reject(new Error("Not connected"));
+        return;
+      }
+      const id = ++this._callIdCounter;
+      const timer = setTimeout(() => {
+        this._pendingCalls.delete(id);
+        reject(new Error(`API call '${name}' timeout after ${this._timeout}ms`));
+      }, this._timeout);
+      this._pendingCalls.set(id, {
+        resolve,
+        reject,
+        timer
+      });
+      const packet = [
+        PacketType.ApiRequest,
+        id,
+        name,
+        input
+      ];
+      this._ws.send(this._codec.encode(packet));
+    });
+  }
+  /**
+   * @zh 发送消息
+   * @en Send message
+   */
+  send(name, data) {
+    if (!this._connected || !this._ws) return;
+    const packet = [
+      PacketType.Message,
+      name,
+      data
+    ];
+    this._ws.send(this._codec.encode(packet));
+  }
+  // ========================================================================
+  // Message Handling | 消息处理
+  // ========================================================================
+  /**
+   * @zh 监听消息
+   * @en Listen for message
+   */
+  on(name, handler) {
+    let handlers = this._msgHandlers.get(name);
+    if (!handlers) {
+      handlers = /* @__PURE__ */ new Set();
+      this._msgHandlers.set(name, handlers);
+    }
+    handlers.add(handler);
+    return this;
+  }
+  /**
+   * @zh 取消监听消息
+   * @en Remove message listener
+   */
+  off(name, handler) {
+    if (handler) {
+      this._msgHandlers.get(name)?.delete(handler);
+    } else {
+      this._msgHandlers.delete(name);
+    }
+    return this;
+  }
+  /**
+   * @zh 等待收到指定消息
+   * @en Wait for a specific message
+   */
+  waitForMessage(type, timeout) {
+    return new Promise((resolve, reject) => {
+      const timeoutMs = timeout ?? this._timeout;
+      const timer = setTimeout(() => {
+        this.off(type, handler);
+        reject(new Error(`Timeout waiting for message '${type}' after ${timeoutMs}ms`));
+      }, timeoutMs);
+      const handler = /* @__PURE__ */ __name((data) => {
+        clearTimeout(timer);
+        this.off(type, handler);
+        resolve(data);
+      }, "handler");
+      this.on(type, handler);
+    });
+  }
+  /**
+   * @zh 等待收到指定房间消息
+   * @en Wait for a specific room message
+   */
+  waitForRoomMessage(type, timeout) {
+    return new Promise((resolve, reject) => {
+      const timeoutMs = timeout ?? this._timeout;
+      const timer = setTimeout(() => {
+        this.off("RoomMessage", handler);
+        reject(new Error(`Timeout waiting for room message '${type}' after ${timeoutMs}ms`));
+      }, timeoutMs);
+      const handler = /* @__PURE__ */ __name((data) => {
+        const msg = data;
+        if (msg.type === type) {
+          clearTimeout(timer);
+          this.off("RoomMessage", handler);
+          resolve(msg.data);
+        }
+      }, "handler");
+      this.on("RoomMessage", handler);
+    });
+  }
+  // ========================================================================
+  // Assertions | 断言辅助
+  // ========================================================================
+  /**
+   * @zh 是否收到过指定消息
+   * @en Whether received a specific message
+   */
+  hasReceivedMessage(type) {
+    return this._receivedMessages.some((m) => m.type === type);
+  }
+  /**
+   * @zh 获取指定类型的所有消息
+   * @en Get all messages of a specific type
+   */
+  getMessagesOfType(type) {
+    return this._receivedMessages.filter((m) => m.type === type).map((m) => m.data);
+  }
+  /**
+   * @zh 获取最后收到的指定类型消息
+   * @en Get the last received message of a specific type
+   */
+  getLastMessage(type) {
+    for (let i = this._receivedMessages.length - 1; i >= 0; i--) {
+      if (this._receivedMessages[i].type === type) {
+        return this._receivedMessages[i].data;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * @zh 清空消息记录
+   * @en Clear message records
+   */
+  clearMessages() {
+    this._receivedMessages.length = 0;
+  }
+  /**
+   * @zh 获取收到的消息数量
+   * @en Get received message count
+   */
+  getMessageCount(type) {
+    if (type) {
+      return this._receivedMessages.filter((m) => m.type === type).length;
+    }
+    return this._receivedMessages.length;
+  }
+  // ========================================================================
+  // Private Methods | 私有方法
+  // ========================================================================
+  _handleMessage(raw) {
+    try {
+      const packet = this._codec.decode(raw);
+      const type = packet[0];
+      switch (type) {
+        case PacketType.ApiResponse:
+          this._handleApiResponse([
+            packet[0],
+            packet[1],
+            packet[2]
+          ]);
+          break;
+        case PacketType.ApiError:
+          this._handleApiError([
+            packet[0],
+            packet[1],
+            packet[2],
+            packet[3]
+          ]);
+          break;
+        case PacketType.Message:
+          this._handleMsg([
+            packet[0],
+            packet[1],
+            packet[2]
+          ]);
+          break;
+      }
+    } catch (err) {
+      console.error("[TestClient] Failed to handle message:", err);
+    }
+  }
+  _handleApiResponse([, id, result]) {
+    const pending = this._pendingCalls.get(id);
+    if (pending) {
+      clearTimeout(pending.timer);
+      this._pendingCalls.delete(id);
+      pending.resolve(result);
+    }
+  }
+  _handleApiError([, id, code, message]) {
+    const pending = this._pendingCalls.get(id);
+    if (pending) {
+      clearTimeout(pending.timer);
+      this._pendingCalls.delete(id);
+      pending.reject(new Error(`[${code}] ${message}`));
+    }
+  }
+  _handleMsg([, name, data]) {
+    this._receivedMessages.push({
+      type: name,
+      data,
+      timestamp: Date.now()
+    });
+    const handlers = this._msgHandlers.get(name);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          handler(data);
+        } catch (err) {
+          console.error("[TestClient] Handler error:", err);
+        }
+      }
+    }
+  }
+  _rejectAllPending(reason) {
+    for (const [, pending] of this._pendingCalls) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error(reason));
+    }
+    this._pendingCalls.clear();
+  }
+};
+__name(_TestClient, "TestClient");
+var TestClient = _TestClient;
+
+// src/testing/TestServer.ts
+async function getRandomPort() {
+  const net = await import('net');
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.listen(0, () => {
+      const address = server.address();
+      if (address && typeof address === "object") {
+        const port = address.port;
+        server.close(() => resolve(port));
+      } else {
+        server.close(() => reject(new Error("Failed to get port")));
+      }
+    });
+    server.on("error", reject);
+  });
+}
+__name(getRandomPort, "getRandomPort");
+async function createTestServer(options = {}) {
+  const port = options.port || await getRandomPort();
+  const silent = options.silent ?? true;
+  const originalLog = console.log;
+  if (silent) {
+    console.log = () => {
+    };
+  }
+  const server = await createServer({
+    port,
+    tickRate: options.tickRate ?? 0,
+    apiDir: "__non_existent_api__",
+    msgDir: "__non_existent_msg__"
+  });
+  await server.start();
+  if (silent) {
+    console.log = originalLog;
+  }
+  return {
+    server,
+    port,
+    cleanup: /* @__PURE__ */ __name(async () => {
+      await server.stop();
+    }, "cleanup")
+  };
+}
+__name(createTestServer, "createTestServer");
+async function createTestEnv(options = {}) {
+  const { server, port, cleanup: serverCleanup } = await createTestServer(options);
+  const clients = [];
+  return {
+    server,
+    port,
+    clients,
+    async createClient(clientOptions) {
+      const client = new TestClient(port, clientOptions);
+      await client.connect();
+      clients.push(client);
+      return client;
+    },
+    async createClients(count, clientOptions) {
+      const newClients = [];
+      for (let i = 0; i < count; i++) {
+        const client = new TestClient(port, clientOptions);
+        await client.connect();
+        clients.push(client);
+        newClients.push(client);
+      }
+      return newClients;
+    },
+    async cleanup() {
+      await Promise.all(clients.map((c) => c.disconnect().catch(() => {
+      })));
+      clients.length = 0;
+      await serverCleanup();
+    }
+  };
+}
+__name(createTestEnv, "createTestEnv");
+
+// src/testing/MockRoom.ts
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var _MockRoom = class _MockRoom extends Room {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "state", {
+      messages: [],
+      joinCount: 0,
+      leaveCount: 0
+    });
+  }
+  onCreate() {
+  }
+  onJoin(player) {
+    this.state.joinCount++;
+    this.broadcast("PlayerJoined", {
+      playerId: player.id,
+      joinCount: this.state.joinCount
+    });
+  }
+  onLeave(player) {
+    this.state.leaveCount++;
+    this.broadcast("PlayerLeft", {
+      playerId: player.id,
+      leaveCount: this.state.leaveCount
+    });
+  }
+  handleAnyMessage(data, player, type) {
+    this.state.messages.push({
+      type,
+      data,
+      playerId: player.id
+    });
+    this.broadcast("MessageReceived", {
+      type,
+      data,
+      from: player.id
+    });
+  }
+  handleEcho(data, player) {
+    player.send("EchoReply", data);
+  }
+  handleBroadcast(data, _player) {
+    this.broadcast("BroadcastMessage", data);
+  }
+  handlePing(_data, player) {
+    player.send("Pong", {
+      timestamp: Date.now()
+    });
+  }
+};
+__name(_MockRoom, "MockRoom");
+var MockRoom = _MockRoom;
+_ts_decorate([
+  onMessage("*"),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    Object,
+    typeof Player === "undefined" ? Object : Player,
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], MockRoom.prototype, "handleAnyMessage", null);
+_ts_decorate([
+  onMessage("Echo"),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    Object,
+    typeof Player === "undefined" ? Object : Player
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], MockRoom.prototype, "handleEcho", null);
+_ts_decorate([
+  onMessage("Broadcast"),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    Object,
+    typeof Player === "undefined" ? Object : Player
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], MockRoom.prototype, "handleBroadcast", null);
+_ts_decorate([
+  onMessage("Ping"),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    Object,
+    typeof Player === "undefined" ? Object : Player
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], MockRoom.prototype, "handlePing", null);
+var _EchoRoom = class _EchoRoom extends Room {
+  handleAnyMessage(data, player, type) {
+    player.send(type, data);
+  }
+};
+__name(_EchoRoom, "EchoRoom");
+var EchoRoom = _EchoRoom;
+_ts_decorate([
+  onMessage("*"),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    Object,
+    typeof Player === "undefined" ? Object : Player,
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], EchoRoom.prototype, "handleAnyMessage", null);
+var _BroadcastRoom = class _BroadcastRoom extends Room {
+  onJoin(player) {
+    this.broadcast("PlayerJoined", {
+      id: player.id
+    });
+  }
+  onLeave(player) {
+    this.broadcast("PlayerLeft", {
+      id: player.id
+    });
+  }
+  handleAnyMessage(data, player, type) {
+    this.broadcast(type, {
+      from: player.id,
+      data
+    });
+  }
+};
+__name(_BroadcastRoom, "BroadcastRoom");
+var BroadcastRoom = _BroadcastRoom;
+_ts_decorate([
+  onMessage("*"),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    Object,
+    typeof Player === "undefined" ? Object : Player,
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], BroadcastRoom.prototype, "handleAnyMessage", null);
+
+export { MockRoom, TestClient, createTestEnv, createTestServer };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map