@typespec/emitter-framework 0.11.0-dev.0 → 0.11.0-dev.10

package/test/typescript/components/interface-method.test.tsx

@@ -1,27 +1,25 @@
-import { render } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
+import { Tester } from "#test/test-host.js";
+import { getProgram } from "#test/utils.js";
 import { InterfaceDeclaration, SourceFile } from "@alloy-js/typescript";
 import type { Operation } from "@typespec/compiler";
-import type { BasicTestRunner } from "@typespec/compiler/testing";
-import { beforeEach, describe, it } from "vitest";
+import { t, type TesterInstance } from "@typespec/compiler/testing";
+import { beforeEach, describe, expect, it } from "vitest";
 import { Output } from "../../../src/core/components/output.jsx";
 import { InterfaceMethod } from "../../../src/typescript/components/interface-method.jsx";
-import { assertFileContents } from "../../utils.js";
-import { createEmitterFrameworkTestRunner, getProgram } from "../test-host.js";
 
 describe("interface methods with a `type` prop", () => {
-  let runner: BasicTestRunner;
+  let runner: TesterInstance;
 
   beforeEach(async () => {
-    runner = await createEmitterFrameworkTestRunner();
+    runner = await Tester.createInstance();
   });
 
   it("creates a interface method", async () => {
-    const { getName } = (await runner.compile(`
-      @test op getName(id: string): string;
+    const { getName } = (await runner.compile(t.code`
+      @test op ${t.op("getName")}(id: string): string;
     `)) as { getName: Operation };
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <InterfaceDeclaration name="basicInterface">
@@ -29,24 +27,19 @@ describe("interface methods with a `type` prop", () => {
           </InterfaceDeclaration>
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         interface basicInterface {
           getName(id: string): string
         }
-      `,
-    );
+      `);
   });
 
   it("creates an async interface function", async () => {
-    const { getName } = (await runner.compile(`
-      @test op getName(id: string): string;
-    `)) as { getName: Operation };
+    const { getName } = await runner.compile(t.code`
+      @test op ${t.op("getName")}(id: string): string;
+    `);
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <InterfaceDeclaration name="basicInterface">
@@ -54,24 +47,19 @@ describe("interface methods with a `type` prop", () => {
           </InterfaceDeclaration>
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         interface basicInterface {
           getName(id: string): Promise<string>
         }
-      `,
-    );
+      `);
   });
 
   it("can append extra parameters with raw params provided", async () => {
-    const { getName } = (await runner.compile(`
-      @test op getName(id: string): string;
-    `)) as { getName: Operation };
+    const { getName } = await runner.compile(t.code`
+      @test op ${t.op("getName")}(id: string): string;
+    `);
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <InterfaceDeclaration name="basicInterface">
@@ -83,24 +71,19 @@ describe("interface methods with a `type` prop", () => {
           </InterfaceDeclaration>
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         interface basicInterface {
           getName(id: string, foo: string): string
         }
-      `,
-    );
+      `);
   });
 
   it("can prepend extra parameters with raw params provided", async () => {
-    const { getName } = (await runner.compile(`
-      @test op getName(id: string): string;
-    `)) as { getName: Operation };
+    const { getName } = await runner.compile(t.code`
+      @test op ${t.op("getName")}(id: string): string;
+    `);
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <InterfaceDeclaration name="basicInterface">
@@ -112,24 +95,19 @@ describe("interface methods with a `type` prop", () => {
           </InterfaceDeclaration>
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         interface basicInterface {
           getName(foo: string, id: string): string
         }
-      `,
-    );
+      `);
   });
 
   it("can replace parameters with raw params provided", async () => {
-    const { getName } = (await runner.compile(`
-      @test op getName(id: string): string;
-    `)) as { getName: Operation };
+    const { getName } = await runner.compile(t.code`
+      @test op ${t.op("getName")}(id: string): string;
+    `);
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <InterfaceDeclaration name="basicInterface">
@@ -144,24 +122,19 @@ describe("interface methods with a `type` prop", () => {
           </InterfaceDeclaration>
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         interface basicInterface {
           getName(foo: string, bar: number): string
         }
-      `,
-    );
+      `);
   });
 
   it("can override return type", async () => {
-    const { getName } = (await runner.compile(`
-      @test op getName(id: string): string;
-    `)) as { getName: Operation };
+    const { getName } = await runner.compile(t.code`
+      @test op ${t.op("getName")}(id: string): string;
+    `);
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <InterfaceDeclaration name="basicInterface">
@@ -169,24 +142,19 @@ describe("interface methods with a `type` prop", () => {
           </InterfaceDeclaration>
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         interface basicInterface {
           getName(id: string): Promise<Record<string, unknown>>
         }
-      `,
-    );
+      `);
   });
 
   it("can override method name", async () => {
-    const { getName } = (await runner.compile(`
-      @test op getName(id: string): string;
-    `)) as { getName: Operation };
+    const { getName } = await runner.compile(t.code`
+      @test op ${t.op("getName")}(id: string): string;
+    `);
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <InterfaceDeclaration name="basicInterface">
@@ -194,23 +162,18 @@ describe("interface methods with a `type` prop", () => {
           </InterfaceDeclaration>
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         interface basicInterface {
           getNameCustom(id: string): string
         }
-      `,
-    );
+      `);
   });
 });
 
 describe("interface methods without a `type` prop", () => {
   it("renders a plain interface method", async () => {
     const program = await getProgram("");
-    const res = render(
+    expect(
       <Output program={program}>
         <SourceFile path="test.ts">
           <InterfaceDeclaration name="basicInterface">
@@ -222,15 +185,10 @@ describe("interface methods without a `type` prop", () => {
           </InterfaceDeclaration>
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         interface basicInterface {
           plainMethod(param1: string): number
         }
-      `,
-    );
+      `);
   });
 });

package/test/typescript/components/type-alias-declaration.test.tsx

@@ -1,9 +1,11 @@
+import { Tester } from "#test/test-host.js";
+import { getProgram } from "#test/utils.js";
 import { SourceFile } from "@alloy-js/typescript";
-import type { Namespace, Operation } from "@typespec/compiler";
+import type { Namespace } from "@typespec/compiler";
+import { t } from "@typespec/compiler/testing";
 import { describe, expect, it } from "vitest";
 import { Output } from "../../../src/core/components/output.jsx";
 import { TypeAliasDeclaration } from "../../../src/typescript/components/type-alias-declaration.jsx";
-import { createEmitterFrameworkTestRunner, getProgram } from "../test-host.js";
 
 describe("Typescript Type Alias Declaration", () => {
   describe("Type Alias bound to Typespec Scalar", () => {
@@ -136,10 +138,10 @@ describe("Typescript Type Alias Declaration", () => {
   });
 
   it("creates a type alias of a function", async () => {
-    const runner = await createEmitterFrameworkTestRunner();
-    const { getName } = (await runner.compile(`
-      @test op getName(id: string): string;
-    `)) as { getName: Operation };
+    const runner = await Tester.createInstance();
+    const { getName } = await runner.compile(t.code`
+      @test op  ${t.op("getName")}(id: string): string;
+    `);
 
     expect(
       <Output program={runner.program}>

package/test/typescript/components/type-transform.test.tsx

@@ -1,8 +1,9 @@
+import { Tester } from "#test/test-host.js";
 import { code, Output } from "@alloy-js/core";
 import * as ts from "@alloy-js/typescript";
 import { SourceFile } from "@alloy-js/typescript";
 import type { Model } from "@typespec/compiler";
-import type { BasicTestRunner } from "@typespec/compiler/testing";
+import { t, type TesterInstance } from "@typespec/compiler/testing";
 import { beforeEach, describe, expect, it } from "vitest";
 import {
   ArraySerializer,
@@ -16,27 +17,26 @@ import {
   TypeTransformDeclaration,
 } from "../../../src/typescript/components/type-transform.js";
 import { TypeDeclaration } from "../../../src/typescript/index.js";
-import { createEmitterFrameworkTestRunner } from "../test-host.js";
 
 describe.skip("Typescript Type Transform", () => {
-  let testRunner: BasicTestRunner;
+  let testRunner: TesterInstance;
   const namePolicy = ts.createTSNamePolicy();
   beforeEach(async () => {
-    testRunner = await createEmitterFrameworkTestRunner();
+    testRunner = await Tester.createInstance();
   });
   describe("Model Transforms", () => {
     describe("ModelTransformExpression", () => {
       it("should render a transform expression to client", async () => {
-        const spec = `
+        const spec = t.code`
           namespace DemoService;
-          @test model Widget {
+          @test model ${t.model("Widget")} {
             id: string;
             birth_year: int32;
             color: "blue" | "red";
           }
           `;
 
-        const { Widget } = (await testRunner.compile(spec)) as { Widget: Model };
+        const { Widget } = await testRunner.compile(spec);
 
         expect(
           <Output namePolicy={namePolicy}>
@@ -62,16 +62,16 @@ describe.skip("Typescript Type Transform", () => {
       });
 
       it("should render a transform expression to wire", async () => {
-        const spec = `
+        const spec = t.code`
           namespace DemoService;
-          @test model Widget {
+          @test model ${t.model("Widget")} {
             id: string;
             birth_year: int32;
             color: "blue" | "red";
           }
           `;
 
-        const { Widget } = (await testRunner.compile(spec)) as { Widget: Model };
+        const { Widget } = await testRunner.compile(spec);
 
         expect(
           <Output namePolicy={namePolicy}>
@@ -97,9 +97,9 @@ describe.skip("Typescript Type Transform", () => {
       });
 
       it("should render a transform expression that contains a utcDateTime to client", async () => {
-        const spec = `
+        const spec = t.code`
           namespace DemoService;
-          @test model Widget {
+          @test model ${t.model("Widget")} {
             id: string;
             birth_date: utcDateTime;
             color: "blue" | "red";
@@ -139,9 +139,9 @@ describe.skip("Typescript Type Transform", () => {
 
     describe("TypeTransformDeclaration", () => {
       it("should render a transform functions for a model containing array", async () => {
-        const spec = `
+        const spec = t.code`
           namespace DemoService;
-          @test model Widget {
+          @test model ${t.model("Widget")} {
             id: string;
             my_color: "blue" | "red";
             simple?: string[];
@@ -151,7 +151,7 @@ describe.skip("Typescript Type Transform", () => {
           }
           `;
 
-        const { Widget } = (await testRunner.compile(spec)) as { Widget: Model };
+        const { Widget } = await testRunner.compile(spec);
 
         expect(
           <Output namePolicy={namePolicy}>
@@ -198,9 +198,9 @@ describe.skip("Typescript Type Transform", () => {
          `);
       });
       it("should render a transform functions for a model containing record", async () => {
-        const spec = `
+        const spec = t.code`
           namespace DemoService;
-          @test model Widget {
+          @test model ${t.model("Widget")} {
             id: string;
             my_color: "blue" | "red";
             simple: Record<string>;
@@ -209,7 +209,7 @@ describe.skip("Typescript Type Transform", () => {
           }
           `;
 
-        const { Widget } = (await testRunner.compile(spec)) as { Widget: Model };
+        const { Widget } = await testRunner.compile(spec);
 
         expect(
           <Output namePolicy={namePolicy}>
@@ -253,15 +253,15 @@ describe.skip("Typescript Type Transform", () => {
          `);
       });
       it("should render a transform functions for a model", async () => {
-        const spec = `
+        const spec = t.code`
           namespace DemoService;
-          @test model Widget {
+          @test model ${t.model("Widget")} {
             id: string;
             my_color: "blue" | "red";
           }
           `;
 
-        const { Widget } = (await testRunner.compile(spec)) as { Widget: Model };
+        const { Widget } = await testRunner.compile(spec);
 
         expect(
           <Output namePolicy={namePolicy}>
@@ -293,14 +293,14 @@ describe.skip("Typescript Type Transform", () => {
     });
     describe("Calling a model transform functions", () => {
       it("should collapse a model with single property", async () => {
-        const spec = `
+        const spec = t.code`
           namespace DemoService;
-          @test model Widget {
+          @test model ${t.model("Widget")} {
             id: string;
           }
           `;
 
-        const { Widget } = (await testRunner.compile(spec)) as { Widget: Model };
+        const { Widget } = await testRunner.compile(spec);
 
         expect(
           <Output namePolicy={namePolicy}>
@@ -318,15 +318,15 @@ describe.skip("Typescript Type Transform", () => {
       });
 
       it("should call  transform functions for a model", async () => {
-        const spec = `
+        const spec = t.code`
           namespace DemoService;
-          @test model Widget {
+          @test model ${t.model("Widget")} {
             id: string;
             my_color: "blue" | "red";
           }
           `;
 
-        const { Widget } = (await testRunner.compile(spec)) as { Widget: Model };
+        const { Widget } = await testRunner.compile(spec);
 
         expect(
           <Output namePolicy={namePolicy}>
@@ -356,20 +356,20 @@ describe.skip("Typescript Type Transform", () => {
 
   describe("Discriminated Model Transforms", () => {
     it("should handle a discriminated union", async () => {
-      const { Pet, Cat, Dog } = (await testRunner.compile(`
+      const { Pet, Cat, Dog } = await testRunner.compile(t.code`
         @discriminator("kind")
-        @test model Pet {
+        @test model ${t.model("Pet")} {
           kind: string;
         }
 
-        @test model Cat extends Pet {
+        @test model ${t.model("Cat")} extends Pet {
           kind: "cat";
         }
 
-        @test model Dog extends Pet {
+        @test model ${t.model("Dog")} extends Pet {
           kind: "dog";
         }
-      `)) as { Pet: Model; Cat: Model; Dog: Model };
+      `);
 
       expect(
         <Output namePolicy={namePolicy}>
@@ -436,21 +436,21 @@ describe.skip("Typescript Type Transform", () => {
   });
   describe("Discriminated Union Transforms", () => {
     it("should handle a discriminated union", async () => {
-      const { Pet, Cat, Dog } = (await testRunner.compile(`
+      const { Pet, Cat, Dog } = await testRunner.compile(t.code`
         @discriminator("kind")
-        @test union Pet {
+        @test union ${t.union("Pet")}{
           cat: Cat;
           dog: Dog;
         }
 
-        @test model Cat  {
+        @test model ${t.model("Cat")} {
           kind: "cat";
         }
 
-        @test model Dog {
+        @test model ${t.model("Dog")} {
           kind: "dog";
         }
-      `)) as { Pet: Model; Cat: Model; Dog: Model };
+      `);
 
       expect(
         <Output namePolicy={namePolicy}>

package/test/typescript/components/value-expression.test.tsx

@@ -1,3 +1,4 @@
+import { getProgram } from "#test/utils.js";
 import { Output } from "@alloy-js/core";
 import { dedent } from "@alloy-js/core/testing";
 import { SourceFile } from "@alloy-js/typescript";
@@ -13,7 +14,6 @@ import {
 import { $ } from "@typespec/compiler/typekit";
 import { assert, beforeAll, describe, expect, it } from "vitest";
 import { ValueExpression } from "../../../src/typescript/components/value-expression.js";
-import { getProgram } from "../test-host.js";
 
 let program: Program;
 beforeAll(async () => {

package/test/utils.ts

@@ -1,19 +1,26 @@
+import { Tester } from "#test/test-host.js";
 import { type Children, type OutputDirectory, render } from "@alloy-js/core";
 import { Output } from "@alloy-js/core/stc";
 import { SourceFile } from "@alloy-js/typescript/stc";
 import type { Program } from "@typespec/compiler";
 import { assert } from "vitest";
-import { getProgram } from "./typescript/test-host.js";
 
 export async function getEmitOutput(tspCode: string, cb: (program: Program) => Children) {
   const program = await getProgram(tspCode);
-
-  const res = render(Output().children(SourceFile({ path: "test.ts" }).children(cb(program))));
+  const res = render(Output().children(SourceFile({ path: "test.ts" }).children(cb(program))), {
+    insertFinalNewLine: false,
+  });
   const testFile = res.contents.find((file) => file.path === "test.ts")!;
   assert("contents" in testFile, "test.ts file does not have contents");
   return testFile.contents;
 }
 
+export async function getProgram(tspCode: string) {
+  const runner = await Tester.createInstance();
+  const { program } = await runner.compile(tspCode);
+  return program;
+}
+
 export function assertFileContents(res: OutputDirectory, contents: string) {
   const testFile = res.contents.find((file) => file.path === "test.ts")!;
   assert(testFile, "test.ts file not rendered");

package/dist/test/typescript/test-host.d.ts

@@ -1,16 +0,0 @@
-import type { Program } from "@typespec/compiler";
-export declare function createTypespecCliTestHost(options?: {
-    libraries: "Http"[];
-}): Promise<import("@typespec/compiler/testing").TestHost>;
-export declare function createEmitterFrameworkTestRunner(options?: {
-    autoUsings?: string[];
-}): Promise<import("@typespec/compiler/testing").BasicTestRunner>;
-export declare function getProgram(code: string, options?: {
-    libraries: "Http"[];
-}): Promise<Program>;
-/**
- * Initializes an empty program in the compiler.
- * This is useful when you want to initialize the default TypeKits without any code.
- */
-export declare function initEmptyProgram(): Promise<void>;
-//# sourceMappingURL=test-host.d.ts.map

package/dist/test/typescript/test-host.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"test-host.d.ts","sourceRoot":"","sources":["../../../test/typescript/test-host.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAQlD,wBAAsB,yBAAyB,CAC7C,OAAO,GAAE;IAAE,SAAS,EAAE,MAAM,EAAE,CAAA;CAAsB,0DASrD;AAED,wBAAsB,gCAAgC,CAAC,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CAAO,iEAK7F;AAED,wBAAsB,UAAU,CAC9B,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;IAAE,SAAS,EAAE,MAAM,EAAE,CAAA;CAAsB,GACnD,OAAO,CAAC,OAAO,CAAC,CAUlB;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAEtD"}

package/dist/test/typescript/test-host.js

@@ -1,40 +0,0 @@
-import { createTestHost, createTestWrapper, expectDiagnosticEmpty } from "@typespec/compiler/testing";
-import { HttpTestLibrary } from "@typespec/http/testing";
-export async function createTypespecCliTestHost(options = {
-  libraries: []
-}) {
-  const libraries = [];
-  if (options.libraries.includes("Http")) {
-    libraries.push(HttpTestLibrary);
-  }
-  return createTestHost({
-    libraries
-  });
-}
-export async function createEmitterFrameworkTestRunner(options = {}) {
-  const host = await createTypespecCliTestHost();
-  return createTestWrapper(host, {
-    autoUsings: options.autoUsings
-  });
-}
-export async function getProgram(code, options = {
-  libraries: []
-}) {
-  const host = await createTypespecCliTestHost(options);
-  const wrapper = createTestWrapper(host, {
-    compilerOptions: {
-      noEmit: true
-    }
-  });
-  const [_, diagnostics] = await wrapper.compileAndDiagnose(code);
-  expectDiagnosticEmpty(diagnostics);
-  return wrapper.program;
-}
-
-/**
- * Initializes an empty program in the compiler.
- * This is useful when you want to initialize the default TypeKits without any code.
- */
-export async function initEmptyProgram() {
-  await getProgram("");
-}

package/test/typescript/test-host.ts

@@ -1,49 +0,0 @@
-import type { Program } from "@typespec/compiler";
-import {
-  createTestHost,
-  createTestWrapper,
-  expectDiagnosticEmpty,
-} from "@typespec/compiler/testing";
-import { HttpTestLibrary } from "@typespec/http/testing";
-
-export async function createTypespecCliTestHost(
-  options: { libraries: "Http"[] } = { libraries: [] },
-) {
-  const libraries = [];
-  if (options.libraries.includes("Http")) {
-    libraries.push(HttpTestLibrary);
-  }
-  return createTestHost({
-    libraries,
-  });
-}
-
-export async function createEmitterFrameworkTestRunner(options: { autoUsings?: string[] } = {}) {
-  const host = await createTypespecCliTestHost();
-  return createTestWrapper(host, {
-    autoUsings: options.autoUsings,
-  });
-}
-
-export async function getProgram(
-  code: string,
-  options: { libraries: "Http"[] } = { libraries: [] },
-): Promise<Program> {
-  const host = await createTypespecCliTestHost(options);
-  const wrapper = createTestWrapper(host, {
-    compilerOptions: {
-      noEmit: true,
-    },
-  });
-  const [_, diagnostics] = await wrapper.compileAndDiagnose(code);
-  expectDiagnosticEmpty(diagnostics);
-  return wrapper.program;
-}
-
-/**
- * Initializes an empty program in the compiler.
- * This is useful when you want to initialize the default TypeKits without any code.
- */
-export async function initEmptyProgram(): Promise<void> {
-  await getProgram("");
-}