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

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,
           });
         }
       },
@@ -290,19 +286,26 @@ async function main() {
           .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) => {
         await uploadScenarioManifest({
           scenariosPaths: args.scenariosPaths,
           storageAccountName: args.storageAccountName,
-          setName: args.setName,
+          setNames: args.setName,
+          containerName: args.containerName,
         });
       },
     )
@@ -342,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) => {
@@ -352,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/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;
 };