@planet-matrix/mobius-model 0.5.0 → 0.9.0

package/tests/unit/socket/socket-unit-heartbeat.spec.ts

@@ -0,0 +1,214 @@
+import { afterEach, expect, test, vi } from "vitest"
+
+import {
+  SocketUnitHeartbeat,
+  resolveSocketUnitHeartbeatOptions,
+  validateSocketUnitHeartbeatOptions,
+} from "#Source/socket/index.ts"
+
+afterEach(() => {
+  vi.clearAllTimers()
+  vi.useRealTimers()
+})
+
+test("SocketUnitHeartbeat validates required handlers and resolves default values", () => {
+  expect(() => validateSocketUnitHeartbeatOptions({
+    enableActiveHeartbeat: true,
+  })).toThrow("Active heartbeat message handler is required")
+
+  expect(() => validateSocketUnitHeartbeatOptions({
+    enablePassiveHeartbeat: true,
+  })).toThrow("Passive heartbeat message handler is required")
+
+  expect(() => validateSocketUnitHeartbeatOptions({
+    heartbeatInterval: 0,
+  })).toThrow("Heartbeat interval must be a positive finite number.")
+
+  expect(() => validateSocketUnitHeartbeatOptions({
+    maxResponseTime: 0,
+  })).toThrow("Max response time must be a positive finite number.")
+
+  expect(() => validateSocketUnitHeartbeatOptions({
+    maxHeartbeatLostCount: 0,
+  })).toThrow("Max heartbeat lost count must be at least 1.")
+
+  const resolvedOptions = resolveSocketUnitHeartbeatOptions({})
+
+  expect(resolvedOptions).toMatchObject({
+    enableActiveHeartbeat: false,
+    enablePassiveHeartbeat: false,
+    heartbeatInterval: 30_000,
+    maxResponseTime: 10_000,
+    maxHeartbeatLostCount: 3,
+  })
+})
+
+test("SocketUnitHeartbeat unifies active and passive handling with newest-first matching", async () => {
+  vi.useFakeTimers()
+
+  const sentMessages: Array<{ action: string; messageString: string }> = []
+  const close = vi.fn(() => {
+    throw new Error("Heartbeat close should not be called in this test.")
+  })
+  const heartbeat = new SocketUnitHeartbeat<{ kind: string; round?: number }>({
+    enableActiveHeartbeat: true,
+    enablePassiveHeartbeat: true,
+    heartbeatInterval: 100,
+    maxResponseTime: 500,
+    maxHeartbeatLostCount: 2,
+    activeHeartbeatMessageHandlerGenerator: () => {
+      return {
+        buildPingMessage: () => {
+          return { kind: "ping" }
+        },
+        verifyPongMessage: (_clientId, message) => {
+          return message.kind === "pong"
+        },
+      }
+    },
+    passiveHeartbeatMessageHandlerGenerator: () => {
+      return {
+        verifyPingMessage: (_clientId, message) => {
+          return message.kind === "ping-from-peer"
+        },
+        buildPongMessage: () => {
+          return { kind: "pong-from-peer" }
+        },
+      }
+    },
+  }, {
+    sendMessage: (message) => {
+      sentMessages.push(message)
+      return true
+    },
+    close,
+  })
+
+  expect(heartbeat.getSnapshot()).toMatchObject({
+    enabledActiveHeartbeat: true,
+    enabledPassiveHeartbeat: true,
+    failCount: 0,
+    isRunning: false,
+    recentStates: [],
+    successCount: 0,
+    waitingCount: 0,
+  })
+
+  heartbeat.start("client-1")
+
+  expect(heartbeat.getSnapshot().isRunning).toBe(true)
+
+  await vi.advanceTimersByTimeAsync(100)
+  await vi.advanceTimersByTimeAsync(100)
+
+  const waitingSnapshot = heartbeat.getSnapshot()
+
+  expect(sentMessages).toHaveLength(2)
+  expect(waitingSnapshot.waitingCount).toBe(2)
+  expect(waitingSnapshot.recentStates).toHaveLength(2)
+  expect(waitingSnapshot.recentStates.every((state) => {
+    return state.status === "waiting" && state.hasPendingResponseTimer === true
+  })).toBe(true)
+
+  const activeHandled = heartbeat.handleMessage("client-1", { kind: "pong" })
+
+  expect(activeHandled).toBe(true)
+  expect(heartbeat.getSnapshot()).toMatchObject({
+    failCount: 0,
+    recentStates: [],
+    successCount: 0,
+    waitingCount: 0,
+  })
+
+  const passiveHandled = heartbeat.handleMessage("client-1", { kind: "ping-from-peer" })
+
+  expect(passiveHandled).toBe(true)
+  expect(sentMessages.at(-1)).toEqual({
+    action: "Passive heartbeat pong send",
+    messageString: JSON.stringify({ kind: "pong-from-peer" }),
+  })
+
+  heartbeat.stop()
+
+  expect(close).not.toHaveBeenCalled()
+  expect(heartbeat.getSnapshot()).toMatchObject({
+    isRunning: false,
+    recentStates: [],
+    waitingCount: 0,
+  })
+})
+
+test("SocketUnitHeartbeat closes transport after consecutive timeout limit is reached", async () => {
+  vi.useFakeTimers()
+
+  let closeCount = 0
+  const heartbeat = new SocketUnitHeartbeat<{ kind: string }>({
+    enableActiveHeartbeat: true,
+    heartbeatInterval: 100,
+    maxResponseTime: 10,
+    maxHeartbeatLostCount: 2,
+    activeHeartbeatMessageHandlerGenerator: () => {
+      return {
+        buildPingMessage: () => {
+          return { kind: "ping" }
+        },
+        verifyPongMessage: () => {
+          return false
+        },
+      }
+    },
+  }, {
+    sendMessage: () => {
+      return true
+    },
+    close: () => {
+      closeCount = closeCount + 1
+    },
+  })
+
+  heartbeat.start("client-2")
+
+  await vi.advanceTimersByTimeAsync(100)
+  await vi.advanceTimersByTimeAsync(10)
+  expect(heartbeat.getSnapshot().failCount).toBe(1)
+  expect(closeCount).toBe(0)
+
+  await vi.advanceTimersByTimeAsync(100)
+  await vi.advanceTimersByTimeAsync(10)
+  expect(heartbeat.getSnapshot().failCount).toBeGreaterThanOrEqual(1)
+  expect(closeCount).toBe(1)
+})
+
+test("SocketUnitHeartbeat stays idle when active heartbeat is disabled and ignores unmatched messages", () => {
+  const heartbeat = new SocketUnitHeartbeat<{ kind: string }>({
+    enablePassiveHeartbeat: true,
+    passiveHeartbeatMessageHandlerGenerator: () => {
+      return {
+        verifyPingMessage: (_clientId, message) => {
+          return message.kind === "ping"
+        },
+        buildPongMessage: () => {
+          return { kind: "pong" }
+        },
+      }
+    },
+  }, {
+    sendMessage: () => {
+      return true
+    },
+    close: () => {
+      throw new Error("Heartbeat close should not be called in this test.")
+    },
+  })
+
+  heartbeat.start("client-3")
+
+  expect(heartbeat.getSnapshot()).toMatchObject({
+    isRunning: false,
+    recentStates: [],
+    waitingCount: 0,
+  })
+
+  expect(heartbeat.handleMessage("client-3", { kind: "unmatched" })).toBe(false)
+  expect(heartbeat.handleMessage("client-3", { kind: "ping" })).toBe(true)
+})