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

package/dist/src/csharp/components/enum/declaration.test.js

@@ -0,0 +1,309 @@
+import { createComponent as _$createComponent, createIntrinsic as _$createIntrinsic } from "@alloy-js/core/jsx-runtime";
+import { Tester } from "#test/test-host.js";
+import { createCSharpNamePolicy, Namespace, SourceFile } from "@alloy-js/csharp";
+import { t } from "@typespec/compiler/testing";
+import { beforeEach, expect, it } from "vitest";
+import { Output } from "../../../core/index.js";
+import { EnumDeclaration } from "../../index.js";
+let runner;
+beforeEach(async () => {
+  runner = await Tester.createInstance();
+});
+function Wrapper(props) {
+  const policy = createCSharpNamePolicy();
+  return _$createComponent(Output, {
+    get program() {
+      return runner.program;
+    },
+    namePolicy: policy,
+    get children() {
+      return _$createComponent(Namespace, {
+        name: "TestNamespace",
+        get children() {
+          return _$createComponent(SourceFile, {
+            path: "test.cs",
+            get children() {
+              return props.children;
+            }
+          });
+        }
+      });
+    }
+  });
+}
+it("renders a basic enum declaration", async () => {
+  const {
+    TestEnum
+  } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {
+      Value1;
+      Value2;
+      Value3;
+    }
+  `);
+  expect(_$createComponent(Wrapper, {
+    get children() {
+      return _$createComponent(EnumDeclaration, {
+        type: TestEnum
+      });
+    }
+  })).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum TestEnum
+        {
+            Value1,
+            Value2,
+            Value3
+        }
+    }
+  `);
+});
+it("renders an empty enum declaration", async () => {
+  const {
+    TestEnum
+  } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {}
+  `);
+  expect(_$createComponent(Wrapper, {
+    get children() {
+      return _$createComponent(EnumDeclaration, {
+        type: TestEnum
+      });
+    }
+  })).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum TestEnum
+        {
+
+        }
+    }
+  `);
+});
+it("can override enum name", async () => {
+  const {
+    TestEnum
+  } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {
+      Value1;
+      Value2;
+    }
+  `);
+  expect(_$createComponent(Wrapper, {
+    get children() {
+      return _$createComponent(EnumDeclaration, {
+        type: TestEnum,
+        name: "CustomEnumName"
+      });
+    }
+  })).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum CustomEnumName
+        {
+            Value1,
+            Value2
+        }
+    }
+  `);
+});
+it("renders an enum with access modifiers", async () => {
+  const {
+    TestEnum
+  } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {
+      Value1;
+      Value2;
+    }
+  `);
+  expect(_$createComponent(Wrapper, {
+    get children() {
+      return _$createComponent(EnumDeclaration, {
+        type: TestEnum,
+        internal: true
+      });
+    }
+  })).toRenderTo(`
+    namespace TestNamespace
+    {
+        internal enum TestEnum
+        {
+            Value1,
+            Value2
+        }
+    }
+  `);
+});
+it("renders enum with C# naming conventions", async () => {
+  const {
+    TestEnum
+  } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {
+      value_one;
+      value_two;
+      value_three;
+    }
+  `);
+  expect(_$createComponent(Output, {
+    get program() {
+      return runner.program;
+    },
+    get namePolicy() {
+      return createCSharpNamePolicy();
+    },
+    get children() {
+      return _$createComponent(Namespace, {
+        name: "TestNamespace",
+        get children() {
+          return _$createComponent(SourceFile, {
+            path: "test.cs",
+            get children() {
+              return _$createComponent(EnumDeclaration, {
+                type: TestEnum
+              });
+            }
+          });
+        }
+      });
+    }
+  })).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum TestEnum
+        {
+            ValueOne,
+            ValueTwo,
+            ValueThree
+        }
+    }
+  `);
+});
+it("renders enum with single value", async () => {
+  const {
+    TestEnum
+  } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {
+      OnlyValue;
+    }
+  `);
+  expect(_$createComponent(Wrapper, {
+    get children() {
+      return _$createComponent(EnumDeclaration, {
+        type: TestEnum
+      });
+    }
+  })).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum TestEnum
+        {
+            OnlyValue
+        }
+    }
+  `);
+});
+it("renders enum with numeric-like member names", async () => {
+  const {
+    TestEnum
+  } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {
+      Value0;
+      Value1;
+      Value10;
+      Value100;
+    }
+  `);
+  expect(_$createComponent(Wrapper, {
+    get children() {
+      return _$createComponent(EnumDeclaration, {
+        type: TestEnum
+      });
+    }
+  })).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum TestEnum
+        {
+            Value0,
+            Value1,
+            Value10,
+            Value100
+        }
+    }
+  `);
+});
+it("renders multiple enums in the same namespace", async () => {
+  const {
+    TestEnum1,
+    TestEnum2
+  } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum1")} {
+      Value1;
+      Value2;
+    }
+    @test enum ${t.enum("TestEnum2")} {
+      OptionA;
+      OptionB;
+      OptionC;
+    }
+  `);
+  expect(_$createComponent(Wrapper, {
+    get children() {
+      return [_$createComponent(EnumDeclaration, {
+        type: TestEnum1
+      }), _$createIntrinsic("hbr", {}), _$createComponent(EnumDeclaration, {
+        type: TestEnum2
+      })];
+    }
+  })).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum TestEnum1
+        {
+            Value1,
+            Value2
+        }
+        enum TestEnum2
+        {
+            OptionA,
+            OptionB,
+            OptionC
+        }
+    }
+  `);
+});
+it("renders an enum with doc comments", async () => {
+  const {
+    TestEnum
+  } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {
+      @doc("This is value one")
+      Value1;
+      /** This is value two */
+      Value2;
+    }
+  `);
+  expect(_$createComponent(Wrapper, {
+    get children() {
+      return _$createComponent(EnumDeclaration, {
+        type: TestEnum
+      });
+    }
+  })).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum TestEnum
+        {
+            /// <summary>
+            /// This is value one
+            /// </summary>
+            Value1,
+            /// <summary>
+            /// This is value two
+            /// </summary>
+            Value2
+        }
+    }
+  `);
+});

package/dist/src/csharp/components/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./class/declaration.js";
-export * from "./enum-declaration.jsx";
+export * from "./enum/declaration.jsx";
 export * from "./property/property.jsx";
 export * from "./type-expression.jsx";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/csharp/components/index.js

@@ -1,4 +1,4 @@
 export * from "./class/declaration.js";
-export * from "./enum-declaration.js";
+export * from "./enum/declaration.js";
 export * from "./property/property.js";
 export * from "./type-expression.js";

package/dist/src/csharp/components/property/property.test.js

@@ -53,10 +53,10 @@ it("maps prop: string | null to nullable property", async () => {
   })).toRenderTo(`
       namespace TestNamespace
       {
-        class Test
-        {
-          public required string? Prop1 { get; set; }
-        }
+          class Test
+          {
+              public required string? Prop1 { get; set; }
+          }
       }
   `);
 });
@@ -79,11 +79,11 @@ describe("jsonAttributes", () => {
     })).toRenderTo(`
       namespace TestNamespace
       {
-        class Test
-        {
-          [System.Text.Json.JsonPropertyName("prop1")]
-          public required string Prop1 { get; set; }
-        }
+          class Test
+          {
+              [System.Text.Json.JsonPropertyName("prop1")]
+              public required string Prop1 { get; set; }
+          }
       }
   `);
   });
@@ -106,11 +106,11 @@ describe("jsonAttributes", () => {
     })).toRenderTo(`
       namespace TestNamespace
       {
-        class Test
-        {
-          [System.Text.Json.JsonPropertyName("prop_1")]
-          public required string Prop1 { get; set; }
-        }
+          class Test
+          {
+              [System.Text.Json.JsonPropertyName("prop_1")]
+              public required string Prop1 { get; set; }
+          }
       }
   `);
   });

package/dist/src/testing/scenario-test/code-block-expectation.d.ts

@@ -0,0 +1,33 @@
+import type { SnippetExtractor } from "./snippet-extractor.js";
+export interface ElementQuery {
+    /** Type to query */
+    type: string;
+    /** Name of the type to query */
+    name: string;
+}
+export interface CodeBlockQuery {
+    /** Language */
+    lang: string;
+    /** File path */
+    file: string;
+    /** Query for content in the file */
+    query?: ElementQuery;
+}
+export interface CodeBlockExpectation extends CodeBlockQuery {
+    /** Expected content of the code block */
+    expected: string;
+}
+/**
+ * Parse a markdown code block following the expectation syntax
+ */
+export declare function parseCodeblockExpectation(heading: string, content: string): CodeBlockExpectation;
+/**
+ * Parse the codeblock heading for what it should validate.
+ * Expected format
+ * ```
+ * ts path/to/file.ts {type} {name}
+ * ```
+ */
+export declare function parseCodeBlockHeading(heading: string): CodeBlockQuery;
+export declare function getExcerptForQuery(snippetExtractor: SnippetExtractor, expectation: CodeBlockQuery, outputs: Record<string, string>): string;
+//# sourceMappingURL=code-block-expectation.d.ts.map

package/dist/src/testing/scenario-test/code-block-expectation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-block-expectation.d.ts","sourceRoot":"","sources":["../../../../src/testing/scenario-test/code-block-expectation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,MAAM,WAAW,YAAY;IAC3B,oBAAoB;IACpB,IAAI,EAAE,MAAM,CAAC;IAEb,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,cAAc;IAC7B,eAAe;IACf,IAAI,EAAE,MAAM,CAAC;IAEb,gBAAgB;IAChB,IAAI,EAAE,MAAM,CAAC;IAEb,oCAAoC;IACpC,KAAK,CAAC,EAAE,YAAY,CAAC;CACtB;AAED,MAAM,WAAW,oBAAqB,SAAQ,cAAc;IAC1D,yCAAyC;IACzC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,oBAAoB,CAMhG;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,CAerE;AAED,wBAAgB,kBAAkB,CAChC,gBAAgB,EAAE,gBAAgB,EAClC,WAAW,EAAE,cAAc,EAC3B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9B,MAAM,CAUR"}

package/dist/src/testing/scenario-test/code-block-expectation.js

@@ -0,0 +1,69 @@
+/**
+ * Parse a markdown code block following the expectation syntax
+ */
+export function parseCodeblockExpectation(heading, content) {
+  const query = parseCodeBlockHeading(heading);
+  return {
+    ...query,
+    expected: content
+  };
+}
+
+/**
+ * Parse the codeblock heading for what it should validate.
+ * Expected format
+ * ```
+ * ts path/to/file.ts {type} {name}
+ * ```
+ */
+export function parseCodeBlockHeading(heading) {
+  const [lang, file, type, name] = heading.split(" ");
+  if (!file) {
+    throw new Error(`Invalid code block heading: "${heading}". Missing file path. Expected format: "<lang> <path>"`);
+  }
+  if (type && !name) {
+    throw new Error(`Invalid code block heading: "${heading}". Missing name when using type. Expected format: "<lang> <path> [type] [name]"`);
+  }
+  return {
+    lang,
+    file,
+    query: type ? {
+      type,
+      name
+    } : undefined
+  };
+}
+export function getExcerptForQuery(snippetExtractor, expectation, outputs) {
+  const content = outputs[expectation.file];
+  if (!content) {
+    throw new Error(`File ${expectation.file} not found in emitted files:\n ${Object.keys(outputs).join("\n")}`);
+  }
+  return getExcerptInFile(snippetExtractor, expectation, content);
+}
+function getExcerptInFile(snippetExtractor, expectation, sourceFile) {
+  if (expectation.query) {
+    const excerpt = tryGetExcerptInFile(snippetExtractor, expectation.query, sourceFile);
+    if (!excerpt) {
+      throw new Error(`Could not find ${expectation.query.type} "${expectation.query.name}" in file "${expectation.file}".`);
+    }
+    return excerpt;
+  } else {
+    return sourceFile;
+  }
+}
+function tryGetExcerptInFile(snippetExtractor, query, sourceFile) {
+  switch (query.type) {
+    case "interface":
+      return snippetExtractor.getInterface(sourceFile, query.name);
+    case "type":
+      return snippetExtractor.getTypeAlias(sourceFile, query.name);
+    case "enum":
+      return snippetExtractor.getEnum(sourceFile, query.name);
+    case "function":
+      return snippetExtractor.getFunction(sourceFile, query.name);
+    case "class":
+      return snippetExtractor.getClass(sourceFile, query.name);
+    default:
+      throw new Error("Unsupported type in code block expectation: " + query.type);
+  }
+}

package/dist/src/testing/scenario-test/code-block-expectation.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=code-block-expectation.test.d.ts.map

package/dist/src/testing/scenario-test/code-block-expectation.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-block-expectation.test.d.ts","sourceRoot":"","sources":["../../../../src/testing/scenario-test/code-block-expectation.test.ts"],"names":[],"mappings":""}

package/dist/src/testing/scenario-test/code-block-expectation.test.js

@@ -0,0 +1,80 @@
+import { d } from "@alloy-js/core/testing";
+import { beforeAll, describe, expect, it } from "vitest";
+import { getExcerptForQuery, parseCodeBlockHeading } from "./code-block-expectation.js";
+import { createSnippetExtractor, createTypeScriptExtractorConfig } from "./snippet-extractor.js";
+describe("parseCodeBlockHeading", () => {
+  it("parse whole file expectation", () => {
+    expect(parseCodeBlockHeading("ts path/to/file.ts")).toEqual({
+      lang: "ts",
+      file: "path/to/file.ts"
+    });
+  });
+  it("throws error when no file is provided", () => {
+    expect(() => parseCodeBlockHeading("ts")).toThrow('Invalid code block heading: "ts". Missing file path. Expected format: "<lang> <path>"');
+  });
+  it("parse parse with type and name", () => {
+    expect(parseCodeBlockHeading("ts path/to/file.ts interface foo")).toEqual({
+      lang: "ts",
+      file: "path/to/file.ts",
+      query: {
+        type: "interface",
+        name: "foo"
+      }
+    });
+  });
+  it("throws error when using type but no name is provided", () => {
+    expect(() => parseCodeBlockHeading("ts path/to/file.ts interface")).toThrow('Invalid code block heading: "ts path/to/file.ts interface". Missing name when using type. Expected format: "<lang> <path> [type] [name]"');
+  });
+});
+describe("getExcerptForQuery", () => {
+  let snippetExtractor;
+  beforeAll(async () => {
+    const tsExtractorConfig = await createTypeScriptExtractorConfig();
+    snippetExtractor = createSnippetExtractor(tsExtractorConfig);
+  });
+  it("gets a whole file", async () => {
+    const expectation = {
+      lang: "ts",
+      file: "file.ts"
+    };
+    const outputs = {
+      "file.ts": d`
+        interface bar {
+        
+        }
+        interface foo {
+          bar: string;
+        }      
+      `
+    };
+    const excerpt = getExcerptForQuery(snippetExtractor, expectation, outputs);
+    expect(excerpt).toBe(outputs["file.ts"]);
+  });
+  it("gets an interface for typescript", async () => {
+    const expectation = {
+      lang: "ts",
+      file: "file.ts",
+      query: {
+        type: "interface",
+        name: "foo"
+      }
+    };
+    const outputs = {
+      "file.ts": d`
+        interface bar {
+        
+        }
+
+        interface foo {
+          bar: string;
+        }
+      `
+    };
+    const excerpt = getExcerptForQuery(snippetExtractor, expectation, outputs);
+    expect(excerpt).toBe(d`
+      interface foo {
+        bar: string;
+      }
+    `);
+  });
+});

package/dist/src/testing/scenario-test/harness.d.ts

@@ -1,4 +1,4 @@
-import type { TypeSpecTestLibrary } from "@typespec/compiler/testing";
+import { type EmitterTester } from "@typespec/compiler/testing";
 import type { LanguageConfiguration, SnippetExtractor } from "./snippet-extractor.js";
-export declare function executeScenarios(testLibrary: TypeSpecTestLibrary, languageConfiguration: LanguageConfiguration, scenariosLocation: string, emitterOutputDir: string, snippetExtractor: SnippetExtractor): Promise<void>;
+export declare function executeScenarios(tester: EmitterTester, languageConfiguration: LanguageConfiguration, scenariosLocation: string, snippetExtractor: SnippetExtractor): Promise<void>;
 //# sourceMappingURL=harness.d.ts.map

package/dist/src/testing/scenario-test/harness.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"harness.d.ts","sourceRoot":"","sources":["../../../../src/testing/scenario-test/harness.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAMtE,OAAO,KAAK,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AA+HtF,wBAAsB,gBAAgB,CACpC,WAAW,EAAE,mBAAmB,EAChC,qBAAqB,EAAE,qBAAqB,EAC5C,iBAAiB,EAAE,MAAM,EACzB,gBAAgB,EAAE,MAAM,EACxB,gBAAgB,EAAE,gBAAgB,iBAkBnC"}
+{"version":3,"file":"harness.d.ts","sourceRoot":"","sources":["../../../../src/testing/scenario-test/harness.ts"],"names":[],"mappings":"AACA,OAAO,EAAyB,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAUvF,OAAO,KAAK,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAKtF,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,aAAa,EACrB,qBAAqB,EAAE,qBAAqB,EAC5C,iBAAiB,EAAE,MAAM,EACzB,gBAAgB,EAAE,gBAAgB,iBAKnC"}