384 lines
12 KiB
TypeScript
384 lines
12 KiB
TypeScript
import { afterEach, describe, expect, it, vi } from "vitest";
|
|
|
|
vi.mock("@/convex/helpers", () => ({
|
|
requireAuth: vi.fn(),
|
|
}));
|
|
|
|
import type { Id } from "@/convex/_generated/dataModel";
|
|
import { create, swapMixerInputs } from "@/convex/edges";
|
|
import { requireAuth } from "@/convex/helpers";
|
|
|
|
type MockCanvas = {
|
|
_id: Id<"canvases">;
|
|
ownerId: string;
|
|
updatedAt: number;
|
|
};
|
|
|
|
type MockNode = {
|
|
_id: Id<"nodes">;
|
|
canvasId: Id<"canvases">;
|
|
type: string;
|
|
};
|
|
|
|
type MockEdge = {
|
|
_id: Id<"edges">;
|
|
canvasId: Id<"canvases">;
|
|
sourceNodeId: Id<"nodes">;
|
|
targetNodeId: Id<"nodes">;
|
|
sourceHandle?: string;
|
|
targetHandle?: string;
|
|
};
|
|
|
|
function createMockCtx(args?: {
|
|
canvases?: MockCanvas[];
|
|
nodes?: MockNode[];
|
|
edges?: MockEdge[];
|
|
}) {
|
|
const canvases = new Map((args?.canvases ?? []).map((canvas) => [canvas._id, { ...canvas }]));
|
|
const nodes = new Map((args?.nodes ?? []).map((node) => [node._id, { ...node }]));
|
|
const edges = new Map((args?.edges ?? []).map((edge) => [edge._id, { ...edge }]));
|
|
const deletes: Id<"edges">[] = [];
|
|
let insertedEdgeCount = 0;
|
|
|
|
const ctx = {
|
|
db: {
|
|
get: vi.fn(async (id: string) => {
|
|
if (canvases.has(id as Id<"canvases">)) {
|
|
return canvases.get(id as Id<"canvases">) ?? null;
|
|
}
|
|
if (nodes.has(id as Id<"nodes">)) {
|
|
return nodes.get(id as Id<"nodes">) ?? null;
|
|
}
|
|
if (edges.has(id as Id<"edges">)) {
|
|
return edges.get(id as Id<"edges">) ?? null;
|
|
}
|
|
return null;
|
|
}),
|
|
query: vi.fn((table: "mutationRequests" | "edges") => {
|
|
if (table === "mutationRequests") {
|
|
return {
|
|
withIndex: vi.fn(() => ({
|
|
first: vi.fn(async () => null),
|
|
})),
|
|
};
|
|
}
|
|
|
|
if (table === "edges") {
|
|
return {
|
|
withIndex: vi.fn(
|
|
(
|
|
_index: "by_target",
|
|
apply: (q: { eq: (field: string, value: unknown) => unknown }) => unknown,
|
|
) => {
|
|
const clauses: Array<{ field: string; value: unknown }> = [];
|
|
const queryBuilder = {
|
|
eq(field: string, value: unknown) {
|
|
clauses.push({ field, value });
|
|
return this;
|
|
},
|
|
};
|
|
apply(queryBuilder);
|
|
|
|
const targetNodeId = clauses.find((clause) => clause.field === "targetNodeId")
|
|
?.value as Id<"nodes"> | undefined;
|
|
const incoming = Array.from(edges.values()).filter(
|
|
(edge) => edge.targetNodeId === targetNodeId,
|
|
);
|
|
|
|
return {
|
|
take: vi.fn(async (count: number) => incoming.slice(0, count)),
|
|
};
|
|
},
|
|
),
|
|
};
|
|
}
|
|
|
|
throw new Error(`Unexpected query table: ${table}`);
|
|
}),
|
|
insert: vi.fn(async (table: "edges" | "mutationRequests", value: Record<string, unknown>) => {
|
|
if (table === "mutationRequests") {
|
|
return "mutation_request_1";
|
|
}
|
|
insertedEdgeCount += 1;
|
|
const edgeId = `edge-new-${insertedEdgeCount}` as Id<"edges">;
|
|
edges.set(edgeId, {
|
|
_id: edgeId,
|
|
canvasId: value.canvasId as Id<"canvases">,
|
|
sourceNodeId: value.sourceNodeId as Id<"nodes">,
|
|
targetNodeId: value.targetNodeId as Id<"nodes">,
|
|
sourceHandle: value.sourceHandle as string | undefined,
|
|
targetHandle: value.targetHandle as string | undefined,
|
|
});
|
|
return edgeId;
|
|
}),
|
|
patch: vi.fn(async (id: string, patch: Record<string, unknown>) => {
|
|
if (canvases.has(id as Id<"canvases">)) {
|
|
const canvas = canvases.get(id as Id<"canvases">);
|
|
if (!canvas) {
|
|
throw new Error("Canvas missing");
|
|
}
|
|
canvases.set(id as Id<"canvases">, { ...canvas, ...patch });
|
|
return;
|
|
}
|
|
|
|
if (edges.has(id as Id<"edges">)) {
|
|
const edge = edges.get(id as Id<"edges">);
|
|
if (!edge) {
|
|
throw new Error("Edge missing");
|
|
}
|
|
edges.set(id as Id<"edges">, { ...edge, ...patch });
|
|
return;
|
|
}
|
|
|
|
throw new Error("Record missing");
|
|
}),
|
|
delete: vi.fn(async (edgeId: Id<"edges">) => {
|
|
deletes.push(edgeId);
|
|
edges.delete(edgeId);
|
|
}),
|
|
},
|
|
};
|
|
|
|
return {
|
|
ctx,
|
|
listEdges: () => Array.from(edges.values()),
|
|
listCanvases: () => Array.from(canvases.values()),
|
|
deletes,
|
|
};
|
|
}
|
|
|
|
describe("edges.create", () => {
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
it("treats edgeIdToIgnore as replacement and removes ignored edge", async () => {
|
|
vi.mocked(requireAuth).mockResolvedValue({ userId: "user-1" } as never);
|
|
const canvasId = "canvas-1" as Id<"canvases">;
|
|
const targetNodeId = "node-target" as Id<"nodes">;
|
|
const oldEdgeId = "edge-old" as Id<"edges">;
|
|
const mock = createMockCtx({
|
|
canvases: [{ _id: canvasId, ownerId: "user-1", updatedAt: 1 }],
|
|
nodes: [
|
|
{ _id: "node-source-1" as Id<"nodes">, canvasId, type: "image" },
|
|
{ _id: "node-source-2" as Id<"nodes">, canvasId, type: "image" },
|
|
{ _id: targetNodeId, canvasId, type: "mixer" },
|
|
],
|
|
edges: [
|
|
{
|
|
_id: oldEdgeId,
|
|
canvasId,
|
|
sourceNodeId: "node-source-1" as Id<"nodes">,
|
|
targetNodeId,
|
|
targetHandle: "base",
|
|
},
|
|
],
|
|
});
|
|
|
|
await (create as unknown as {
|
|
_handler: (
|
|
ctx: unknown,
|
|
args: {
|
|
canvasId: Id<"canvases">;
|
|
sourceNodeId: Id<"nodes">;
|
|
targetNodeId: Id<"nodes">;
|
|
targetHandle?: string;
|
|
edgeIdToIgnore?: Id<"edges">;
|
|
},
|
|
) => Promise<Id<"edges">>;
|
|
})._handler(mock.ctx, {
|
|
canvasId,
|
|
sourceNodeId: "node-source-2" as Id<"nodes">,
|
|
targetNodeId,
|
|
targetHandle: "base",
|
|
edgeIdToIgnore: oldEdgeId,
|
|
});
|
|
|
|
const incomingToTarget = mock
|
|
.listEdges()
|
|
.filter((edge) => edge.targetNodeId === targetNodeId && edge.targetHandle === "base");
|
|
|
|
expect(incomingToTarget).toHaveLength(1);
|
|
expect(incomingToTarget[0]?._id).not.toBe(oldEdgeId);
|
|
expect(mock.deletes).toEqual([oldEdgeId]);
|
|
});
|
|
});
|
|
|
|
describe("edges.swapMixerInputs", () => {
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
it("swaps handles between two mixer input edges and updates canvas timestamp", async () => {
|
|
vi.mocked(requireAuth).mockResolvedValue({ userId: "user-1" } as never);
|
|
const canvasId = "canvas-1" as Id<"canvases">;
|
|
const mixerNodeId = "node-mixer" as Id<"nodes">;
|
|
const mock = createMockCtx({
|
|
canvases: [{ _id: canvasId, ownerId: "user-1", updatedAt: 1 }],
|
|
nodes: [{ _id: mixerNodeId, canvasId, type: "mixer" }],
|
|
edges: [
|
|
{
|
|
_id: "edge-base" as Id<"edges">,
|
|
canvasId,
|
|
sourceNodeId: "source-1" as Id<"nodes">,
|
|
targetNodeId: mixerNodeId,
|
|
targetHandle: "base",
|
|
},
|
|
{
|
|
_id: "edge-overlay" as Id<"edges">,
|
|
canvasId,
|
|
sourceNodeId: "source-2" as Id<"nodes">,
|
|
targetNodeId: mixerNodeId,
|
|
targetHandle: "overlay",
|
|
},
|
|
],
|
|
});
|
|
|
|
await (swapMixerInputs as unknown as {
|
|
_handler: (
|
|
ctx: unknown,
|
|
args: {
|
|
canvasId: Id<"canvases">;
|
|
edgeId: Id<"edges">;
|
|
otherEdgeId: Id<"edges">;
|
|
},
|
|
) => Promise<void>;
|
|
})._handler(mock.ctx, {
|
|
canvasId,
|
|
edgeId: "edge-base" as Id<"edges">,
|
|
otherEdgeId: "edge-overlay" as Id<"edges">,
|
|
});
|
|
|
|
const swappedEdges = mock.listEdges();
|
|
expect(swappedEdges.find((edge) => edge._id === ("edge-base" as Id<"edges">))?.targetHandle).toBe(
|
|
"overlay",
|
|
);
|
|
expect(
|
|
swappedEdges.find((edge) => edge._id === ("edge-overlay" as Id<"edges">))?.targetHandle,
|
|
).toBe("base");
|
|
expect(mock.listCanvases()[0]?.updatedAt).toBeGreaterThan(1);
|
|
});
|
|
|
|
it("fails when one of the edge IDs does not exist", async () => {
|
|
vi.mocked(requireAuth).mockResolvedValue({ userId: "user-1" } as never);
|
|
const canvasId = "canvas-1" as Id<"canvases">;
|
|
const mock = createMockCtx({
|
|
canvases: [{ _id: canvasId, ownerId: "user-1", updatedAt: 1 }],
|
|
edges: [
|
|
{
|
|
_id: "edge-base" as Id<"edges">,
|
|
canvasId,
|
|
sourceNodeId: "source-1" as Id<"nodes">,
|
|
targetNodeId: "node-mixer" as Id<"nodes">,
|
|
targetHandle: "base",
|
|
},
|
|
],
|
|
});
|
|
|
|
await expect(
|
|
(swapMixerInputs as unknown as {
|
|
_handler: (
|
|
ctx: unknown,
|
|
args: {
|
|
canvasId: Id<"canvases">;
|
|
edgeId: Id<"edges">;
|
|
otherEdgeId: Id<"edges">;
|
|
},
|
|
) => Promise<void>;
|
|
})._handler(mock.ctx, {
|
|
canvasId,
|
|
edgeId: "edge-base" as Id<"edges">,
|
|
otherEdgeId: "edge-missing" as Id<"edges">,
|
|
}),
|
|
).rejects.toThrow("Edge not found");
|
|
});
|
|
|
|
it("fails when edges are not exactly one base and one overlay handle", async () => {
|
|
vi.mocked(requireAuth).mockResolvedValue({ userId: "user-1" } as never);
|
|
const canvasId = "canvas-1" as Id<"canvases">;
|
|
const mixerNodeId = "node-mixer" as Id<"nodes">;
|
|
const mock = createMockCtx({
|
|
canvases: [{ _id: canvasId, ownerId: "user-1", updatedAt: 1 }],
|
|
nodes: [{ _id: mixerNodeId, canvasId, type: "mixer" }],
|
|
edges: [
|
|
{
|
|
_id: "edge-1" as Id<"edges">,
|
|
canvasId,
|
|
sourceNodeId: "source-1" as Id<"nodes">,
|
|
targetNodeId: mixerNodeId,
|
|
targetHandle: "base",
|
|
},
|
|
{
|
|
_id: "edge-2" as Id<"edges">,
|
|
canvasId,
|
|
sourceNodeId: "source-2" as Id<"nodes">,
|
|
targetNodeId: mixerNodeId,
|
|
targetHandle: "base",
|
|
},
|
|
],
|
|
});
|
|
|
|
await expect(
|
|
(swapMixerInputs as unknown as {
|
|
_handler: (
|
|
ctx: unknown,
|
|
args: {
|
|
canvasId: Id<"canvases">;
|
|
edgeId: Id<"edges">;
|
|
otherEdgeId: Id<"edges">;
|
|
},
|
|
) => Promise<void>;
|
|
})._handler(mock.ctx, {
|
|
canvasId,
|
|
edgeId: "edge-1" as Id<"edges">,
|
|
otherEdgeId: "edge-2" as Id<"edges">,
|
|
}),
|
|
).rejects.toThrow("Mixer swap requires one base and one overlay edge");
|
|
});
|
|
|
|
it("fails when edges do not belong to the same mixer target on the same canvas", async () => {
|
|
vi.mocked(requireAuth).mockResolvedValue({ userId: "user-1" } as never);
|
|
const canvasId = "canvas-1" as Id<"canvases">;
|
|
const mock = createMockCtx({
|
|
canvases: [{ _id: canvasId, ownerId: "user-1", updatedAt: 1 }],
|
|
nodes: [
|
|
{ _id: "node-mixer-a" as Id<"nodes">, canvasId, type: "mixer" },
|
|
{ _id: "node-mixer-b" as Id<"nodes">, canvasId, type: "mixer" },
|
|
],
|
|
edges: [
|
|
{
|
|
_id: "edge-base" as Id<"edges">,
|
|
canvasId,
|
|
sourceNodeId: "source-1" as Id<"nodes">,
|
|
targetNodeId: "node-mixer-a" as Id<"nodes">,
|
|
targetHandle: "base",
|
|
},
|
|
{
|
|
_id: "edge-overlay" as Id<"edges">,
|
|
canvasId,
|
|
sourceNodeId: "source-2" as Id<"nodes">,
|
|
targetNodeId: "node-mixer-b" as Id<"nodes">,
|
|
targetHandle: "overlay",
|
|
},
|
|
],
|
|
});
|
|
|
|
await expect(
|
|
(swapMixerInputs as unknown as {
|
|
_handler: (
|
|
ctx: unknown,
|
|
args: {
|
|
canvasId: Id<"canvases">;
|
|
edgeId: Id<"edges">;
|
|
otherEdgeId: Id<"edges">;
|
|
},
|
|
) => Promise<void>;
|
|
})._handler(mock.ctx, {
|
|
canvasId,
|
|
edgeId: "edge-base" as Id<"edges">,
|
|
otherEdgeId: "edge-overlay" as Id<"edges">,
|
|
}),
|
|
).rejects.toThrow("Edges must target the same mixer node");
|
|
});
|
|
});
|