@typespec/emitter-framework 0.6.0-dev.2 → 0.6.0-dev.5

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

@@ -564,7 +564,7 @@ describe("Typescript Interface", () => {
         const actualContent = await format(testFile.contents as string, { parser: "typescript" });
         const expectedContent = await format(
           `export interface WidgetOperations {
-          getName: (id: string) => string;
+          getName(id: string): string;
         }`,
           {
             parser: "typescript",
@@ -605,8 +605,8 @@ describe("Typescript Interface", () => {
         const actualContent = await format(testFile.contents as string, { parser: "typescript" });
         const expectedContent = await format(
           `export interface WidgetOperations {
-          getName: (foo: Foo) => string;
-          getOtherName: (name: string) => string
+          getName(foo: Foo): string;
+          getOtherName(name: string): string
         }
         export interface Foo {
           name: string;
@@ -654,7 +654,7 @@ describe("Typescript Interface", () => {
         const actualContent = await format(testFile.contents as string, { parser: "typescript" });
         const expectedContent = await format(
           `export interface WidgetOperations {
-          getName: (id: string) => Widget;
+          getName(id: string): Widget;
         }
         export interface Widget {
           id: string;
@@ -707,8 +707,8 @@ describe("Typescript Interface", () => {
         const actualContent = await format(testFile.contents as string, { parser: "typescript" });
         const expectedContent = await format(
           `export interface WidgetOperationsExtended {
-          getName: (id: string) => Widget;
-          delete: (id: string) => void;
+          getName(id: string): Widget;
+          delete(id: string): void;
         }
         export interface Widget {
           id: string;

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

@@ -0,0 +1,234 @@
+import { Output, render } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { InterfaceDeclaration, SourceFile } from "@alloy-js/typescript";
+import { Operation } from "@typespec/compiler";
+import { BasicTestRunner } from "@typespec/compiler/testing";
+import { beforeEach, describe, it } from "vitest";
+import { InterfaceMethod } from "../../../src/typescript/components/interface-method.jsx";
+import { assertFileContents } from "../../utils.js";
+import { createEmitterFrameworkTestRunner } from "../test-host.js";
+
+describe("interface methods with a `type` prop", () => {
+  let runner: BasicTestRunner;
+
+  beforeEach(async () => {
+    runner = await createEmitterFrameworkTestRunner();
+  });
+
+  it("creates a interface method", async () => {
+    const { getName } = (await runner.compile(`
+      @test op getName(id: string): string;
+    `)) as { getName: Operation };
+
+    const res = render(
+      <Output>
+        <SourceFile path="test.ts">
+          <InterfaceDeclaration name="basicInterface">
+            <InterfaceMethod type={getName} name={getName.name} />
+          </InterfaceDeclaration>
+        </SourceFile>
+      </Output>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+        interface basicInterface {
+          getName(id: string): string
+        }
+      `,
+    );
+  });
+
+  it("creates an async interface function", async () => {
+    const { getName } = (await runner.compile(`
+      @test op getName(id: string): string;
+    `)) as { getName: Operation };
+
+    const res = render(
+      <Output>
+        <SourceFile path="test.ts">
+          <InterfaceDeclaration name="basicInterface">
+            <InterfaceMethod async type={getName} />
+          </InterfaceDeclaration>
+        </SourceFile>
+      </Output>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+        interface basicInterface {
+          getName(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 res = render(
+      <Output>
+        <SourceFile path="test.ts">
+          <InterfaceDeclaration name="basicInterface">
+            <InterfaceMethod
+              type={getName}
+              parametersMode="append"
+              parameters={[{ name: "foo", type: "string" }]}
+            />
+          </InterfaceDeclaration>
+        </SourceFile>
+      </Output>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+        interface basicInterface {
+          getName(id: string, foo: string): string
+        }
+      `,
+    );
+  });
+
+  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 res = render(
+      <Output>
+        <SourceFile path="test.ts">
+          <InterfaceDeclaration name="basicInterface">
+            <InterfaceMethod
+              type={getName}
+              parametersMode="prepend"
+              parameters={[{ name: "foo", type: "string" }]}
+            />
+          </InterfaceDeclaration>
+        </SourceFile>
+      </Output>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+        interface basicInterface {
+          getName(foo: string, id: string): string
+        }
+      `,
+    );
+  });
+
+  it("can replace parameters with raw params provided", async () => {
+    const { getName } = (await runner.compile(`
+      @test op getName(id: string): string;
+    `)) as { getName: Operation };
+
+    const res = render(
+      <Output>
+        <SourceFile path="test.ts">
+          <InterfaceDeclaration name="basicInterface">
+            <InterfaceMethod
+              type={getName}
+              parametersMode="replace"
+              parameters={[
+                { name: "foo", type: "string" },
+                { name: "bar", type: "number" },
+              ]}
+            />
+          </InterfaceDeclaration>
+        </SourceFile>
+      </Output>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+        interface basicInterface {
+          getName(foo: string, bar: number): string
+        }
+      `,
+    );
+  });
+
+  it("can override return type", async () => {
+    const { getName } = (await runner.compile(`
+      @test op getName(id: string): string;
+    `)) as { getName: Operation };
+
+    const res = render(
+      <Output>
+        <SourceFile path="test.ts">
+          <InterfaceDeclaration name="basicInterface">
+            <InterfaceMethod type={getName} returnType="Promise<Record<string, unknown>>" />
+          </InterfaceDeclaration>
+        </SourceFile>
+      </Output>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+        interface basicInterface {
+          getName(id: string): Promise<Record<string, unknown>>
+        }
+      `,
+    );
+  });
+
+  it("can override method name", async () => {
+    const { getName } = (await runner.compile(`
+      @test op getName(id: string): string;
+    `)) as { getName: Operation };
+
+    const res = render(
+      <Output>
+        <SourceFile path="test.ts">
+          <InterfaceDeclaration name="basicInterface">
+            <InterfaceMethod type={getName} name="getNameCustom" />
+          </InterfaceDeclaration>
+        </SourceFile>
+      </Output>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+        interface basicInterface {
+          getNameCustom(id: string): string
+        }
+      `,
+    );
+  });
+});
+
+describe("interface methods without a `type` prop", () => {
+  it("renders a plain interface method", async () => {
+    const res = render(
+      <Output>
+        <SourceFile path="test.ts">
+          <InterfaceDeclaration name="basicInterface">
+            <InterfaceMethod
+              name="plainMethod"
+              parameters={[{ name: "param1", type: "string" }]}
+              returnType="number"
+            />
+          </InterfaceDeclaration>
+        </SourceFile>
+      </Output>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+        interface basicInterface {
+          plainMethod(param1: string): number
+        }
+      `,
+    );
+  });
+});

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

@@ -1,10 +1,11 @@
 import { Output, render } from "@alloy-js/core";
 import { SourceFile } from "@alloy-js/typescript";
-import { Namespace } from "@typespec/compiler";
+import { Namespace, Operation } from "@typespec/compiler";
 import { format } from "prettier";
 import { assert, describe, expect, it } from "vitest";
 import { TypeAliasDeclaration } from "../../../src/typescript/components/type-alias-declaration.jsx";
-import { getProgram } from "../test-host.js";
+import { assertFileContents } from "../../utils.js";
+import { createEmitterFrameworkTestRunner, getProgram } from "../test-host.js";
 
 describe("Typescript Type Alias Declaration", () => {
   describe("Type Alias bound to Typespec Scalar", () => {
@@ -117,4 +118,21 @@ 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 res = render(
+      <Output>
+        <SourceFile path="test.ts">
+          <TypeAliasDeclaration type={getName} />
+        </SourceFile>
+      </Output>,
+    );
+
+    assertFileContents(res, "type getName = (id: string) => string;");
+  });
 });

package/test/utils.ts

@@ -1,7 +1,8 @@
-import { Children, render } from "@alloy-js/core";
+import { Children, OutputDirectory, render } from "@alloy-js/core";
 import { Output } from "@alloy-js/core/stc";
 import { SourceFile } from "@alloy-js/typescript/stc";
 import { Program } from "@typespec/compiler";
+import { assert } from "vitest";
 import { getProgram } from "./typescript/test-host.js";
 
 export async function getEmitOutput(tspCode: string, cb: (program: Program) => Children) {
@@ -12,3 +13,9 @@ export async function getEmitOutput(tspCode: string, cb: (program: Program) => C
 
   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.equal(testFile.contents, contents);
+}