@planet-matrix/mobius-model 0.6.0 → 0.9.0

package/tests/unit/http/api-adapter/node-http.spec.ts

@@ -0,0 +1,191 @@
+import type { AddressInfo } from "node:net"
+
+import { afterEach, expect, test } from "vitest"
+
+import { Http } from "#Source/index.ts"
+
+afterEach(async () => {
+  await Promise.resolve()
+})
+
+test("ApiHostNodeHttp exposes usable URLs and forwards request data to ApiCoreNodeHttp", async () => {
+  const apiHost = Http.createApiHostNodeHttp({ port: 0 })
+
+  apiHost.attachApiCoreHandler(async (apiCore) => {
+    const path = await apiCore.getRequestPath()
+    const method = await apiCore.getRequestMethod()
+    const search = await apiCore.getRequestSearch()
+    const bodyJson = await apiCore.getRequestBodyJson()
+
+    await apiCore.json({
+      path,
+      method,
+      search,
+      bodyJson,
+    })
+  })
+
+  const startResult = await apiHost.start()
+  // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+  const address = apiHost.safeGetServer().address() as AddressInfo
+
+  expect(startResult.urlList).toContain(`http://127.0.0.1:${address.port}`)
+  expect(startResult.urlList).toContain(`http://localhost:${address.port}`)
+  expect(startResult.urlList).toContain(`http://[::1]:${address.port}`)
+
+  const response = await fetch(`http://127.0.0.1:${address.port}/users?page=2`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({ name: "Mobius" }),
+  })
+
+  await expect(response.json()).resolves.toEqual({
+    path: "/users",
+    method: "POST",
+    search: "?page=2",
+    bodyJson: { name: "Mobius" },
+  })
+
+  await apiHost.close()
+
+  expect(apiHost.isRunning()).toBe(false)
+})
+
+test("ApiCoreNodeHttp returns a stable error response when the handler throws", async () => {
+  const apiHost = Http.createApiHostNodeHttp({ port: 0 })
+
+  apiHost.attachApiCoreHandler(() => {
+    throw new Error("boom")
+  })
+
+  await apiHost.start()
+  // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+  const address = apiHost.safeGetServer().address() as AddressInfo
+
+  const response = await fetch(`http://127.0.0.1:${address.port}/error`, {
+    method: "GET",
+  })
+
+  expect(response.status).toBe(500)
+  await expect(response.json()).resolves.toEqual({
+    status: "error",
+    data: {
+      reason: "internal_server_error",
+    },
+  })
+
+  await apiHost.close()
+})
+
+test("ApiCoreNodeHttp treats an empty request body as an empty object", async () => {
+  const apiHost = Http.createApiHostNodeHttp({ port: 0 })
+
+  apiHost.attachApiCoreHandler(async (apiCore) => {
+    await apiCore.json({
+      bodyJson: await apiCore.getRequestBodyJson(),
+    })
+  })
+
+  await apiHost.start()
+  // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+  const address = apiHost.safeGetServer().address() as AddressInfo
+
+  const response = await fetch(`http://127.0.0.1:${address.port}/empty`, {
+    method: "GET",
+  })
+
+  await expect(response.json()).resolves.toEqual({
+    bodyJson: {},
+  })
+
+  await apiHost.close()
+})
+
+test("ApiCoreNodeHttp exposes normalized headers and parses multipart form data", async () => {
+  const apiHost = Http.createApiHostNodeHttp({ port: 0 })
+
+  apiHost.attachApiCoreHandler(async (apiCore) => {
+    const headers = await apiCore.getRequestHeaders()
+    const formData = await apiCore.getRequestBodyFormData()
+    const files = await apiCore.getRequestFiles()
+
+    await apiCore.json({
+      contentType: headers["content-type"],
+      customHeader: await apiCore.getRequestHeader("X-Custom-Header"),
+      formData: formData.map((entry) => {
+        if (entry.value instanceof File) {
+          return {
+            name: entry.name,
+            value: {
+              kind: "file",
+              name: entry.value.name,
+              size: entry.value.size,
+              type: entry.value.type,
+            },
+          }
+        }
+
+        return {
+          name: entry.name,
+          value: entry.value,
+        }
+      }),
+      files: files.map((file) => {
+        return {
+          name: file.name,
+          fileName: file.value.name,
+          size: file.value.size,
+          type: file.value.type,
+        }
+      }),
+    })
+  })
+
+  await apiHost.start()
+  // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+  const address = apiHost.safeGetServer().address() as AddressInfo
+
+  const formData = new FormData()
+  formData.append("user", "Mobius")
+  formData.append("avatar", new File(["hello"], "avatar.txt", { type: "text/plain" }))
+
+  const response = await fetch(`http://127.0.0.1:${address.port}/upload`, {
+    method: "POST",
+    headers: {
+      "X-Custom-Header": "alpha",
+    },
+    body: formData,
+  })
+
+  await expect(response.json()).resolves.toEqual({
+    contentType: [expect.stringContaining("multipart/form-data")],
+    customHeader: ["alpha"],
+    formData: [
+      {
+        name: "user",
+        value: "Mobius",
+      },
+      {
+        name: "avatar",
+        value: {
+          kind: "file",
+          name: "avatar.txt",
+          size: 5,
+          type: "text/plain",
+        },
+      },
+    ],
+    files: [
+      {
+        name: "avatar",
+        fileName: "avatar.txt",
+        size: 5,
+        type: "text/plain",
+      },
+    ],
+  })
+
+  await apiHost.close()
+})

package/tests/unit/json/repair.spec.ts

@@ -0,0 +1,11 @@
+import { expect, test } from "vitest"
+
+import { repairJson } from "#Source/json/index.ts"
+
+test("repairJson repairs common JSON-like text issues and throws for unrecoverable input", () => {
+  expect(repairJson("{foo:1,}")).toBe('{"foo":1}')
+  expect(repairJson("{'name':'mobius',}")).toBe('{"name":"mobius"}')
+  expect(repairJson('{"items":[1,2,],}')).toBe('{"items":[1,2]}')
+
+  expect(() => repairJson('{"a":1,,"b":2}')).toThrow()
+})

package/tests/unit/log/logger.spec.ts

@@ -35,19 +35,34 @@ const makeMemoryEmitter = (sink: string[]): LogEmitterItem => {
 test("Logger.fromOptions returns provided logger and otherwise derives from global logger", () => {
   const explicit = new Logger({ name: "Explicit" })
   const resolvedExplicit = Logger.fromOptions({ logger: explicit })
-  const resolvedDerived = Logger.fromOptions({})
+  const resolvedDerived = Logger.fromOptions({}).setDefaultName("Derived")
 
   expect(resolvedExplicit).toBe(explicit)
   expect(resolvedDerived.hasParent()).toBe(true)
-  expect(resolvedDerived.getNameTags()).toContain(getGlobalLogger().getName())
+  expect(resolvedDerived.getNameTags()).toEqual([getGlobalLogger().getName(), "Derived"])
 })
 
 test("Logger.derive creates child logger with inherited configs", () => {
   const parent = new Logger({ name: "Parent" })
-  const child = Logger.derive(parent)
+  const child = Logger.derive(parent).setDefaultName("Child")
 
   expect(child.hasParent()).toBe(true)
-  expect(child.getNameTags()).toEqual(["Parent", "Unnamed"])
+  expect(child.getNameTags()).toEqual(["Parent", "Child"])
+})
+
+test("Logger name APIs prefer explicit name and fall back to defaultName", () => {
+  const logger = new Logger({})
+
+  expect(logger.getName()).toBe("Unnamed")
+
+  logger.setDefaultName("DefaultLogger")
+  expect(logger.getName()).toBe("DefaultLogger")
+
+  logger.setName("ExplicitLogger")
+  expect(logger.getName()).toBe("ExplicitLogger")
+
+  logger.setName(undefined)
+  expect(logger.getName()).toBe("DefaultLogger")
 })
 
 test("Logger config APIs merge and apply parent configs", () => {

package/tests/unit/openai/openai.spec.ts

@@ -0,0 +1,64 @@
+import { expect, test } from "vitest"
+
+import { streamConsumeInMacroTask } from "#Source/basic/index.ts"
+import { eitherToTuple } from "#Source/result/index.ts"
+import { tubeToReadableStream } from "#Source/tube/index.ts"
+import { Openai } from "#Source/openai/index.ts"
+
+const testApiKey = "sk-DLj8aHvKjvHfZ7IHA2F07c968c3d4aE491C1525e40E24932"
+const testBaseUrl = "https://cn.api.openai-next.com/v1/"
+const openai = new Openai({
+  apiKey: testApiKey,
+  baseUrl: testBaseUrl,
+})
+
+test("customEmbedding ", { timeout: 60_000 }, async () => {
+  const embedding = await openai.customEmbedding({
+    input: "床前明月光，疑是地上霜。举头望明月，低头思故乡。",
+  })
+  const [left, right] = eitherToTuple(embedding)
+  if (left !== undefined) {
+    throw new Error(`请求失败: ${JSON.stringify(left)}`)
+  }
+  const resultLength = right.embedding.length
+  expect(resultLength).toBe(1_536)
+})
+
+test("customChatCompletion ", { timeout: 60_000 }, async () => {
+  const nonStreamingResult = await openai.customChatCompletionNonStreaming({
+    model: "gpt-4o-mini",
+    messages: [
+      { role: "system", content: "你是讲故事大王。" },
+      { role: "user", content: "讲一个小红帽吃掉大灰狼的故事。" },
+    ],
+  })
+  const [left, right] = eitherToTuple(nonStreamingResult)
+  if (left !== undefined) {
+    throw new Error(`请求失败: ${JSON.stringify(left)}`)
+  }
+  const contentLength = right.content.length
+  expect(contentLength).toBeGreaterThan(0)
+})
+
+test("customChatCompletionStreaming ", { timeout: 60_000 }, async () => {
+  const [left, right] = eitherToTuple(await openai.customChatCompletionStreaming({
+    model: "gpt-4o-mini",
+    messages: [
+      { role: "system", content: "你是讲故事大王。" },
+      { role: "user", content: "讲一个小红帽吃掉大灰狼的故事。" },
+    ],
+  }))
+  if (left !== undefined) {
+    throw new Error(`请求失败: ${JSON.stringify(left)}`)
+  }
+  else {
+    const stream = tubeToReadableStream(right.completionTube)
+    streamConsumeInMacroTask({
+      readableStream: stream,
+      onValue: (chunk) => {
+        console.log(JSON.stringify(chunk.content.total, null, 2))
+        // process.stdout.write()
+      },
+    })
+  }
+})

package/tests/unit/orchestration/dispatching/dispatcher.spec.ts

@@ -0,0 +1,41 @@
+import { expect, test } from "vitest"
+
+import { Dispatcher, DownCountSelector } from "#Source/orchestration/index.ts"
+
+test("Dispatcher getSelector reuses selectors by id and applies filter on first creation", async () => {
+  const dispatcher = new Dispatcher({
+    itemList: ["alpha", "beta", "gamma"],
+  })
+
+  const firstResult = dispatcher.getSelector({
+    id: "shared",
+    filter: (item) => item !== "alpha",
+  })
+  const secondResult = dispatcher.getSelector({
+    id: "shared",
+    filter: () => true,
+  })
+
+  expect(firstResult.selector).toBeInstanceOf(DownCountSelector)
+  expect(secondResult.selector).toBe(firstResult.selector)
+
+  const firstItem = await firstResult.selector.getItem()
+
+  expect(firstItem.isRight()).toBe(true)
+  expect(firstItem.assertRight().getRight().item).toBe("beta")
+})
+
+test("Dispatcher destroySelector discards an existing selector and allows recreation", () => {
+  const dispatcher = new Dispatcher({
+    itemList: ["alpha", "beta"],
+  })
+
+  const firstSelector = dispatcher.getSelector({ id: "shared" }).selector
+
+  dispatcher.destroySelector("missing")
+  dispatcher.destroySelector("shared")
+
+  const recreatedSelector = dispatcher.getSelector({ id: "shared" }).selector
+
+  expect(recreatedSelector).not.toBe(firstSelector)
+})

package/tests/unit/orchestration/dispatching/selector/down-count-selector.spec.ts

@@ -0,0 +1,81 @@
+import { expect, test } from "vitest"
+
+import { DownCountSelector } from "#Source/orchestration/index.ts"
+
+test("DownCountSelector getId returns the configured selector id", () => {
+  const selector = new DownCountSelector({
+    id: "selector-1",
+    itemList: ["alpha"],
+  })
+
+  expect(selector.getId()).toBe("selector-1")
+})
+
+test("DownCountSelector getItem distinguishes no choice, no available, and reset-driven reuse", async () => {
+  const emptySelector = new DownCountSelector<string>({
+    id: "empty",
+    itemList: [],
+  })
+
+  const emptyResult = await emptySelector.getItem()
+
+  expect(emptyResult.isLeft()).toBe(true)
+  expect(emptyResult.assertLeft().getLeft()).toEqual({
+    code: "NO_CHOICE",
+  })
+
+  const noAvailableSelector = new DownCountSelector({
+    id: "no-available",
+    itemList: ["alpha", "beta"],
+    resetAllWhenNoAvailable: false,
+  })
+
+  const firstResult = await noAvailableSelector.getItem()
+
+  expect(firstResult.isRight()).toBe(true)
+
+  firstResult.assertRight().getRight().markUnavailable()
+
+  const secondResult = await noAvailableSelector.getItem()
+
+  expect(secondResult.isRight()).toBe(true)
+  expect(secondResult.assertRight().getRight().item).toBe("beta")
+
+  secondResult.assertRight().getRight().markUnavailable()
+
+  const noAvailableResult = await noAvailableSelector.getItem()
+
+  expect(noAvailableResult.isLeft()).toBe(true)
+  expect(noAvailableResult.assertLeft().getLeft()).toEqual({
+    code: "NO_AVAILABLE",
+  })
+
+  const resetSelector = new DownCountSelector({
+    id: "reset",
+    itemList: ["only"],
+  })
+
+  const resetFirstResult = await resetSelector.getItem()
+
+  expect(resetFirstResult.isRight()).toBe(true)
+
+  resetFirstResult.assertRight().getRight().markUnavailable()
+
+  const resetSecondResult = await resetSelector.getItem()
+
+  expect(resetSecondResult.isRight()).toBe(true)
+  expect(resetSecondResult.assertRight().getRight().item).toBe("only")
+
+  resetSecondResult.assertRight().getRight().markUnavailable()
+
+  const recoveredResult = await resetSelector.getItem()
+
+  expect(recoveredResult.isRight()).toBe(true)
+
+  recoveredResult.assertRight().getRight().markAvailable()
+
+  const availableAgainResult = await resetSelector.getItem()
+
+  expect(availableAgainResult.isRight()).toBe(true)
+  expect(availableAgainResult.assertRight().getRight().item).toBe("only")
+})

package/tests/unit/orchestration/scheduling/scheduler.spec.ts

@@ -0,0 +1,103 @@
+import { expect, test, vi } from "vitest"
+
+import { Scheduler, Task } from "#Source/orchestration/index.ts"
+
+test("Scheduler runs one-shot tasks and records run logs", async () => {
+  vi.useFakeTimers()
+  vi.setSystemTime(new Date(2_026, 0, 1, 0, 0, 0, 0))
+
+  try {
+    const run = vi.fn(() => undefined)
+    const runAt = new Date(Date.now() + 1_000)
+    const scheduler = new Scheduler({
+      tasks: [
+        new Task({
+          name: "alpha",
+          cron: runAt,
+          run,
+        }),
+      ],
+    })
+
+    scheduler.run()
+
+    await vi.advanceTimersByTimeAsync(999)
+    expect(run).toHaveBeenCalledTimes(0)
+
+    await vi.advanceTimersByTimeAsync(1)
+
+    expect(run).toHaveBeenCalledTimes(1)
+    expect(scheduler.getErrLog()).toEqual([])
+    expect(scheduler.getRunLog()).toHaveLength(1)
+    expect(scheduler.getRunLog()[0]).toEqual({
+      name: "alpha",
+      time: runAt,
+    })
+  }
+  finally {
+    vi.clearAllTimers()
+    vi.useRealTimers()
+  }
+})
+
+test("Scheduler records both run and error logs when a task fails", async () => {
+  vi.useFakeTimers()
+  vi.setSystemTime(new Date(2_026, 0, 1, 0, 0, 0, 0))
+
+  try {
+    const error = new Error("boom")
+    const run = vi.fn(async () => await Promise.reject(error))
+    const runAt = new Date(Date.now() + 1_000)
+    const scheduler = new Scheduler({
+      tasks: [
+        new Task({
+          name: "beta",
+          cron: runAt,
+          run,
+        }),
+      ],
+    })
+
+    scheduler.run()
+    await vi.advanceTimersByTimeAsync(1_000)
+
+    expect(run).toHaveBeenCalledTimes(1)
+    expect(scheduler.getRunLog()).toHaveLength(1)
+    expect(scheduler.getErrLog()).toEqual([
+      {
+        name: "beta",
+        time: runAt,
+        reason: "Error: boom",
+      },
+    ])
+  }
+  finally {
+    vi.clearAllTimers()
+    vi.useRealTimers()
+  }
+})
+
+test("Scheduler.run rejects duplicate starts", () => {
+  vi.useFakeTimers()
+  vi.setSystemTime(new Date(2_026, 0, 1, 0, 0, 0, 0))
+
+  try {
+    const scheduler = new Scheduler({
+      tasks: [
+        new Task({
+          name: "gamma",
+          cron: new Date(Date.now() + 1_000),
+          run: () => undefined,
+        }),
+      ],
+    })
+
+    scheduler.run()
+
+    expect(() => scheduler.run()).toThrow("Scheduler is already running")
+  }
+  finally {
+    vi.clearAllTimers()
+    vi.useRealTimers()
+  }
+})

package/tests/unit/random/base.spec.ts

@@ -0,0 +1,58 @@
+import { expect, test, vi } from "vitest"
+
+import { getRandomIndex, getRandomUint32, getRandomUnitValue } from "#Source/random/index.ts"
+
+test("getRandomUint32 returns an integer within uint32 range across available random sources", () => {
+  const cryptoBackedValue = getRandomUint32()
+  expect(Number.isInteger(cryptoBackedValue)).toBe(true)
+  expect(cryptoBackedValue).toBeGreaterThanOrEqual(0)
+  expect(cryptoBackedValue).toBeLessThan(0x1_0000_0000)
+
+  vi.stubGlobal("crypto", undefined)
+
+  try {
+    const fallbackValue = getRandomUint32()
+    expect(Number.isInteger(fallbackValue)).toBe(true)
+    expect(fallbackValue).toBeGreaterThanOrEqual(0)
+    expect(fallbackValue).toBeLessThan(0x1_0000_0000)
+  }
+  finally {
+    vi.unstubAllGlobals()
+  }
+})
+
+test("getRandomUnitValue returns a unit-interval float across available random sources", () => {
+  const cryptoBackedValue = getRandomUnitValue()
+  expect(cryptoBackedValue).toBeGreaterThanOrEqual(0)
+  expect(cryptoBackedValue).toBeLessThan(1)
+
+  vi.stubGlobal("crypto", undefined)
+
+  try {
+    const fallbackValue = getRandomUnitValue()
+    expect(fallbackValue).toBeGreaterThanOrEqual(0)
+    expect(fallbackValue).toBeLessThan(1)
+  }
+  finally {
+    vi.unstubAllGlobals()
+  }
+})
+
+test("getRandomIndex returns an integer index within alphabet bounds across available random sources", () => {
+  const cryptoBackedValue = getRandomIndex(3)
+  expect(Number.isInteger(cryptoBackedValue)).toBe(true)
+  expect(cryptoBackedValue).toBeGreaterThanOrEqual(0)
+  expect(cryptoBackedValue).toBeLessThan(3)
+
+  vi.stubGlobal("crypto", undefined)
+
+  try {
+    const fallbackValue = getRandomIndex(3)
+    expect(Number.isInteger(fallbackValue)).toBe(true)
+    expect(fallbackValue).toBeGreaterThanOrEqual(0)
+    expect(fallbackValue).toBeLessThan(3)
+  }
+  finally {
+    vi.unstubAllGlobals()
+  }
+})

package/tests/unit/random/random-boolean.spec.ts

@@ -0,0 +1,25 @@
+import { expect, test, vi } from "vitest"
+
+import { randomBoolean } from "#Source/random/index.ts"
+
+test("randomBoolean returns expected output across probabilities and available random sources", () => {
+  const defaultValue = randomBoolean()
+  expect(typeof defaultValue).toBe("boolean")
+
+  expect(randomBoolean(0)).toBe(false)
+  expect(randomBoolean(1)).toBe(true)
+  expect(() => randomBoolean(Number.NaN)).toThrow(TypeError)
+  expect(() => randomBoolean(Number.POSITIVE_INFINITY)).toThrow(TypeError)
+  expect(() => randomBoolean(-0.1)).toThrow(RangeError)
+  expect(() => randomBoolean(1.1)).toThrow(RangeError)
+
+  vi.stubGlobal("crypto", undefined)
+
+  try {
+    const fallbackValue = randomBoolean(0.5)
+    expect(typeof fallbackValue).toBe("boolean")
+  }
+  finally {
+    vi.unstubAllGlobals()
+  }
+})

package/tests/unit/random/random-integer.spec.ts

@@ -0,0 +1,32 @@
+import { expect, test, vi } from "vitest"
+
+import { randomInteger } from "#Source/random/index.ts"
+
+test("randomInteger returns expected output across ranges and available random sources", () => {
+  const singleBoundValue = randomInteger(5)
+  expect(singleBoundValue).toBeGreaterThanOrEqual(0)
+  expect(singleBoundValue).toBeLessThanOrEqual(5)
+  expect(Number.isInteger(singleBoundValue)).toBe(true)
+
+  const reversedRangeValue = randomInteger(8, 3)
+  expect(reversedRangeValue).toBeGreaterThanOrEqual(3)
+  expect(reversedRangeValue).toBeLessThanOrEqual(8)
+  expect(Number.isInteger(reversedRangeValue)).toBe(true)
+
+  expect(randomInteger(4, 4)).toBe(4)
+  expect(() => randomInteger(1.5)).toThrow(TypeError)
+  expect(() => randomInteger(Number.NaN)).toThrow(TypeError)
+  expect(() => randomInteger(1, Number.POSITIVE_INFINITY)).toThrow(TypeError)
+
+  vi.stubGlobal("crypto", undefined)
+
+  try {
+    const fallbackValue = randomInteger(-2, 2)
+    expect(fallbackValue).toBeGreaterThanOrEqual(-2)
+    expect(fallbackValue).toBeLessThanOrEqual(2)
+    expect(Number.isInteger(fallbackValue)).toBe(true)
+  }
+  finally {
+    vi.unstubAllGlobals()
+  }
+})

package/tests/unit/random/random-number.spec.ts

@@ -0,0 +1,33 @@
+import { expect, test, vi } from "vitest"
+
+import { randomNumber } from "#Source/random/index.ts"
+
+test("randomNumber returns expected output across ranges and available random sources", () => {
+  const defaultValue = randomNumber()
+  expect(defaultValue).toBeGreaterThanOrEqual(0)
+  expect(defaultValue).toBeLessThan(1)
+
+  const singleBoundValue = randomNumber(5)
+  expect(singleBoundValue).toBeGreaterThanOrEqual(0)
+  expect(singleBoundValue).toBeLessThan(5)
+
+  const reversedRangeValue = randomNumber(10, 3)
+  expect(reversedRangeValue).toBeGreaterThanOrEqual(3)
+  expect(reversedRangeValue).toBeLessThan(10)
+
+  expect(randomNumber(4, 4)).toBe(4)
+  expect(() => randomNumber(Number.NaN)).toThrow(TypeError)
+  expect(() => randomNumber(Number.POSITIVE_INFINITY)).toThrow(TypeError)
+  expect(() => randomNumber(1, Number.NEGATIVE_INFINITY)).toThrow(TypeError)
+
+  vi.stubGlobal("crypto", undefined)
+
+  try {
+    const fallbackValue = randomNumber(-2, 2)
+    expect(fallbackValue).toBeGreaterThanOrEqual(-2)
+    expect(fallbackValue).toBeLessThan(2)
+  }
+  finally {
+    vi.unstubAllGlobals()
+  }
+})