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

package/src/testing/scenario-test/test-host.ts

@@ -1,83 +0,0 @@
-import type { CompilerOptions, Diagnostic } from "@typespec/compiler";
-import {
-  type BasicTestRunner,
-  createTestHost,
-  createTestWrapper,
-  type TestHostConfig,
-  type TypeSpecTestLibrary,
-} from "@typespec/compiler/testing";
-import { HttpTestLibrary } from "@typespec/http/testing";
-import { RestTestLibrary } from "@typespec/rest/testing";
-import { join, relative } from "path";
-
-export interface EmittedFile {
-  path: string;
-  content: string;
-}
-
-async function createEmitterTestRunner(
-  testLibrary: TypeSpecTestLibrary,
-  options: {
-    testHostConfig?: TestHostConfig;
-    autoImports?: string[];
-    autoUsings?: string[];
-    compilerOptions?: CompilerOptions;
-  } = {},
-) {
-  const libraries = options.testHostConfig?.libraries ?? [
-    testLibrary,
-    HttpTestLibrary,
-    RestTestLibrary,
-  ];
-  const host = await createTestHost({ libraries });
-
-  return createTestWrapper(host, {
-    autoImports: options.autoImports ?? ["@typespec/http", "@typespec/rest"],
-    autoUsings: options.autoUsings ?? ["TypeSpec.Http", "TypeSpec.Rest"],
-    compilerOptions: options.compilerOptions ?? {
-      noEmit: false,
-      emit: [testLibrary.name],
-    },
-  });
-}
-
-export async function emitWithDiagnostics(
-  testLibrary: TypeSpecTestLibrary,
-  emitterOutputDir: string,
-  code: string,
-): Promise<[EmittedFile[], readonly Diagnostic[]]> {
-  const runner = await createEmitterTestRunner(testLibrary);
-  await runner.compileAndDiagnose(code, {
-    outputDir: "tsp-output",
-  });
-  const result = await readFilesRecursively(emitterOutputDir, emitterOutputDir, runner);
-  return [result, runner.program.diagnostics];
-}
-
-async function readFilesRecursively(
-  currentDir: string,
-  emitterOutputDir: string,
-  runner: BasicTestRunner,
-): Promise<EmittedFile[]> {
-  const entries = await runner.program.host.readDir(currentDir);
-  const result: EmittedFile[] = [];
-
-  for (const entry of entries) {
-    const fullPath = join(currentDir, entry);
-    const stat = await runner.program.host.stat(fullPath);
-
-    if (stat.isDirectory()) {
-      // Recursively read files in the directory
-      const nestedFiles = await readFilesRecursively(fullPath, emitterOutputDir, runner);
-      result.push(...nestedFiles);
-    } else if (stat.isFile()) {
-      // Read the file
-      // Read the file and store it with a relative path
-      const relativePath = relative(emitterOutputDir, fullPath);
-      const fileContent = await runner.program.host.readFile(fullPath);
-      result.push({ path: relativePath, content: fileContent.text });
-    }
-  }
-
-  return result;
-}

package/test/csharp/components/enum-declaration.test.tsx

@@ -1,337 +0,0 @@
-import { render } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
-import * as cs from "@alloy-js/csharp";
-import { Namespace, SourceFile } from "@alloy-js/csharp";
-import type { Enum } from "@typespec/compiler";
-import type { BasicTestRunner } from "@typespec/compiler/testing";
-import { beforeEach, it } from "vitest";
-import { Output } from "../../../src/core/index.js";
-import { EnumDeclaration } from "../../../src/csharp/index.js";
-import { createEmitterFrameworkTestRunner } from "../test-host.js";
-import { assertFileContents } from "../utils.js";
-
-let runner: BasicTestRunner;
-
-beforeEach(async () => {
-  runner = await createEmitterFrameworkTestRunner();
-});
-
-it("renders a basic enum declaration", async () => {
-  const { TestEnum } = (await runner.compile(`
-    @test enum TestEnum {
-      Value1;
-      Value2;
-      Value3;
-    }
-  `)) as { TestEnum: Enum };
-
-  const res = render(
-    <Output program={runner.program}>
-      <Namespace name="TestNamespace">
-        <SourceFile path="test.cs">
-          <EnumDeclaration type={TestEnum} />
-        </SourceFile>
-      </Namespace>
-    </Output>,
-  );
-
-  assertFileContents(
-    res,
-    d`
-      namespace TestNamespace
-      {
-          enum TestEnum
-          {
-              Value1,
-              Value2,
-              Value3
-          }
-      }
-    `,
-  );
-});
-
-it("renders an empty enum declaration", async () => {
-  const { TestEnum } = (await runner.compile(`
-    @test enum TestEnum {}
-  `)) as { TestEnum: Enum };
-
-  const res = render(
-    <Output program={runner.program}>
-      <Namespace name="TestNamespace">
-        <SourceFile path="test.cs">
-          <EnumDeclaration type={TestEnum} />
-        </SourceFile>
-      </Namespace>
-    </Output>,
-  );
-
-  assertFileContents(
-    res,
-    d`
-      namespace TestNamespace
-      {
-          enum TestEnum
-          {
-
-          }
-      }
-    `,
-  );
-});
-
-it("can override enum name", async () => {
-  const { TestEnum } = (await runner.compile(`
-    @test enum TestEnum {
-      Value1;
-      Value2;
-    }
-  `)) as { TestEnum: Enum };
-
-  const res = render(
-    <Output program={runner.program}>
-      <Namespace name="TestNamespace">
-        <SourceFile path="test.cs">
-          <EnumDeclaration type={TestEnum} name="CustomEnumName" />
-        </SourceFile>
-      </Namespace>
-    </Output>,
-  );
-
-  assertFileContents(
-    res,
-    d`
-      namespace TestNamespace
-      {
-          enum CustomEnumName
-          {
-              Value1,
-              Value2
-          }
-      }
-    `,
-  );
-});
-
-it("renders an enum with access modifiers", async () => {
-  const { TestEnum } = (await runner.compile(`
-    @test enum TestEnum {
-      Value1;
-      Value2;
-    }
-  `)) as { TestEnum: Enum };
-
-  const res = render(
-    <Output program={runner.program}>
-      <Namespace name="TestNamespace">
-        <SourceFile path="test.cs">
-          <EnumDeclaration type={TestEnum} internal />
-        </SourceFile>
-      </Namespace>
-    </Output>,
-  );
-
-  assertFileContents(
-    res,
-    d`
-      namespace TestNamespace
-      {
-          internal enum TestEnum
-          {
-              Value1,
-              Value2
-          }
-      }
-    `,
-  );
-});
-
-it("renders enum with C# naming conventions", async () => {
-  const { TestEnum } = (await runner.compile(`
-    @test enum TestEnum {
-      value_one;
-      value_two;
-      value_three;
-    }
-  `)) as { TestEnum: Enum };
-
-  const res = render(
-    <Output program={runner.program} namePolicy={cs.createCSharpNamePolicy()}>
-      <Namespace name="TestNamespace">
-        <SourceFile path="test.cs">
-          <EnumDeclaration type={TestEnum} />
-        </SourceFile>
-      </Namespace>
-    </Output>,
-  );
-
-  assertFileContents(
-    res,
-    d`
-      namespace TestNamespace
-      {
-          enum TestEnum
-          {
-              ValueOne,
-              ValueTwo,
-              ValueThree
-          }
-      }
-    `,
-  );
-});
-
-it("renders enum with single value", async () => {
-  const { TestEnum } = (await runner.compile(`
-    @test enum TestEnum {
-      OnlyValue;
-    }
-  `)) as { TestEnum: Enum };
-
-  const res = render(
-    <Output program={runner.program}>
-      <Namespace name="TestNamespace">
-        <SourceFile path="test.cs">
-          <EnumDeclaration type={TestEnum} />
-        </SourceFile>
-      </Namespace>
-    </Output>,
-  );
-
-  assertFileContents(
-    res,
-    d`
-      namespace TestNamespace
-      {
-          enum TestEnum
-          {
-              OnlyValue
-          }
-      }
-    `,
-  );
-});
-
-it("renders enum with numeric-like member names", async () => {
-  const { TestEnum } = (await runner.compile(`
-    @test enum TestEnum {
-      Value0;
-      Value1;
-      Value10;
-      Value100;
-    }
-  `)) as { TestEnum: Enum };
-
-  const res = render(
-    <Output program={runner.program}>
-      <Namespace name="TestNamespace">
-        <SourceFile path="test.cs">
-          <EnumDeclaration type={TestEnum} />
-        </SourceFile>
-      </Namespace>
-    </Output>,
-  );
-
-  assertFileContents(
-    res,
-    d`
-      namespace TestNamespace
-      {
-          enum TestEnum
-          {
-              Value0,
-              Value1,
-              Value10,
-              Value100
-          }
-      }
-    `,
-  );
-});
-
-it("renders multiple enums in the same namespace", async () => {
-  const { TestEnum1, TestEnum2 } = (await runner.compile(`
-    @test enum TestEnum1 {
-      Value1;
-      Value2;
-    }
-    @test enum TestEnum2 {
-      OptionA;
-      OptionB;
-      OptionC;
-    }
-  `)) as { TestEnum1: Enum; TestEnum2: Enum };
-
-  const res = render(
-    <Output program={runner.program}>
-      <Namespace name="TestNamespace">
-        <SourceFile path="test.cs">
-          <EnumDeclaration type={TestEnum1} />
-          <hbr />
-          <EnumDeclaration type={TestEnum2} />
-        </SourceFile>
-      </Namespace>
-    </Output>,
-  );
-
-  assertFileContents(
-    res,
-    d`
-      namespace TestNamespace
-      {
-          enum TestEnum1
-          {
-              Value1,
-              Value2
-          }
-          enum TestEnum2
-          {
-              OptionA,
-              OptionB,
-              OptionC
-          }
-      }
-    `,
-  );
-});
-
-it("renders an enum with doc comments", async () => {
-  const { TestEnum } = (await runner.compile(`
-    @test enum TestEnum {
-      @doc("This is value one")
-      Value1;
-      /** This is value two */
-      Value2;
-    }
-  `)) as { TestEnum: Enum };
-
-  const res = render(
-    <Output program={runner.program}>
-      <Namespace name="TestNamespace">
-        <SourceFile path="test.cs">
-          <EnumDeclaration type={TestEnum} />
-        </SourceFile>
-      </Namespace>
-    </Output>,
-  );
-
-  assertFileContents(
-    res,
-    d`
-      namespace TestNamespace
-      {
-          enum TestEnum
-          {
-              /// <summary>
-              /// This is value one
-              /// </summary>
-              Value1,
-              /// <summary>
-              /// This is value two
-              /// </summary>
-              Value2
-          }
-      }
-    `,
-  );
-});

package/test/csharp/test-host.ts

@@ -1,42 +0,0 @@
-import type { Program } from "@typespec/compiler";
-import {
-  createTestHost,
-  createTestWrapper,
-  expectDiagnosticEmpty,
-  type TypeSpecTestLibrary,
-} from "@typespec/compiler/testing";
-import { HttpTestLibrary } from "@typespec/http/testing";
-
-export async function createTypespecCliTestHost(
-  options: { libraries: "Http"[] } = { libraries: [] },
-) {
-  const libraries: TypeSpecTestLibrary[] = [];
-  if (options.libraries.includes("Http")) {
-    libraries.push(HttpTestLibrary);
-  }
-  return createTestHost({
-    libraries,
-  });
-}
-
-export async function createEmitterFrameworkTestRunner(options: { autoUsings?: string[] } = {}) {
-  const host = await createTypespecCliTestHost();
-  return createTestWrapper(host, {
-    autoUsings: options.autoUsings,
-  });
-}
-
-export async function getProgram(
-  code: string,
-  options: { libraries: "Http"[] } = { libraries: [] },
-): Promise<Program> {
-  const host = await createTypespecCliTestHost(options);
-  const wrapper = createTestWrapper(host, {
-    compilerOptions: {
-      noEmit: true,
-    },
-  });
-  const [_, diagnostics] = await wrapper.compileAndDiagnose(code);
-  expectDiagnosticEmpty(diagnostics);
-  return wrapper.program;
-}

package/test/csharp/utils.ts

@@ -1,8 +0,0 @@
-import type { OutputDirectory } from "@alloy-js/core";
-import { assert } from "vitest";
-
-export function assertFileContents(res: OutputDirectory, contents: string) {
-  const testFile = res.contents.find((file) => file.path === "test.cs")!;
-  assert(testFile, "test.cs file not rendered");
-  assert.equal(testFile.contents, contents);
-}