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

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

@@ -1,4 +1,4 @@
-import { Block, type Children, For, mapJoin } from "@alloy-js/core";
+import { type Children, For, mapJoin } from "@alloy-js/core";
 import * as ts from "@alloy-js/typescript";
 import {
   type Interface,
@@ -73,9 +73,9 @@ export interface InterfaceExpressionProps extends ts.InterfaceExpressionProps {
 
 export function InterfaceExpression(props: InterfaceExpressionProps) {
   return (
-    <Block>
+    <ts.InterfaceExpression>
       <InterfaceBody {...props} />
-    </Block>
+    </ts.InterfaceExpression>
   );
 }
 

package/src/typescript/components/union/expression.test.tsx

@@ -1,5 +1,5 @@
-import { Output } from "#core/index.js";
 import { Tester } from "#test/test-host.js";
+import { TestFile } from "#test/typescript/utils.jsx";
 import { t } from "@typespec/compiler/testing";
 import { expect, it } from "vitest";
 import { UnionExpression } from "./expression.jsx";
@@ -13,9 +13,9 @@ it("renders a union expression", async () => {
   `);
 
   expect(
-    <Output program={program}>
+    <TestFile program={program}>
       <UnionExpression type={TestUnion} />
-    </Output>,
+    </TestFile>,
   ).toRenderTo(`"one" | "two"`);
 });
 
@@ -28,9 +28,9 @@ it("renders a union expression without conflicting names", async () => {
   `);
 
   expect(
-    <Output program={program}>
+    <TestFile program={program}>
       <UnionExpression type={TestUnion} />
-    </Output>,
+    </TestFile>,
   ).toRenderTo(`
     {
       common: "one";

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

@@ -1,9 +1,8 @@
-import { render } from "@alloy-js/core";
+import { code } from "@alloy-js/core";
 import { d } from "@alloy-js/core/testing";
 import { SourceFile } from "@alloy-js/typescript";
 import type { Namespace } 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 { FunctionDeclaration } from "../../../src/typescript/components/function-declaration.js";
 import { getProgram } from "../test-host.js";
@@ -19,21 +18,13 @@ describe("Typescript Function Declaration", () => {
         const [namespace] = program.resolveTypeReference("DemoService");
         const operation = Array.from((namespace as Namespace).operations.values())[0];
 
-        const res = render(
+        expect(
           <Output program={program}>
             <SourceFile path="test.ts">
               <FunctionDeclaration type={operation} />
             </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(`function getName(id: string): string{}`, {
-          parser: "typescript",
-        });
-        expect(actualContent).toBe(expectedContent);
+        ).toRenderTo(`function getName(id: string): string {}`);
       });
 
       it("creates a function with JSDoc", async () => {
@@ -50,31 +41,20 @@ describe("Typescript Function Declaration", () => {
         const [namespace] = program.resolveTypeReference("DemoService");
         const operation = Array.from((namespace as Namespace).operations.values())[0];
 
-        const res = render(
+        expect(
           <Output program={program}>
             <SourceFile path="test.ts">
               <FunctionDeclaration type={operation} />
             </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(`
           /**
            * This is a test function
-           * 
+           *
            * @param {string} id - This is the id
            * @param {string} name
            */
-          function getName(id: string, name: string): string{}`,
-          {
-            parser: "typescript",
-          },
-        );
-        expect(actualContent).toBe(expectedContent);
+          function getName(id: string, name: string): string {}`);
       });
 
       it("creates a function with overridden JSDoc", async () => {
@@ -88,30 +68,19 @@ describe("Typescript Function Declaration", () => {
         const [namespace] = program.resolveTypeReference("DemoService");
         const operation = Array.from((namespace as Namespace).operations.values())[0];
 
-        const res = render(
+        expect(
           <Output program={program}>
             <SourceFile path="test.ts">
               <FunctionDeclaration doc={["This is a custom description"]} type={operation} />
             </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(`
           /**
            * This is a custom description
            *
            * @param {string} id
            */
-          function getName(id: string): string{}`,
-          {
-            parser: "typescript",
-          },
-        );
-        expect(actualContent).toBe(expectedContent);
+          function getName(id: string): string {}`);
       });
 
       it("creates an async function", async () => {
@@ -123,27 +92,13 @@ describe("Typescript Function Declaration", () => {
         const [namespace] = program.resolveTypeReference("DemoService");
         const operation = Array.from((namespace as Namespace).operations.values())[0];
 
-        const res = render(
+        expect(
           <Output program={program}>
             <SourceFile path="test.ts">
               <FunctionDeclaration async type={operation} />
             </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(
-          d`async function getName(id: string): Promise<string> {
-          
-          
-          }`,
-          {
-            parser: "typescript",
-          },
-        );
-        expect(actualContent).toBe(expectedContent);
+        ).toRenderTo(d`async function getName(id: string): Promise<string> {}`);
       });
 
       it("exports a function", async () => {
@@ -155,21 +110,13 @@ describe("Typescript Function Declaration", () => {
         const [namespace] = program.resolveTypeReference("DemoService");
         const operation = Array.from((namespace as Namespace).operations.values())[0];
 
-        const res = render(
+        expect(
           <Output program={program}>
             <SourceFile path="test.ts">
               <FunctionDeclaration export type={operation} />
             </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 function getName(id: string): string{}`, {
-          parser: "typescript",
-        });
-        expect(actualContent).toBe(expectedContent);
+        ).toRenderTo(`export function getName(id: string): string {}`);
       });
 
       it("can override name", async () => {
@@ -181,21 +128,13 @@ describe("Typescript Function Declaration", () => {
         const [namespace] = program.resolveTypeReference("DemoService");
         const operation = Array.from((namespace as Namespace).operations.values())[0];
 
-        const res = render(
+        expect(
           <Output program={program}>
             <SourceFile path="test.ts">
               <FunctionDeclaration name="newName" type={operation} />
             </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(`function newName(id: string): string{}`, {
-          parser: "typescript",
-        });
-        expect(actualContent).toBe(expectedContent);
+        ).toRenderTo(`function newName(id: string): string {}`);
       });
 
       it("can append extra parameters with raw params provided", async () => {
@@ -207,7 +146,7 @@ describe("Typescript Function Declaration", () => {
         const [namespace] = program.resolveTypeReference("DemoService");
         const operation = Array.from((namespace as Namespace).operations.values())[0];
 
-        const res = render(
+        expect(
           <Output program={program}>
             <SourceFile path="test.ts">
               <FunctionDeclaration
@@ -219,18 +158,7 @@ describe("Typescript Function Declaration", () => {
               />
             </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(
-          `function createPerson(name: string, age: number, id: string): string{}`,
-          {
-            parser: "typescript",
-          },
-        );
-        expect(actualContent).toBe(expectedContent);
+        ).toRenderTo(`function createPerson(name: string, age: number, id: string): string {}`);
       });
 
       it.skip("can override parameters with an array of ModelProperties", async () => {
@@ -248,7 +176,7 @@ describe("Typescript Function Declaration", () => {
         const operation = Array.from((namespace as Namespace).operations.values())[0];
         const model = Array.from((namespace as Namespace).models.values())[0];
 
-        const res = render(
+        expect(
           <Output program={program}>
             <SourceFile path="test.ts">
               <FunctionDeclaration type={operation}>
@@ -256,18 +184,7 @@ describe("Typescript Function Declaration", () => {
               </FunctionDeclaration>
             </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(
-          `function createPerson(name: string, age: number): string{}`,
-          { parser: "typescript" },
-        );
-
-        expect(actualContent).toBe(expectedContent);
+        ).toRenderTo(`function createPerson(name: string, age: number): string {}`);
       });
 
       it("can render function body", async () => {
@@ -279,29 +196,22 @@ describe("Typescript Function Declaration", () => {
         const [namespace] = program.resolveTypeReference("DemoService");
         const operation = Array.from((namespace as Namespace).operations.values())[0];
 
-        const res = render(
+        expect(
           <Output program={program}>
             <SourceFile path="test.ts">
               <FunctionDeclaration export type={operation}>
-                const message = "Hello World!"; console.log(message);
+                {code`
+                  const message = "Hello World!";
+                  console.log(message);
+                `}
               </FunctionDeclaration>
             </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 function createPerson(id: string): string {
-               const message = "Hello World!";
-               console.log(message);
-           }`,
-          { parser: "typescript" },
-        );
-
-        expect(actualContent).toBe(expectedContent);
+        ).toRenderTo(`
+          export function createPerson(id: string): string {
+            const message = "Hello World!";
+            console.log(message);
+          }`);
       });
     });
   });