@tsonic/frontend 0.0.1

package/src/program/bindings.test.ts

@@ -0,0 +1,512 @@
+/**
+ * Tests for binding manifest loading and registry
+ */
+
+import { describe, it, beforeEach, afterEach } from "mocha";
+import { expect } from "chai";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { BindingRegistry, loadBindings } from "./bindings.js";
+
+describe("Binding System", () => {
+  describe("BindingRegistry", () => {
+    it("should add and retrieve bindings", () => {
+      const registry = new BindingRegistry();
+
+      registry.addBindings("/test/manifest.json", {
+        bindings: {
+          console: {
+            kind: "global",
+            assembly: "Tsonic.Runtime",
+            type: "Tsonic.Runtime.console",
+          },
+          fs: {
+            kind: "module",
+            assembly: "Tsonic.NodeApi",
+            type: "Tsonic.NodeApi.fs",
+          },
+        },
+      });
+
+      const consoleBinding = registry.getBinding("console");
+      expect(consoleBinding).to.deep.equal({
+        kind: "global",
+        assembly: "Tsonic.Runtime",
+        type: "Tsonic.Runtime.console",
+      });
+
+      const fsBinding = registry.getBinding("fs");
+      expect(fsBinding).to.deep.equal({
+        kind: "module",
+        assembly: "Tsonic.NodeApi",
+        type: "Tsonic.NodeApi.fs",
+      });
+    });
+
+    it("should return undefined for non-existent bindings", () => {
+      const registry = new BindingRegistry();
+      const binding = registry.getBinding("nonexistent");
+      expect(binding).to.equal(undefined);
+    });
+
+    it("should return all bindings", () => {
+      const registry = new BindingRegistry();
+
+      registry.addBindings("/test/manifest.json", {
+        bindings: {
+          console: {
+            kind: "global",
+            assembly: "Tsonic.Runtime",
+            type: "Tsonic.Runtime.console",
+          },
+          Math: {
+            kind: "global",
+            assembly: "Tsonic.Runtime",
+            type: "Tsonic.Runtime.Math",
+          },
+        },
+      });
+
+      const allBindings = registry.getAllBindings();
+      expect(allBindings).to.have.lengthOf(2);
+      expect(allBindings.map((b) => b[0]).sort()).to.deep.equal([
+        "Math",
+        "console",
+      ]);
+    });
+
+    it("should clear all bindings", () => {
+      const registry = new BindingRegistry();
+
+      registry.addBindings("/test/manifest.json", {
+        bindings: {
+          console: {
+            kind: "global",
+            assembly: "Tsonic.Runtime",
+            type: "Tsonic.Runtime.console",
+          },
+        },
+      });
+
+      expect(registry.getAllBindings()).to.have.lengthOf(1);
+
+      registry.clear();
+      expect(registry.getAllBindings()).to.have.lengthOf(0);
+      expect(registry.getBinding("console")).to.equal(undefined);
+    });
+
+    it("should handle multiple manifest files", () => {
+      const registry = new BindingRegistry();
+
+      registry.addBindings("/test/runtime.json", {
+        bindings: {
+          console: {
+            kind: "global",
+            assembly: "Tsonic.Runtime",
+            type: "Tsonic.Runtime.console",
+          },
+        },
+      });
+
+      registry.addBindings("/test/node.json", {
+        bindings: {
+          fs: {
+            kind: "module",
+            assembly: "Tsonic.NodeApi",
+            type: "Tsonic.NodeApi.fs",
+          },
+        },
+      });
+
+      expect(registry.getAllBindings()).to.have.lengthOf(2);
+      expect(registry.getBinding("console")).not.to.equal(undefined);
+      expect(registry.getBinding("fs")).not.to.equal(undefined);
+    });
+  });
+
+  describe("loadBindings", () => {
+    let tempDir: string;
+
+    beforeEach(() => {
+      // Create a temporary directory for test files
+      tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "tsonic-bindings-test-"));
+    });
+
+    afterEach(() => {
+      // Clean up temporary directory
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+
+    it("should load bindings from a manifest file in typeRoot", () => {
+      // Create a test binding manifest
+      const manifestPath = path.join(tempDir, "test.bindings.json");
+      const manifest = {
+        bindings: {
+          console: {
+            kind: "global",
+            assembly: "Tsonic.Runtime",
+            type: "Tsonic.Runtime.console",
+          },
+        },
+      };
+      fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+
+      const registry = loadBindings([tempDir]);
+
+      const binding = registry.getBinding("console");
+      expect(binding).to.deep.equal({
+        kind: "global",
+        assembly: "Tsonic.Runtime",
+        type: "Tsonic.Runtime.console",
+      });
+    });
+
+    it("should load bindings from manifest next to .d.ts file", () => {
+      // Create a subdirectory structure
+      const subDir = path.join(tempDir, "types");
+      fs.mkdirSync(subDir, { recursive: true });
+
+      // Create .d.ts and .bindings.json files
+      fs.writeFileSync(path.join(subDir, "runtime.d.ts"), "");
+      const manifest = {
+        bindings: {
+          Math: {
+            kind: "global",
+            assembly: "Tsonic.Runtime",
+            type: "Tsonic.Runtime.Math",
+          },
+        },
+      };
+      fs.writeFileSync(
+        path.join(subDir, "runtime.bindings.json"),
+        JSON.stringify(manifest, null, 2)
+      );
+
+      const registry = loadBindings([tempDir]);
+
+      const binding = registry.getBinding("Math");
+      expect(binding).to.deep.equal({
+        kind: "global",
+        assembly: "Tsonic.Runtime",
+        type: "Tsonic.Runtime.Math",
+      });
+    });
+
+    it("should handle non-existent typeRoots gracefully", () => {
+      const registry = loadBindings(["/nonexistent/path"]);
+      expect(registry.getAllBindings()).to.have.lengthOf(0);
+    });
+
+    it("should load from multiple typeRoots", () => {
+      // Create two separate directories
+      const dir1 = path.join(tempDir, "dir1");
+      const dir2 = path.join(tempDir, "dir2");
+      fs.mkdirSync(dir1);
+      fs.mkdirSync(dir2);
+
+      // Create manifest in first directory
+      const manifest1 = {
+        bindings: {
+          console: {
+            kind: "global",
+            assembly: "Tsonic.Runtime",
+            type: "Tsonic.Runtime.console",
+          },
+        },
+      };
+      fs.writeFileSync(
+        path.join(dir1, "runtime.bindings.json"),
+        JSON.stringify(manifest1, null, 2)
+      );
+
+      // Create manifest in second directory
+      const manifest2 = {
+        bindings: {
+          fs: {
+            kind: "module",
+            assembly: "Tsonic.NodeApi",
+            type: "Tsonic.NodeApi.fs",
+          },
+        },
+      };
+      fs.writeFileSync(
+        path.join(dir2, "node.bindings.json"),
+        JSON.stringify(manifest2, null, 2)
+      );
+
+      const registry = loadBindings([dir1, dir2]);
+
+      expect(registry.getAllBindings()).to.have.lengthOf(2);
+      expect(registry.getBinding("console")).not.to.equal(undefined);
+      expect(registry.getBinding("fs")).not.to.equal(undefined);
+    });
+
+    it("should handle malformed JSON gracefully", () => {
+      const manifestPath = path.join(tempDir, "bad.bindings.json");
+      fs.writeFileSync(manifestPath, "{ invalid json }");
+
+      // Should not throw, just skip the bad file
+      const registry = loadBindings([tempDir]);
+      expect(registry.getAllBindings()).to.have.lengthOf(0);
+    });
+
+    it("should distinguish between global and module bindings", () => {
+      const manifest = {
+        bindings: {
+          console: {
+            kind: "global",
+            assembly: "Tsonic.Runtime",
+            type: "Tsonic.Runtime.console",
+          },
+          fs: {
+            kind: "module",
+            assembly: "Tsonic.NodeApi",
+            type: "Tsonic.NodeApi.fs",
+          },
+        },
+      };
+      fs.writeFileSync(
+        path.join(tempDir, "mixed.bindings.json"),
+        JSON.stringify(manifest, null, 2)
+      );
+
+      const registry = loadBindings([tempDir]);
+
+      const consoleBinding = registry.getBinding("console");
+      expect(consoleBinding?.kind).to.equal("global");
+
+      const fsBinding = registry.getBinding("fs");
+      expect(fsBinding?.kind).to.equal("module");
+    });
+  });
+
+  describe("Hierarchical Binding Manifests", () => {
+    it("should add and retrieve hierarchical namespace bindings", () => {
+      const registry = new BindingRegistry();
+
+      registry.addBindings("/test/system-linq.json", {
+        assembly: "System.Linq",
+        namespaces: [
+          {
+            name: "System.Linq",
+            alias: "systemLinq",
+            types: [
+              {
+                name: "Enumerable",
+                alias: "enumerable",
+                kind: "class",
+                members: [],
+              },
+            ],
+          },
+        ],
+      });
+
+      const namespace = registry.getNamespace("systemLinq");
+      expect(namespace).to.not.equal(undefined);
+      expect(namespace?.name).to.equal("System.Linq");
+      expect(namespace?.types).to.have.lengthOf(1);
+    });
+
+    it("should retrieve type bindings from hierarchical manifest", () => {
+      const registry = new BindingRegistry();
+
+      registry.addBindings("/test/system-linq.json", {
+        assembly: "System.Linq",
+        namespaces: [
+          {
+            name: "System.Linq",
+            alias: "systemLinq",
+            types: [
+              {
+                name: "Enumerable",
+                alias: "enumerable",
+                kind: "class",
+                members: [],
+              },
+            ],
+          },
+        ],
+      });
+
+      const type = registry.getType("enumerable");
+      expect(type).to.not.equal(undefined);
+      expect(type?.name).to.equal("Enumerable");
+      expect(type?.kind).to.equal("class");
+    });
+
+    it("should retrieve member bindings from hierarchical manifest", () => {
+      const registry = new BindingRegistry();
+
+      registry.addBindings("/test/system-linq.json", {
+        assembly: "System.Linq",
+        namespaces: [
+          {
+            name: "System.Linq",
+            alias: "systemLinq",
+            types: [
+              {
+                name: "Enumerable",
+                alias: "enumerable",
+                kind: "class",
+                members: [
+                  {
+                    kind: "method",
+                    name: "SelectMany",
+                    alias: "selectMany",
+                    binding: {
+                      assembly: "System.Linq",
+                      type: "System.Linq.Enumerable",
+                      member: "SelectMany",
+                    },
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      });
+
+      const member = registry.getMember("enumerable", "selectMany");
+      expect(member).to.not.equal(undefined);
+      expect(member?.name).to.equal("SelectMany");
+      expect(member?.binding.type).to.equal("System.Linq.Enumerable");
+      expect(member?.binding.member).to.equal("SelectMany");
+    });
+
+    it("should handle multiple namespaces in one manifest", () => {
+      const registry = new BindingRegistry();
+
+      registry.addBindings("/test/multi-namespace.json", {
+        assembly: "MyLib",
+        namespaces: [
+          {
+            name: "MyLib.Namespace1",
+            alias: "ns1",
+            types: [],
+          },
+          {
+            name: "MyLib.Namespace2",
+            alias: "ns2",
+            types: [],
+          },
+        ],
+      });
+
+      expect(registry.getNamespace("ns1")).to.not.equal(undefined);
+      expect(registry.getNamespace("ns2")).to.not.equal(undefined);
+      expect(registry.getAllNamespaces()).to.have.lengthOf(2);
+    });
+
+    it("should support both legacy and hierarchical manifests", () => {
+      const registry = new BindingRegistry();
+
+      // Add legacy manifest
+      registry.addBindings("/test/legacy.json", {
+        bindings: {
+          console: {
+            kind: "global",
+            assembly: "Tsonic.Runtime",
+            type: "Tsonic.Runtime.console",
+          },
+        },
+      });
+
+      // Add hierarchical manifest
+      registry.addBindings("/test/hierarchical.json", {
+        assembly: "System.Linq",
+        namespaces: [
+          {
+            name: "System.Linq",
+            alias: "systemLinq",
+            types: [],
+          },
+        ],
+      });
+
+      // Both should work
+      expect(registry.getBinding("console")).to.not.equal(undefined);
+      expect(registry.getNamespace("systemLinq")).to.not.equal(undefined);
+    });
+
+    it("should return undefined for non-existent hierarchical bindings", () => {
+      const registry = new BindingRegistry();
+
+      expect(registry.getNamespace("nonexistent")).to.equal(undefined);
+      expect(registry.getType("nonexistent")).to.equal(undefined);
+      expect(registry.getMember("nonexistent", "member")).to.equal(undefined);
+    });
+
+    it("should clear hierarchical bindings along with simple bindings", () => {
+      const registry = new BindingRegistry();
+
+      registry.addBindings("/test/mixed.json", {
+        assembly: "Test",
+        namespaces: [
+          {
+            name: "Test.NS",
+            alias: "ns",
+            types: [],
+          },
+        ],
+      });
+
+      expect(registry.getAllNamespaces()).to.have.lengthOf(1);
+
+      registry.clear();
+
+      expect(registry.getAllNamespaces()).to.have.lengthOf(0);
+      expect(registry.getNamespace("ns")).to.equal(undefined);
+    });
+
+    it("should index member bindings by type.member key", () => {
+      const registry = new BindingRegistry();
+
+      registry.addBindings("/test/members.json", {
+        assembly: "MyLib",
+        namespaces: [
+          {
+            name: "MyLib",
+            alias: "myLib",
+            types: [
+              {
+                name: "TypeA",
+                alias: "typeA",
+                kind: "class",
+                members: [
+                  {
+                    kind: "method",
+                    name: "Method1",
+                    alias: "method1",
+                    binding: {
+                      assembly: "MyLib",
+                      type: "MyLib.TypeA",
+                      member: "Method1",
+                    },
+                  },
+                  {
+                    kind: "method",
+                    name: "Method2",
+                    alias: "method2",
+                    binding: {
+                      assembly: "MyLib",
+                      type: "MyLib.TypeA",
+                      member: "Method2",
+                    },
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      });
+
+      const member1 = registry.getMember("typeA", "method1");
+      const member2 = registry.getMember("typeA", "method2");
+
+      expect(member1?.name).to.equal("Method1");
+      expect(member2?.name).to.equal("Method2");
+    });
+  });
+});