@typespec/emitter-framework 0.10.0-dev.2 → 0.10.0

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

@@ -1,11 +1,8 @@
-import { render } from "@alloy-js/core";
 import { SourceFile } from "@alloy-js/typescript";
 import type { Namespace, Operation } from "@typespec/compiler";
-import { format } from "prettier";
-import { assert, describe, expect, it } from "vitest";
+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 { assertFileContents } from "../../utils.js";
 import { createEmitterFrameworkTestRunner, getProgram } from "../test-host.js";
 
 describe("Typescript Type Alias Declaration", () => {
@@ -20,21 +17,13 @@ describe("Typescript Type Alias Declaration", () => {
         const [namespace] = program.resolveTypeReference("DemoService");
         const scalar = Array.from((namespace as Namespace).scalars.values())[0];
 
-        const res = render(
+        expect(
           <Output program={program}>
             <SourceFile path="test.ts">
               <TypeAliasDeclaration type={scalar} />
             </SourceFile>
           </Output>,
-        );
-
-        const testFile = res.contents.find((file) => file.path === "test.ts");
-        assert(testFile, "test.ts file not rendered");
-        const actualContent = await format(testFile.contents as string, { parser: "typescript" });
-        const expectedContent = await format(`type MyDate = Date;`, {
-          parser: "typescript",
-        });
-        expect(actualContent).toBe(expectedContent);
+        ).toRenderTo(`type MyDate = Date;`);
       });
 
       it("creates a type alias declaration with JSDoc", async () => {
@@ -49,28 +38,17 @@ describe("Typescript Type Alias Declaration", () => {
         const [namespace] = program.resolveTypeReference("DemoService");
         const scalar = Array.from((namespace as Namespace).scalars.values())[0];
 
-        const res = render(
+        expect(
           <Output program={program}>
             <SourceFile path="test.ts">
               <TypeAliasDeclaration type={scalar} />
             </SourceFile>
           </Output>,
-        );
-
-        const testFile = res.contents.find((file) => file.path === "test.ts");
-        assert(testFile, "test.ts file not rendered");
-        const actualContent = await format(testFile.contents as string, { parser: "typescript" });
-        const expectedContent = await format(
-          `
+        ).toRenderTo(`
           /**
            * Type to represent a date
            */
-          type MyDate = Date;`,
-          {
-            parser: "typescript",
-          },
-        );
-        expect(actualContent).toBe(expectedContent);
+          type MyDate = Date;`);
       });
 
       it("can override JSDoc", async () => {
@@ -85,28 +63,17 @@ describe("Typescript Type Alias Declaration", () => {
         const [namespace] = program.resolveTypeReference("DemoService");
         const scalar = Array.from((namespace as Namespace).scalars.values())[0];
 
-        const res = render(
+        expect(
           <Output program={program}>
             <SourceFile path="test.ts">
               <TypeAliasDeclaration doc={"Overridden Doc"} type={scalar} />
             </SourceFile>
           </Output>,
-        );
-
-        const testFile = res.contents.find((file) => file.path === "test.ts");
-        assert(testFile, "test.ts file not rendered");
-        const actualContent = await format(testFile.contents as string, { parser: "typescript" });
-        const expectedContent = await format(
-          `
+        ).toRenderTo(`
           /**
            * Overridden Doc
            */
-          type MyDate = Date;`,
-          {
-            parser: "typescript",
-          },
-        );
-        expect(actualContent).toBe(expectedContent);
+          type MyDate = Date;`);
       });
 
       it("creates a type alias declaration for a utcDateTime with unixTimeStamp encoding", async () => {
@@ -119,21 +86,13 @@ describe("Typescript Type Alias Declaration", () => {
         const [namespace] = program.resolveTypeReference("DemoService");
         const scalar = Array.from((namespace as Namespace).scalars.values())[0];
 
-        const res = render(
+        expect(
           <Output program={program}>
             <SourceFile path="test.ts">
               <TypeAliasDeclaration type={scalar} />
             </SourceFile>
           </Output>,
-        );
-
-        const testFile = res.contents.find((file) => file.path === "test.ts");
-        assert(testFile, "test.ts file not rendered");
-        const actualContent = await format(testFile.contents as string, { parser: "typescript" });
-        const expectedContent = await format(`type MyDate = Date;`, {
-          parser: "typescript",
-        });
-        expect(actualContent).toBe(expectedContent);
+        ).toRenderTo(`type MyDate = Date;`);
       });
 
       it("creates a type alias declaration for a utcDateTime with rfc7231 encoding", async () => {
@@ -146,21 +105,13 @@ describe("Typescript Type Alias Declaration", () => {
         const [namespace] = program.resolveTypeReference("DemoService");
         const scalar = Array.from((namespace as Namespace).scalars.values())[0];
 
-        const res = render(
+        expect(
           <Output program={program}>
             <SourceFile path="test.ts">
               <TypeAliasDeclaration type={scalar} />
             </SourceFile>
           </Output>,
-        );
-
-        const testFile = res.contents.find((file) => file.path === "test.ts");
-        assert(testFile, "test.ts file not rendered");
-        const actualContent = await format(testFile.contents as string, { parser: "typescript" });
-        const expectedContent = await format(`type MyDate = Date;`, {
-          parser: "typescript",
-        });
-        expect(actualContent).toBe(expectedContent);
+        ).toRenderTo(`type MyDate = Date;`);
       });
 
       it("creates a type alias declaration for a utcDateTime with rfc3339 encoding", async () => {
@@ -173,21 +124,13 @@ describe("Typescript Type Alias Declaration", () => {
         const [namespace] = program.resolveTypeReference("DemoService");
         const scalar = Array.from((namespace as Namespace).scalars.values())[0];
 
-        const res = render(
+        expect(
           <Output program={program}>
             <SourceFile path="test.ts">
               <TypeAliasDeclaration export type={scalar} />
             </SourceFile>
           </Output>,
-        );
-
-        const testFile = res.contents.find((file) => file.path === "test.ts");
-        assert(testFile, "test.ts file not rendered");
-        const actualContent = await format(testFile.contents as string, { parser: "typescript" });
-        const expectedContent = await format(`export type MyDate = Date;`, {
-          parser: "typescript",
-        });
-        expect(actualContent).toBe(expectedContent);
+        ).toRenderTo(`export type MyDate = Date;`);
       });
     });
   });
@@ -198,14 +141,12 @@ describe("Typescript Type Alias Declaration", () => {
       @test op getName(id: string): string;
     `)) as { getName: Operation };
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <TypeAliasDeclaration type={getName} />
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(res, "type getName = (id: string) => string;");
+    ).toRenderTo("type getName = (id: string) => string;");
   });
 });

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

@@ -1,10 +1,9 @@
-import { code, Output, render } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
+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 { assert, beforeEach, describe, expect, it } from "vitest";
+import { beforeEach, describe, expect, it } from "vitest";
 import {
   ArraySerializer,
   DateDeserializer,
@@ -39,7 +38,7 @@ describe.skip("Typescript Type Transform", () => {
 
         const { Widget } = (await testRunner.compile(spec)) as { Widget: Model };
 
-        const res = render(
+        expect(
           <Output namePolicy={namePolicy}>
             <SourceFile path="test.ts">
               {code`
@@ -53,19 +52,13 @@ describe.skip("Typescript Type Transform", () => {
               />
             </SourceFile>
           </Output>,
-        );
-
-        const testFile = res.contents.find((file) => file.path === "test.ts");
-        assert(testFile, "test.ts file not rendered");
-        const actualContent = testFile.contents;
-        const expectedContent = d`
+        ).toRenderTo(`
           const wireWidget = {id: "1", birth_year: 1988, color: "blue"};
           const clientWidget = {
             "id": wireWidget.id,
             "birthYear": wireWidget.birth_year,
             "color": wireWidget.color
-          }`;
-        expect(actualContent).toBe(expectedContent);
+          }`);
       });
 
       it("should render a transform expression to wire", async () => {
@@ -80,7 +73,7 @@ describe.skip("Typescript Type Transform", () => {
 
         const { Widget } = (await testRunner.compile(spec)) as { Widget: Model };
 
-        const res = render(
+        expect(
           <Output namePolicy={namePolicy}>
             <SourceFile path="test.ts">
               {code`
@@ -94,19 +87,13 @@ describe.skip("Typescript Type Transform", () => {
               />
             </SourceFile>
           </Output>,
-        );
-
-        const testFile = res.contents.find((file) => file.path === "test.ts");
-        assert(testFile, "test.ts file not rendered");
-        const actualContent = testFile.contents;
-        const expectedContent = d`
+        ).toRenderTo(`
           const clientWidget = {id: "1", birthYear: 1988, color: "blue"};
           const wireWidget = {
             "id": clientWidget.id,
             "birth_year": clientWidget.birthYear,
             "color": clientWidget.color
-          }`;
-        expect(actualContent).toBe(expectedContent);
+          }`);
       });
 
       it("should render a transform expression that contains a utcDateTime to client", async () => {
@@ -121,7 +108,7 @@ describe.skip("Typescript Type Transform", () => {
 
         const { Widget } = (await testRunner.compile(spec)) as { Widget: Model };
 
-        const res = render(
+        expect(
           <Output namePolicy={namePolicy}>
             <SourceFile path="static-serializers.ts">
               <DateDeserializer />
@@ -138,12 +125,7 @@ describe.skip("Typescript Type Transform", () => {
               />
             </SourceFile>
           </Output>,
-        );
-
-        const testFile = res.contents.find((file) => file.path === "test.ts");
-        assert(testFile, "test.ts file not rendered");
-        const actualContent = testFile.contents;
-        const expectedContent = d`
+        ).toRenderTo(`
           import { dateDeserializer } from "./static-serializers.js";
           
           const wireWidget = {id: "1", birth_date: "1988-04-29T19:30:00Z", color: "blue"};
@@ -151,8 +133,7 @@ describe.skip("Typescript Type Transform", () => {
             "id": wireWidget.id,
             "birthDate": dateDeserializer(wireWidget.birth_date),
             "color": wireWidget.color
-          }`;
-        expect(actualContent).toBe(expectedContent);
+          }`);
       });
     });
 
@@ -172,7 +153,7 @@ describe.skip("Typescript Type Transform", () => {
 
         const { Widget } = (await testRunner.compile(spec)) as { Widget: Model };
 
-        const res = render(
+        expect(
           <Output namePolicy={namePolicy}>
             <SourceFile path="serializers.ts">
               <ArraySerializer />
@@ -183,12 +164,7 @@ describe.skip("Typescript Type Transform", () => {
               <TypeTransformDeclaration type={Widget} target="transport" />
             </SourceFile>
           </Output>,
-        );
-
-        const testFile = res.contents.find((file) => file.path === "test.ts");
-        assert(testFile, "test.ts file not rendered");
-        const actualContent = testFile.contents;
-        const expectedContent = d`
+        ).toRenderTo(`
           import { arraySerializer } from "./serializers.js";
           
           export interface Widget {
@@ -219,8 +195,7 @@ describe.skip("Typescript Type Transform", () => {
               "optionalString": item.optionalString
             };
           }
-         `;
-        expect(actualContent).toBe(expectedContent);
+         `);
       });
       it("should render a transform functions for a model containing record", async () => {
         const spec = `
@@ -236,7 +211,7 @@ describe.skip("Typescript Type Transform", () => {
 
         const { Widget } = (await testRunner.compile(spec)) as { Widget: Model };
 
-        const res = render(
+        expect(
           <Output namePolicy={namePolicy}>
             <SourceFile path="serializers.ts">
               <RecordSerializer />
@@ -247,12 +222,7 @@ describe.skip("Typescript Type Transform", () => {
               <TypeTransformDeclaration type={Widget} target="transport" />
             </SourceFile>
           </Output>,
-        );
-
-        const testFile = res.contents.find((file) => file.path === "test.ts");
-        assert(testFile, "test.ts file not rendered");
-        const actualContent = testFile.contents;
-        const expectedContent = d`
+        ).toRenderTo(`
           import { recordSerializer } from "./serializers.js";
           
           export interface Widget {
@@ -280,8 +250,7 @@ describe.skip("Typescript Type Transform", () => {
               "nested": recordSerializer(item.nested, (i: any) => recordSerializer(i, widgetToTransport))
             };
           }
-         `;
-        expect(actualContent).toBe(expectedContent);
+         `);
       });
       it("should render a transform functions for a model", async () => {
         const spec = `
@@ -294,7 +263,7 @@ describe.skip("Typescript Type Transform", () => {
 
         const { Widget } = (await testRunner.compile(spec)) as { Widget: Model };
 
-        const res = render(
+        expect(
           <Output namePolicy={namePolicy}>
             <SourceFile path="test.ts">
               <TypeDeclaration export type={Widget} />
@@ -302,12 +271,7 @@ describe.skip("Typescript Type Transform", () => {
               <TypeTransformDeclaration type={Widget} target="transport" />
             </SourceFile>
           </Output>,
-        );
-
-        const testFile = res.contents.find((file) => file.path === "test.ts");
-        assert(testFile, "test.ts file not rendered");
-        const actualContent = testFile.contents;
-        const expectedContent = d`
+        ).toRenderTo(`
           export interface Widget {
             "id": string;
             "myColor": "blue" | "red";
@@ -324,8 +288,7 @@ describe.skip("Typescript Type Transform", () => {
               "my_color": item.myColor
             };
           }
-         `;
-        expect(actualContent).toBe(expectedContent);
+         `);
       });
     });
     describe("Calling a model transform functions", () => {
@@ -339,7 +302,7 @@ describe.skip("Typescript Type Transform", () => {
 
         const { Widget } = (await testRunner.compile(spec)) as { Widget: Model };
 
-        const res = render(
+        expect(
           <Output namePolicy={namePolicy}>
             <SourceFile path="test.ts">
               {code`
@@ -348,16 +311,10 @@ describe.skip("Typescript Type Transform", () => {
                 `}
             </SourceFile>
           </Output>,
-        );
-
-        const testFile = res.contents.find((file) => file.path === "test.ts");
-        assert(testFile, "test.ts file not rendered");
-        const actualContent = testFile.contents;
-        const expectedContent = d`
+        ).toRenderTo(`
           const clientWidget = {id: "1", my_color: "blue"};
           const wireWidget = clientWidget.id
-         `;
-        expect(actualContent).toBe(expectedContent);
+         `);
       });
 
       it("should call  transform functions for a model", async () => {
@@ -371,7 +328,7 @@ describe.skip("Typescript Type Transform", () => {
 
         const { Widget } = (await testRunner.compile(spec)) as { Widget: Model };
 
-        const res = render(
+        expect(
           <Output namePolicy={namePolicy}>
             <SourceFile path="types.ts">
               <TypeDeclaration export type={Widget} />
@@ -386,19 +343,13 @@ describe.skip("Typescript Type Transform", () => {
                 `}
             </SourceFile>
           </Output>,
-        );
-
-        const testFile = res.contents.find((file) => file.path === "test.ts");
-        assert(testFile, "test.ts file not rendered");
-        const actualContent = testFile.contents;
-        const expectedContent = d`
+        ).toRenderTo(`
           import { widgetToApplication, widgetToTransport } from "./types.js";
           
           const wireWidget = {id: "1", my_color: "blue"};
           const clientWidget = widgetToApplication(wireWidget);
           const wireWidget2 = widgetToTransport(clientWidget);
-         `;
-        expect(actualContent).toBe(expectedContent);
+         `);
       });
     });
   });
@@ -420,7 +371,7 @@ describe.skip("Typescript Type Transform", () => {
         }
       `)) as { Pet: Model; Cat: Model; Dog: Model };
 
-      const res = render(
+      expect(
         <Output namePolicy={namePolicy}>
           <SourceFile path="test.ts">
             <TypeDeclaration export type={Pet} />
@@ -434,12 +385,7 @@ describe.skip("Typescript Type Transform", () => {
             <TypeTransformDeclaration type={Pet} target="transport" />
           </SourceFile>
         </Output>,
-      );
-
-      const testFile = res.contents.find((file) => file.path === "test.ts");
-      assert(testFile, "test.ts file not rendered");
-      const actualContent = testFile.contents;
-      const expectedContent = d`
+      ).toRenderTo(`
       export interface Pet {
         "kind": string;
       }
@@ -485,8 +431,7 @@ describe.skip("Typescript Type Transform", () => {
           return dogToTransport(item)
         }
       }
-       `;
-      expect(actualContent).toBe(expectedContent);
+       `);
     });
   });
   describe("Discriminated Union Transforms", () => {
@@ -507,7 +452,7 @@ describe.skip("Typescript Type Transform", () => {
         }
       `)) as { Pet: Model; Cat: Model; Dog: Model };
 
-      const res = render(
+      expect(
         <Output namePolicy={namePolicy}>
           <SourceFile path="test.ts">
             <TypeDeclaration export type={Pet} />
@@ -521,12 +466,7 @@ describe.skip("Typescript Type Transform", () => {
             <TypeTransformDeclaration type={Pet} target="transport" />
           </SourceFile>
         </Output>,
-      );
-
-      const testFile = res.contents.find((file) => file.path === "test.ts");
-      assert(testFile, "test.ts file not rendered");
-      const actualContent = testFile.contents;
-      const expectedContent = d`
+      ).toRenderTo(`
       export type Pet = Cat | Dog;
       export interface Dog {
         "kind": "dog";
@@ -570,8 +510,7 @@ describe.skip("Typescript Type Transform", () => {
           return dogToTransport(item)
         }
       }
-       `;
-      expect(actualContent).toBe(expectedContent);
+       `);
     });
   });
 });

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

@@ -1,4 +1,4 @@
-import { Output, render } from "@alloy-js/core";
+import { Output } from "@alloy-js/core";
 import { dedent } from "@alloy-js/core/testing";
 import { SourceFile } from "@alloy-js/typescript";
 import {
@@ -221,23 +221,15 @@ it("renders enums", async () => {
  */
 async function testValueExpression(value: Value, expected: string) {
   const prefix = "const val = ";
-  const res = render(
+
+  expect(
     <Output>
       <SourceFile path="test.ts">
         {prefix}
         <ValueExpression value={value} />
       </SourceFile>
     </Output>,
-  );
-  const testFile = res.contents.find((file) => file.path === "test.ts");
-
-  assert.exists(testFile, "test.ts file not rendered");
-
-  assert.equal(
-    testFile.contents,
-    `${prefix}${expected}`,
-    "test.ts file contents do not match expected",
-  );
+  ).toRenderTo(`${prefix}${expected}`);
 }
 
 /**

package/test/typescript/utils.tsx

@@ -0,0 +1,12 @@
+import type { Children } from "@alloy-js/core/jsx-runtime";
+import { SourceFile } from "@alloy-js/typescript";
+import type { Program } from "@typespec/compiler";
+import { Output } from "../../src/core/components/output.jsx";
+
+export function TestFile(props: { program: Program; children: Children }) {
+  return (
+    <Output program={props.program}>
+      <SourceFile path="test.ts">{props.children}</SourceFile>
+    </Output>
+  );
+}

package/test/utils.ts

@@ -10,12 +10,13 @@ export async function getEmitOutput(tspCode: string, cb: (program: Program) => C
 
   const res = render(Output().children(SourceFile({ path: "test.ts" }).children(cb(program))));
   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 function assertFileContents(res: OutputDirectory, contents: string) {
   const testFile = res.contents.find((file) => file.path === "test.ts")!;
   assert(testFile, "test.ts file not rendered");
+  assert("contents" in testFile, "test.ts file does not have contents");
   assert.equal(testFile.contents, contents);
 }