@typespec/emitter-framework 0.11.0-dev.7 → 0.11.0-dev.9

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

@@ -1,11 +1,9 @@
-import { type Children, render } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
-import { Namespace, SourceFile } from "@alloy-js/csharp";
+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 { beforeEach, describe, it } from "vitest";
+import { beforeEach, describe, expect, it } from "vitest";
 import { createEmitterFrameworkTestRunner } from "../../../test/typescript/test-host.js";
-import { assertFileContents } from "../../../test/utils.js";
 import { Output } from "../../core/index.js";
 import { ClassDeclaration } from "./class/declaration.js";
 import { TypeExpression } from "./type-expression.jsx";
@@ -19,9 +17,7 @@ beforeEach(async () => {
 function Wrapper(props: { children: Children }) {
   return (
     <Output program={runner.program}>
-      <Namespace name="TestNamespace">
-        <SourceFile path="test.ts">{props.children}</SourceFile>
-      </Namespace>
+      <SourceFile path="test.ts">{props.children}</SourceFile>
     </Output>
   );
 }
@@ -43,61 +39,37 @@ describe("map scalar to c# built-in types", () => {
     ["int64", "long"],
   ])("%s => %s", async (tspType, csType) => {
     const type = await compileType(tspType);
-    const res = render(
+    expect(
       <Wrapper>
         <TypeExpression type={type} />
       </Wrapper>,
-    );
-
-    assertFileContents(
-      res,
-      d`
-          namespace TestNamespace
-          {
-              ${csType}
-          }
-        `,
-    );
+    ).toRenderTo(`
+        ${csType}
+        `);
   });
 });
 
 it("maps array to c# array", async () => {
   const type = await compileType("int32[]");
-  const res = render(
+  expect(
     <Wrapper>
       <TypeExpression type={type} />
     </Wrapper>,
-  );
-
-  assertFileContents(
-    res,
-    d`
-          namespace TestNamespace
-          {
-              int[]
-          }
-        `,
-  );
+  ).toRenderTo(`
+    int[]
+  `);
 });
 
 describe("Record map to IDictionary", () => {
   it("for primitive types", async () => {
     const type = await compileType("Record<int32>");
-    const res = render(
+    expect(
       <Wrapper>
         <TypeExpression type={type} />
       </Wrapper>,
-    );
-
-    assertFileContents(
-      res,
-      d`
-          namespace TestNamespace
-          {
-              IDictionary<string, int>
-          }
-        `,
-    );
+    ).toRenderTo(`
+      IDictionary<string, int>
+    `);
   });
 
   it("for models", async () => {
@@ -108,27 +80,19 @@ describe("Record map to IDictionary", () => {
       @test model Pet {}
     `)) as { test: ModelProperty; Pet: Model };
 
-    const res = render(
+    expect(
       <Wrapper>
         <ClassDeclaration type={Pet} />
         <hbr />
         <TypeExpression type={test.type} />
       </Wrapper>,
-    );
-
-    assertFileContents(
-      res,
-      d`
-          namespace TestNamespace
-          {
-              class Pet
-              {
-          
-              }
-              IDictionary<string, Pet>
-          }
-        `,
-    );
+    ).toRenderTo(`
+      class Pet
+      {
+      
+      }
+      IDictionary<string, Pet>
+    `);
   });
 });
 
@@ -140,24 +104,16 @@ describe("Nullable union", () => {
       }
     `)) as { Pet: Model };
 
-    const res = render(
+    expect(
       <Wrapper>
         <ClassDeclaration type={Pet} />
       </Wrapper>,
-    );
-
-    assertFileContents(
-      res,
-      d`
-          namespace TestNamespace
-          {
-              class Pet
-              {
-                  public required bool? name { get; set; }
-              }
-          }
-        `,
-    );
+    ).toRenderTo(`
+      class Pet
+      {
+          public required bool? name { get; set; }
+      }
+    `);
   });
 });
 
@@ -172,26 +128,21 @@ describe("Literal types", () => {
       }
     `)) as { Pet: Model };
 
-    const res = render(
+    expect(
       <Wrapper>
         <ClassDeclaration type={Pet} />
       </Wrapper>,
-    );
-
-    assertFileContents(
-      res,
-      d`
-          namespace TestNamespace
-          {
-              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; }
-              }
-          }
-        `,
-    );
+    ).toRenderTo(`
+      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,12 +1,9 @@
-import { render } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
 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 { 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", () => {
@@ -21,22 +18,17 @@ describe("arrow functions with a `type` prop", () => {
       @test op getName(id: string): string;
     `)) as { getName: Operation };
 
-    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 () => {
@@ -44,20 +36,15 @@ describe("arrow functions with a `type` prop", () => {
       @test op getName(id: string): string;
     `)) as { getName: Operation };
 
-    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 () => {
@@ -65,7 +52,7 @@ describe("arrow functions with a `type` prop", () => {
       @test op getName(id: string): string;
     `)) as { getName: Operation };
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <ArrowFunction
@@ -74,13 +61,8 @@ describe("arrow functions with a `type` prop", () => {
           />
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         (additionalParam: number, id: string): string => {}
-      `,
-    );
+      `);
   });
 });

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

@@ -1,12 +1,9 @@
-import { render } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
 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 { 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", () => {
@@ -21,22 +18,17 @@ describe("function expressions with a `type` prop", () => {
       @test op getName(id: string): string;
     `)) as { getName: Operation };
 
-    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 () => {
@@ -44,20 +36,15 @@ describe("function expressions with a `type` prop", () => {
       @test op getName(id: string): string;
     `)) as { getName: Operation };
 
-    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 () => {
@@ -65,7 +52,7 @@ describe("function expressions with a `type` prop", () => {
       @test op getName(id: string): string;
     `)) as { getName: Operation };
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <FunctionExpression
@@ -74,13 +61,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,12 +1,9 @@
-import { render } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
 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 { 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", () => {
@@ -21,20 +18,15 @@ describe("function types with a `type` prop", () => {
       @test op getName(id: string): string;
     `)) as { getName: Operation };
 
-    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 () => {
@@ -42,20 +34,15 @@ describe("function types with a `type` prop", () => {
       @test op getName(id: string): string;
     `)) as { getName: Operation };
 
-    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 () => {
@@ -63,19 +50,14 @@ describe("function types with a `type` prop", () => {
       @test 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-method.test.tsx

@@ -1,12 +1,9 @@
-import { render } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
 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 { 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", () => {
@@ -21,7 +18,7 @@ describe("interface methods with a `type` prop", () => {
       @test op getName(id: string): string;
     `)) as { getName: Operation };
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <InterfaceDeclaration name="basicInterface">
@@ -29,16 +26,11 @@ 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 () => {
@@ -46,7 +38,7 @@ describe("interface methods with a `type` prop", () => {
       @test op getName(id: string): string;
     `)) as { getName: Operation };
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <InterfaceDeclaration name="basicInterface">
@@ -54,16 +46,11 @@ 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 () => {
@@ -71,7 +58,7 @@ describe("interface methods with a `type` prop", () => {
       @test op getName(id: string): string;
     `)) as { getName: Operation };
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <InterfaceDeclaration name="basicInterface">
@@ -83,16 +70,11 @@ 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 () => {
@@ -100,7 +82,7 @@ describe("interface methods with a `type` prop", () => {
       @test op getName(id: string): string;
     `)) as { getName: Operation };
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <InterfaceDeclaration name="basicInterface">
@@ -112,16 +94,11 @@ 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 () => {
@@ -129,7 +106,7 @@ describe("interface methods with a `type` prop", () => {
       @test op getName(id: string): string;
     `)) as { getName: Operation };
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <InterfaceDeclaration name="basicInterface">
@@ -144,16 +121,11 @@ 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 () => {
@@ -161,7 +133,7 @@ describe("interface methods with a `type` prop", () => {
       @test op getName(id: string): string;
     `)) as { getName: Operation };
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <InterfaceDeclaration name="basicInterface">
@@ -169,16 +141,11 @@ 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 () => {
@@ -186,7 +153,7 @@ describe("interface methods with a `type` prop", () => {
       @test op getName(id: string): string;
     `)) as { getName: Operation };
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <InterfaceDeclaration name="basicInterface">
@@ -194,23 +161,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 +184,10 @@ describe("interface methods without a `type` prop", () => {
           </InterfaceDeclaration>
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         interface basicInterface {
           plainMethod(param1: string): number
         }
-      `,
-    );
+      `);
   });
 });