@readymadeit/mcp 0.0.0-stage → 0.1.0

package/bundle/hkp-frontend/src/runtime/browser/tests/demo-boards.regression.test.tsx

@@ -0,0 +1,386 @@
+import React, { useContext, useEffect } from "react";
+import { act, render, waitFor } from "@testing-library/react";
+import { beforeAll, describe, expect, it, vi } from "vitest";
+
+import BoardProvider, {
+  BoardContextState,
+  BoardCtx,
+} from "hkp-frontend/src/BoardContext";
+import BrowserRegistry from "hkp-frontend/src/runtime/browser/BrowserRegistry";
+import { linkBlocks } from "hkp-frontend/src/core/linkBlocks";
+import { isBlockUse } from "hkp-frontend/src/runtime/board/blocks";
+import { filesUnitOrigin, isComposition } from "hkp-frontend/src/core/linkUnits";
+import {
+  UnitBoard,
+  qualifyRuntimeId,
+  unitBaseName,
+} from "hkp-frontend/src/runtime/board/units";
+import { allowedServices } from "hkp-frontend/src/runtime/browser/BrowserRegistry";
+import {
+  BoardDescriptor,
+  RuntimeApi,
+  RuntimeApiMap,
+  RuntimeDescriptor,
+  ServiceDescriptor,
+  isBoardDescriptor,
+} from "hkp-frontend/src/types";
+
+const boardModules = import.meta.glob("../../../../../boards/*.json", {
+  eager: true,
+  import: "default",
+}) as Record<string, BoardDescriptor>;
+
+const boardEntries = Object.entries(boardModules)
+  .map(([modulePath, board]) => ({
+    modulePath,
+    fileName: modulePath.split("/").at(-1) || modulePath,
+    board,
+  }))
+  .sort((a, b) => a.fileName.localeCompare(b.fileName));
+
+/**
+ * Where a composition's units are found: the other boards beside it, as the
+ * demo registry hands them to the app.
+ */
+const repositoryUnits = filesUnitOrigin(
+  new Map(boardEntries.map(({ fileName, board }) => [fileName, board as UnitBoard])),
+  "the repository's boards",
+);
+
+/**
+ * The runtimes a board runs as, with how many services each has: its own, and
+ * for a composition each unit's under the id the projection gives it.
+ */
+function runsAs(board: BoardDescriptor): {
+  runtimes: RuntimeDescriptor[];
+  serviceCounts: Record<string, number>;
+} {
+  const runtimes = [...board.runtimes];
+  const serviceCounts: Record<string, number> = Object.fromEntries(
+    board.runtimes.map((runtime) => [runtime.id, (board.services[runtime.id] || []).length]),
+  );
+  for (const unit of (board as UnitBoard).units ?? []) {
+    const source = boardEntries.find(
+      ({ fileName }) => unitBaseName(fileName) === unitBaseName(unit.uri),
+    )?.board;
+    if (!source) {
+      continue;
+    }
+    const name = unit.as ?? unitBaseName(unit.uri);
+    for (const runtime of source.runtimes) {
+      const id = qualifyRuntimeId(name, runtime.id);
+      runtimes.push({ ...runtime, id });
+      serviceCounts[id] = (source.services[runtime.id] || []).length;
+    }
+  }
+  return { runtimes, serviceCounts };
+}
+
+function ContextProbe({
+  onChange,
+}: {
+  onChange: (ctx: BoardContextState | null) => void;
+}) {
+  const ctx = useContext(BoardCtx);
+  useEffect(() => {
+    onChange(ctx);
+  }, [ctx, onChange]);
+  return null;
+}
+
+function createRuntimeApiMock(
+  restoreRuntimeSpy: ReturnType<typeof vi.fn>,
+): RuntimeApi {
+  return {
+    addRuntime: vi.fn(async () => null),
+    restoreRuntime: restoreRuntimeSpy,
+    removeRuntime: vi.fn(async () => {}),
+    processRuntime: vi.fn(async () => {}),
+    addService: vi.fn(async () => null),
+    removeService: vi.fn(async () => null),
+    configureService: vi.fn(async () => ({})),
+    getServiceConfig: vi.fn(async () => ({})),
+    processService: vi.fn(async () => ({})),
+    rearrangeServices: vi.fn(async (_scope, newOrder) => newOrder),
+  };
+}
+
+function createRuntimeApis(runtimes: RuntimeDescriptor[]): {
+  runtimeApis: RuntimeApiMap;
+  restoreSpies: Map<string, ReturnType<typeof vi.fn>>;
+} {
+  const runtimeApis: RuntimeApiMap = {};
+  const restoreSpies = new Map<string, ReturnType<typeof vi.fn>>();
+
+  for (const runtime of runtimes) {
+    if (runtimeApis[runtime.type]) {
+      continue;
+    }
+
+    const restoreRuntimeSpy = vi.fn(
+      async (
+        descriptor: RuntimeDescriptor,
+        services: ServiceDescriptor[] = [],
+      ) => ({
+        runtime: descriptor,
+        services,
+        scope: { descriptor } as any,
+        registry: [],
+      }),
+    );
+
+    restoreSpies.set(runtime.type, restoreRuntimeSpy);
+    runtimeApis[runtime.type] = createRuntimeApiMock(restoreRuntimeSpy);
+  }
+
+  return { runtimeApis, restoreSpies };
+}
+
+function serviceIdsForRuntime(board: BoardDescriptor, runtimeId: string) {
+  return (board.services[runtimeId] || []).map((service) => service.serviceId);
+}
+
+/** Every service a pipeline names, however deep it sits in sub-pipelines. */
+function nestedServiceIds(value: unknown, found: string[] = []): string[] {
+  if (Array.isArray(value)) {
+    value.forEach((entry) => nestedServiceIds(entry, found));
+  } else if (value && typeof value === "object") {
+    const entry = value as Record<string, unknown>;
+    if (typeof entry.serviceId === "string") {
+      found.push(entry.serviceId);
+    }
+    Object.values(entry).forEach((inner) => nestedServiceIds(inner, found));
+  }
+  return found;
+}
+
+function getBoardByFileName(fileName: string): BoardDescriptor {
+  const match = boardEntries.find((entry) => entry.fileName === fileName);
+  if (!match) {
+    throw new Error(`Board fixture not found: ${fileName}`);
+  }
+  return match.board;
+}
+
+describe("demo boards regression", () => {
+  describe("structure", () => {
+    it("discovers demo boards", () => {
+      expect(boardEntries.length).toBeGreaterThan(0);
+    });
+
+    for (const { fileName, board } of boardEntries) {
+      it(`${fileName} matches board descriptor contract`, () => {
+        expect(isBoardDescriptor(board)).toBe(true);
+
+        const runtimeIds = new Set(board.runtimes.map((runtime) => runtime.id));
+        expect(runtimeIds.size).toBe(board.runtimes.length);
+
+        for (const runtime of board.runtimes) {
+          const services = board.services[runtime.id];
+          expect(Array.isArray(services)).toBe(true);
+
+          const uuids = new Set<string>();
+          for (const service of services || []) {
+            expect(typeof service.uuid).toBe("string");
+            expect(service.uuid.length).toBeGreaterThan(0);
+            expect(uuids.has(service.uuid)).toBe(false);
+            uuids.add(service.uuid);
+            // A use of a block names the block, not a service; what it
+            // expands to is checked where the board is linked, below.
+            if (isBlockUse(service)) {
+              expect(service.block.length).toBeGreaterThan(0);
+              continue;
+            }
+            expect(typeof service.serviceId).toBe("string");
+            expect(service.serviceId.length).toBeGreaterThan(0);
+            expect(typeof service.serviceName).toBe("string");
+            expect(service.serviceName.length).toBeGreaterThan(0);
+          }
+        }
+
+        for (const runtimeId of Object.keys(board.services)) {
+          expect(runtimeIds.has(runtimeId)).toBe(true);
+        }
+      });
+    }
+  });
+
+  describe("browser service resolution", () => {
+    let browserRegistry: BrowserRegistry;
+
+    beforeAll(async () => {
+      browserRegistry = await BrowserRegistry.create();
+    });
+
+    for (const { fileName, board } of boardEntries) {
+      it(`${fileName} resolves browser service modules`, () => {
+        // As it runs: a use of a block names no service itself, and the
+        // services its definition names are what the runtime is handed.
+        const linked = linkBlocks(board);
+        expect(
+          linked.diagnostics.filter((entry) => entry.level === "error"),
+          `${fileName} does not link`,
+        ).toEqual([]);
+        for (const runtime of linked.board.runtimes) {
+          if (runtime.type !== "browser") {
+            continue;
+          }
+
+          for (const serviceId of nestedServiceIds(
+            linked.board.services[runtime.id] || [],
+          )) {
+            const module = browserRegistry.findServiceModule(serviceId);
+            const allowlisted = allowedServices.includes(serviceId);
+            expect(
+              module || allowlisted,
+              `${fileName} references missing browser service: ${serviceId}`,
+            ).toBeTruthy();
+          }
+        }
+      });
+    }
+  });
+
+  describe("restore smoke", () => {
+    for (const { fileName, board } of boardEntries) {
+      it(`restores ${fileName} through BoardProvider setBoardState`, async () => {
+        // A composition is restored as the app restores it, with its units to
+        // hand, and runs as its projection: its own runtimes and its units'.
+        const expected = runsAs(board);
+        const { runtimeApis, restoreSpies } = createRuntimeApis(expected.runtimes);
+        let latestCtx: BoardContextState | null = null;
+
+        render(
+          <BoardProvider
+            user={null}
+            boardName="demo-regression"
+            runtimeApis={runtimeApis}
+            onRemoveRuntime={vi.fn(async () => {})}
+            initialState={{
+              runtimes: [],
+              services: {},
+              scopes: {},
+              registry: {},
+            }}
+          >
+            <ContextProbe onChange={(ctx) => (latestCtx = ctx)} />
+          </BoardProvider>,
+        );
+
+        await waitFor(() => expect(latestCtx).toBeTruthy());
+
+        await act(async () => {
+          await latestCtx!.setBoardState(
+            board,
+            isComposition(board as UnitBoard) ? repositoryUnits : undefined,
+          );
+        });
+
+        await waitFor(() => {
+          expect(latestCtx!.runtimes.map((runtime) => runtime.id)).toEqual(
+            expected.runtimes.map((runtime) => runtime.id),
+          );
+        });
+
+        for (const runtime of expected.runtimes) {
+          expect(latestCtx!.services[runtime.id]).toHaveLength(
+            expected.serviceCounts[runtime.id],
+          );
+        }
+
+        const expectedRestoreCallsByType = expected.runtimes.reduce(
+          (all, runtime) => ({
+            ...all,
+            [runtime.type]: (all[runtime.type] || 0) + 1,
+          }),
+          {} as Record<string, number>,
+        );
+
+        for (const [runtimeType, restoreSpy] of restoreSpies.entries()) {
+          expect(restoreSpy).toHaveBeenCalledTimes(
+            expectedRestoreCallsByType[runtimeType] || 0,
+          );
+        }
+      });
+    }
+  });
+
+  describe("board contracts", () => {
+    it("animate board includes animation pipeline services", () => {
+      const board = getBoardByFileName("animate-board.json");
+      expect(board.runtimes).toHaveLength(1);
+
+      const runtimeId = board.runtimes[0].id;
+      expect(serviceIdsForRuntime(board, runtimeId)).toEqual([
+        "hookup.to/service/timer",
+        "tracks",
+        "hookup.to/service/monitor",
+        "hookup.to/service/canvas",
+        "hookup.to/service/gif-encoder",
+      ]);
+    });
+
+    it("game of life board includes visual and audio branches", () => {
+      const board = getBoardByFileName("game-of-life-board.json");
+      expect(board.runtimes).toHaveLength(1);
+      const runtimeId = board.runtimes[0].id;
+
+      const topLevelServiceIds = serviceIdsForRuntime(board, runtimeId);
+      expect(topLevelServiceIds).toEqual([
+        "hookup.to/service/timer",
+        "hookup.to/service/game-of-life",
+        "tracks",
+      ]);
+
+      const tracksService = (board.services[runtimeId] || []).find(
+        (service) => service.serviceId === "tracks",
+      ) as any;
+      expect(tracksService).toBeTruthy();
+
+      // A track is a pipeline, so each branch's services sit in it directly —
+      // there is nothing for a sub-service to wrap.
+      const branchServiceIds = (tracksService.state?.tracks || []).flatMap(
+        (track: any) => (track.pipeline || []).map((step: any) => step.serviceId),
+      );
+
+      expect(branchServiceIds).toEqual([
+        "hookup.to/service/game-of-life-renderer",
+        "hookup.to/service/canvas",
+        "hookup.to/service/map",
+        "hookup.to/service/map",
+        "hookup.to/service/sort",
+        "hookup.to/service/limit",
+        "hookup.to/service/map",
+        "hookup.to/service/sound",
+      ]);
+    });
+
+    it("encrypt board keeps separate encrypt and decrypt runtimes", () => {
+      const board = getBoardByFileName("encrypt-board.json");
+      expect(board.runtimes).toHaveLength(2);
+
+      const encryptRuntime = board.runtimes.find(
+        (runtime) => runtime.name === "Encrypt",
+      );
+      const decryptRuntime = board.runtimes.find(
+        (runtime) => runtime.name === "Decrypt",
+      );
+
+      expect(encryptRuntime).toBeTruthy();
+      expect(decryptRuntime).toBeTruthy();
+
+      const encryptServices = serviceIdsForRuntime(board, encryptRuntime!.id);
+      const decryptServices = serviceIdsForRuntime(board, decryptRuntime!.id);
+
+      expect(encryptServices).toEqual([
+        "hookup.to/service/injector",
+        "hookup.to/service/encrypt",
+        "hookup.to/service/monitor",
+      ]);
+      expect(decryptServices).toEqual([
+        "hookup.to/service/decrypt",
+        "hookup.to/service/monitor",
+      ]);
+    });
+  });
+});

package/bundle/hkp-frontend/src/runtime/browser/tests/failed-call-lifecycle.test.ts

@@ -0,0 +1,56 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import api from "../BrowserRuntimeApi";
+import BrowserRuntimeScope from "../BrowserRuntimeScope";
+import { setCapturing } from "../../captureMode";
+import { ServiceInstance } from "hkp-frontend/src/types";
+
+/**
+ * A call that fails is over all the same: it is reported finished, with
+ * nothing produced. What shows a service running counts the calls still open,
+ * so a failed call that never said it ended would show it running for good.
+ */
+
+const lifecycle = (calls: any[][]) =>
+  calls
+    .map(([notification]) => notification?.__internal)
+    .filter((internal) => internal?.state?.startsWith("call-process"));
+const withoutCall = (internals: any[]) =>
+  internals.map(({ state, data }) => ({ state, data }));
+
+describe("a call that fails", () => {
+  // About the values a frame is shown, which reports carry in Capture mode.
+  beforeEach(() => setCapturing(true));
+  afterEach(() => setCapturing(false));
+
+  it("is reported finished, with nothing produced", async () => {
+    const { scope: scope_ } = await api.addRuntime(
+      { name: "Browser", type: "browser" } as any,
+      null,
+      "test-board",
+    );
+    const scope = scope_ as BrowserRuntimeScope;
+    scope.onResult = async () => {};
+    const added = await api.addService(scope, {
+      serviceId: "hookup.to/service/monitor",
+      serviceName: "Failing",
+    } as any);
+    const svc = scope.findServiceInstance(added!.uuid)[0] as ServiceInstance;
+    svc.process = async () => {
+      throw new Error("broken");
+    };
+    const target = vi.fn();
+    scope.app.registerNotificationTarget!(svc, target);
+    vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    await scope.next(null, { n: 1 }, null, false);
+
+    const [started, finished] = lifecycle(target.mock.calls);
+    expect(withoutCall([started, finished])).toEqual([
+      { state: "call-process", data: { n: 1 } },
+      { state: "call-process-finished", data: null },
+    ]);
+    // Its end is reported as the end of that call.
+    expect(finished.call).toBe(started.call);
+  });
+});

package/bundle/hkp-frontend/src/runtime/browser/tests/http-client.integration.test.ts

@@ -0,0 +1,146 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import BrowserRuntimeScope from "hkp-frontend/src/runtime/browser/BrowserRuntimeScope";
+import BrowserRegistry from "hkp-frontend/src/runtime/browser/BrowserRegistry";
+import {
+  addService,
+  configureService,
+  processService,
+} from "hkp-frontend/src/runtime/browser/BrowserRuntimeApi";
+import { RuntimeDescriptor } from "hkp-frontend/src/types";
+
+/**
+ * The HTTP Client inside a real runtime, rather than against a mock app.
+ *
+ * The service's whole shape follows from one fact — the response does not exist
+ * when the push passes through it — and that fact only shows up with a pipeline
+ * behind it: the services after it must not be called with nothing, and must be
+ * called with the response once there is one. This is that, end to end, with
+ * only the network replaced.
+ */
+
+async function createScope() {
+  const runtime: RuntimeDescriptor = {
+    id: "rt-http-1",
+    name: "Browser Runtime",
+    type: "browser",
+  };
+  const registry = await BrowserRegistry.create();
+  return new BrowserRuntimeScope(runtime, registry);
+}
+
+/** A service that records what reached it, to stand in for the rest of a board. */
+function recordingService(uuid: string, seen: unknown[]) {
+  return {
+    uuid,
+    board: "test-board",
+    app: null,
+    serviceId: `test/${uuid}`,
+    serviceName: uuid,
+    configure: vi.fn(),
+    process: vi.fn((input: unknown) => {
+      seen.push(input);
+      return input;
+    }),
+    destroy: vi.fn(),
+    bypass: false,
+  } as any;
+}
+
+let fetchMock: ReturnType<typeof vi.fn>;
+
+beforeEach(() => {
+  fetchMock = vi.fn();
+  vi.stubGlobal("fetch", fetchMock);
+});
+
+describe("http-client in a browser runtime", () => {
+  it("is a service the browser registry can build", async () => {
+    const scope = await createScope();
+
+    const descriptor = await addService(
+      scope as any,
+      { serviceId: "http-client", serviceName: "Request" } as any,
+      "request",
+    );
+
+    expect(descriptor).not.toBeNull();
+    expect(scope.findServiceInstance("request")[0]).toBeDefined();
+  });
+
+  it("calls the services behind it with the response, once there is one", async () => {
+    const scope = await createScope();
+    const seen: unknown[] = [];
+    const results: unknown[] = [];
+    scope.onResult = async (_uuid, result) => {
+      results.push(result);
+    };
+
+    await addService(
+      scope as any,
+      { serviceId: "http-client", serviceName: "Request" } as any,
+      "request",
+    );
+    scope.appendService(recordingService("response", seen));
+    await configureService(
+      scope as any,
+      { uuid: "request" } as any,
+      { url: "https://api.example.com/zen" },
+    );
+
+    let respond: (response: Response) => void = () => {};
+    fetchMock.mockImplementation(
+      () => new Promise<Response>((resolve) => (respond = resolve)),
+    );
+
+    processService(scope as any, { uuid: "request" } as any, undefined);
+
+    // The push has passed through: the request is out, and nothing was handed
+    // on — a response it does not have yet cannot be the pipeline's value.
+    await vi.waitFor(() => expect(fetchMock).toHaveBeenCalled());
+    expect(seen).toEqual([]);
+
+    respond(
+      new Response(new TextEncoder().encode('{"hello":"board"}'), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      }),
+    );
+
+    await vi.waitFor(() => expect(seen).toHaveLength(1));
+    expect(seen[0]).toMatchObject({
+      meta: { status: 200, url: "https://api.example.com/zen" },
+      body: { hello: "board" },
+    });
+    // And the runtime's own result is the response too, so a board's next
+    // runtime is reached rather than left waiting.
+    expect(results[results.length - 1]).toMatchObject({
+      body: { hello: "board" },
+    });
+  });
+
+  it("leaves the pipeline alone when the request fails", async () => {
+    const scope = await createScope();
+    const seen: unknown[] = [];
+
+    await addService(
+      scope as any,
+      { serviceId: "http-client", serviceName: "Request" } as any,
+      "request",
+    );
+    scope.appendService(recordingService("response", seen));
+    await configureService(
+      scope as any,
+      { uuid: "request" } as any,
+      { url: "https://api.example.com" },
+    );
+
+    fetchMock.mockRejectedValue(new TypeError("Failed to fetch"));
+
+    processService(scope as any, { uuid: "request" } as any, undefined);
+
+    await vi.waitFor(() => expect(fetchMock).toHaveBeenCalled());
+    await Promise.resolve();
+    expect(seen).toEqual([]);
+  });
+});