@alloy-js/csharp 0.1.0

package/test/class.test.tsx

@@ -0,0 +1,249 @@
+import * as core from "@alloy-js/core";
+import * as coretest from "@alloy-js/core/testing";
+import { expect, it } from "vitest";
+import * as csharp from "../src/index.js";
+import * as utils from "./utils.js";
+
+it("declares class with no members", () => {
+  const res = utils.toSourceText(
+    <csharp.Class accessModifier='public' name="TestClass" />,
+  );
+
+  expect(res).toBe(coretest.d`
+    namespace TestCode
+    {
+      public class TestClass;
+    }
+  `);
+});
+
+it("declares class with some members", () => {
+  const res = utils.toSourceText(
+    <csharp.Class accessModifier='public' name="TestClass">
+      <csharp.ClassMember accessModifier="public" name="MemberOne" type="string" />
+      <csharp.ClassMember accessModifier="private" name="MemberTwo" type="int" />
+    </csharp.Class>,
+  );
+
+  expect(res).toBe(coretest.d`
+    namespace TestCode
+    {
+      public class TestClass
+      {
+        public string MemberOne;
+        private int memberTwo;
+      }
+    }
+  `);
+});
+
+it("declares class with some methods", () => {
+  const res = utils.toSourceText(
+    <csharp.Class accessModifier='public' name="TestClass">
+      <csharp.ClassMethod accessModifier="public" name="MethodOne" />
+      <csharp.ClassMethod accessModifier="private" methodModifier="virtual" name="MethodTwo" />
+    </csharp.Class>,
+  );
+
+  expect(res).toBe(coretest.d`
+    namespace TestCode
+    {
+      public class TestClass
+      {
+        public void MethodOne() {}
+        private virtual void MethodTwo() {}
+      }
+    }
+  `);
+});
+
+it("declares class with params and return type", () => {
+  const params = [
+    {
+      name: "IntParam",
+      type: "int",
+    },
+    {
+      name: "StringParam",
+      type: "string",
+    },
+  ];
+  const res = utils.toSourceText(
+    <csharp.Class accessModifier='public' name="TestClass">
+      <csharp.ClassMethod accessModifier="public" name="MethodOne" parameters={params} returns="string" />
+    </csharp.Class>,
+  );
+
+  expect(res).toBe(coretest.d`
+    namespace TestCode
+    {
+      public class TestClass
+      {
+        public string MethodOne(int intParam, string stringParam) {}
+      }
+    }
+  `);
+});
+
+it("uses refkeys for members, params, and return type", () => {
+  const inputTypeRefkey = core.refkey();
+  const testResultTypeRefkey = core.refkey();
+  const enumTypeRefkey = core.refkey();
+
+  const params = [
+    {
+      name: "IntParam",
+      type: "int",
+    },
+    {
+      name: "BodyParam",
+      type: inputTypeRefkey,
+    },
+  ];
+
+  const res = core.render(
+    <core.Output namePolicy={csharp.createCSharpNamePolicy()}>
+      <csharp.Namespace name='TestCode'>
+        <csharp.SourceFile path="Test.cs">
+          <csharp.Enum accessModifier='public' name="TestEnum" refkey={enumTypeRefkey}>
+            <csharp.EnumMember name="One" />,
+            <csharp.EnumMember name="Two" />
+          </csharp.Enum>
+          <csharp.Class accessModifier="public" name="TestInput" refkey={inputTypeRefkey} />
+          <csharp.Class accessModifier="public" name="TestResult" refkey={testResultTypeRefkey} />
+          <csharp.Class accessModifier='public' name="TestClass">
+            <csharp.ClassMember accessModifier="private" name="MemberOne" type={enumTypeRefkey} />
+            <csharp.ClassMethod accessModifier="public" name="MethodOne" parameters={params} returns={testResultTypeRefkey}>
+              return new {testResultTypeRefkey}();
+            </csharp.ClassMethod>
+          </csharp.Class>
+        </csharp.SourceFile>
+      </csharp.Namespace>
+    </core.Output>,
+  );
+
+  expect(res.contents[0].contents).toBe(coretest.d`
+    namespace TestCode
+    {
+      public enum TestEnum
+      {
+        One,
+        Two
+      }
+      public class TestInput;
+      public class TestResult;
+      public class TestClass
+      {
+        private TestEnum memberOne;
+        public TestResult MethodOne(int intParam, TestInput bodyParam)
+        {
+          return new TestResult();
+        }
+      }
+    }
+  `);
+});
+
+it("declares class with generic parameters", () => {
+  const typeParameters = {
+    T: core.refkey(),
+    U: core.refkey(),
+  };
+
+  const res = utils.toSourceText(
+    <csharp.Class accessModifier='public' name="TestClass" typeParameters={typeParameters}>
+      <csharp.ClassMember accessModifier="public" name="memberOne" type={typeParameters.T} />
+      <csharp.ClassMember accessModifier="private" name="memberTwo" type={typeParameters.U} />
+    </csharp.Class>,
+  );
+
+  expect(res).toBe(coretest.d`
+    namespace TestCode
+    {
+      public class TestClass<T, U>
+      {
+        public T MemberOne;
+        private U memberTwo;
+      }
+    }
+  `);
+});
+
+it("declares class with invalid members", () => {
+  const decl =
+    <csharp.Class accessModifier='public' name="TestClass">
+      <csharp.EnumMember name="One" />,
+      <csharp.EnumMember name="Two" />
+    </csharp.Class>;
+
+  expect(() => utils.toSourceText(decl)).toThrow(
+    "can't define an enum member outside of an enum-decl scope",
+  );
+});
+
+it("declares class with constructor", () => {
+  const res = utils.toSourceText(
+    <csharp.Class accessModifier='public' name="TestClass">
+      <csharp.ClassConstructor accessModifier="public" />
+    </csharp.Class>,
+  );
+
+  expect(res).toBe(coretest.d`
+    namespace TestCode
+    {
+      public class TestClass
+      {
+        public TestClass() {}
+      }
+    }
+  `);
+});
+
+it("declares class with constructor params and assigns values to fields", () => {
+  const thisNameRefkey = core.refkey();
+  const thisSizeRefkey = core.refkey();
+  const paramNameRefkey = core.refkey();
+  const paramSizeRefkey = core.refkey();
+
+  const ctorParams = [
+    {
+      name: "name",
+      type: "string",
+      refkey: paramNameRefkey,
+    },
+    {
+      name: "size",
+      type: "int",
+      refkey: paramSizeRefkey,
+    },
+  ];
+
+  const res = utils.toSourceText(
+    <csharp.Class accessModifier='public' name="TestClass">
+      <csharp.ClassMember accessModifier="private" name="name" type="string" refkey={thisNameRefkey} />
+      <csharp.ClassMember accessModifier="private" name="size" type="int" refkey={thisSizeRefkey} />
+      <csharp.ClassConstructor accessModifier="public" parameters={ctorParams}>
+        {thisNameRefkey} = {paramNameRefkey};
+        {thisSizeRefkey} = {paramSizeRefkey};
+      </csharp.ClassConstructor>
+    </csharp.Class>,
+  );
+
+  // TODO: assignments to members should have this. prefix
+  // e.g. this.name = name;
+  expect(res).toBe(coretest.d`
+    namespace TestCode
+    {
+      public class TestClass
+      {
+        private string name;
+        private int size;
+        public TestClass(string name, int size)
+        {
+          name = name;
+          size = size;
+        }
+      }
+    }
+  `);
+});

package/test/enum.test.tsx

@@ -0,0 +1,147 @@
+import * as core from "@alloy-js/core";
+import * as coretest from "@alloy-js/core/testing";
+import { expect, it } from "vitest";
+import * as csharp from "../src/index.js";
+import * as utils from "./utils.js";
+
+it("declares enum with no members", () => {
+  const res = utils.toSourceText(
+    <csharp.Enum accessModifier='public' name="TestEnum" />,
+  );
+
+  expect(res).toBe(coretest.d`
+    namespace TestCode
+    {
+      public enum TestEnum;
+    }
+  `);
+});
+
+it("declares enum with members", () => {
+  const res = utils.toSourceText(
+    <csharp.Enum accessModifier='public' name="TestEnum">
+      <csharp.EnumMember name="One" />,
+      <csharp.EnumMember name="Two" />
+    </csharp.Enum>,
+  );
+
+  expect(res).toBe(coretest.d`
+    namespace TestCode
+    {
+      public enum TestEnum
+      {
+        One,
+        Two
+      }
+    }
+  `);
+});
+
+it("applies naming policy to enum and members", () => {
+  const res = utils.toSourceText(
+    <csharp.Enum accessModifier='public' name="testEnum">
+      <csharp.EnumMember name="one" />,
+      <csharp.EnumMember name="two" />
+    </csharp.Enum>,
+  );
+
+  expect(res).toBe(coretest.d`
+    namespace TestCode
+    {
+      public enum TestEnum
+      {
+        One,
+        Two
+      }
+    }
+  `);
+});
+
+it("can reference things by refkey", () => {
+  const enumRK = core.refkey();
+  const twoRK = core.refkey();
+
+  const res = core.render(
+    <core.Output>
+      <csharp.Namespace name='TestCode'>
+        <csharp.SourceFile path="Test.cs">
+          <csharp.Enum accessModifier='public' name="TestEnum" refkey={enumRK}>
+            <csharp.EnumMember name="One" />,
+            <csharp.EnumMember name="Two" refkey={twoRK} />
+          </csharp.Enum>
+          {enumRK};
+          {twoRK};
+        </csharp.SourceFile>
+      </csharp.Namespace>
+    </core.Output>,
+  );
+
+  expect(res.contents[0].contents).toBe(coretest.d`
+    namespace TestCode
+    {
+      public enum TestEnum
+      {
+        One,
+        Two
+      }
+      TestEnum;
+      TestEnum.Two;
+    }
+  `);
+});
+
+it("can reference things by refkey across files", () => {
+  const enumRK = core.refkey();
+  const barRK = core.refkey();
+
+  const res = core.render(
+    <core.Output>
+      <csharp.Namespace name='TestCode'>
+        <csharp.SourceFile path="Test.cs">
+          <csharp.Enum accessModifier='public' name="TestEnum">
+            <csharp.EnumMember name="One" />,
+            <csharp.EnumMember name="Two" />
+          </csharp.Enum>
+          {enumRK};
+          {barRK};
+        </csharp.SourceFile>
+        <csharp.SourceFile path="Other.cs">
+          <csharp.Enum accessModifier='public' name="OtherEnum" refkey={enumRK}>
+            <csharp.EnumMember name="Foo" />,
+            <csharp.EnumMember name="Bar" refkey={barRK} />
+          </csharp.Enum>
+          {enumRK};
+          {barRK};
+        </csharp.SourceFile>
+      </csharp.Namespace>
+    </core.Output>,
+  );
+
+  expect(res.contents[0].path).toBe("Test.cs");
+  expect(res.contents[0].contents).toBe(coretest.d`
+    namespace TestCode
+    {
+      public enum TestEnum
+      {
+        One,
+        Two
+      }
+      OtherEnum;
+      OtherEnum.Bar;
+    }
+  `);
+
+  expect(res.contents[1].path).toBe("Other.cs");
+  expect(res.contents[1].contents).toBe(coretest.d`
+    namespace TestCode
+    {
+      public enum OtherEnum
+      {
+        Foo,
+        Bar
+      }
+      OtherEnum;
+      OtherEnum.Bar;
+    }
+  `);
+});

package/test/namespace.test.tsx

@@ -0,0 +1,59 @@
+import * as core from "@alloy-js/core";
+import * as coretest from "@alloy-js/core/testing";
+import { expect, it } from "vitest";
+import * as csharp from "../src/index.js";
+
+it("defines multiple namespaces and source files with unique content", () => {
+  const res = core.render(
+    <core.Output>
+      <csharp.Namespace name='Namespace1'>
+        <csharp.SourceFile path="Model1.cs">
+          <csharp.Class accessModifier='public' name="Model1" />
+        </csharp.SourceFile>
+        <csharp.SourceFile path="Model2.cs">
+          <csharp.Class accessModifier='public' name="Model2" />
+        </csharp.SourceFile>
+      </csharp.Namespace>
+      <csharp.Namespace name='Namespace2'>
+        <csharp.SourceFile path="Model3.cs">
+          <csharp.Class accessModifier='public' name="Model3" />
+        </csharp.SourceFile>
+        <csharp.SourceFile path="Model4.cs">
+          <csharp.Class accessModifier='public' name="Model4" />
+        </csharp.SourceFile>
+      </csharp.Namespace>
+    </core.Output>,
+  );
+
+  expect(res.contents[0].path).equals("Model1.cs");
+  expect(res.contents[0].contents).toBe(coretest.d`
+    namespace Namespace1
+    {
+      public class Model1;
+    }
+  `);
+
+  expect(res.contents[1].path).equals("Model2.cs");
+  expect(res.contents[1].contents).toBe(coretest.d`
+    namespace Namespace1
+    {
+      public class Model2;
+    }
+  `);
+
+  expect(res.contents[2].path).equals("Model3.cs");
+  expect(res.contents[2].contents).toBe(coretest.d`
+    namespace Namespace2
+    {
+      public class Model3;
+    }
+  `);
+
+  expect(res.contents[3].path).equals("Model4.cs");
+  expect(res.contents[3].contents).toBe(coretest.d`
+    namespace Namespace2
+    {
+      public class Model4;
+    }
+  `);
+});

package/test/projectdirectory.test.tsx

@@ -0,0 +1,106 @@
+import * as core from "@alloy-js/core";
+import * as coretest from "@alloy-js/core/testing";
+import { expect, it } from "vitest";
+import * as csharp from "../src/index.js";
+
+it("defines a project directory file with multiple source files", () => {
+  const res = core.render(
+    <core.Output>
+      <csharp.ProjectDirectory name="TestProject" path="~/projects" version="0.1.0" description="a test project">
+        <csharp.Namespace name='TestCode'>
+          <csharp.SourceFile path="Test1.cs">
+            <csharp.Class accessModifier='public' name="TestClass1" />
+          </csharp.SourceFile>
+          <csharp.SourceFile path="Test2.cs">
+            <csharp.Class accessModifier='public' name="TestClass2" />
+          </csharp.SourceFile>
+        </csharp.Namespace>
+      </csharp.ProjectDirectory>
+    </core.Output>,
+  );
+
+  const projDir = res.contents[0] as core.OutputDirectory;
+
+  expect(projDir.path).equals("~/projects/TestProject");
+  expect(projDir.contents[0].path).equals(
+    "~/projects/TestProject/TestProject.csproj",
+  );
+  expect(projDir.contents[0].contents).toBe(coretest.d`
+    <Project Sdk="Microsoft.NET.Sdk">
+      <PropertyGroup>
+        <Version>0.1.0</Version>
+        <Description>a test project</Description>
+        <TargetFramework>net8.0</TargetFramework>
+      </PropertyGroup>
+    </Project>
+  `);
+
+  const srcDir = projDir.contents[1] as core.OutputDirectory;
+
+  expect(srcDir.contents[0].path).equals("~/projects/TestProject/src/Test1.cs");
+  expect(srcDir.contents[0].contents).toBe(coretest.d`
+    namespace TestCode
+    {
+      public class TestClass1;
+    }
+  `);
+
+  expect(srcDir.contents[1].path).equals("~/projects/TestProject/src/Test2.cs");
+  expect(srcDir.contents[1].contents).toBe(coretest.d`
+    namespace TestCode
+    {
+      public class TestClass2;
+    }
+  `);
+});
+
+it("defines a project directory file with multiple source files and a custom TFM", () => {
+  const res = core.render(
+    <core.Output>
+      <csharp.ProjectDirectory name="TestProject" path="~/projects" version="0.1.0" description="a test project" targetFrameworkMoniker="netstandard2.1">
+        <csharp.Namespace name='TestCode'>
+          <csharp.SourceFile path="Test1.cs">
+            <csharp.Class accessModifier='public' name="TestClass1" />
+          </csharp.SourceFile>
+          <csharp.SourceFile path="Test2.cs">
+            <csharp.Class accessModifier='public' name="TestClass2" />
+          </csharp.SourceFile>
+        </csharp.Namespace>
+      </csharp.ProjectDirectory>
+    </core.Output>,
+  );
+
+  const projDir = res.contents[0] as core.OutputDirectory;
+
+  expect(projDir.path).equals("~/projects/TestProject");
+  expect(projDir.contents[0].path).equals(
+    "~/projects/TestProject/TestProject.csproj",
+  );
+  expect(projDir.contents[0].contents).toBe(coretest.d`
+    <Project Sdk="Microsoft.NET.Sdk">
+      <PropertyGroup>
+        <Version>0.1.0</Version>
+        <Description>a test project</Description>
+        <TargetFramework>netstandard2.1</TargetFramework>
+      </PropertyGroup>
+    </Project>
+  `);
+
+  const srcDir = projDir.contents[1] as core.OutputDirectory;
+
+  expect(srcDir.contents[0].path).equals("~/projects/TestProject/src/Test1.cs");
+  expect(srcDir.contents[0].contents).toBe(coretest.d`
+    namespace TestCode
+    {
+      public class TestClass1;
+    }
+  `);
+
+  expect(srcDir.contents[1].path).equals("~/projects/TestProject/src/Test2.cs");
+  expect(srcDir.contents[1].contents).toBe(coretest.d`
+    namespace TestCode
+    {
+      public class TestClass2;
+    }
+  `);
+});

package/test/sourcefile.test.tsx

@@ -0,0 +1,46 @@
+import * as core from "@alloy-js/core";
+import * as coretest from "@alloy-js/core/testing";
+import { expect, it } from "vitest";
+import * as csharp from "../src/index.js";
+
+it("defines multiple source files with unique content", () => {
+  const res = core.render(
+    <core.Output>
+      <csharp.Namespace name='TestCode'>
+        <csharp.SourceFile path="Test1.cs">
+          <csharp.Class accessModifier='public' name="TestClass1" />
+        </csharp.SourceFile>
+        <csharp.SourceFile path="Test2.cs">
+          <csharp.Class accessModifier='public' name="TestClass2" />
+        </csharp.SourceFile>
+      </csharp.Namespace>
+    </core.Output>,
+  );
+
+  expect(res.contents[0].path).equals("Test1.cs");
+  expect(res.contents[0].contents).toBe(coretest.d`
+    namespace TestCode
+    {
+      public class TestClass1;
+    }
+  `);
+
+  expect(res.contents[1].path).equals("Test2.cs");
+  expect(res.contents[1].contents).toBe(coretest.d`
+    namespace TestCode
+    {
+      public class TestClass2;
+    }
+  `);
+});
+
+it("throws when declaring a source file outside a namespace", () => {
+  const decl =
+    <core.Output>
+    <csharp.SourceFile path="Test.cs" />
+  </core.Output>;
+
+  expect(() => core.render(decl)).toThrow(
+    "SourceFile must be declared inside a namespace",
+  );
+});

package/test/using.test.tsx

@@ -0,0 +1,97 @@
+import * as core from "@alloy-js/core";
+import * as coretest from "@alloy-js/core/testing";
+import { expect, it } from "vitest";
+import * as csharp from "../src/index.js";
+
+it("uses a single namespace", () => {
+  const res = core.render(
+    <core.Output>
+      <csharp.Namespace name='TestCode'>
+        <csharp.SourceFile path="Test1.cs" using={["Foo"]} />
+      </csharp.Namespace>
+    </core.Output>,
+  );
+
+  expect(res.contents[0].contents).toBe(coretest.d`
+    using Foo;
+    namespace TestCode {}
+  `);
+});
+
+it("uses multiple namespaces", () => {
+  const res = core.render(
+    <core.Output>
+      <csharp.Namespace name='TestCode'>
+        <csharp.SourceFile path="Test1.cs" using={["Foo", "Bar.Baz"]} />
+      </csharp.Namespace>
+    </core.Output>,
+  );
+
+  expect(res.contents[0].contents).toBe(coretest.d`
+    using Bar.Baz;
+    using Foo;
+    namespace TestCode {}
+  `);
+});
+
+it("adds using statement across namespaces", () => {
+  const inputTypeRefkey = core.refkey();
+  const outputTypeRefkey = core.refkey();
+  const twoValRefkey = core.refkey();
+
+  const params = [
+    {
+      name: "BodyParam",
+      type: inputTypeRefkey,
+    },
+  ];
+
+  const res = core.render(
+    <core.Output namePolicy={csharp.createCSharpNamePolicy()}>
+      <csharp.Namespace name='Models'>
+        <csharp.SourceFile path="Models.cs">
+          <csharp.Class accessModifier='public' name="Input" refkey={inputTypeRefkey} />
+          <csharp.Class accessModifier='public' name="Output" refkey={outputTypeRefkey} />
+          <csharp.Enum accessModifier='public' name="TestEnum">
+            <csharp.EnumMember name="One" />,
+            <csharp.EnumMember name="Two" refkey={twoValRefkey} />
+          </csharp.Enum>
+        </csharp.SourceFile>
+      </csharp.Namespace>
+      <csharp.Namespace name='Client'>
+        <csharp.SourceFile path="Client.cs" using={["System"]}>
+          <csharp.Class accessModifier='public' name="Client">
+            <csharp.ClassMethod accessModifier="public" name="MethodOne" parameters={params} returns={outputTypeRefkey} />
+          </csharp.Class>
+          {twoValRefkey};
+        </csharp.SourceFile>
+      </csharp.Namespace>
+    </core.Output>,
+  );
+
+  expect(res.contents[0].contents).toBe(coretest.d`
+    namespace Models
+    {
+      public class Input;
+      public class Output;
+      public enum TestEnum
+      {
+        One,
+        Two
+      }
+    }
+  `);
+
+  expect(res.contents[1].contents).toBe(coretest.d`
+    using Models;
+    using System;
+    namespace Client
+    {
+      public class Client
+      {
+        public Output MethodOne(Input bodyParam) {}
+      }
+      TestEnum.Two;
+    }
+  `);
+});