@flowscripter/dynamic-plugin-framework 1.2.0

package/tests/plugin_manager/plugin_repository/UrlPluginSource_test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, test } from "bun:test";
+import path from "node:path";
+import UrlPluginSource from "../../../src/plugin_manager/plugin_repository/UrlPluginSource.ts";
+
+const PLUGIN_1_URL = "file://" +
+  path.join(
+    path.dirname(Bun.fileURLToPath(import.meta.url)),
+    "../../fixtures/ValidPlugin1.ts",
+  );
+
+const INVALID_PLUGIN_URL = "file://" +
+  path.join(
+    path.dirname(Bun.fileURLToPath(import.meta.url)),
+    "../../fixtures/InvalidPlugin1.ts",
+  );
+
+describe("UrlPluginSource Tests", () => {
+  test("Returns undefined on invalid plugin", async () => {
+    const urlPluginSource = new UrlPluginSource();
+
+    expect(
+      await urlPluginSource.loadPlugin(
+        new URL(INVALID_PLUGIN_URL),
+      ),
+    ).toBeUndefined();
+  });
+
+  test("Loads a plugin", async () => {
+    const urlPluginSource = new UrlPluginSource();
+
+    const plugin = await urlPluginSource.loadPlugin(new URL(PLUGIN_1_URL));
+
+    expect(plugin).not.toEqual(undefined);
+    expect(plugin?.extensionDescriptors.length).toEqual(1);
+  });
+
+  test("Can load a plugin twice", async () => {
+    const urlPluginSource = new UrlPluginSource();
+
+    let plugin = await urlPluginSource.loadPlugin(new URL(PLUGIN_1_URL));
+
+    expect(plugin).not.toEqual(undefined);
+
+    plugin = await urlPluginSource.loadPlugin(new URL(PLUGIN_1_URL));
+
+    expect(plugin).not.toEqual(undefined);
+  });
+});

package/tests/plugin_manager/registry/InMemoryExtensionPointRegistry_test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, test } from "bun:test";
+import InMemoryExtensionPointRegistry from "../../../src/plugin_manager/registry/InMemoryExtensionPointRegistry.ts";
+import {
+  EXTENSION_POINT_1,
+  EXTENSION_POINT_2,
+} from "../../fixtures/Constants.ts";
+
+describe("InMemoryExtensionPointRegistry Tests", () => {
+  test("Register extension point", async () => {
+    const extensionPointRegistry = new InMemoryExtensionPointRegistry();
+
+    expect(await extensionPointRegistry.isRegistered(EXTENSION_POINT_1))
+      .toBeFalse();
+
+    await extensionPointRegistry.register(EXTENSION_POINT_1);
+
+    expect(await extensionPointRegistry.isRegistered(EXTENSION_POINT_1))
+      .toBeTrue();
+  });
+
+  test("Cannot register extension point twice", async () => {
+    const extensionPointRegistry = new InMemoryExtensionPointRegistry();
+
+    await extensionPointRegistry.register(EXTENSION_POINT_1);
+
+    expect(extensionPointRegistry.register(EXTENSION_POINT_1))
+      .rejects.toThrow();
+  });
+
+  test("Get registered extension points", async () => {
+    const extensionPointRegistry = new InMemoryExtensionPointRegistry();
+
+    await extensionPointRegistry.register(EXTENSION_POINT_1);
+    await extensionPointRegistry.register(EXTENSION_POINT_2);
+
+    const extensionPoints = await extensionPointRegistry.getAll();
+
+    expect(extensionPoints.has(EXTENSION_POINT_1)).toBeTrue();
+    expect(extensionPoints.has(EXTENSION_POINT_2)).toBeTrue();
+  });
+});

package/tests/plugin_manager/registry/InMemoryExtensionRegistry_test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, test } from "bun:test";
+import InMemoryExtensionRegistry from "../../../src/plugin_manager/registry/InMemoryExtensionRegistry.ts";
+import type ExtensionEntry from "../../../src/plugin_manager/plugin_repository/ExtensionEntry.ts";
+
+import {
+  EXTENSION_1_HANDLE,
+  EXTENSION_1_ID,
+  EXTENSION_2_HANDLE,
+  EXTENSION_2_ID,
+  EXTENSION_POINT_1,
+  EXTENSION_POINT_2,
+  PLUGIN_1_ID,
+  PLUGIN_2_ID,
+} from "../../fixtures/Constants.ts";
+
+const extensionEntry1: ExtensionEntry = {
+  pluginId: PLUGIN_1_ID,
+  extensionId: EXTENSION_1_ID,
+  extensionPoint: EXTENSION_POINT_1,
+};
+const extensionEntry2: ExtensionEntry = {
+  pluginId: PLUGIN_2_ID,
+  extensionId: EXTENSION_2_ID,
+  extensionPoint: EXTENSION_POINT_2,
+};
+
+describe("InMemoryExtensionRegistry Tests", () => {
+  test("Register extension", async () => {
+    const extensionRegistry = new InMemoryExtensionRegistry();
+
+    expect(extensionRegistry.get(EXTENSION_1_HANDLE)).rejects
+      .toThrow();
+
+    await extensionRegistry.register(EXTENSION_1_HANDLE, extensionEntry1);
+
+    await extensionRegistry.get(EXTENSION_1_HANDLE);
+  });
+
+  test("Cannot register extension twice", async () => {
+    const extensionRegistry = new InMemoryExtensionRegistry();
+
+    await extensionRegistry.register(EXTENSION_1_HANDLE, extensionEntry1);
+
+    expect(extensionRegistry.register(EXTENSION_1_HANDLE, extensionEntry1))
+      .rejects.toThrow();
+  });
+
+  test("Get registered extensions", async () => {
+    const extensionRegistry = new InMemoryExtensionRegistry();
+
+    await extensionRegistry.register(EXTENSION_1_HANDLE, extensionEntry1);
+    await extensionRegistry.register(EXTENSION_2_HANDLE, extensionEntry2);
+
+    const extensionEntries1 = await extensionRegistry.getExtensions(
+      EXTENSION_POINT_1,
+    );
+
+    expect(extensionEntries1.size).toEqual(1);
+    expect(
+      extensionEntries1.get(EXTENSION_1_HANDLE)?.extensionId,
+    ).toEqual(EXTENSION_1_ID);
+
+    const extensionEntries2 = await extensionRegistry.getExtensions(
+      EXTENSION_POINT_2,
+    );
+
+    expect(extensionEntries2.size).toEqual(1);
+    expect(
+      extensionEntries2.get(EXTENSION_2_HANDLE)?.extensionId,
+    ).toEqual(EXTENSION_2_ID);
+  });
+});

package/tests/plugin_manager/util/PluginLoader_test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, test } from "bun:test";
+import loadPlugin from "../../../src/plugin_manager/util/PluginLoader.ts";
+
+describe("PluginLoader Tests", () => {
+  test("Rejects invalid URL", async () => {
+    const pluginLoadResult = await loadPlugin("foo");
+
+    expect(pluginLoadResult.isValidPlugin).toBeFalse();
+    expect(pluginLoadResult.error?.message).toStartWith("Cannot find package");
+  });
+
+  test("Rejects invalid modules", async () => {
+    const pluginLoadResult = await loadPlugin(
+      "../plugin_repository/UrlListPluginRepository.ts",
+    );
+
+    expect(pluginLoadResult.isValidPlugin).toBeFalse();
+    expect(
+      pluginLoadResult.error?.message,
+    ).toEqual(
+      "Plugin from ../plugin_repository/UrlListPluginRepository.ts does not provide an extensionDescriptors array",
+    );
+  });
+
+  test("Rejects invalid plugins", async () => {
+    let pluginLoadResult = await loadPlugin(
+      "../../../tests/fixtures/InvalidPlugin1.ts",
+    );
+
+    expect(pluginLoadResult.isValidPlugin).toBeFalse();
+    expect(pluginLoadResult.error?.name).toEqual("Error");
+    expect(
+      pluginLoadResult.error?.message,
+    ).toEqual(
+      "Plugin from ../../../tests/fixtures/InvalidPlugin1.ts does not provide an extensionDescriptors array",
+    );
+
+    pluginLoadResult = await loadPlugin(
+      "../../../tests/fixtures/InvalidPlugin2.ts",
+    );
+
+    expect(pluginLoadResult.isValidPlugin).toBeFalse();
+    expect(pluginLoadResult.error?.name).toEqual("Error");
+    expect(
+      pluginLoadResult.error?.message,
+    ).toEqual(
+      "Plugin from ../../../tests/fixtures/InvalidPlugin2.ts does not provide an extensionPoint string in one of the extensionDescriptors",
+    );
+
+    pluginLoadResult = await loadPlugin(
+      "../../../tests/fixtures/InvalidPlugin3.ts",
+    );
+
+    expect(pluginLoadResult.isValidPlugin).toBeFalse();
+    expect(pluginLoadResult.error?.name).toEqual("Error");
+    expect(
+      pluginLoadResult.error?.message,
+    ).toEqual(
+      "Plugin from ../../../tests/fixtures/InvalidPlugin3.ts does not provide a factory with a create function in one of the extensionDescriptors",
+    );
+
+    pluginLoadResult = await loadPlugin(
+      "../../../tests/fixtures/InvalidPlugin4.ts",
+    );
+
+    expect(pluginLoadResult.isValidPlugin).toBeFalse();
+    expect(pluginLoadResult.error?.name).toEqual("Error");
+    expect(
+      pluginLoadResult.error?.message,
+    ).toEqual(
+      "Plugin from ../../../tests/fixtures/InvalidPlugin4.ts does not provide a factory with a create function in one of the extensionDescriptors",
+    );
+
+    pluginLoadResult = await loadPlugin(
+      "../../../tests/fixtures/InvalidPlugin5.ts",
+    );
+
+    expect(pluginLoadResult.isValidPlugin).toBeFalse();
+    expect(pluginLoadResult.error?.name).toEqual("Error");
+    expect(
+      pluginLoadResult.error?.message,
+    ).toEqual(
+      "Plugin from ../../../tests/fixtures/InvalidPlugin5.ts does not provide a factory with a create function in one of the extensionDescriptors",
+    );
+  });
+
+  test("Returns valid plugin", async () => {
+    const pluginLoadResult = await loadPlugin(
+      "../../../tests/fixtures/ValidPlugin1.ts",
+    );
+
+    expect(pluginLoadResult.isValidPlugin).toBeTrue();
+    expect(pluginLoadResult.error).toBeUndefined();
+
+    const plugin = pluginLoadResult.plugin;
+
+    expect(plugin?.pluginData?.get("foo")).toEqual("bar");
+
+    expect(plugin?.extensionDescriptors.length).toEqual(1);
+
+    const extensionDescriptor = plugin?.extensionDescriptors[0];
+
+    expect(extensionDescriptor?.extensionData?.get("foo")).toEqual("bar");
+
+    await extensionDescriptor?.factory.create();
+  });
+});

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    // Enable latest features
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}