@arcote.tech/arc-map 0.7.28 → 0.7.29

package/tests/usecase-model.test.ts

@@ -1,197 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { buildUseCaseModel, type OccurrenceRef } from "../src/app/usecase-model";
-import { resolveRef } from "../src/refs";
-import type { MapEdge, MapJson } from "../src/types";
-
-function el(id: string, kind: any, extra: any = {}) {
-  return { id, name: id, kind, spaceId: "s", ...extra };
-}
-function edge(source: string, target: string, kind: MapEdge["kind"]): MapEdge {
-  return { id: `${source}->${target}:${kind}`, source, target, kind, crossContext: false };
-}
-
-// cmd reads v, writes e; listener l also writes e; v,x are views; e event.
-const map: MapJson = {
-  spaces: [{ id: "s", name: "s" }],
-  elements: [
-    el("cmd", "command", { queryDeps: ["v"], mutationDeps: ["e"] }),
-    el("l", "listener", { mutationDeps: ["e"] }),
-    el("v", "view"),
-    el("e", "event"),
-    el("x", "view"),
-  ],
-  edges: [edge("cmd", "v", "queries"), edge("cmd", "e", "mutates"), edge("l", "e", "mutates")],
-  components: [],
-  componentEdges: [],
-};
-
-function occ(occId: string, props: any, label = occId): OccurrenceRef {
-  return { occId, ref: resolveRef(props), label };
-}
-
-describe("buildUseCaseModel", () => {
-  test("one step per occurrence (duplicates kept)", () => {
-    const m = buildUseCaseModel({
-      map,
-      occurrences: [occ("o1", { command: "cmd" }), occ("o2", { command: "cmd" })],
-    });
-    expect(m.steps.map((s) => s.occId)).toEqual(["o1", "o2"]);
-    expect(m.steps.map((s) => s.seq)).toEqual([1, 2]);
-    expect(m.steps.every((s) => s.exists)).toBe(true);
-  });
-
-  test("missing reference → step with exists=false", () => {
-    const m = buildUseCaseModel({ map, occurrences: [occ("o1", { command: "ghost" })] });
-    expect(m.steps[0].exists).toBe(false);
-    expect(m.steps[0].element).toBeUndefined();
-  });
-
-  test("forward badges exclude visible; query dep becomes a badge", () => {
-    const m = buildUseCaseModel({
-      map,
-      occurrences: [occ("o1", { command: "cmd" }), occ("o2", { event: "e" })],
-    });
-    const cmd = m.steps.find((s) => s.occId === "o1")!;
-    // cmd queries v (not visible → badge); mutates e (visible → excluded).
-    expect(cmd.badges.queries).toEqual(["v"]);
-    expect(cmd.badges.mutates).toBeUndefined();
-  });
-
-  test("reverse mutatedBy badge (e is written by cmd[visible] and l[hidden])", () => {
-    const m = buildUseCaseModel({
-      map,
-      occurrences: [occ("o1", { command: "cmd" }), occ("o2", { event: "e" })],
-    });
-    const e = m.steps.find((s) => s.occId === "o2")!;
-    // mutatedBy = {cmd (visible→excluded), l (hidden→badge)}.
-    expect(e.badges.mutatedBy).toEqual(["l"]);
-  });
-
-  test("connector sits on the DIRECTED flow path between two narrated steps", () => {
-    // cmd emits e, listener l handles e → directed flow cmd → e → l, so e is
-    // genuinely BETWEEN them and surfaces as a connector.
-    const chainMap: MapJson = {
-      spaces: [{ id: "s", name: "s" }],
-      elements: [el("cmd", "command", { mutationDeps: ["e"] }), el("e", "event"), el("l", "listener")],
-      edges: [edge("cmd", "e", "emits"), edge("l", "e", "handles")],
-      components: [],
-      componentEdges: [],
-    };
-    const m = buildUseCaseModel({
-      map: chainMap,
-      occurrences: [occ("o1", { command: "cmd" }), occ("o2", { listener: "l" })],
-    });
-    expect(m.connectors.map((c) => c.id)).toEqual(["e"]);
-    expect(m.connectors[0].between).toEqual([1, 2]); // [upstream cmd, downstream l]
-    expect(m.connectors[0].order).toBe(1);
-    expect(m.connectors[0].count).toBe(1);
-    expect(m.visible.has("e")).toBe(true);
-    // e is a connector (visible) → cmd no longer badges it as mutates.
-    expect(m.steps.find((s) => s.occId === "o1")!.badges.mutates).toBeUndefined();
-  });
-
-  test("shared downstream is NOT a connector (no directed between-path)", () => {
-    // In `map`, cmd AND l both write e → e is downstream of both, not between
-    // them. Directed flow finds no cmd→l / l→cmd path, so no connector.
-    const m = buildUseCaseModel({
-      map,
-      occurrences: [occ("o1", { command: "cmd" }), occ("o2", { listener: "l" })],
-    });
-    expect(m.connectors.length).toBe(0);
-    expect(m.visible.has("e")).toBe(false);
-  });
-
-  test("usedByUI badge from componentEdges + component refs resolve", () => {
-    const uiMap: MapJson = {
-      spaces: [{ id: "s", name: "s" }],
-      elements: [el("acc", "aggregate")],
-      edges: [],
-      components: [
-        { id: "pkg/login.tsx", file: "pkg/login.tsx", name: "login" },
-        { id: "pkg/other.tsx", file: "pkg/other.tsx", name: "other" },
-      ],
-      componentEdges: [
-        { id: "e1", source: "pkg/login.tsx", target: "acc", usage: "query", methods: [] },
-      ],
-    };
-    // narrate the aggregate; login.tsx uses it → usedByUI badge.
-    const m = buildUseCaseModel({ map: uiMap, occurrences: [occ("o1", { aggregate: "acc" })] });
-    expect(m.steps[0].badges.usedByUI).toEqual(["pkg/login.tsx"]);
-    expect(m.uiById.has("pkg/login.tsx")).toBe(true);
-
-    // `<Arc component="...">` resolves against the component (UI) layer.
-    const m2 = buildUseCaseModel({ map: uiMap, occurrences: [occ("o1", { component: "pkg/login.tsx" })] });
-    expect(m2.steps[0].exists).toBe(true);
-    expect(m2.steps[0].element?.kind).toBe("page");
-  });
-
-  test("depth/lane: plain sequence increments depth, lane 0", () => {
-    const m = buildUseCaseModel({ map, occurrences: [occ("o1", { command: "cmd" }), occ("o2", { event: "e" })] });
-    expect(m.steps.map((s) => [s.depth, s.lane])).toEqual([[0, 0], [1, 0]]);
-  });
-
-  test("depth/lane: <Parallel> members share depth on separate lanes; next plain advances", () => {
-    const p = (occId: string, props: any, lane: number) => ({
-      occId, ref: resolveRef(props), label: occId,
-      path: [{ type: "parallel" as const, id: "p1", laneIndex: lane }],
-    });
-    const m = buildUseCaseModel({
-      map,
-      occurrences: [
-        p("a", { command: "cmd" }, 0),
-        p("b", { view: "v" }, 1),
-        occ("c", { event: "e" }),
-      ],
-    });
-    const by = new Map(m.steps.map((s) => [s.occId, s]));
-    expect([by.get("a")!.depth, by.get("a")!.lane]).toEqual([0, 0]);
-    expect([by.get("b")!.depth, by.get("b")!.lane]).toEqual([0, 1]); // same depth, lane 1
-    expect([by.get("c")!.depth, by.get("c")!.lane]).toEqual([1, 0]); // block occupies 1 slot
-  });
-
-  test("depth/lane: <Branch>/<Lane> marks alt and sets lanes", () => {
-    const b = (occId: string, props: any, lane: number, title: string) => ({
-      occId, ref: resolveRef(props), label: occId,
-      path: [
-        { type: "branch" as const, id: "br1", laneIndex: lane },
-        { type: "lane" as const, id: "l" + lane, title, alt: true },
-      ],
-    });
-    const m = buildUseCaseModel({
-      map,
-      occurrences: [b("ok", { view: "v" }, 0, "Sukces"), b("err", { event: "e" }, 1, "Błąd")],
-    });
-    const by = new Map(m.steps.map((s) => [s.occId, s]));
-    expect(by.get("ok")!.alt).toBe(true);
-    expect([by.get("ok")!.depth, by.get("ok")!.lane]).toEqual([0, 0]);
-    expect([by.get("err")!.depth, by.get("err")!.lane]).toEqual([0, 1]);
-    expect(by.get("ok")!.laneTitle).toBe("Sukces");
-  });
-
-  test("aggregate mutationMethod uses per-method deps", () => {
-    const aggMap: MapJson = {
-      spaces: [{ id: "s", name: "s" }],
-      elements: [
-        el("acc", "aggregate", {
-          methods: [
-            { name: "check", kind: "mutate", queryDeps: ["dirA"], mutationDeps: ["dirB"] },
-            { name: "other", kind: "mutate", queryDeps: ["zzz"], mutationDeps: [] },
-          ],
-        }),
-        el("dirA", "view"),
-        el("dirB", "event"),
-        el("zzz", "view"),
-      ],
-      edges: [],
-      components: [],
-      componentEdges: [],
-    };
-    const m = buildUseCaseModel({
-      map: aggMap,
-      occurrences: [occ("o1", { aggregate: "acc", mutationMethod: "check" })],
-    });
-    const step = m.steps[0];
-    expect(step.badges.queries).toEqual(["dirA"]); // check's deps, NOT other's "zzz"
-    expect(step.badges.mutates).toEqual(["dirB"]);
-  });
-});