New testing framework

.chronus/changes/tester-v2-2025-4-14-20-23-17.md

@@ -0,0 +1,8 @@
+---
+# Change versionKind to one of: internal, fix, dependencies, feature, deprecation, breaking
+changeKind: feature
+packages:
+  - "@typespec/compiler"
+---
+
+[API] Addition of a new testing framework. See https://typespec.io/docs/extending-typespec/testing

.chronus/changes/tester-v2-2025-4-15-17-52-11.md

@@ -0,0 +1,15 @@
+---
+# Change versionKind to one of: internal, fix, dependencies, feature, deprecation, breaking
+changeKind: internal
+packages:
+  - "@typespec/http"
+  - "@typespec/openapi"
+  - "@typespec/openapi3"
+  - "@typespec/rest"
+  - "@typespec/sse"
+  - "@typespec/streams"
+  - "@typespec/versioning"
+  - "@typespec/xml"
+---
+
+Migrated to new tester

packages/compiler/src/testing/fourslash.ts

@@ -0,0 +1,26 @@
+/**
+ * PositionedMarker represents a marker in the code with its name and position.
+ */
+export interface PositionedMarker {
+  /** Marker name */
+  readonly name: string;
+  /** Position of the marker */
+  readonly pos: number;
+}
+
+/**
+ * Extract TypeScript fourslash-style markers: /\*markerName*\/
+ * @param code
+ * @returns  an array of Marker objects with name, pos, and end
+ */
+export function extractMarkers(code: string): PositionedMarker[] {
+  const markerRegex = /\/\*([a-zA-Z0-9_]+)\*\//g;
+  const markers: PositionedMarker[] = [];
+  let match: RegExpExecArray | null;
+  while ((match = markerRegex.exec(code)) !== null) {
+    const markerName = match[1];
+    const pos = markerRegex.lastIndex;
+    markers.push({ name: markerName, pos });
+  }
+  return markers;
+}

packages/compiler/src/testing/fs.ts

@@ -0,0 +1,156 @@
+import { readdir, readFile, stat } from "fs/promises";
+import { join } from "path";
+import { pathToFileURL } from "url";
+import { getAnyExtensionFromPath, resolvePath } from "../core/path-utils.js";
+import { createStringMap } from "../utils/misc.js";
+import { createTestCompilerHost, TestHostOptions } from "./test-compiler-host.js";
+import { findFilesFromPattern } from "./test-host.js";
+import type { JsFile, MockFile, TestFileSystem, TypeSpecTestLibrary } from "./types.js";
+
+export function resolveVirtualPath(path: string, ...paths: string[]) {
+  // NB: We should always resolve an absolute path, and there is no absolute
+  // path that works across OSes. This ensures that we can still rely on API
+  // like pathToFileURL in tests.
+  const rootDir = process.platform === "win32" ? "Z:/test" : "/test";
+  return resolvePath(rootDir, path, ...paths);
+}
+
+/**
+ * Constructor for various mock files.
+ */
+export const mockFile = {
+  /** Define a JS file with the given named exports */
+  js: (exports: Record<string, unknown>): JsFile => {
+    return { kind: "js", exports };
+  },
+};
+
+export function createTestFileSystem(options?: TestHostOptions): TestFileSystem {
+  const virtualFs = createStringMap<string>(!!options?.caseInsensitiveFileSystem);
+  const jsImports = createStringMap<Promise<any>>(!!options?.caseInsensitiveFileSystem);
+  return createTestFileSystemInternal(virtualFs, jsImports, options);
+}
+
+function createTestFileSystemInternal(
+  virtualFs: Map<string, string>,
+  jsImports: Map<string, Record<string, any>>,
+  options?: TestHostOptions,
+): TestFileSystem {
+  const compilerHost = createTestCompilerHost(virtualFs, jsImports, options);
+
+  let frozen = false;
+  return {
+    add,
+    addTypeSpecFile,
+    addJsFile,
+    addRealTypeSpecFile,
+    addRealJsFile,
+    addRealFolder,
+    addTypeSpecLibrary,
+    fs: virtualFs,
+    compilerHost,
+    freeze,
+    clone,
+  };
+
+  function assertNotFrozen() {
+    if (frozen) {
+      throw new Error("Cannot modify the file system after it has been frozen.");
+    }
+  }
+
+  function add(path: string, contents: MockFile) {
+    assertNotFrozen();
+    if (typeof contents === "string") {
+      addRaw(path, contents);
+    } else {
+      addJsFile(path, contents.exports);
+    }
+  }
+
+  function addRaw(path: string, contents: string) {
+    assertNotFrozen();
+    virtualFs.set(resolveVirtualPath(path), contents);
+  }
+
+  function addJsFile(path: string, contents: Record<string, any>) {
+    assertNotFrozen();
+
+    const key = resolveVirtualPath(path);
+    virtualFs.set(key, ""); // don't need contents
+    jsImports.set(key, new Promise((r) => r(contents)));
+  }
+
+  function addTypeSpecFile(path: string, contents: string) {
+    assertNotFrozen();
+    virtualFs.set(resolveVirtualPath(path), contents);
+  }
+
+  async function addRealTypeSpecFile(path: string, existingPath: string) {
+    assertNotFrozen();
+
+    virtualFs.set(resolveVirtualPath(path), await readFile(existingPath, "utf8"));
+  }
+
+  async function addRealFolder(folder: string, existingFolder: string) {
+    assertNotFrozen();
+
+    const entries = await readdir(existingFolder);
+    for (const entry of entries) {
+      const existingPath = join(existingFolder, entry);
+      const virtualPath = join(folder, entry);
+      const s = await stat(existingPath);
+      if (s.isFile()) {
+        if (existingPath.endsWith(".js")) {
+          await addRealJsFile(virtualPath, existingPath);
+        } else {
+          await addRealTypeSpecFile(virtualPath, existingPath);
+        }
+      }
+      if (s.isDirectory()) {
+        await addRealFolder(virtualPath, existingPath);
+      }
+    }
+  }
+
+  async function addRealJsFile(path: string, existingPath: string) {
+    assertNotFrozen();
+
+    const key = resolveVirtualPath(path);
+    const exports = await import(pathToFileURL(existingPath).href);
+
+    virtualFs.set(key, "");
+    jsImports.set(key, exports);
+  }
+
+  async function addTypeSpecLibrary(testLibrary: TypeSpecTestLibrary) {
+    assertNotFrozen();
+
+    for (const { realDir, pattern, virtualPath } of testLibrary.files) {
+      const lookupDir = resolvePath(testLibrary.packageRoot, realDir);
+      const entries = await findFilesFromPattern(lookupDir, pattern);
+      for (const entry of entries) {
+        const fileRealPath = resolvePath(lookupDir, entry);
+        const fileVirtualPath = resolveVirtualPath(virtualPath, entry);
+        switch (getAnyExtensionFromPath(fileRealPath)) {
+          case ".tsp":
+          case ".json":
+            const contents = await readFile(fileRealPath, "utf-8");
+            addTypeSpecFile(fileVirtualPath, contents);
+            break;
+          case ".js":
+          case ".mjs":
+            await addRealJsFile(fileVirtualPath, fileRealPath);
+            break;
+        }
+      }
+    }
+  }
+  function freeze() {
+    frozen = true;
+  }
+
+  function clone() {
+    return createTestFileSystemInternal(new Map(virtualFs), new Map(jsImports), options);
+  }
+}

packages/compiler/src/testing/index.ts

@@ -1,20 +1,21 @@
+export {
+  /** @deprecated Using this should be a noop. Prefer new test framework*/
+  StandardTestLibrary,
+} from "./test-compiler-host.js";
+
 export { expectCodeFixOnAst } from "./code-fix-testing.js";
 export { expectDiagnosticEmpty, expectDiagnostics, type DiagnosticMatch } from "./expect.js";
+export { createTestFileSystem, mockFile } from "./fs.js";
+export { t } from "./marked-template.js";
 export {
   createLinterRuleTester,
   type ApplyCodeFixExpect,
   type LinterRuleTestExpect,
   type LinterRuleTester,
 } from "./rule-tester.js";
 export { extractCursor, extractSquiggles } from "./source-utils.js";
-export {
-  StandardTestLibrary,
-  createTestFileSystem,
-  createTestHost,
-  createTestRunner,
-  findFilesFromPattern,
-  type TestHostOptions,
-} from "./test-host.js";
+export type { TestHostOptions } from "./test-compiler-host.js";
+export { createTestHost, createTestRunner, findFilesFromPattern } from "./test-host.js";
 export {
   createTestLibrary,
   createTestWrapper,
@@ -24,13 +25,23 @@ export {
   trimBlankLines,
   type TestWrapperOptions,
 } from "./test-utils.js";
+export { createTester } from "./tester.js";
 export type {
   BasicTestRunner,
-  TestFileSystem,
+  EmitterTester,
+  EmitterTesterInstance,
+  JsFile,
+  MockFile,
+  TestCompileOptions,
+  TestCompileResult,
+  TestEmitterCompileResult,
+  TestFileSystem as TestFileSystem,
   TestFiles,
   TestHost,
   TestHostConfig,
   TestHostError,
+  Tester,
+  TesterInstance,
   TypeSpecTestLibrary,
   TypeSpecTestLibraryInit,
 } from "./types.js";