@readymadeit/mcp 0.0.0-stage → 0.1.0

package/bundle/hkp-frontend/src/runtime/browser/tests/runtime-add.integration.test.tsx

@@ -0,0 +1,256 @@
+import React, { useContext, useEffect } from "react";
+import { describe, it, expect, vi } from "vitest";
+import { act, render, waitFor } from "@testing-library/react";
+
+import BoardProvider, {
+  BoardCtx,
+  BoardContextState,
+} from "hkp-frontend/src/BoardContext";
+import { RuntimeApiMap, RuntimeClass } from "hkp-frontend/src/types";
+
+function ContextProbe({
+  onChange,
+}: {
+  onChange: (ctx: BoardContextState | null) => void;
+}) {
+  const ctx = useContext(BoardCtx);
+  useEffect(() => {
+    onChange(ctx);
+  }, [ctx, onChange]);
+  return null;
+}
+
+describe("runtime add integration", () => {
+  it("addRuntime appends runtime with scope, registry, and empty services", async () => {
+    const createdRuntime = {
+      id: "rt-added-1",
+      name: "Browser Runtime",
+      type: "browser",
+    } as any;
+    const createdScope = { marker: "scope-1" } as any;
+    const createdRegistry = [
+      { serviceId: "hookup.to/service/input", serviceName: "Input" },
+    ];
+
+    const browserApi = {
+      addRuntime: vi.fn(async () => ({
+        runtime: createdRuntime,
+        services: [],
+        registry: createdRegistry,
+        scope: createdScope,
+      })),
+      removeRuntime: vi.fn(async () => {}),
+      restoreRuntime: vi.fn(),
+      processRuntime: vi.fn(),
+      addService: vi.fn(),
+      removeService: vi.fn(),
+      configureService: vi.fn(),
+      getServiceConfig: vi.fn(),
+      processService: vi.fn(),
+      rearrangeServices: vi.fn(),
+    } as any;
+
+    const runtimeApis: RuntimeApiMap = {
+      browser: browserApi,
+    };
+
+    let latestCtx: BoardContextState | null = null;
+
+    render(
+      <BoardProvider
+        user={null}
+        boardName="test-board"
+        runtimeApis={runtimeApis}
+        onRemoveRuntime={vi.fn(async () => {})}
+      >
+        <ContextProbe onChange={(ctx) => (latestCtx = ctx)} />
+      </BoardProvider>,
+    );
+
+    await waitFor(() => {
+      expect(latestCtx).toBeTruthy();
+    });
+
+    const rtClass: RuntimeClass = {
+      name: "Browser Runtime",
+      type: "browser",
+      color: "#abc",
+    };
+
+    await act(async () => {
+      await latestCtx!.addRuntime(rtClass);
+    });
+
+    expect(browserApi.addRuntime).toHaveBeenCalledTimes(1);
+    await waitFor(() => {
+      expect(latestCtx!.runtimes).toHaveLength(1);
+    });
+
+    expect(latestCtx!.runtimes[0].id).toBe(createdRuntime.id);
+    expect(latestCtx!.services[createdRuntime.id]).toEqual([]);
+    expect(latestCtx!.registry[createdRuntime.id]).toEqual(createdRegistry);
+    expect(latestCtx!.scopes[createdRuntime.id]).toBe(createdScope);
+  });
+
+  it("addRuntime keeps existing runtimes and appends new runtime", async () => {
+    const addRuntimeMock = vi
+      .fn()
+      .mockResolvedValueOnce({
+        runtime: { id: "rt-1", name: "Runtime 1", type: "browser" },
+        services: [],
+        registry: [],
+        scope: { id: "scope-1" },
+      })
+      .mockResolvedValueOnce({
+        runtime: { id: "rt-2", name: "Runtime 2", type: "browser" },
+        services: [],
+        registry: [],
+        scope: { id: "scope-2" },
+      });
+
+    const browserApi = {
+      addRuntime: addRuntimeMock,
+      removeRuntime: vi.fn(async () => {}),
+      restoreRuntime: vi.fn(),
+      processRuntime: vi.fn(),
+      addService: vi.fn(),
+      removeService: vi.fn(),
+      configureService: vi.fn(),
+      getServiceConfig: vi.fn(),
+      processService: vi.fn(),
+      rearrangeServices: vi.fn(),
+    } as any;
+
+    const runtimeApis: RuntimeApiMap = { browser: browserApi };
+    let latestCtx: BoardContextState | null = null;
+
+    render(
+      <BoardProvider
+        user={null}
+        boardName="test-board"
+        runtimeApis={runtimeApis}
+        onRemoveRuntime={vi.fn(async () => {})}
+      >
+        <ContextProbe onChange={(ctx) => (latestCtx = ctx)} />
+      </BoardProvider>,
+    );
+
+    await waitFor(() => expect(latestCtx).toBeTruthy());
+
+    const rtClass: RuntimeClass = {
+      name: "Browser Runtime",
+      type: "browser",
+    };
+
+    await act(async () => {
+      await latestCtx!.addRuntime(rtClass);
+      await latestCtx!.addRuntime(rtClass);
+    });
+
+    await waitFor(() => {
+      expect(latestCtx!.runtimes.map((r) => r.id)).toEqual(["rt-1", "rt-2"]);
+    });
+  });
+
+  it("addRuntime null result does not partially mutate board state", async () => {
+    const browserApi = {
+      addRuntime: vi.fn(async () => null),
+      removeRuntime: vi.fn(async () => {}),
+      restoreRuntime: vi.fn(),
+      processRuntime: vi.fn(),
+      addService: vi.fn(),
+      removeService: vi.fn(),
+      configureService: vi.fn(),
+      getServiceConfig: vi.fn(),
+      processService: vi.fn(),
+      rearrangeServices: vi.fn(),
+    } as any;
+
+    const runtimeApis: RuntimeApiMap = { browser: browserApi };
+    let latestCtx: BoardContextState | null = null;
+    render(
+      <BoardProvider
+        user={null}
+        boardName="test-board"
+        runtimeApis={runtimeApis}
+        onRemoveRuntime={vi.fn(async () => {})}
+      >
+        <ContextProbe onChange={(ctx) => (latestCtx = ctx)} />
+      </BoardProvider>,
+    );
+
+    await waitFor(() => expect(latestCtx).toBeTruthy());
+
+    await act(async () => {
+      await latestCtx!.addRuntime({ name: "Browser Runtime", type: "browser" });
+    });
+
+    expect(latestCtx!.runtimes).toHaveLength(0);
+    expect(Object.keys(latestCtx!.services)).toHaveLength(0);
+    expect(Object.keys(latestCtx!.registry)).toHaveLength(0);
+    expect(Object.keys(latestCtx!.scopes)).toHaveLength(0);
+  });
+
+  it("added runtime can be processed via board runtime api/scope wiring", async () => {
+    const scopeObj = { id: "scope-process" } as any;
+    const processRuntimeSpy = vi.fn(async (_scope: any, params: any) => params);
+
+    const browserApi = {
+      addRuntime: vi.fn(async () => ({
+        runtime: { id: "rt-proc", name: "Runtime Proc", type: "browser" },
+        services: [],
+        registry: [],
+        scope: scopeObj,
+      })),
+      processRuntime: processRuntimeSpy,
+      removeRuntime: vi.fn(async () => {}),
+      restoreRuntime: vi.fn(),
+      addService: vi.fn(),
+      removeService: vi.fn(),
+      configureService: vi.fn(),
+      getServiceConfig: vi.fn(),
+      processService: vi.fn(),
+      rearrangeServices: vi.fn(),
+    } as any;
+
+    const runtimeApis: RuntimeApiMap = { browser: browserApi };
+    let latestCtx: BoardContextState | null = null;
+
+    render(
+      <BoardProvider
+        user={null}
+        boardName="test-board"
+        runtimeApis={runtimeApis}
+        onRemoveRuntime={vi.fn(async () => {})}
+      >
+        <ContextProbe onChange={(ctx) => (latestCtx = ctx)} />
+      </BoardProvider>,
+    );
+
+    await waitFor(() => {
+      expect(latestCtx).toBeTruthy();
+    });
+
+    await act(async () => {
+      await latestCtx!.addRuntime({ name: "Browser Runtime", type: "browser" });
+    });
+
+    await waitFor(() => {
+      expect(latestCtx!.runtimes).toHaveLength(1);
+    });
+
+    const runtime = latestCtx!.runtimes[0];
+    const scope = latestCtx!.scopes[runtime.id];
+    const api = latestCtx!.runtimeApis[runtime.type];
+
+    await act(async () => {
+      await api.processRuntime(scope, { hello: "world" }, null);
+    });
+
+    expect(processRuntimeSpy).toHaveBeenCalledWith(
+      scopeObj,
+      { hello: "world" },
+      null,
+    );
+  });
+});

package/bundle/hkp-frontend/src/runtime/browser/tests/runtime-operations.integration.test.tsx

@@ -0,0 +1,310 @@
+import React, { useContext, useEffect } from "react";
+import { describe, it, expect, vi } from "vitest";
+import { act, render, waitFor } from "@testing-library/react";
+
+import BoardProvider, {
+  BoardCtx,
+  BoardContextState,
+} from "hkp-frontend/src/BoardContext";
+import { RuntimeApiMap, RuntimeClass, RuntimeDescriptor } from "hkp-frontend/src/types";
+
+function ContextProbe({
+  onChange,
+}: {
+  onChange: (ctx: BoardContextState | null) => void;
+}) {
+  const ctx = useContext(BoardCtx);
+  useEffect(() => {
+    onChange(ctx);
+  }, [ctx, onChange]);
+  return null;
+}
+
+function makeApi(overrides: Record<string, unknown> = {}) {
+  const defaultApi = {
+    addRuntime: vi.fn(async () => {}),
+    removeRuntime: vi.fn(async () => {}),
+    restoreRuntime: vi.fn(),
+    processRuntime: vi.fn(),
+    addService: vi.fn(async () => ({})),
+    removeService: vi.fn(async () => {}),
+    configureService: vi.fn(async () => {}),
+    getServiceConfig: vi.fn(async () => ({})),
+    processService: vi.fn(),
+    rearrangeServices: vi.fn(async (_: unknown, svcs: unknown) => svcs),
+  };
+  return { ...defaultApi, ...overrides } as any;
+}
+
+function makeRuntime(id: string, name = "Runtime"): RuntimeDescriptor {
+  return { id, name, type: "browser" };
+}
+
+function renderWithRuntimes(
+  api: any,
+  runtimes: RuntimeDescriptor[],
+  extraProps: Record<string, unknown> = {},
+) {
+  const runtimeApis: RuntimeApiMap = { browser: api };
+  const scopes = Object.fromEntries(
+    runtimes.map((rt) => [rt.id, { id: `scope-${rt.id}` } as any]),
+  );
+  let latestCtx: BoardContextState | null = null;
+
+  render(
+    <BoardProvider
+      user={null}
+      boardName="test-board"
+      runtimeApis={runtimeApis}
+      onRemoveRuntime={vi.fn(async () => {})}
+      initialState={{
+        runtimes,
+        services: Object.fromEntries(runtimes.map((rt) => [rt.id, []])),
+        scopes,
+        registry: Object.fromEntries(runtimes.map((rt) => [rt.id, []])),
+      }}
+      {...(extraProps as any)}
+    >
+      <ContextProbe onChange={(ctx) => (latestCtx = ctx)} />
+    </BoardProvider>,
+  );
+
+  return { getCtx: () => latestCtx };
+}
+
+describe("runtime operations integration", () => {
+  describe("arrangeRuntime", () => {
+    it("reorders two runtimes", async () => {
+      const rtA = makeRuntime("rt-a", "Runtime A");
+      const rtB = makeRuntime("rt-b", "Runtime B");
+      const api = makeApi();
+      const { getCtx } = renderWithRuntimes(api, [rtA, rtB]);
+      await waitFor(() => expect(getCtx()).toBeTruthy());
+
+      // reorderRuntime adjusts position for post-removal indexing when moving
+      // forward: position 2 places rt-a after rt-b in a 2-element array.
+      await act(async () => {
+        await getCtx()!.arrangeRuntime(rtA.id, 2);
+      });
+
+      await waitFor(() => {
+        expect(getCtx()!.runtimes.map((r) => r.id)).toEqual(["rt-b", "rt-a"]);
+      });
+    });
+
+    it("moving the last item to position 0 puts it first", async () => {
+      const rtA = makeRuntime("rt-a");
+      const rtB = makeRuntime("rt-b");
+      const rtC = makeRuntime("rt-c");
+      const api = makeApi();
+      const { getCtx } = renderWithRuntimes(api, [rtA, rtB, rtC]);
+      await waitFor(() => expect(getCtx()).toBeTruthy());
+
+      await act(async () => {
+        await getCtx()!.arrangeRuntime(rtC.id, 0);
+      });
+
+      await waitFor(() => {
+        expect(getCtx()!.runtimes[0].id).toBe("rt-c");
+      });
+    });
+  });
+
+  describe("setRuntimeName", () => {
+    it("updates the name of the target runtime", async () => {
+      const rt = makeRuntime("rt-rename", "Old Name");
+      const api = makeApi();
+      const { getCtx } = renderWithRuntimes(api, [rt]);
+      await waitFor(() => expect(getCtx()).toBeTruthy());
+
+      await act(async () => {
+        await getCtx()!.setRuntimeName(rt.id, "New Name");
+      });
+
+      await waitFor(() => {
+        expect(getCtx()!.runtimes[0].name).toBe("New Name");
+      });
+    });
+
+    it("only renames the targeted runtime", async () => {
+      const rtA = makeRuntime("rt-a", "Alpha");
+      const rtB = makeRuntime("rt-b", "Beta");
+      const api = makeApi();
+      const { getCtx } = renderWithRuntimes(api, [rtA, rtB]);
+      await waitFor(() => expect(getCtx()).toBeTruthy());
+
+      await act(async () => {
+        await getCtx()!.setRuntimeName(rtA.id, "Alpha Renamed");
+      });
+
+      await waitFor(() => {
+        expect(getCtx()!.runtimes[0].name).toBe("Alpha Renamed");
+      });
+      expect(getCtx()!.runtimes[1].name).toBe("Beta");
+    });
+  });
+
+  describe("addAvailableRuntime", () => {
+    it("appends a new runtime class to availableRuntimeEngines", async () => {
+      const api = makeApi();
+      const { getCtx } = renderWithRuntimes(api, []);
+      await waitFor(() => expect(getCtx()).toBeTruthy());
+
+      const rtClass: RuntimeClass = { name: "My Runtime", type: "browser", color: "#f00" };
+
+      await act(async () => {
+        getCtx()!.addAvailableRuntime(rtClass, false);
+      });
+
+      await waitFor(() => {
+        const engines = getCtx()!.availableRuntimeEngines;
+        expect(engines.some((e) => e.name === "My Runtime")).toBe(true);
+      });
+    });
+
+    it("replaces an existing entry when overwriteIfExists is true", async () => {
+      const api = makeApi();
+      const rtClass: RuntimeClass = { name: "My Runtime", type: "browser", color: "#f00" };
+
+      const { getCtx } = renderWithRuntimes(api, [], {
+        availableRuntimeEngines: [rtClass],
+      });
+      await waitFor(() => expect(getCtx()).toBeTruthy());
+
+      const updated: RuntimeClass = { name: "My Runtime", type: "browser", color: "#0f0" };
+
+      await act(async () => {
+        getCtx()!.addAvailableRuntime(updated, true);
+      });
+
+      await waitFor(() => {
+        const engines = getCtx()!.availableRuntimeEngines;
+        const match = engines.filter((e) => e.name === "My Runtime");
+        expect(match).toHaveLength(1);
+        expect(match[0].color).toBe("#0f0");
+      });
+    });
+
+    it("does not replace when overwriteIfExists is false", async () => {
+      const api = makeApi();
+      const rtClass: RuntimeClass = { name: "My Runtime", type: "browser", color: "#f00" };
+
+      const { getCtx } = renderWithRuntimes(api, [], {
+        availableRuntimeEngines: [rtClass],
+      });
+      await waitFor(() => expect(getCtx()).toBeTruthy());
+
+      const duplicate: RuntimeClass = { name: "My Runtime", type: "browser", color: "#0f0" };
+
+      await act(async () => {
+        getCtx()!.addAvailableRuntime(duplicate, false);
+      });
+
+      await waitFor(() => {
+        const engines = getCtx()!.availableRuntimeEngines;
+        expect(engines.filter((e) => e.name === "My Runtime")).toHaveLength(2);
+      });
+    });
+  });
+
+  describe("updateAvailableRuntime", () => {
+    it("renames an entry in place, leaving nothing behind", async () => {
+      const api = makeApi();
+      const before: RuntimeClass = {
+        name: "Old Name",
+        type: "rest",
+        url: "http://127.0.0.1:8080",
+      };
+      const keep: RuntimeClass = { name: "Other", type: "browser" };
+
+      const { getCtx } = renderWithRuntimes(api, [], {
+        availableRuntimeEngines: [before, keep],
+      });
+      await waitFor(() => expect(getCtx()).toBeTruthy());
+
+      const after: RuntimeClass = {
+        name: "New Name",
+        type: "rest",
+        url: "http://127.0.0.1:9090",
+      };
+
+      await act(async () => {
+        getCtx()!.updateAvailableRuntime(before, after);
+      });
+
+      await waitFor(() => {
+        const engines = getCtx()!.availableRuntimeEngines;
+        expect(engines.some((e) => e.name === "Old Name")).toBe(false);
+        expect(engines[0]).toMatchObject({
+          name: "New Name",
+          url: "http://127.0.0.1:9090",
+        });
+        expect(engines.some((e) => e.name === "Other")).toBe(true);
+      });
+    });
+
+    it("collapses a rename onto a name the pool already holds", async () => {
+      const api = makeApi();
+      const before: RuntimeClass = { name: "Alpha", type: "rest", url: "http://a" };
+      const clash: RuntimeClass = { name: "Beta", type: "rest", url: "http://b" };
+
+      const { getCtx } = renderWithRuntimes(api, [], {
+        availableRuntimeEngines: [before, clash],
+      });
+      await waitFor(() => expect(getCtx()).toBeTruthy());
+
+      await act(async () => {
+        getCtx()!.updateAvailableRuntime(before, { ...before, name: "Beta" });
+      });
+
+      await waitFor(() => {
+        const engines = getCtx()!.availableRuntimeEngines;
+        const match = engines.filter((e) => e.name === "Beta");
+        expect(match).toHaveLength(1);
+        expect(match[0].url).toBe("http://a");
+      });
+    });
+  });
+
+  describe("removeAvailableRuntime", () => {
+    it("removes the named runtime class from availableRuntimeEngines", async () => {
+      const api = makeApi();
+      const rtClass: RuntimeClass = { name: "Removable Runtime", type: "browser" };
+
+      const { getCtx } = renderWithRuntimes(api, [], {
+        availableRuntimeEngines: [rtClass],
+      });
+      await waitFor(() => expect(getCtx()).toBeTruthy());
+
+      await act(async () => {
+        getCtx()!.removeAvailableRuntime(rtClass);
+      });
+
+      await waitFor(() => {
+        const engines = getCtx()!.availableRuntimeEngines;
+        expect(engines.some((e) => e.name === "Removable Runtime")).toBe(false);
+      });
+    });
+
+    it("keeps other entries intact", async () => {
+      const api = makeApi();
+      const keep: RuntimeClass = { name: "Keep Me", type: "browser" };
+      const remove: RuntimeClass = { name: "Remove Me", type: "browser" };
+
+      const { getCtx } = renderWithRuntimes(api, [], {
+        availableRuntimeEngines: [keep, remove],
+      });
+      await waitFor(() => expect(getCtx()).toBeTruthy());
+
+      await act(async () => {
+        getCtx()!.removeAvailableRuntime(remove);
+      });
+
+      await waitFor(() => {
+        const engines = getCtx()!.availableRuntimeEngines;
+        expect(engines.some((e) => e.name === "Keep Me")).toBe(true);
+        expect(engines.some((e) => e.name === "Remove Me")).toBe(false);
+      });
+    });
+  });
+});