@typespec/http-server-js 0.58.0-alpha.12-dev.0 → 0.58.0-alpha.12-dev.2

package/test/datetime.test.ts

@@ -0,0 +1,226 @@
+import { deepStrictEqual, strictEqual, throws } from "assert";
+import { describe, it } from "vitest";
+import { Duration } from "../src/helpers/datetime.js";
+
+describe("datetime", () => {
+  describe("duration", () => {
+    it("parses an ISO8601 duration string", () => {
+      deepStrictEqual(Duration.parseISO8601("P1Y2M3D"), {
+        sign: "+",
+        years: 1,
+        months: 2,
+        weeks: 0,
+        days: 3,
+        hours: 0,
+        minutes: 0,
+        seconds: 0,
+      });
+    });
+
+    it("parses a negative ISO8601 duration string", () => {
+      deepStrictEqual(Duration.parseISO8601("-P1Y2M3D"), {
+        sign: "-",
+        years: 1,
+        months: 2,
+        weeks: 0,
+        days: 3,
+        hours: 0,
+        minutes: 0,
+        seconds: 0,
+      });
+    });
+
+    it("parses a duration string with hours and minutes", () => {
+      deepStrictEqual(Duration.parseISO8601("PT1H2M"), {
+        sign: "+",
+        years: 0,
+        months: 0,
+        weeks: 0,
+        days: 0,
+        hours: 1,
+        minutes: 2,
+        seconds: 0,
+      });
+    });
+
+    it("parses a duration string with fractional years", () => {
+      deepStrictEqual(Duration.parseISO8601("P1.5Y"), {
+        sign: "+",
+        years: 1.5,
+        months: 0,
+        weeks: 0,
+        days: 0,
+        hours: 0,
+        minutes: 0,
+        seconds: 0,
+      });
+    });
+
+    it("does not parse an invalid duration string", () => {
+      throws(() => Duration.parseISO8601("1Y2M3D4H"), {
+        message: "Invalid ISO8601 duration: 1Y2M3D4H",
+      });
+    });
+
+    it("does not parse a duration string with too many digits in a component", () => {
+      throws(
+        () =>
+          Duration.parseISO8601(
+            "P123429384502934875023948572039485720394857230948572309485723094857203948572309456789.19821374652345232304958273049582730495827340958720349857452345234529223450928347592834387456928374659238476Y",
+          ),
+        {
+          message:
+            "ISO8601 duration string is too long: P123429384502934875023948572039485720394857230948572309485723094857203948572309456789.19821374652345232304958273049582730495827340958720349857452345234529223450928347592834387456928374659238476Y",
+        },
+      );
+    });
+
+    it("does not parse a duration string with an invalid group", () => {
+      throws(() => Duration.parseISO8601("P1Y2M3D4H5X"), {
+        message: "Invalid ISO8601 duration: P1Y2M3D4H5X",
+      });
+    });
+
+    it("does not parse a duration string with missing group", () => {
+      throws(() => Duration.parseISO8601("P1Y2M3D4H5.5"), {
+        message: "Invalid ISO8601 duration: P1Y2M3D4H5.5",
+      });
+    });
+
+    it("does not parse a duration string with multiple points", () => {
+      throws(() => Duration.parseISO8601("P1.2.3Y"), {
+        message: "Invalid ISO8601 duration: P1.2.3Y",
+      });
+    });
+
+    it("allows comma as decimal separator", () => {
+      deepStrictEqual(Duration.parseISO8601("P1,5Y4.2DT1,005S"), {
+        sign: "+",
+        years: 1.5,
+        months: 0,
+        weeks: 0,
+        days: 4.2,
+        hours: 0,
+        minutes: 0,
+        seconds: 1.005,
+      });
+    });
+
+    it("writes an ISO8601 duration string", () => {
+      const duration: Duration = {
+        sign: "+",
+        years: 1,
+        months: 2,
+        weeks: 3,
+        days: 4,
+        hours: 5,
+        minutes: 6,
+        seconds: 7,
+      };
+
+      strictEqual(Duration.toISO8601(duration), "P1Y2M3W4DT5H6M7S");
+    });
+
+    it("writes a negative ISO8601 duration string", () => {
+      const duration: Duration = {
+        sign: "-",
+        years: 1,
+        months: 2,
+        weeks: 3,
+        days: 4,
+        hours: 5,
+        minutes: 6,
+        seconds: 7,
+      };
+
+      strictEqual(Duration.toISO8601(duration), "-P1Y2M3W4DT5H6M7S");
+    });
+
+    it("writes a duration string with only years", () => {
+      const duration: Duration = {
+        sign: "+",
+        years: 1,
+        months: 0,
+        weeks: 0,
+        days: 0,
+        hours: 0,
+        minutes: 0,
+        seconds: 0,
+      };
+
+      strictEqual(Duration.toISO8601(duration), "P1Y");
+    });
+
+    it("writes a duration string with only hours", () => {
+      const duration: Duration = {
+        sign: "+",
+        years: 0,
+        months: 0,
+        weeks: 0,
+        days: 0,
+        hours: 36,
+        minutes: 0,
+        seconds: 0,
+      };
+
+      strictEqual(Duration.toISO8601(duration), "PT36H");
+    });
+
+    it("writes a duration string with fractional amounts", () => {
+      const duration: Duration = {
+        sign: "+",
+        years: 1.5,
+        months: 0,
+        weeks: 0,
+        days: 0,
+        hours: 0,
+        minutes: 0,
+        seconds: 1.005,
+      };
+
+      strictEqual(Duration.toISO8601(duration), "P1.5YT1.005S");
+    });
+
+    it("computes total seconds in durations", () => {
+      const duration = Duration.parseISO8601("PT22H96M60S");
+
+      strictEqual(Duration.totalSeconds(duration), 22 * 60 * 60 + 96 * 60 + 60);
+      strictEqual(Duration.totalSecondsBigInt(duration), 22n * 60n * 60n + 96n * 60n + 60n);
+    });
+
+    it("computes total seconds in durations with fractional amounts", () => {
+      const duration = Duration.parseISO8601("PT1.5H22.005S");
+
+      strictEqual(Duration.totalSeconds(duration), 1.5 * 60 * 60 + 22 + 0.005);
+    });
+
+    it("does not allow total seconds for durations with years, months, weeks, or days", () => {
+      const durations = ["P1Y", "P1M", "P1W", "P1D"].map((iso) => Duration.parseISO8601(iso));
+
+      for (const duration of durations) {
+        throws(() => Duration.totalSeconds(duration), {
+          message:
+            "Cannot calculate total seconds for a duration with years, months, weeks, or days.",
+        });
+
+        throws(() => Duration.totalSecondsBigInt(duration), {
+          message:
+            "Cannot calculate total seconds for a duration with years, months, weeks, or days.",
+        });
+      }
+    });
+
+    it("does not allow total seconds as bigint for durations with fractional amounts", () => {
+      const durations = ["PT1.5H", "PT1.5M", "PT1.5S", "PT1H1.5M", "PT1H1.5S", "PT1M1.5S"].map(
+        (iso) => Duration.parseISO8601(iso),
+      );
+
+      for (const duration of durations) {
+        throws(() => Duration.totalSecondsBigInt(duration), {
+          message:
+            "Cannot calculate total seconds as a BigInt for a duration with non-integer components.",
+        });
+      }
+    });
+  });
+});

package/test/e2e/helpers.ts

@@ -0,0 +1,59 @@
+import { createServer, IncomingMessage, Server, ServerResponse } from "node:http";
+
+interface BasicRouter {
+  /**
+   * Dispatches the request to the appropriate service based on the request path.
+   *
+   * This member function may be used directly as a handler for a Node HTTP server.
+   *
+   * @param request - The incoming HTTP request.
+   * @param response - The outgoing HTTP response.
+   */
+  dispatch(request: IncomingMessage, response: ServerResponse): void;
+}
+
+export function startServer(router: BasicRouter, abortSignal: AbortSignal): Promise<string> {
+  return new Promise<string>((resolve, reject) => {
+    if (abortSignal.aborted) {
+      return reject(new Error("Server start cancelled"));
+    }
+    const server = createServer((req, res) => router.dispatch(req, res));
+    const stop = () => {
+      return new Promise<void>((r) => {
+        server.close(() => r);
+        server.closeAllConnections();
+      });
+    };
+    abortSignal.addEventListener("abort", () => {
+      stop().catch(() => {});
+    });
+    server.listen(function (this: Server) {
+      const address = this.address();
+      if (!address) {
+        reject(new Error("Server address not available"));
+        stop().catch(() => {});
+        return;
+      }
+
+      resolve(typeof address === "string" ? address : `http://localhost:${address.port}`);
+    });
+    server.on("error", reject);
+  });
+}
+
+/**
+ * Meant to be used for the `onInternalError` handler in the router
+ * in order to log any failed test assertions from within service handlers.
+ * Purely informational as the test will fail regardless.
+ * @param ctx The HttpContext from the http-server-js router
+ */
+function logAssertionErrors(ctx: any, error: Error): void {
+  // eslint-disable-next-line no-console
+  console.error(error);
+  ctx.response.statusCode = 599;
+  ctx.response.end();
+}
+
+export const testRouterOptions = {
+  onInternalError: logAssertionErrors,
+};

package/test/e2e/http/parameters/basic/main.test.e2e.ts

@@ -0,0 +1,36 @@
+import { deepStrictEqual } from "node:assert";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createBasicRouter } from "../../../generated/parameters/basic/src/generated/http/router.js";
+import { startServer, testRouterOptions } from "../../../helpers.js";
+import { runScenario } from "../../../spector.js";
+
+describe("Parameters.Basic", () => {
+  let serverAbortController: AbortController;
+  beforeEach(() => {
+    serverAbortController = new AbortController();
+  });
+  afterEach(() => {
+    serverAbortController.abort();
+  });
+
+  it("passes all scenarios", async () => {
+    const router = createBasicRouter(
+      {
+        async simple(ctx, body) {
+          deepStrictEqual(body, { name: "foo" });
+          return { statusCode: 204 };
+        },
+      },
+      {
+        async simple(ctx, name) {
+          deepStrictEqual(name, "foo");
+          return { statusCode: 204 };
+        },
+      },
+      testRouterOptions,
+    );
+    const baseUrl = await startServer(router, serverAbortController.signal);
+    const { status } = await runScenario("parameters/basic/**/*", baseUrl);
+    expect(status).toBe("pass");
+  });
+});

package/test/e2e/http/parameters/body-optionality/main.test.e2e.ts

@@ -0,0 +1,45 @@
+import { deepStrictEqual } from "node:assert";
+import { afterEach, assert, beforeEach, describe, expect, it } from "vitest";
+import { createBodyOptionalityRouter } from "../../../generated/parameters/body-optionality/src/generated/http/router.js";
+import { startServer, testRouterOptions } from "../../../helpers.js";
+import { runScenario } from "../../../spector.js";
+
+describe("Parameters.BodyOptionality", () => {
+  let serverAbortController: AbortController;
+  beforeEach(() => {
+    serverAbortController = new AbortController();
+  });
+  afterEach(() => {
+    serverAbortController.abort();
+  });
+
+  it("passes all scenarios", async () => {
+    const router = createBodyOptionalityRouter(
+      {
+        async requiredExplicit(ctx, body) {
+          deepStrictEqual(body, { name: "foo" });
+          return { statusCode: 204 };
+        },
+        async requiredImplicit(ctx, name) {
+          deepStrictEqual(name, "foo");
+          return { statusCode: 204 };
+        },
+      },
+      {
+        async omit(ctx, options) {
+          assert.isUndefined(options?.body);
+          return { statusCode: 204 };
+        },
+        async set(ctx, options) {
+          assert(options?.body);
+          assert.deepStrictEqual(options.body, { name: "foo" });
+          return { statusCode: 204 };
+        },
+      },
+      testRouterOptions,
+    );
+    const baseUrl = await startServer(router, serverAbortController.signal);
+    const { status } = await runScenario("parameters/body-optionality/**/*", baseUrl);
+    expect(status).toBe("pass");
+  });
+});

package/test/e2e/http/parameters/spread/main.test.e2e.ts

@@ -0,0 +1,92 @@
+import { deepStrictEqual } from "node:assert";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createSpreadRouter } from "../../../generated/parameters/spread/src/generated/http/router.js";
+import { startServer, testRouterOptions } from "../../../helpers.js";
+import { runScenario } from "../../../spector.js";
+
+describe("Parameters.Spread", () => {
+  let serverAbortController: AbortController;
+  beforeEach(() => {
+    serverAbortController = new AbortController();
+  });
+  afterEach(() => {
+    serverAbortController.abort();
+  });
+
+  it("passes all scenarios", async () => {
+    const router = createSpreadRouter(
+      {
+        async spreadAsRequestBody(ctx, name) {
+          deepStrictEqual(name, "foo");
+          return { statusCode: 204 };
+        },
+        async spreadCompositeRequest(ctx, name, testHeader, body) {
+          deepStrictEqual(name, "foo");
+          deepStrictEqual(testHeader, "bar");
+          deepStrictEqual(body, { name: "foo" });
+          return { statusCode: 204 };
+        },
+        async spreadCompositeRequestMix(ctx, name, testHeader, prop) {
+          deepStrictEqual(name, "foo");
+          deepStrictEqual(testHeader, "bar");
+          deepStrictEqual(prop, "foo");
+          return { statusCode: 204 };
+        },
+        async spreadCompositeRequestOnlyWithBody(ctx, body) {
+          deepStrictEqual(body, { name: "foo" });
+          return { statusCode: 204 };
+        },
+        async spreadCompositeRequestWithoutBody(ctx, name, testHeader) {
+          deepStrictEqual(name, "foo");
+          deepStrictEqual(testHeader, "bar");
+          return { statusCode: 204 };
+        },
+      },
+      {
+        async spreadAsRequestBody(ctx, name) {
+          deepStrictEqual(name, "foo");
+          return { statusCode: 204 };
+        },
+        async spreadAsRequestParameter(ctx, id, xMsTestHeader, name) {
+          deepStrictEqual(id, "1");
+          deepStrictEqual(xMsTestHeader, "bar");
+          deepStrictEqual(name, "foo");
+          return { statusCode: 204 };
+        },
+        async spreadParameterWithInnerAlias(ctx, id, name, age, xMsTestHeader) {
+          deepStrictEqual(id, "1");
+          deepStrictEqual(name, "foo");
+          deepStrictEqual(age, 1);
+          deepStrictEqual(xMsTestHeader, "bar");
+          return { statusCode: 204 };
+        },
+        async spreadParameterWithInnerModel(ctx, id, name, xMsTestHeader) {
+          deepStrictEqual(id, "1");
+          deepStrictEqual(name, "foo");
+          deepStrictEqual(xMsTestHeader, "bar");
+          return { statusCode: 204 };
+        },
+        async spreadWithMultipleParameters(
+          ctx,
+          id,
+          xMsTestHeader,
+          requiredString,
+          requiredIntList,
+          options,
+        ) {
+          deepStrictEqual(id, "1");
+          deepStrictEqual(xMsTestHeader, "bar");
+          deepStrictEqual(requiredString, "foo");
+          deepStrictEqual(requiredIntList, [1, 2]);
+          deepStrictEqual(options?.optionalInt, 1);
+          deepStrictEqual(options?.optionalStringList, ["foo", "bar"]);
+          return { statusCode: 204 };
+        },
+      },
+      testRouterOptions,
+    );
+    const baseUrl = await startServer(router, serverAbortController.signal);
+    const { status } = await runScenario("parameters/spread/**/*", baseUrl);
+    expect(status).toBe("pass");
+  });
+});

package/test/e2e/http/type/model/empty/main.test.e2e.ts

@@ -0,0 +1,35 @@
+import { deepStrictEqual } from "node:assert";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createEmptyRouter } from "../../../../generated/type/model/empty/src/generated/http/router.js";
+import { startServer, testRouterOptions } from "../../../../helpers.js";
+import { runScenario } from "../../../../spector.js";
+
+describe("Type.Model.Empty", () => {
+  let serverAbortController: AbortController;
+  beforeEach(() => {
+    serverAbortController = new AbortController();
+  });
+  afterEach(() => {
+    serverAbortController.abort();
+  });
+
+  it("passes all scenarios", async () => {
+    const router = createEmptyRouter(
+      {
+        async getEmpty(ctx) {
+          return { body: {} };
+        },
+        async postRoundTripEmpty(ctx, body) {
+          return { body };
+        },
+        async putEmpty(ctx, input) {
+          deepStrictEqual(input, {});
+        },
+      },
+      testRouterOptions,
+    );
+    const baseUrl = await startServer(router, serverAbortController.signal);
+    const { status } = await runScenario("type/model/empty/**/*", baseUrl);
+    expect(status).toBe("pass");
+  });
+});

package/test/e2e/spector.ts

@@ -0,0 +1,33 @@
+import { run } from "@typespec/internal-build-utils";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "pathe";
+
+// Root of `http-server-js` package so vscode test integration runs from the correct directory
+const CWD = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+export async function runScenario(
+  scenario: string,
+  baseUrl: string,
+): Promise<{ status: "pass" | "fail" }> {
+  try {
+    await run(
+      "npx",
+      [
+        "tsp-spector",
+        "knock",
+        "./node_modules/@typespec/http-specs/specs",
+        "--filter",
+        scenario,
+        "--baseUrl",
+        baseUrl,
+      ],
+      {
+        shell: true,
+        cwd: CWD,
+      },
+    );
+    return { status: "pass" };
+  } catch (e) {
+    return { status: "fail" };
+  }
+}