Use Effect OpenAPI fixtures in remaining tests

RhysSullivan · RhysSullivan · commit bcc7bc9ced98 · 2026-05-16T09:54:43.000-07:00
diff --git a/apps/cloud/src/mcp-miniflare.e2e.node.test.ts b/apps/cloud/src/mcp-miniflare.e2e.node.test.ts
@@ -24,21 +24,14 @@ import { resolve } from "node:path";
 import { createServer } from "node:http";
 import type { AddressInfo } from "node:net";
 
-import {
-  HttpApi,
-  HttpApiBuilder,
-  HttpApiEndpoint,
-  HttpApiGroup,
-  OpenApi,
-} from "effect/unstable/httpapi";
-import { HttpRouter, HttpServer } from "effect/unstable/http";
-import * as NodeHttpServer from "@effect/platform-node/NodeHttpServer";
-import { Context, Data, Effect, Layer, Option, Predicate, Schema } from "effect";
+import { HttpApi, HttpApiBuilder, HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { Context, Data, Effect, Exit, Layer, Option, Schema, Scope } from "effect";
 
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { ElicitRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { unstable_dev, type Unstable_DevWorker } from "wrangler";
+import { serveOpenApiHttpApiTestServer } from "@executor-js/plugin-openapi/testing";
 
 import { makeTestBearer } from "./test-bearer";
 
@@ -64,22 +57,13 @@ const ApproveHandlers = HttpApiBuilder.group(UpstreamApi, "approve", (h) =>
   h.handle("approveThing", () => Effect.succeed(ApprovedResponse.make({ approved: true }))),
 );
 
-const UpstreamApiLive = HttpApiBuilder.layer(UpstreamApi).pipe(Layer.provide(ApproveHandlers));
-
-const UpstreamServeLayer = HttpRouter.serve(UpstreamApiLive).pipe(
-  Layer.provide(UpstreamApiLive),
-  Layer.provideMerge(HttpRouter.layer),
-  Layer.provideMerge(NodeHttpServer.layer(() => createServer(), { port: 0, host: "127.0.0.1" })),
-);
-
 // ---------------------------------------------------------------------------
 // Services
 // ---------------------------------------------------------------------------
 
-class Upstream extends Context.Service<
-  Upstream,
-  { readonly specJson: string; readonly url: string }
->()("MiniflareE2E/Upstream") {}
+class Upstream extends Context.Service<Upstream, { readonly specJson: string }>()(
+  "MiniflareE2E/Upstream",
+) {}
 
 class Worker extends Context.Service<
   Worker,
@@ -116,23 +100,18 @@ class MiniflareE2ETestError extends Data.TaggedError("MiniflareE2ETestError")<{
 
 const UpstreamLive = Layer.effect(
   Upstream,
-  Effect.gen(function* () {
-    const server = yield* HttpServer.HttpServer;
-    const addr = server.address;
-    if (!Predicate.isTagged("TcpAddress")(addr)) {
-      return yield* new MiniflareE2ETestError({
-        message: "upstream server bound to non-TCP address",
-        cause: addr,
-      });
-    }
-    const url = `http://127.0.0.1:${addr.port}`;
-    const specJson = JSON.stringify({
-      ...OpenApi.fromApi(UpstreamApi),
-      servers: [{ url }],
-    });
-    return { specJson, url };
-  }),
-).pipe(Layer.provide(UpstreamServeLayer));
+  Effect.acquireRelease(
+    Effect.gen(function* () {
+      const scope = yield* Scope.make();
+      const server = yield* serveOpenApiHttpApiTestServer({
+        api: UpstreamApi,
+        handlersLayer: ApproveHandlers,
+      }).pipe(Scope.provide(scope));
+      return { server, scope };
+    }),
+    ({ scope }) => Scope.close(scope, Exit.void),
+  ).pipe(Effect.map(({ server }) => ({ specJson: server.specJson }))),
+);
 
 // ---------------------------------------------------------------------------
 // Telemetry receiver — a node HTTP server on a random port that speaks
diff --git a/apps/cloud/src/services/tenant-isolation.node.test.ts b/apps/cloud/src/services/tenant-isolation.node.test.ts
@@ -3,24 +3,22 @@
 // on the full cloud module graph.
 
 import { describe, expect, it } from "@effect/vitest";
-import { Effect, Result } from "effect";
+import { Effect, Result, Schema } from "effect";
+import { HttpApi, HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
 
 import { ConnectionId, ScopeId, SecretId } from "@executor-js/sdk";
 
 import { asOrg } from "./__test-harness__/api-harness";
 
-const MINIMAL_OPENAPI_SPEC = JSON.stringify({
-  openapi: "3.0.0",
-  info: { title: "Tenant Test API", version: "1.0.0" },
-  paths: {
-    "/ping": {
-      get: {
-        operationId: "ping",
-        responses: { "200": { description: "ok" } },
-      },
-    },
-  },
-});
+const PingGroup = HttpApiGroup.make("default", { topLevel: true }).add(
+  HttpApiEndpoint.get("ping", "/ping", { success: Schema.Unknown }),
+);
+
+const TenantIsolationApi = HttpApi.make("tenantIsolationTest")
+  .add(PingGroup)
+  .annotateMerge(OpenApi.annotations({ title: "Tenant Test API", version: "1.0.0" }));
+
+const MINIMAL_OPENAPI_SPEC = JSON.stringify(OpenApi.fromApi(TenantIsolationApi));
 
 describe("tenant isolation (HTTP)", () => {
   it.effect("write requests cannot target another org scope", () =>
diff --git a/packages/plugins/openapi/src/sdk/index.test.ts b/packages/plugins/openapi/src/sdk/index.test.ts
@@ -41,6 +41,36 @@ const PetstoreApi = HttpApi.make("petstore").add(PetstoreGroup);
 // Generate OpenAPI spec from the Effect API definition
 const spec = OpenApi.fromApi(PetstoreApi);
 
+type TestOpenApiServer = {
+  readonly url: string;
+  readonly description?: string;
+  readonly variables?: Record<
+    string,
+    {
+      readonly default: string;
+      readonly enum?: [string, ...string[]];
+      readonly description?: string;
+    }
+  >;
+};
+
+const pingSpecWithServers = (title: string, servers: readonly TestOpenApiServer[]) =>
+  OpenApi.fromApi(
+    HttpApi.make("serverVariablesTest")
+      .add(
+        HttpApiGroup.make("default", { topLevel: true }).add(
+          HttpApiEndpoint.get("ping", "/ping", { success: Schema.Unknown }),
+        ),
+      )
+      .annotateMerge(
+        OpenApi.annotations({
+          title,
+          version: "1.0.0",
+          servers,
+        }),
+      ),
+  );
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -165,26 +195,19 @@ describe("OpenAPI plugin", () => {
 
   it.effect("extracts server variables with enum and description", () =>
     Effect.gen(function* () {
-      const specWithServerVars = {
-        openapi: "3.0.0",
-        info: { title: "Sentry", version: "1.0.0" },
-        servers: [
-          {
-            url: "https://{region}.sentry.io",
-            description: "Regional endpoint",
-            variables: {
-              region: {
-                default: "us",
-                description: "The data-storage-location for an organization",
-                enum: ["us", "de"],
-              },
+      const specWithServerVars = pingSpecWithServers("Sentry", [
+        {
+          url: "https://{region}.sentry.io",
+          description: "Regional endpoint",
+          variables: {
+            region: {
+              default: "us",
+              description: "The data-storage-location for an organization",
+              enum: ["us", "de"],
             },
           },
-        ],
-        paths: {
-          "/ping": { get: { responses: { "200": { description: "ok" } } } },
         },
-      };
+      ]);
       // @effect-diagnostics-next-line preferSchemaOverJson:off
       const doc = yield* parse(JSON.stringify(specWithServerVars));
       const result = yield* extract(doc);
@@ -212,27 +235,20 @@ describe("OpenAPI plugin", () => {
 // ---------------------------------------------------------------------------
 
 describe("extract — server variables", () => {
-  const specWithServerVars = {
-    openapi: "3.0.0",
-    info: { title: "Test", version: "1.0.0" },
-    servers: [
-      {
-        url: "https://{region}.example.com/{basePath}",
-        description: "Regional endpoint",
-        variables: {
-          region: {
-            default: "us",
-            enum: ["us", "eu", "ap"],
-            description: "Data region",
-          },
-          basePath: { default: "v1" },
+  const specWithServerVars = pingSpecWithServers("Test", [
+    {
+      url: "https://{region}.example.com/{basePath}",
+      description: "Regional endpoint",
+      variables: {
+        region: {
+          default: "us",
+          enum: ["us", "eu", "ap"],
+          description: "Data region",
         },
+        basePath: { default: "v1" },
       },
-    ],
-    paths: {
-      "/ping": { get: { responses: { "200": { description: "ok" } } } },
     },
-  };
+  ]);
 
   it.effect("preserves enum, default, and description for server variables", () =>
     Effect.gen(function* () {
diff --git a/packages/plugins/openapi/src/sdk/preview-oauth2.test.ts b/packages/plugins/openapi/src/sdk/preview-oauth2.test.ts
@@ -8,28 +8,43 @@
 // ---------------------------------------------------------------------------
 
 import { describe, expect, it } from "@effect/vitest";
-import { Effect, Option } from "effect";
+import { Effect, Option, Schema } from "effect";
 import { FetchHttpClient } from "effect/unstable/http";
+import { HttpApi, HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
 
 import { previewSpec as previewSpecRaw } from "./preview";
 
 const previewSpec = (input: string) =>
   previewSpecRaw(input).pipe(Effect.provide(FetchHttpClient.layer));
 
+const PreviewGroup = HttpApiGroup.make("default", { topLevel: true }).add(
+  HttpApiEndpoint.get("ping", "/ping", { success: Schema.Unknown }),
+);
+
+const PreviewApi = HttpApi.make("previewOauth2Test")
+  .add(PreviewGroup)
+  .annotateMerge(
+    OpenApi.annotations({
+      title: "Test API",
+      version: "1.0.0",
+      servers: [{ url: "https://api.example.com" }],
+    }),
+  );
+
 const minimalSpec = (
   securitySchemes: Record<string, unknown>,
   components: Record<string, unknown> = {},
-) => ({
-  openapi: "3.0.0",
-  info: { title: "Test API", version: "1.0.0" },
-  servers: [{ url: "https://api.example.com" }],
-  paths: {
-    "/ping": {
-      get: { responses: { "200": { description: "ok" } } },
-    },
-  },
-  components: { ...components, securitySchemes },
-});
+) =>
+  OpenApi.fromApi(
+    PreviewApi.annotateMerge(
+      OpenApi.annotations({
+        transform: (spec) => ({
+          ...spec,
+          components: { ...components, securitySchemes },
+        }),
+      }),
+    ),
+  );
 
 describe("previewSpec OAuth2 extraction", () => {
   it.effect("extracts authorizationCode flow with URLs, scopes, refreshUrl", () =>
@@ -139,37 +154,17 @@ describe("previewSpec OAuth2 extraction", () => {
 
   it.effect("resolves security schemes defined via $ref", () =>
     Effect.gen(function* () {
-      const spec = minimalSpec(
-        {
-          api_token: { $ref: "#/components/securitySchemes/_api_token_impl" },
-        },
-        {
-          securitySchemes: {
-            _api_token_impl: {
-              type: "http",
-              scheme: "bearer",
-              bearerFormat: "JWT",
-              description: "Internal token scheme",
-            },
-          },
-        },
-      );
-      // Note: the outer securitySchemes at `components.securitySchemes` is
-      // what previewSpec reads; the `_api_token_impl` shim inside
-      // components.securitySchemes allows $ref resolution via the resolver.
-      // The test spec above is slightly awkward because we have to nest both
-      // under the same key — adjust by merging.
-      spec.components = {
-        securitySchemes: {
-          api_token: { $ref: "#/components/securitySchemes/_api_token_impl" },
-          _api_token_impl: {
-            type: "http",
-            scheme: "bearer",
-            bearerFormat: "JWT",
-            description: "Internal token scheme",
-          },
+      const spec = minimalSpec({
+        api_token: { $ref: "#/components/securitySchemes/_api_token_impl" },
+        _api_token_impl: {
+          type: "http",
+          scheme: "bearer",
+          bearerFormat: "JWT",
+          description: "Internal token scheme",
         },
-      };
+      });
+      // Note: `api_token` should resolve through the sibling
+      // `_api_token_impl` scheme in `components.securitySchemes`.
 
       const preview = yield* previewSpec(JSON.stringify(spec));
       // Both keys are present, but the `api_token` entry should resolve to
@@ -181,7 +176,6 @@ describe("previewSpec OAuth2 extraction", () => {
       expect(Option.getOrElse(apiToken!.bearerFormat, () => "")).toBe("JWT");
     }),
   );
-
   it.effect("captures openIdConnectUrl for openIdConnect schemes", () =>
     Effect.gen(function* () {
       const spec = minimalSpec({
