@typespec/emitter-framework 0.11.0-dev.8 → 0.11.0

package/src/csharp/components/type-expression.test.tsx

@@ -1,17 +1,17 @@
+import { Tester } from "#test/test-host.js";
 import { type Children } from "@alloy-js/core";
 import { SourceFile } from "@alloy-js/csharp";
-import type { Model, ModelProperty } from "@typespec/compiler";
-import type { BasicTestRunner } from "@typespec/compiler/testing";
+import type { ModelProperty } from "@typespec/compiler";
+import { t, type TesterInstance } from "@typespec/compiler/testing";
 import { beforeEach, describe, expect, it } from "vitest";
-import { createEmitterFrameworkTestRunner } from "../../../test/typescript/test-host.js";
 import { Output } from "../../core/index.js";
 import { ClassDeclaration } from "./class/declaration.js";
 import { TypeExpression } from "./type-expression.jsx";
 
-let runner: BasicTestRunner;
+let runner: TesterInstance;
 
 beforeEach(async () => {
-  runner = await createEmitterFrameworkTestRunner();
+  runner = await Tester.createInstance();
 });
 
 function Wrapper(props: { children: Children }) {
@@ -73,12 +73,12 @@ describe("Record map to IDictionary", () => {
   });
 
   it("for models", async () => {
-    const { test, Pet } = (await runner.compile(`
+    const { test, Pet } = await runner.compile(t.code`
       model Test {
-        @test test: Record<Pet>;
+         ${t.modelProperty("test")}: Record<Pet>;
       }
-      @test model Pet {}
-    `)) as { test: ModelProperty; Pet: Model };
+      @test model ${t.model("Pet")} {}
+    `);
 
     expect(
       <Wrapper>
@@ -98,11 +98,11 @@ describe("Record map to IDictionary", () => {
 
 describe("Nullable union", () => {
   it("nullable boolean", async () => {
-    const { Pet } = (await runner.compile(`
-      @test model Pet {
+    const { Pet } = await runner.compile(t.code`
+      @test model ${t.model("Pet")} {
         @test name: boolean | null;
       }
-    `)) as { Pet: Model };
+    `);
 
     expect(
       <Wrapper>
@@ -119,14 +119,14 @@ describe("Nullable union", () => {
 
 describe("Literal types", () => {
   it("literal types (string, int, double, bool)", async () => {
-    const { Pet } = (await runner.compile(`
-      @test model Pet {
+    const { Pet } = await runner.compile(t.code`
+      @test model ${t.model("Pet")} {
         @test boolName: true;
         @test intName: 42;
         @test doubleName: 3.14;
         @test stringName: "Hello";
       }
-    `)) as { Pet: Model };
+    `);
 
     expect(
       <Wrapper>
@@ -136,8 +136,11 @@ describe("Literal types", () => {
       class Pet
       {
           public required bool boolName { get; set; }
+
           public required int intName { get; set; }
+
           public required double doubleName { get; set; }
+      
           public required string stringName { get; set; }
       }
     `);

package/test/typescript/components/arrow-function.test.tsx

@@ -1,22 +1,21 @@
+import { Tester } from "#test/test-host.js";
 import { SourceFile } from "@alloy-js/typescript";
-import type { Operation } from "@typespec/compiler";
-import type { BasicTestRunner } from "@typespec/compiler/testing";
+import { type TesterInstance, t } from "@typespec/compiler/testing";
 import { beforeEach, describe, expect, it } from "vitest";
 import { Output } from "../../../src/core/components/output.jsx";
 import { ArrowFunction } from "../../../src/typescript/components/arrow-function.jsx";
-import { createEmitterFrameworkTestRunner } from "../test-host.js";
 
 describe("arrow functions with a `type` prop", () => {
-  let runner: BasicTestRunner;
+  let runner: TesterInstance;
 
   beforeEach(async () => {
-    runner = await createEmitterFrameworkTestRunner();
+    runner = await Tester.createInstance();
   });
 
   it("creates a 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;
+    `);
 
     expect(
       <Output program={runner.program}>
@@ -32,9 +31,9 @@ describe("arrow functions with a `type` prop", () => {
   });
 
   it("creates an async 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;
+    `);
 
     expect(
       <Output program={runner.program}>
@@ -48,9 +47,9 @@ describe("arrow functions with a `type` prop", () => {
   });
 
   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;
+    `);
 
     expect(
       <Output program={runner.program}>

package/test/typescript/components/component-override.test.tsx

@@ -2,6 +2,7 @@ import {
   Experimental_ComponentOverrides,
   Experimental_ComponentOverridesConfig,
 } from "#core/index.js";
+import { Tester } from "#test/test-host.js";
 import { FunctionDeclaration } from "#typescript/index.js";
 import { For, List, type Children } from "@alloy-js/core";
 import { d } from "@alloy-js/core/testing";
@@ -10,7 +11,6 @@ import type { Namespace } from "@typespec/compiler";
 import { expect, it } from "vitest";
 import { Output } from "../../../src/core/components/output.jsx";
 import { InterfaceDeclaration } from "../../../src/typescript/components/interface-declaration.jsx";
-import { Tester } from "../../test-host.js";
 
 it("uses overridden component", async () => {
   const { program } = await Tester.compile(`

package/test/typescript/components/function-declaration.test.tsx

@@ -1,3 +1,4 @@
+import { getProgram } from "#test/utils.js";
 import { code } from "@alloy-js/core";
 import { d } from "@alloy-js/core/testing";
 import { SourceFile } from "@alloy-js/typescript";
@@ -5,7 +6,7 @@ import type { Namespace } from "@typespec/compiler";
 import { describe, expect, it } from "vitest";
 import { Output } from "../../../src/core/components/output.jsx";
 import { FunctionDeclaration } from "../../../src/typescript/components/function-declaration.js";
-import { getProgram } from "../test-host.js";
+
 describe("Typescript Function Declaration", () => {
   describe("Function bound to Typespec Types", () => {
     describe("Bound to Operation", () => {

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

@@ -1,22 +1,21 @@
+import { Tester } from "#test/test-host.js";
 import { SourceFile } from "@alloy-js/typescript";
-import type { Operation } 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 { Output } from "../../../src/core/components/output.jsx";
 import { FunctionExpression } from "../../../src/typescript/components/function-expression.jsx";
-import { createEmitterFrameworkTestRunner } from "../test-host.js";
 
 describe("function expressions with a `type` prop", () => {
-  let runner: BasicTestRunner;
+  let runner: TesterInstance;
 
   beforeEach(async () => {
-    runner = await createEmitterFrameworkTestRunner();
+    runner = await Tester.createInstance();
   });
 
   it("creates a 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;
+    `);
 
     expect(
       <Output program={runner.program}>
@@ -32,9 +31,9 @@ describe("function expressions with a `type` prop", () => {
   });
 
   it("creates an async 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;
+    `);
 
     expect(
       <Output program={runner.program}>
@@ -48,9 +47,9 @@ describe("function expressions with a `type` prop", () => {
   });
 
   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;
+    `);
 
     expect(
       <Output program={runner.program}>

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

@@ -1,22 +1,22 @@
+import { Tester } from "#test/test-host.js";
 import { SourceFile } from "@alloy-js/typescript";
 import type { Operation } 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 { Output } from "../../../src/core/components/output.jsx";
 import { FunctionType } from "../../../src/typescript/index.js";
-import { createEmitterFrameworkTestRunner } from "../test-host.js";
 
 describe("function types with a `type` prop", () => {
-  let runner: BasicTestRunner;
+  let runner: TesterInstance;
 
   beforeEach(async () => {
-    runner = await createEmitterFrameworkTestRunner();
+    runner = await Tester.createInstance();
   });
 
   it("creates a function 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;
+    `);
 
     expect(
       <Output program={runner.program}>
@@ -30,9 +30,9 @@ describe("function types with a `type` prop", () => {
   });
 
   it("creates an async function 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;
+    `);
 
     expect(
       <Output program={runner.program}>
@@ -46,8 +46,8 @@ describe("function types with a `type` prop", () => {
   });
 
   it("can append extra parameters with raw params provided", 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 };
 
     expect(

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

@@ -1,10 +1,10 @@
+import { getProgram } from "#test/utils.js";
 import { For, List } from "@alloy-js/core";
 import { SourceFile } from "@alloy-js/typescript";
 import type { Namespace } from "@typespec/compiler";
 import { describe, expect, it } from "vitest";
 import { Output } from "../../../src/core/components/output.jsx";
 import { InterfaceDeclaration } from "../../../src/typescript/components/interface-declaration.js";
-import { getProgram } from "../test-host.js";
 
 describe("Typescript Interface", () => {
   describe("Interface bound to Typespec Types", () => {

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

@@ -1,21 +1,22 @@
+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 { 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 { 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 };
 
     expect(
@@ -34,9 +35,9 @@ describe("interface methods with a `type` prop", () => {
   });
 
   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;
+    `);
 
     expect(
       <Output program={runner.program}>
@@ -54,9 +55,9 @@ describe("interface methods with a `type` prop", () => {
   });
 
   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;
+    `);
 
     expect(
       <Output program={runner.program}>
@@ -78,9 +79,9 @@ describe("interface methods with a `type` prop", () => {
   });
 
   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;
+    `);
 
     expect(
       <Output program={runner.program}>
@@ -102,9 +103,9 @@ describe("interface methods with a `type` prop", () => {
   });
 
   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;
+    `);
 
     expect(
       <Output program={runner.program}>
@@ -129,9 +130,9 @@ describe("interface methods with a `type` prop", () => {
   });
 
   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;
+    `);
 
     expect(
       <Output program={runner.program}>
@@ -149,9 +150,9 @@ describe("interface methods with a `type` prop", () => {
   });
 
   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;
+    `);
 
     expect(
       <Output program={runner.program}>

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 () => {