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

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

@@ -1,71 +1,57 @@
-import { render } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
+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 { beforeEach, describe, it } from "vitest";
+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 { assertFileContents } from "../../utils.js";
-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;
+    `);
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <ArrowFunction type={getName}>console.log("Hello!");</ArrowFunction>
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         (id: string): string => {
           console.log("Hello!");
         }
-      `,
-    );
+      `);
   });
 
   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;
+    `);
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <ArrowFunction async type={getName} />
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         async (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">
           <ArrowFunction
@@ -74,13 +60,8 @@ describe("arrow functions with a `type` prop", () => {
           />
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         (additionalParam: number, id: string): string => {}
-      `,
-    );
+      `);
   });
 });

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

@@ -0,0 +1,71 @@
+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";
+import { SourceFile } from "@alloy-js/typescript";
+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";
+
+it("uses overridden component", async () => {
+  const { program } = await Tester.compile(`
+          namespace DemoService;
+          model Foo {
+            knownProp: string;
+          }
+
+          op foo(): Foo;
+
+          `);
+
+  const [namespace] = program.resolveTypeReference("DemoService");
+  const models = Array.from((namespace as Namespace).models.values());
+  const operations = Array.from((namespace as Namespace).operations.values());
+
+  expect(
+    <Output program={program}>
+      <TestClientOverrides>
+        <SourceFile path="test.ts">
+          <List hardline>
+            {models.map((model) => (
+              <InterfaceDeclaration export type={model} />
+            ))}
+          </List>
+          <hbr />
+          <For each={operations}>
+            {(operation) => <FunctionDeclaration export type={operation} />}
+          </For>
+        </SourceFile>
+      </TestClientOverrides>
+    </Output>,
+  ).toRenderTo(
+    d`
+      export interface Foo {
+        knownProp: string;
+      }
+      export function foo(): unknown {}
+            `,
+  );
+});
+
+function TestClientOverrides(props: { children?: Children }) {
+  const overrides = Experimental_ComponentOverridesConfig().forTypeKind("Model", {
+    reference: (props) => {
+      if (props.type.name === "Foo") {
+        return "unknown";
+      } else {
+        return props.default;
+      }
+    },
+  });
+  return (
+    <Experimental_ComponentOverrides overrides={overrides}>
+      {props.children}
+    </Experimental_ComponentOverrides>
+  );
+}

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,71 +1,57 @@
-import { render } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
+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 { 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 { FunctionExpression } from "../../../src/typescript/components/function-expression.jsx";
-import { assertFileContents } from "../../utils.js";
-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;
+    `);
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <FunctionExpression type={getName}>console.log("Hello!");</FunctionExpression>
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         function (id: string): string {
           console.log("Hello!");
         }
-      `,
-    );
+      `);
   });
 
   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;
+    `);
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <FunctionExpression async type={getName} />
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         async function (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">
           <FunctionExpression
@@ -74,13 +60,8 @@ describe("function expressions with a `type` prop", () => {
           />
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         function (additionalParam: number, id: string): string {}
-      `,
-    );
+      `);
   });
 });

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

@@ -1,81 +1,63 @@
-import { render } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
+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 { 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 { FunctionType } from "../../../src/typescript/index.js";
-import { assertFileContents } from "../../utils.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;
+    `);
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <FunctionType type={getName} />
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         (id: string) => string
-      `,
-    );
+      `);
   });
 
   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;
+    `);
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <FunctionType async type={getName} />
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         (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;
+    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">
           <FunctionType type={getName} parameters={[{ name: "additionalParam", type: "number" }]} />
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         (additionalParam: number, id: string) => string
-      `,
-    );
+      `);
   });
 });

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