@planet-matrix/mobius-model 0.5.0 → 0.9.0

package/tests/unit/http/api/api-server.spec.ts

@@ -0,0 +1,363 @@
+import { expect, test, vi } from "vitest"
+import type { StandardSchemaV1 } from "@standard-schema/spec"
+
+import type {
+  ApiCoreHandler,
+  ApiCoreHeaders,
+  ApiCoreRequestFormData,
+  ApiCoreStream,
+  ApiHostStartResult,
+  ApiHandlerContext,
+} from "#Source/http/index.ts"
+import {
+  ApiCore,
+  ApiHost,
+  ApiServer,
+  SuccessResult,
+  createApi,
+  createApiSchema,
+  createApiServer,
+} from "#Source/http/index.ts"
+
+const isRecord = (value: unknown): value is Record<string, unknown> => {
+  return typeof value === "object" && value !== null
+}
+
+const createSchema = <Output>(
+  validate: (value: unknown) => StandardSchemaV1.Result<Output>,
+): StandardSchemaV1<unknown, Output> => {
+  return {
+    "~standard": {
+      version: 1 as const,
+      vendor: "mobius-http-test",
+      validate,
+    },
+  }
+}
+
+const inputQuerySchema = createSchema<{ page: string }>((value) => {
+  if (isRecord(value) && typeof value["page"] === "string") {
+    return {
+      value: {
+        page: value["page"],
+      },
+    }
+  }
+
+  return {
+    issues: [{ message: "page is required" }],
+  }
+})
+
+const inputBodySchema = createSchema<{ name: string }>((value) => {
+  if (isRecord(value) && typeof value["name"] === "string") {
+    return {
+      value: {
+        name: value["name"],
+      },
+    }
+  }
+
+  return {
+    issues: [{ message: "name is required" }],
+  }
+})
+
+const outputSuccessSchema = createSchema<{ status: "success" }>((value) => {
+  if (typeof value === "object" && value !== null && (value as { status?: unknown }).status === "success") {
+    return {
+      value: {
+        status: "success",
+      },
+    }
+  }
+
+  return {
+    issues: [{ message: "status must be success" }],
+  }
+})
+
+const outputErrorSchema = createSchema<{ status: "error" }>((value) => {
+  if (typeof value === "object" && value !== null && (value as { status?: unknown }).status === "error") {
+    return {
+      value: {
+        status: "error",
+      },
+    }
+  }
+
+  return {
+    issues: [{ message: "status must be error" }],
+  }
+})
+
+interface TestApiCoreOptions {
+  url: string
+  method: string
+  headers?: ApiCoreHeaders | undefined
+  bodyText?: string | undefined
+  formData?: ApiCoreRequestFormData | undefined
+}
+
+class TestApiCore extends ApiCore {
+  readonly jsonPayloads: unknown[] = []
+  errorCallCount = 0
+
+  private readonly url: string
+  private readonly method: string
+  private readonly headers: ApiCoreHeaders
+  private readonly bodyText: string
+  private readonly formData: ApiCoreRequestFormData
+
+  constructor(options: TestApiCoreOptions) {
+    super()
+
+    this.url = options.url
+    this.method = options.method
+    this.headers = options.headers ?? {}
+    this.bodyText = options.bodyText ?? ""
+    this.formData = options.formData ?? []
+  }
+
+  async getRequestHeaders(): Promise<ApiCoreHeaders> {
+    return await Promise.resolve(this.headers)
+  }
+
+  async getRequestMethod(): Promise<string> {
+    return await Promise.resolve(this.method)
+  }
+
+  getRequestUrl(): string {
+    return this.url
+  }
+
+  async getRequestBodyText(): Promise<string> {
+    return await Promise.resolve(this.bodyText)
+  }
+
+  async getRequestBodyFormData(): Promise<ApiCoreRequestFormData> {
+    return await Promise.resolve(this.formData)
+  }
+
+  async text(): Promise<void> {
+    return await Promise.resolve()
+  }
+
+  async json(data: unknown): Promise<void> {
+    this.jsonPayloads.push(data)
+    return await Promise.resolve()
+  }
+
+  async stream(): Promise<ApiCoreStream> {
+    return await Promise.resolve({
+      write: async () => {
+        await Promise.resolve()
+      },
+      end: async () => {
+        await Promise.resolve()
+      },
+    })
+  }
+
+  async error(): Promise<void> {
+    this.errorCallCount = this.errorCallCount + 1
+    return await Promise.resolve()
+  }
+}
+
+class TestApiHost extends ApiHost<{ id: string }> {
+  apiCoreHandler: ApiCoreHandler | undefined
+  startCallCount = 0
+
+  constructor() {
+    super({ port: 0 })
+  }
+
+  attachApiCoreHandler(apiCoreHandler: ApiCoreHandler): void {
+    this.apiCoreHandler = apiCoreHandler
+  }
+
+  async start(): Promise<ApiHostStartResult> {
+    this.startCallCount = this.startCallCount + 1
+    this.server = { id: "server-1" }
+
+    return await Promise.resolve({
+      urlList: ["http://127.0.0.1:0"],
+    })
+  }
+
+  async close(): Promise<void> {
+    this.server = undefined
+    await Promise.resolve()
+  }
+
+  async dispatch(apiCore: ApiCore): Promise<void> {
+    if (this.apiCoreHandler === undefined) {
+      throw new Error("ApiCore handler is not attached.")
+    }
+
+    await this.apiCoreHandler(apiCore)
+  }
+}
+
+class TestSuccessResult extends SuccessResult<{ status: "success" }> {
+  private readonly handleCallback: (apiCore: ApiCore) => Promise<void>
+
+  constructor(handleCallback: (apiCore: ApiCore) => Promise<void>) {
+    super({})
+    this.handleCallback = handleCallback
+  }
+
+  async handle(apiCore: ApiCore): Promise<void> {
+    await this.handleCallback(apiCore)
+  }
+}
+
+const testApiSchema = createApiSchema<
+  string,
+  "get" | "post",
+  StandardSchemaV1<unknown, unknown>,
+  StandardSchemaV1<unknown, unknown>,
+  StandardSchemaV1<unknown, unknown>,
+  StandardSchemaV1<unknown, unknown>
+>({
+  path: "/users",
+  method: "post",
+  inputQuerySchema,
+  inputBodySchema,
+  outputSuccessSchema,
+  outputErrorSchema,
+})
+
+test("ApiServer.start delegates to the configured ApiHost", async () => {
+  const apiHost = new TestApiHost()
+  const apiServer = createApiServer({
+    apiList: [],
+    apiHost,
+  })
+
+  const result = await apiServer.start()
+
+  expect(result).toEqual({
+    urlList: ["http://127.0.0.1:0"],
+  })
+  expect(apiHost.startCallCount).toBe(1)
+})
+
+test("ApiServer dispatches matched requests, validates input, and handles the Api result", async () => {
+  const apiHost = new TestApiHost()
+  const apiHandler = vi.fn(async (
+    context: ApiHandlerContext<
+      string,
+      "get" | "post",
+      StandardSchemaV1<unknown, unknown>,
+      StandardSchemaV1<unknown, unknown>,
+      StandardSchemaV1<unknown, unknown>,
+      StandardSchemaV1<unknown, unknown>
+    >,
+  ): Promise<TestSuccessResult> => {
+    await Promise.resolve()
+    return new TestSuccessResult(async (apiCore) => {
+      await apiCore.json({
+        path: context.path,
+        method: context.method,
+        inputQuery: context.inputQuery,
+        inputBody: context.inputBody,
+      })
+    })
+  })
+  const apiServer = createApiServer({
+    apiList: [createApi({ apiSchema: testApiSchema, apiHandler })],
+    apiHost,
+  })
+  expect(apiServer).toBeInstanceOf(ApiServer)
+
+  const apiCore = new TestApiCore({
+    url: "http://127.0.0.1/users?page=2",
+    method: "POST",
+    bodyText: '{"name":"Mobius"}',
+  })
+
+  await apiHost.dispatch(apiCore)
+
+  expect(apiHandler).toHaveBeenCalledTimes(1)
+  expect(apiHandler).toHaveBeenCalledWith(expect.objectContaining({
+    path: "/users",
+    method: "post",
+    inputQuery: {
+      page: "2",
+    },
+    inputBody: {
+      name: "Mobius",
+    },
+    apiCore,
+  }))
+  expect(apiCore.jsonPayloads).toEqual([
+    {
+      path: "/users",
+      method: "post",
+      inputQuery: {
+        page: "2",
+      },
+      inputBody: {
+        name: "Mobius",
+      },
+    },
+  ])
+  expect(apiCore.errorCallCount).toBe(0)
+})
+
+test("ApiServer calls ApiCore.error when no Api matches the request", async () => {
+  const apiHost = new TestApiHost()
+  const apiServer = createApiServer({
+    apiList: [],
+    apiHost,
+  })
+  expect(apiServer).toBeInstanceOf(ApiServer)
+
+  const apiCore = new TestApiCore({
+    url: "http://127.0.0.1/missing?page=2",
+    method: "GET",
+  })
+
+  await apiHost.dispatch(apiCore)
+
+  expect(apiCore.errorCallCount).toBe(1)
+  expect(apiCore.jsonPayloads).toEqual([])
+})
+
+test("ApiServer calls ApiCore.error when input validation fails", async () => {
+  const apiHost = new TestApiHost()
+  const apiHandler = vi.fn(async (
+    context: ApiHandlerContext<
+      string,
+      "get" | "post",
+      StandardSchemaV1<unknown, unknown>,
+      StandardSchemaV1<unknown, unknown>,
+      StandardSchemaV1<unknown, unknown>,
+      StandardSchemaV1<unknown, unknown>
+    >,
+  ): Promise<TestSuccessResult> => {
+    await Promise.resolve()
+    return new TestSuccessResult(async (apiCore) => {
+      await apiCore.json(context)
+    })
+  })
+  const apiServer = createApiServer({
+    apiList: [createApi({ apiSchema: testApiSchema, apiHandler })],
+    apiHost,
+  })
+  expect(apiServer).toBeInstanceOf(ApiServer)
+
+  const apiCore = new TestApiCore({
+    url: "http://127.0.0.1/users",
+    method: "POST",
+    bodyText: '{}',
+  })
+
+  await apiHost.dispatch(apiCore)
+
+  expect(apiHandler).not.toHaveBeenCalled()
+  expect(apiCore.errorCallCount).toBe(1)
+  expect(apiCore.jsonPayloads).toEqual([])
+})

package/tests/unit/http/api/api-test.spec.ts

@@ -0,0 +1,117 @@
+import { expect, test, vi } from "vitest"
+
+import type { StandardSchemaV1 } from "@standard-schema/spec"
+import { createApiSchema, createApiTest, testApi } from "#Source/http/index.ts"
+
+const createSchema = <Output>(
+  validate: (value: unknown) => StandardSchemaV1.Result<Output>,
+): StandardSchemaV1<unknown, Output> => {
+  return {
+    "~standard": {
+      version: 1 as const,
+      vendor: "mobius-http-test",
+      validate,
+    },
+  }
+}
+
+const passthroughSchema = createSchema<unknown>((value) => {
+  return {
+    value,
+  }
+})
+
+const apiSchema = createApiSchema({
+  path: "/health",
+  method: "get",
+  inputQuerySchema: passthroughSchema,
+  inputBodySchema: passthroughSchema,
+  outputSuccessSchema: passthroughSchema,
+  outputErrorSchema: passthroughSchema,
+})
+
+const beforeApiTestHandler = vi.fn(async () => {
+  await Promise.resolve()
+  return {
+    token: "before",
+  }
+})
+
+const apiTestHandler = vi.fn(async () => {
+  await Promise.resolve()
+  return {
+    token: "during",
+  }
+})
+
+const afterApiTestHandler = vi.fn(async () => {
+  await Promise.resolve()
+  return {
+    token: "after",
+  }
+})
+
+const apiTest = createApiTest({
+  apiSchema,
+  beforeApiTestHandler,
+  apiTestHandler,
+  afterApiTestHandler,
+})
+
+test("ApiTest.getApiSchema returns the configured schema", () => {
+  expect(apiTest.getApiSchema()).toBe(apiSchema)
+})
+
+test("ApiTest.getBeforeApiTestHandler returns the configured before handler", () => {
+  expect(apiTest.getBeforeApiTestHandler()).toBe(beforeApiTestHandler)
+})
+
+test("ApiTest.getApiTestHandler returns the configured test handler", () => {
+  expect(apiTest.getApiTestHandler()).toBe(apiTestHandler)
+})
+
+test("ApiTest.getAfterApiTestHandler returns the configured after handler", () => {
+  expect(apiTest.getAfterApiTestHandler()).toBe(afterApiTestHandler)
+})
+
+test("testApi executes the configured handlers in order and forwards intermediate results", async () => {
+  const callOrder: string[] = []
+
+  const orchestratedApiTest = createApiTest({
+    apiSchema,
+    beforeApiTestHandler: async (context) => {
+      await Promise.resolve()
+      callOrder.push(`before:${context.apiSchema.getPath()}`)
+      return {
+        requestId: "r1",
+      }
+    },
+    apiTestHandler: async (context) => {
+      await Promise.resolve()
+      callOrder.push(`test:${context.beforeApiTestResult.requestId}`)
+      return {
+        statusCode: 200,
+      }
+    },
+    afterApiTestHandler: async (context) => {
+      await Promise.resolve()
+      callOrder.push(`after:${context.apiTestResult.statusCode}`)
+      return {
+        summary: `${context.apiSchema.getMethod()} ${context.beforeApiTestResult.requestId}`,
+      }
+    },
+  })
+
+  const result = await testApi({
+    apiTest: orchestratedApiTest,
+  })
+
+  expect(callOrder).toEqual([
+    "before:/health",
+    "test:r1",
+    "after:200",
+  ])
+  expect(result).toEqual({
+    summary: "get r1",
+  })
+})

package/tests/unit/http/api/api.spec.ts

@@ -0,0 +1,121 @@
+import { expect, test } from "vitest"
+
+import type { StandardSchemaV1 } from "@standard-schema/spec"
+import type { ApiHandler } from "#Source/http/index.ts"
+import { SuccessResult, createApi, createApiSchema } from "#Source/http/index.ts"
+
+const isRecord = (value: unknown): value is Record<string, unknown> => {
+  return typeof value === "object" && value !== null
+}
+
+const createSchema = <Output>(
+  validate: (value: unknown) => StandardSchemaV1.Result<Output>,
+): StandardSchemaV1<unknown, Output> => {
+  return {
+    "~standard": {
+      version: 1 as const,
+      vendor: "mobius-http-test",
+      validate,
+    },
+  }
+}
+
+class TestSuccessResult extends SuccessResult<{ status: "success" }> {
+  constructor() {
+    super({})
+  }
+
+  async handle(): Promise<void> {
+    await Promise.resolve()
+  }
+}
+
+const inputQuerySchema = createSchema<{ page: string }>((value) => {
+  if (isRecord(value) && typeof value["page"] === "string") {
+    return {
+      value: {
+        page: value["page"],
+      },
+    }
+  }
+
+  return {
+    issues: [{ message: "page is required" }],
+  }
+})
+
+const inputBodySchema = createSchema<{ name: string }>((value) => {
+  if (isRecord(value) && typeof value["name"] === "string") {
+    return {
+      value: {
+        name: value["name"],
+      },
+    }
+  }
+
+  return {
+    issues: [{ message: "name is required" }],
+  }
+})
+
+const outputSuccessSchema = createSchema<{ status: "success" }>((value) => {
+  if (typeof value === "object" && value !== null && (value as { status?: unknown }).status === "success") {
+    return {
+      value: {
+        status: "success",
+      },
+    }
+  }
+
+  return {
+    issues: [{ message: "status must be success" }],
+  }
+})
+
+const outputErrorSchema = createSchema<{ status: "error" }>((value) => {
+  if (typeof value === "object" && value !== null && (value as { status?: unknown }).status === "error") {
+    return {
+      value: {
+        status: "error",
+      },
+    }
+  }
+
+  return {
+    issues: [{ message: "status must be error" }],
+  }
+})
+
+const apiSchema = createApiSchema({
+  path: "/users",
+  method: "post",
+  inputQuerySchema,
+  inputBodySchema,
+  outputSuccessSchema,
+  outputErrorSchema,
+})
+
+const apiHandler: ApiHandler<
+  "/users",
+  "post",
+  typeof inputQuerySchema,
+  typeof inputBodySchema,
+  typeof outputSuccessSchema,
+  typeof outputErrorSchema
+> = async () => {
+  await Promise.resolve()
+  return new TestSuccessResult()
+}
+
+const api = createApi({
+  apiSchema,
+  apiHandler,
+})
+
+test("Api.getApiSchema returns the configured schema", () => {
+  expect(api.getApiSchema()).toBe(apiSchema)
+})
+
+test("Api.getApiHandler returns the configured handler", () => {
+  expect(api.getApiHandler()).toBe(apiHandler)
+})