@typespec/spector 0.1.0-alpha.2-dev.2 → 0.1.0-alpha.20-dev.0

package/src/app/app.ts

@@ -1,4 +1,13 @@
-import { MockApiDefinition, MockRequest, RequestExt, ScenarioMockApi } from "@typespec/spec-api";
+import {
+  expandDyns,
+  MockApiDefinition,
+  MockBody,
+  MockMultipartBody,
+  MockRequest,
+  RequestExt,
+  ResolverConfig,
+  ScenarioMockApi,
+} from "@typespec/spec-api";
 import { ScenariosMetadata } from "@typespec/spec-coverage-sdk";
 import { Response, Router } from "express";
 import { getScenarioMetadata } from "../coverage/common.js";
@@ -19,6 +28,7 @@ export class MockApiApp {
   private router = Router();
   private server: MockApiServer;
   private coverageTracker: CoverageTracker;
+  private resolverConfig!: ResolverConfig;
 
   constructor(private config: ApiMockAppConfig) {
     this.server = new MockApiServer({ port: config.port });
@@ -54,79 +64,77 @@ export class MockApiApp {
     });
 
     this.server.use("/", this.router);
-    this.server.start();
+    // Getting the resolved port as setting 0 in the config will have express resolve on of the available ports
+    const port = await this.server.start();
+    this.resolverConfig = {
+      baseUrl: `http://localhost:${port}`,
+    };
   }
 
   private registerScenario(name: string, scenario: ScenarioMockApi) {
     for (const endpoint of scenario.apis) {
-      if (endpoint.kind !== "MockApiDefinition") {
-        this.router.route(endpoint.uri)[endpoint.method]((req: RequestExt, res: Response) => {
-          processRequest(
-            this.coverageTracker,
-            name,
-            endpoint.uri,
-            req,
-            res,
-            endpoint.handler,
-          ).catch((e) => {
-            logger.error("Unexpected request error", e);
-            res.status(500).end();
-          });
-        });
-      } else {
-        if (!endpoint.handler) {
-          endpoint.handler = createHandler(endpoint);
-        }
-        this.router.route(endpoint.uri)[endpoint.method]((req: RequestExt, res: Response) => {
-          processRequest(
-            this.coverageTracker,
-            name,
-            endpoint.uri,
-            req,
-            res,
-            endpoint.handler!,
-          ).catch((e) => {
-            logger.error("Unexpected request error", e);
-            res.status(500).end();
-          });
-        });
+      if (!endpoint.handler) {
+        endpoint.handler = createHandler(endpoint, this.resolverConfig);
       }
+      this.router.route(endpoint.uri)[endpoint.method]((req: RequestExt, res: Response) => {
+        processRequest(
+          this.coverageTracker,
+          name,
+          endpoint.uri,
+          req,
+          res,
+          endpoint.handler!,
+          this.resolverConfig,
+        ).catch((e) => {
+          logger.error("Unexpected request error", e);
+          res.status(500).end();
+        });
+      });
     }
   }
 }
 
-function isObject(value: any): boolean {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function validateBody(
+  req: MockRequest,
+  body: MockBody | MockMultipartBody,
+  config: ResolverConfig,
+) {
+  if ("kind" in body) {
+    // custom handler for now.
+  } else {
+    if (Buffer.isBuffer(body.rawContent)) {
+      req.expect.rawBodyEquals(body.rawContent);
+    } else {
+      const raw =
+        typeof body.rawContent === "string" ? body.rawContent : body.rawContent?.serialize(config);
+      switch (body.contentType) {
+        case "application/json":
+          req.expect.coercedBodyEquals(JSON.parse(raw as any));
+          break;
+        case "application/xml":
+          req.expect.xmlBodyEquals(
+            (raw as any).replace(`<?xml version='1.0' encoding='UTF-8'?>`, ""),
+          );
+          break;
+        default:
+          req.expect.rawBodyEquals(raw);
+      }
+    }
+  }
 }
 
-function createHandler(apiDefinition: MockApiDefinition) {
+function createHandler(apiDefinition: MockApiDefinition, config: ResolverConfig) {
   return (req: MockRequest) => {
+    const body = apiDefinition.request?.body;
     // Validate body if present in the request
-    if (apiDefinition.request.body) {
-      if (
-        apiDefinition.request.headers &&
-        apiDefinition.request.headers["Content-Type"] === "application/xml"
-      ) {
-        req.expect.xmlBodyEquals(
-          apiDefinition.request.body.rawContent.replace(
-            `<?xml version='1.0' encoding='UTF-8'?>`,
-            "",
-          ),
-        );
-      } else {
-        if (isObject(apiDefinition.request.body)) {
-          Object.entries(apiDefinition.request.body).forEach(([key, value]) => {
-            req.expect.deepEqual(req.body[key], value);
-          });
-        } else {
-          req.expect.coercedBodyEquals(apiDefinition.request.body);
-        }
-      }
+    if (body) {
+      validateBody(req, body, config);
     }
 
     // Validate headers if present in the request
-    if (apiDefinition.request.headers) {
-      Object.entries(apiDefinition.request.headers).forEach(([key, value]) => {
+    if (apiDefinition.request?.headers) {
+      const headers = expandDyns(apiDefinition.request.headers, config);
+      Object.entries(headers).forEach(([key, value]) => {
         if (key.toLowerCase() !== "content-type") {
           if (Array.isArray(value)) {
             req.expect.deepEqual(req.headers[key], value);
@@ -137,21 +145,12 @@ function createHandler(apiDefinition: MockApiDefinition) {
       });
     }
 
-    // Validate query params if present in the request
-    if (apiDefinition.request.params) {
-      Object.entries(apiDefinition.request.params).forEach(([key, value]) => {
-        if (!req.query[key]) {
-          if (Array.isArray(value)) {
-            req.expect.deepEqual(req.params[key], value);
-          } else {
-            req.expect.deepEqual(req.params[key], String(value));
-          }
+    if (apiDefinition.request?.query) {
+      Object.entries(apiDefinition.request.query).forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+          req.expect.deepEqual(req.query[key], value);
         } else {
-          if (Array.isArray(value)) {
-            req.expect.deepEqual(req.query[key], value);
-          } else {
-            req.expect.containsQueryParam(key, String(value));
-          }
+          req.expect.containsQueryParam(key, String(value));
         }
       });
     }

package/src/app/request-processor.ts

@@ -1,8 +1,10 @@
 import {
+  expandDyns,
   MockRequest,
   MockRequestHandler,
   MockResponse,
   RequestExt,
+  ResolverConfig,
   ValidationError,
 } from "@typespec/spec-api";
 import { Response } from "express";
@@ -17,6 +19,7 @@ export async function processRequest(
   request: RequestExt,
   response: Response,
   func: MockRequestHandler,
+  resolverConfig: ResolverConfig,
 ): Promise<void> {
   const mockRequest = new MockRequest(request);
   const mockResponse = await callHandler(mockRequest, response, func);
@@ -25,18 +28,27 @@ export async function processRequest(
   }
 
   await coverageTracker.trackEndpointResponse(scenarioName, scenarioUri, mockResponse);
-  processResponse(response, mockResponse);
+  processResponse(response, mockResponse, resolverConfig);
 }
 
-const processResponse = (response: Response, mockResponse: MockResponse) => {
+const processResponse = (
+  response: Response,
+  mockResponse: MockResponse,
+  resolverConfig: ResolverConfig,
+) => {
   response.status(mockResponse.status);
 
   if (mockResponse.headers) {
-    response.set(mockResponse.headers);
+    response.set(expandDyns(mockResponse.headers, resolverConfig));
   }
 
   if (mockResponse.body) {
-    response.contentType(mockResponse.body.contentType).send(mockResponse.body.rawContent);
+    const raw =
+      typeof mockResponse.body.rawContent === "string" ||
+      Buffer.isBuffer(mockResponse.body.rawContent)
+        ? mockResponse.body.rawContent
+        : mockResponse.body.rawContent?.serialize(resolverConfig);
+    response.contentType(mockResponse.body.contentType).send(raw);
   }
 
   response.end();

package/src/cli/cli.ts

@@ -92,13 +92,14 @@ async function main() {
     .command("server", "Server management", (cmd) => {
       cmd
         .command(
-          "start <scenariosPath>",
+          "start <scenariosPaths..>",
           "Start the server in the background.",
           (cmd) => {
             return cmd
-              .positional("scenariosPath", {
-                description: "Path to the scenarios and mock apis",
+              .positional("scenariosPaths", {
+                description: "Path(s) to the scenarios and mock apis",
                 type: "string",
+                array: true,
                 demandOption: true,
               })
               .option("port", {
@@ -115,7 +116,7 @@ async function main() {
           },
           async (args) =>
             startInBackground({
-              scenariosPath: resolve(process.cwd(), args.scenariosPath),
+              scenariosPath: args.scenariosPaths,
               port: args.port,
               coverageFile: args.coverageFile,
             }),
@@ -166,7 +167,7 @@ async function main() {
       },
     )
     .command(
-      "server-test <scenariosPaths..>",
+      "knock <scenariosPaths..>",
       "Executes the test cases against the service",
       (cmd) => {
         return cmd
@@ -180,23 +181,18 @@ async function main() {
             description: "Path to the server",
             type: "string",
           })
-          .option("runSingleScenario", {
-            description: "Single Scenario Case to run",
+          .option("filter", {
+            description: "Glob filter of scenario to run",
             type: "string",
           })
-          .option("runScenariosFromFile", {
-            description: "File that has the Scenarios to run",
-            type: "string",
-          })
-          .demandOption("scenariosPaths", "serverBasePath");
+          .demandOption("scenariosPaths");
       },
       async (args) => {
         for (const scenariosPath of args.scenariosPaths) {
           logger.info(`Executing server tests for scenarios at ${scenariosPath}`);
           await serverTest(scenariosPath, {
             baseUrl: args.baseUrl,
-            runSingleScenario: args.runSingleScenario,
-            runScenariosFromFile: args.runScenariosFromFile,
+            filter: args.filter,
           });
         }
       },
@@ -287,20 +283,30 @@ async function main() {
             array: true,
             demandOption: true,
           })
+          .option("setName", {
+            type: "string",
+            description: "Set used to generate the manifest.",
+            array: true,
+            demandOption: true,
+          })
           .option("storageAccountName", {
             type: "string",
             description: "Name of the storage account",
           })
+          .option("containerName", {
+            type: "string",
+            description: "Name of the Container",
+            demandOption: true,
+          })
           .demandOption("storageAccountName");
       },
       async (args) => {
-        for (const scenariosPath of args.scenariosPaths) {
-          logger.info(`Uploading scenario manifest for scenarios at ${scenariosPath}`);
-          await uploadScenarioManifest({
-            scenariosPath: resolve(process.cwd(), scenariosPath),
-            storageAccountName: args.storageAccountName,
-          });
-        }
+        await uploadScenarioManifest({
+          scenariosPaths: args.scenariosPaths,
+          storageAccountName: args.storageAccountName,
+          setNames: args.setName,
+          containerName: args.containerName,
+        });
       },
     )
     .command(
@@ -339,6 +345,11 @@ async function main() {
             type: "string",
             description: "Mode of generator to upload.",
           })
+          .option("containerName", {
+            type: "string",
+            description: "Name of the Container",
+            demandOption: true,
+          })
           .demandOption("generatorMode");
       },
       async (args) => {
@@ -349,6 +360,7 @@ async function main() {
           generatorVersion: args.generatorVersion,
           generatorCommit: args.generatorCommit ?? getCommit(process.cwd()),
           generatorMode: args.generatorMode,
+          containerName: args.containerName,
         });
       },
     )

package/src/coverage/common.ts

@@ -6,5 +6,6 @@ export async function getScenarioMetadata(scenariosPath: string): Promise<Scenar
   return {
     commit: getCommit(scenariosPath),
     version: pkg?.version ?? "?",
+    packageName: pkg?.name ?? "@typespec/http-specs",
   };
 }

package/src/coverage/coverage-tracker.ts

@@ -1,4 +1,4 @@
-import { Fail, KeyedMockResponse, MockResponse, PassByKeyScenario, PassByServiceKeyScenario, ScenarioMockApi } from "@typespec/spec-api";
+import { Fail, KeyedMockResponse, MockResponse, PassByKeyScenario,  ScenarioMockApi } from "@typespec/spec-api";
 import { logger } from "../logger.js";
 import { CoverageReport, ScenariosMetadata, ScenarioStatus } from "@typespec/spec-coverage-sdk";
 import { writeFileSync } from "fs";
@@ -106,7 +106,7 @@ export class CoverageTracker {
       return "pass";
     }
 
-    function checkByKeys(scenario: PassByKeyScenario | PassByServiceKeyScenario) {
+    function checkByKeys(scenario: PassByKeyScenario) {
       for (const endpoint of scenario.apis) {
         const hits = scenarioHits?.get(endpoint.uri);
         if (hits === undefined) {

package/src/coverage/scenario-manifest.ts

@@ -1,13 +1,14 @@
 import { loadScenarios } from "../scenarios-resolver.js";
 import { Diagnostic } from "../utils/diagnostic-reporter.js";
 import { getCommit, getPackageJson } from "../utils/misc-utils.js";
-import { ScenarioLocation, ScenarioManifest, GeneratorMode } from "@typespec/spec-coverage-sdk";
+import { ScenarioLocation, ScenarioManifest } from "@typespec/spec-coverage-sdk";
 import { getSourceLocation, normalizePath } from "@typespec/compiler";
 import { relative } from "path";
 import type { Scenario } from "../lib/decorators.js";
 
 export async function computeScenarioManifest(
   scenariosPath: string,
+  setName: string
 ): Promise<[ScenarioManifest | undefined, readonly Diagnostic[]]> {
   const [scenarios, diagnostics] = await loadScenarios(scenariosPath);
   if (diagnostics.length > 0) {
@@ -16,7 +17,7 @@ export async function computeScenarioManifest(
 
   const commit = getCommit(scenariosPath);
   const pkg = await getPackageJson(scenariosPath);
-  return [createScenarioManifest(scenariosPath, pkg?.version ?? "?", commit, scenarios), []];
+  return [createScenarioManifest(scenariosPath, pkg?.version ?? "?", commit, scenarios, setName), []];
 }
 
 export function createScenarioManifest(
@@ -24,6 +25,7 @@ export function createScenarioManifest(
   version: string,
   commit: string,
   scenarios: Scenario[],
+  setName: string
 ): ScenarioManifest {
   const sortedScenarios = [...scenarios].sort((a, b) => a.name.localeCompare(b.name));
   return {
@@ -38,6 +40,6 @@ export function createScenarioManifest(
       };
       return { name, scenarioDoc, location };
     }),
-    modes: GeneratorMode,
+    setName
   };
 }

package/src/lib/decorators.ts

@@ -50,10 +50,8 @@ export const $scenarioService: ScenarioServiceDecorator = (context, target, rout
     kind: "Model",
     properties,
     decorators: [],
-    projections: [],
     name: "Service",
     derivedModels: [],
-    projectionsByName: [],
   } as any);
   context.call($server, target, "http://localhost:3000", "TestServer endpoint");
   context.call($route, target, route);

package/src/logger.ts

@@ -1,10 +1,41 @@
-import winston from "winston";
+/* eslint-disable no-console */
+import pc from "picocolors";
 
-export const logger = winston.createLogger({
+const levels = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 30,
+};
+
+type Level = keyof typeof levels;
+const levelDisplay: Record<Level, string> = {
+  debug: pc.blue("debug"),
+  info: pc.green("info"),
+  warn: pc.yellow("warn"),
+  error: pc.red("error"),
+};
+
+interface Logger {
+  level: Level;
+  debug: (message: string, ...data: unknown[]) => void;
+  info: (message: string, ...data: unknown[]) => void;
+  warn: (message: string, ...data: unknown[]) => void;
+  error: (message: string, ...data: unknown[]) => void;
+}
+
+export const logger: Logger = {
   level: "info",
-  transports: [
-    new winston.transports.Console({
-      format: winston.format.combine(winston.format.colorize(), winston.format.simple()),
-    }),
-  ],
-});
+  debug: log("debug"),
+  info: log("info"),
+  warn: log("warn"),
+  error: log("error"),
+};
+
+function log(level: Level) {
+  return (message: string, ...data: unknown[]) => {
+    if (levels[level] >= levels[logger.level]) {
+      console.log(levelDisplay[level], message, ...data);
+    }
+  };
+}

package/src/scenarios-resolver.ts

@@ -1,4 +1,4 @@
-import { Operation } from "@typespec/compiler";
+import type { Operation } from "@typespec/compiler";
 import { isSharedRoute } from "@typespec/http";
 import { ScenarioMockApi } from "@typespec/spec-api";
 import { dirname, join, relative, resolve } from "path";

package/src/server/server.ts

@@ -70,30 +70,44 @@ export class MockApiServer {
     this.app.use(bodyParser.text({ type: "text/plain" }));
     this.app.use(
       bodyParser.raw({
-        type: ["application/octet-stream", "image/png"],
+        type: ["application/octet-stream", "image/png", "application/jsonl"],
         limit: "10mb",
         verify: rawBinaryBodySaver,
       }),
     );
-    this.app.use(multer().any());
+    this.app.use(multer().any() as any);
   }
 
   public use(route: string, ...handlers: RequestHandler[]): void {
     this.app.use(route, ...handlers);
   }
 
-  public start(): void {
+  public start(): Promise<number> {
     this.app.use(errorHandler);
 
-    const server = this.app.listen(this.config.port, () => {
-      logger.info(`Started server on ${getAddress(server)}`);
+    return new Promise((resolve, reject) => {
+      const server = this.app.listen(this.config.port, () => {
+        const resolvedPort = getPort(server);
+        if (!resolvedPort) {
+          logger.error("Failed to resolve port");
+          reject(new Error("Failed to resolve port"));
+          return;
+        }
+        logger.info(`Started server on ${resolvedPort}`);
+        resolve(resolvedPort);
+      });
+
+      server.on("error", (err) => {
+        logger.error("Error starting server", err);
+        reject(err);
+      });
     });
   }
 }
 
 export type ServerRequestHandler = (request: RequestExt, response: Response) => void;
 
-const getAddress = (server: Server): string => {
+const getPort = (server: Server): number | undefined | null => {
   const address = server?.address();
-  return typeof address === "string" ? "pipe " + address : "port " + address?.port;
+  return typeof address === "string" ? null : address?.port;
 };