@planet-matrix/mobius-model 0.5.0 → 0.9.0

package/tests/unit/timer/expiration/remaining-manager.spec.ts

@@ -0,0 +1,234 @@
+import { expect, test, vi } from "vitest"
+
+import { ExpirationManager } from "#Source/timer/index.ts"
+
+test("RemainingManager getRemaining only returns seconds for active expirations", () => {
+  vi.useFakeTimers()
+  vi.setSystemTime(new Date(2_026, 0, 1, 0, 0, 0))
+
+  try {
+    const expirationManager = new ExpirationManager<"alpha" | "beta" | "gamma">({
+      enableRemainingManager: false,
+    })
+
+    expirationManager.upsertExpiration("alpha", Date.now() + 2_500)
+    expirationManager.upsertExpiration("beta", Date.now() - 1)
+    expirationManager.upsertExpiration("gamma", Date.now() + 2_500)
+    expirationManager.removeExpiration("gamma")
+
+    expect(expirationManager.remainingManager.getRemaining("alpha")).toBe(3)
+    expect(expirationManager.remainingManager.getRemaining("beta")).toBeUndefined()
+    expect(expirationManager.remainingManager.getRemaining("gamma")).toBeUndefined()
+
+    expirationManager.terminate()
+  }
+  finally {
+    vi.clearAllTimers()
+    vi.useRealTimers()
+  }
+})
+
+test("RemainingManager getRemainingSnapshot only includes active expirations", () => {
+  vi.useFakeTimers()
+  vi.setSystemTime(new Date(2_026, 0, 1, 0, 0, 0))
+
+  try {
+    const expirationManager = new ExpirationManager<"alpha" | "beta" | "gamma">({
+      enableRemainingManager: false,
+    })
+
+    expirationManager.upsertExpiration("alpha", Date.now() + 1_500)
+    expirationManager.upsertExpiration("beta", Date.now() - 1)
+    expirationManager.upsertExpiration("gamma", Date.now() + 1_500)
+    expirationManager.removeExpiration("gamma")
+
+    expect(expirationManager.remainingManager.getRemainingSnapshot()).toEqual({ alpha: 2 })
+
+    expirationManager.terminate()
+  }
+  finally {
+    vi.clearAllTimers()
+    vi.useRealTimers()
+  }
+})
+
+test("RemainingManager emit only publishes changed snapshots", () => {
+  vi.useFakeTimers()
+  vi.setSystemTime(new Date(2_026, 0, 1, 0, 0, 0))
+
+  try {
+    const expirationManager = new ExpirationManager<"alpha">({
+      enableRemainingManager: false,
+    })
+    const remainingSnapshots: Array<{ alpha?: number | undefined }> = []
+
+    expirationManager.remainingManager.event.subscribe("remaining", (remaining): void => {
+      remainingSnapshots.push({ ...remaining })
+    })
+
+    expirationManager.upsertExpiration("alpha", Date.now() + 2_500)
+    expirationManager.remainingManager.emit()
+    vi.advanceTimersByTime(1_000)
+    expirationManager.remainingManager.emit()
+
+    expect(remainingSnapshots).toEqual([{ alpha: 3 }, { alpha: 2 }])
+
+    expirationManager.terminate()
+  }
+  finally {
+    vi.clearAllTimers()
+    vi.useRealTimers()
+  }
+})
+
+test("RemainingManager start enables interval-driven updates", () => {
+  vi.useFakeTimers()
+  vi.setSystemTime(new Date(2_026, 0, 1, 0, 0, 0))
+
+  try {
+    const expirationManager = new ExpirationManager<"alpha">({
+      enableRemainingManager: false,
+    })
+    const remainingSnapshots: Array<{ alpha?: number | undefined }> = []
+
+    expirationManager.remainingManager.event.subscribe("remaining", (remaining): void => {
+      remainingSnapshots.push({ ...remaining })
+    })
+
+    expirationManager.upsertExpiration("alpha", Date.now() + 2_500)
+    vi.advanceTimersByTime(1_000)
+
+    expect(remainingSnapshots).toEqual([{ alpha: 3 }])
+
+    expirationManager.remainingManager.start()
+    vi.advanceTimersByTime(1_000)
+
+    expect(remainingSnapshots).toEqual([{ alpha: 3 }, { alpha: 1 }])
+
+    expirationManager.terminate()
+  }
+  finally {
+    vi.clearAllTimers()
+    vi.useRealTimers()
+  }
+})
+
+test("RemainingManager stop disables interval-driven updates", () => {
+  vi.useFakeTimers()
+  vi.setSystemTime(new Date(2_026, 0, 1, 0, 0, 0))
+
+  try {
+    const expirationManager = new ExpirationManager<"alpha">({
+      enableRemainingManager: true,
+    })
+    const remainingSnapshots: Array<{ alpha?: number | undefined }> = []
+
+    expirationManager.remainingManager.event.subscribe("remaining", (remaining): void => {
+      remainingSnapshots.push({ ...remaining })
+    })
+
+    expirationManager.upsertExpiration("alpha", Date.now() + 3_500)
+    vi.advanceTimersByTime(1_000)
+
+    expect(remainingSnapshots).toEqual([{ alpha: 4 }, { alpha: 3 }])
+
+    expirationManager.remainingManager.stop()
+    vi.advanceTimersByTime(1_000)
+
+    expect(remainingSnapshots).toEqual([{ alpha: 4 }, { alpha: 3 }])
+
+    expirationManager.terminate()
+  }
+  finally {
+    vi.clearAllTimers()
+    vi.useRealTimers()
+  }
+})
+
+test("RemainingManager pause suspends interval-driven updates", () => {
+  vi.useFakeTimers()
+  vi.setSystemTime(new Date(2_026, 0, 1, 0, 0, 0))
+
+  try {
+    const expirationManager = new ExpirationManager<"alpha">({
+      enableRemainingManager: true,
+    })
+    const remainingSnapshots: Array<{ alpha?: number | undefined }> = []
+
+    expirationManager.remainingManager.event.subscribe("remaining", (remaining): void => {
+      remainingSnapshots.push({ ...remaining })
+    })
+
+    expirationManager.upsertExpiration("alpha", Date.now() + 3_500)
+    vi.advanceTimersByTime(1_000)
+    expirationManager.remainingManager.pause()
+    vi.advanceTimersByTime(1_000)
+
+    expect(remainingSnapshots).toEqual([{ alpha: 4 }, { alpha: 3 }])
+
+    expirationManager.terminate()
+  }
+  finally {
+    vi.clearAllTimers()
+    vi.useRealTimers()
+  }
+})
+
+test("RemainingManager resume restarts interval-driven updates after pause", () => {
+  vi.useFakeTimers()
+  vi.setSystemTime(new Date(2_026, 0, 1, 0, 0, 0))
+
+  try {
+    const expirationManager = new ExpirationManager<"alpha">({
+      enableRemainingManager: true,
+    })
+    const remainingSnapshots: Array<{ alpha?: number | undefined }> = []
+
+    expirationManager.remainingManager.event.subscribe("remaining", (remaining): void => {
+      remainingSnapshots.push({ ...remaining })
+    })
+
+    expirationManager.upsertExpiration("alpha", Date.now() + 3_500)
+    expirationManager.remainingManager.pause()
+    vi.advanceTimersByTime(1_000)
+    expirationManager.remainingManager.resume()
+    vi.advanceTimersByTime(1_000)
+
+    expect(remainingSnapshots).toEqual([{ alpha: 4 }, { alpha: 2 }])
+
+    expirationManager.terminate()
+  }
+  finally {
+    vi.clearAllTimers()
+    vi.useRealTimers()
+  }
+})
+
+test("RemainingManager terminate stops future emissions", () => {
+  vi.useFakeTimers()
+  vi.setSystemTime(new Date(2_026, 0, 1, 0, 0, 0))
+
+  try {
+    const expirationManager = new ExpirationManager<"alpha">({
+      enableRemainingManager: true,
+    })
+    const remainingSnapshots: Array<{ alpha?: number | undefined }> = []
+
+    expirationManager.remainingManager.event.subscribe("remaining", (remaining): void => {
+      remainingSnapshots.push({ ...remaining })
+    })
+
+    expirationManager.upsertExpiration("alpha", Date.now() + 3_500)
+    expirationManager.remainingManager.terminate()
+    vi.advanceTimersByTime(2_000)
+    expirationManager.remainingManager.emit()
+
+    expect(remainingSnapshots).toEqual([{ alpha: 4 }])
+
+    expirationManager.terminate()
+  }
+  finally {
+    vi.clearAllTimers()
+    vi.useRealTimers()
+  }
+})

package/tests/unit/tube/helper.spec.ts

@@ -0,0 +1,139 @@
+import { ReadableStream } from "node:stream/web"
+
+import { afterEach, expect, test, vi } from "vitest"
+
+import { streamFromArrayEager } from "#Source/basic/index.ts"
+import {
+  connectTube,
+  readableStreamToTube,
+  Tube,
+  tubeToPromise,
+  tubeToReadableStream,
+} from "#Source/tube/index.ts"
+
+const createTube = (options: Partial<ConstructorParameters<typeof Tube<number, string | Error>>[0]> = {}): Tube<number, string | Error> => {
+  return new Tube<number, string | Error>({
+    historyCount: 3,
+    replayHistory: false,
+    ...options,
+  })
+}
+
+afterEach(() => {
+  vi.useRealTimers()
+})
+
+test("connectTube forwards lifecycle, data and error signals until disconnected", async () => {
+  vi.useFakeTimers()
+  const upstream = createTube({ autoEndOnError: false, autoCloseOnError: false })
+  const downstream = createTube({ autoEndOnError: false, autoCloseOnError: false })
+  const downstreamValues: number[] = []
+
+  downstream.subscribeData({
+    subscriber: (value) => {
+      downstreamValues.push(value)
+    },
+  })
+
+  const disconnect = connectTube(upstream, downstream)
+
+  await upstream.pushData(1)
+  await vi.runAllTimersAsync()
+
+  expect(downstreamValues).toEqual([1])
+  expect(downstream.isOpen()).toBe(true)
+  expect(downstream.isStart()).toBe(true)
+
+  await upstream.pushError("boom")
+  await vi.runAllTimersAsync()
+
+  expect(downstream.safeGetLatestError()).toBe("boom")
+
+  disconnect()
+
+  await upstream.pushData(2)
+  await vi.runAllTimersAsync()
+
+  expect(downstreamValues).toEqual([1])
+})
+
+test("tubeToPromise resolves with the latest data on close and rejects on error or empty close", async () => {
+  vi.useFakeTimers()
+
+  const successTube = createTube()
+  const successPromise = tubeToPromise(successTube)
+  await successTube.pushData(1)
+  await successTube.pushData(2)
+  await successTube.close()
+  await vi.runAllTimersAsync()
+  await expect(successPromise).resolves.toBe(2)
+
+  const errorTube = createTube()
+  const errorPromise = tubeToPromise(errorTube)
+  await errorTube.pushError(new Error("boom"))
+  await vi.runAllTimersAsync()
+  await expect(errorPromise).rejects.toThrow("boom")
+
+  const emptyTube = createTube({ autoStartOnOpen: false, autoEndOnClose: false })
+  const emptyPromise = tubeToPromise(emptyTube)
+  await emptyTube.open()
+  await emptyTube.close()
+  await vi.runAllTimersAsync()
+  await expect(emptyPromise).rejects.toThrow("No data available")
+})
+
+test("tubeToReadableStream exposes tube data and propagates stream errors", async () => {
+  vi.useFakeTimers()
+
+  const successTube = createTube()
+  const successStream = tubeToReadableStream(successTube)
+  const successRead = Array.fromAsync(successStream)
+  await successTube.pushData(1)
+  await successTube.pushData(2)
+  await successTube.close()
+  await vi.runAllTimersAsync()
+  await expect(successRead).resolves.toEqual([1, 2])
+
+  const errorTube = createTube()
+  const errorStream = tubeToReadableStream(errorTube)
+  const errorRead = Array.fromAsync(errorStream)
+  await errorTube.pushError(new Error("broken"))
+  await vi.runAllTimersAsync()
+  await expect(errorRead).rejects.toThrow("broken")
+})
+
+test("readableStreamToTube consumes readable streams into a tube and records stream errors", async () => {
+  vi.useFakeTimers()
+
+  const values: number[] = []
+  const successTube = readableStreamToTube<number, Error>(streamFromArrayEager([1, 2, 3]))
+  successTube.subscribeData({
+    subscriber: (value) => {
+      values.push(value)
+    },
+  })
+
+  await vi.runAllTimersAsync()
+
+  expect(values).toEqual([1, 2, 3])
+  expect(successTube.hasClosed()).toBe(true)
+  expect(successTube.safeGetLatestData()).toBe(3)
+
+  const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => undefined)
+
+  try {
+    const failureTube = readableStreamToTube<number, Error>(new ReadableStream<number>({
+      start(controller): void {
+        controller.error(new Error("stream-failed"))
+      },
+    }))
+
+    await vi.runAllTimersAsync()
+
+    expect(failureTube.safeGetLatestError()).toBeInstanceOf(Error)
+    expect(failureTube.safeGetLatestError().message).toBe("Error: stream-failed")
+  }
+  finally {
+    consoleErrorSpy.mockRestore()
+  }
+})