wehub-resource-sync
628 lines
21 KiB
TypeScript
628 lines
21 KiB
TypeScript
import { describe, it, expect, beforeEach, vi } from "vitest";
|
|
|
|
vi.mock("../src/logger.js", () => ({
|
|
logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
|
|
}));
|
|
|
|
import { registerSentinelsFunction } from "../src/functions/sentinels.js";
|
|
import { registerActionsFunction } from "../src/functions/actions.js";
|
|
import type { Action, ActionEdge, Sentinel } from "../src/types.js";
|
|
|
|
function mockKV() {
|
|
const store = new Map<string, Map<string, unknown>>();
|
|
return {
|
|
get: async <T>(scope: string, key: string): Promise<T | null> => {
|
|
return (store.get(scope)?.get(key) as T) ?? null;
|
|
},
|
|
set: async <T>(scope: string, key: string, data: T): Promise<T> => {
|
|
if (!store.has(scope)) store.set(scope, new Map());
|
|
store.get(scope)!.set(key, data);
|
|
return data;
|
|
},
|
|
delete: async (scope: string, key: string): Promise<void> => {
|
|
store.get(scope)?.delete(key);
|
|
},
|
|
list: async <T>(scope: string): Promise<T[]> => {
|
|
const entries = store.get(scope);
|
|
return entries ? (Array.from(entries.values()) as T[]) : [];
|
|
},
|
|
};
|
|
}
|
|
|
|
function mockSdk() {
|
|
const functions = new Map<string, Function>();
|
|
return {
|
|
registerFunction: (idOrOpts: string | { id: string }, handler: Function) => {
|
|
const id = typeof idOrOpts === "string" ? idOrOpts : idOrOpts.id;
|
|
functions.set(id, handler);
|
|
},
|
|
registerTrigger: () => {},
|
|
trigger: async (idOrInput: string | { function_id: string; payload: unknown }, data?: unknown) => {
|
|
const id = typeof idOrInput === "string" ? idOrInput : idOrInput.function_id;
|
|
const payload = typeof idOrInput === "string" ? data : idOrInput.payload;
|
|
const fn = functions.get(id);
|
|
if (!fn) throw new Error(`No function: ${id}`);
|
|
return fn(payload);
|
|
},
|
|
};
|
|
}
|
|
|
|
describe("Sentinels Functions", () => {
|
|
let sdk: ReturnType<typeof mockSdk>;
|
|
let kv: ReturnType<typeof mockKV>;
|
|
|
|
beforeEach(() => {
|
|
sdk = mockSdk();
|
|
kv = mockKV();
|
|
registerSentinelsFunction(sdk as never, kv as never);
|
|
registerActionsFunction(sdk as never, kv as never);
|
|
});
|
|
|
|
describe("mem::sentinel-create", () => {
|
|
it("creates a webhook sentinel with valid config", async () => {
|
|
const result = (await sdk.trigger("mem::sentinel-create", {
|
|
name: "deploy-hook",
|
|
type: "webhook",
|
|
config: { path: "/hooks/deploy" },
|
|
})) as { success: boolean; sentinel: Sentinel };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.sentinel.id).toMatch(/^snl_/);
|
|
expect(result.sentinel.name).toBe("deploy-hook");
|
|
expect(result.sentinel.type).toBe("webhook");
|
|
expect(result.sentinel.status).toBe("watching");
|
|
expect(result.sentinel.config).toEqual({ path: "/hooks/deploy" });
|
|
expect(result.sentinel.linkedActionIds).toEqual([]);
|
|
expect(result.sentinel.createdAt).toBeDefined();
|
|
});
|
|
|
|
it("creates a timer sentinel with valid config", async () => {
|
|
const result = (await sdk.trigger("mem::sentinel-create", {
|
|
name: "timeout-check",
|
|
type: "timer",
|
|
config: { durationMs: 5000 },
|
|
})) as { success: boolean; sentinel: Sentinel };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.sentinel.type).toBe("timer");
|
|
expect(result.sentinel.status).toBe("watching");
|
|
});
|
|
|
|
it("creates a threshold sentinel with valid config", async () => {
|
|
const result = (await sdk.trigger("mem::sentinel-create", {
|
|
name: "high-calls",
|
|
type: "threshold",
|
|
config: { metric: "api_calls", operator: "gt", value: 100 },
|
|
})) as { success: boolean; sentinel: Sentinel };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.sentinel.type).toBe("threshold");
|
|
});
|
|
|
|
it("creates a pattern sentinel with valid config", async () => {
|
|
const result = (await sdk.trigger("mem::sentinel-create", {
|
|
name: "error-watcher",
|
|
type: "pattern",
|
|
config: { pattern: "error|fail" },
|
|
})) as { success: boolean; sentinel: Sentinel };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.sentinel.type).toBe("pattern");
|
|
});
|
|
|
|
it("creates an approval sentinel without config", async () => {
|
|
const result = (await sdk.trigger("mem::sentinel-create", {
|
|
name: "needs-approval",
|
|
type: "approval",
|
|
})) as { success: boolean; sentinel: Sentinel };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.sentinel.type).toBe("approval");
|
|
expect(result.sentinel.config).toEqual({});
|
|
});
|
|
|
|
it("creates a custom sentinel without config", async () => {
|
|
const result = (await sdk.trigger("mem::sentinel-create", {
|
|
name: "custom-gate",
|
|
type: "custom",
|
|
})) as { success: boolean; sentinel: Sentinel };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.sentinel.type).toBe("custom");
|
|
});
|
|
|
|
it("returns error when name is missing", async () => {
|
|
const result = (await sdk.trigger("mem::sentinel-create", {
|
|
type: "webhook",
|
|
config: { path: "/hooks/deploy" },
|
|
})) as { success: boolean; error: string };
|
|
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain("name is required");
|
|
});
|
|
|
|
it("returns error for invalid type", async () => {
|
|
const result = (await sdk.trigger("mem::sentinel-create", {
|
|
name: "bad-type",
|
|
type: "invalid_type",
|
|
})) as { success: boolean; error: string };
|
|
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain("type must be one of");
|
|
});
|
|
|
|
it("returns error for timer config missing durationMs", async () => {
|
|
const result = (await sdk.trigger("mem::sentinel-create", {
|
|
name: "bad-timer",
|
|
type: "timer",
|
|
config: {},
|
|
})) as { success: boolean; error: string };
|
|
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain("positive durationMs");
|
|
});
|
|
|
|
it("returns error for timer config with negative durationMs", async () => {
|
|
const result = (await sdk.trigger("mem::sentinel-create", {
|
|
name: "neg-timer",
|
|
type: "timer",
|
|
config: { durationMs: -100 },
|
|
})) as { success: boolean; error: string };
|
|
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain("positive durationMs");
|
|
});
|
|
|
|
it("returns error for threshold config missing metric", async () => {
|
|
const result = (await sdk.trigger("mem::sentinel-create", {
|
|
name: "bad-threshold",
|
|
type: "threshold",
|
|
config: { operator: "gt", value: 10 },
|
|
})) as { success: boolean; error: string };
|
|
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain("threshold config requires");
|
|
});
|
|
|
|
it("returns error for threshold config with invalid operator", async () => {
|
|
const result = (await sdk.trigger("mem::sentinel-create", {
|
|
name: "bad-op",
|
|
type: "threshold",
|
|
config: { metric: "calls", operator: "gte", value: 10 },
|
|
})) as { success: boolean; error: string };
|
|
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain("threshold config requires");
|
|
});
|
|
|
|
it("returns error for threshold config missing value", async () => {
|
|
const result = (await sdk.trigger("mem::sentinel-create", {
|
|
name: "no-val",
|
|
type: "threshold",
|
|
config: { metric: "calls", operator: "gt" },
|
|
})) as { success: boolean; error: string };
|
|
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain("threshold config requires");
|
|
});
|
|
|
|
it("returns error for pattern config missing pattern", async () => {
|
|
const result = (await sdk.trigger("mem::sentinel-create", {
|
|
name: "bad-pattern",
|
|
type: "pattern",
|
|
config: {},
|
|
})) as { success: boolean; error: string };
|
|
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain("pattern config requires");
|
|
});
|
|
|
|
it("returns error for webhook config missing path", async () => {
|
|
const result = (await sdk.trigger("mem::sentinel-create", {
|
|
name: "bad-webhook",
|
|
type: "webhook",
|
|
config: {},
|
|
})) as { success: boolean; error: string };
|
|
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain("webhook config requires");
|
|
});
|
|
|
|
it("creates gated_by edges for linkedActionIds", async () => {
|
|
const action = (await sdk.trigger("mem::action-create", {
|
|
title: "Gated task",
|
|
})) as { success: boolean; action: Action };
|
|
|
|
const result = (await sdk.trigger("mem::sentinel-create", {
|
|
name: "gate-sentinel",
|
|
type: "approval",
|
|
linkedActionIds: [action.action.id],
|
|
})) as { success: boolean; sentinel: Sentinel };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.sentinel.linkedActionIds).toEqual([action.action.id]);
|
|
|
|
const edges = await kv.list<ActionEdge>("mem:action-edges");
|
|
const gatedEdges = edges.filter(
|
|
(e) =>
|
|
e.type === "gated_by" &&
|
|
e.sourceActionId === action.action.id &&
|
|
e.targetActionId === result.sentinel.id,
|
|
);
|
|
expect(gatedEdges.length).toBe(1);
|
|
});
|
|
|
|
it("returns error for non-existent linkedActionId", async () => {
|
|
const result = (await sdk.trigger("mem::sentinel-create", {
|
|
name: "bad-link",
|
|
type: "approval",
|
|
linkedActionIds: ["nonexistent_action"],
|
|
})) as { success: boolean; error: string };
|
|
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain("linked action not found");
|
|
});
|
|
|
|
it("sets expiresAt when expiresInMs is provided", async () => {
|
|
const result = (await sdk.trigger("mem::sentinel-create", {
|
|
name: "expiring",
|
|
type: "custom",
|
|
expiresInMs: 60000,
|
|
})) as { success: boolean; sentinel: Sentinel };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.sentinel.expiresAt).toBeDefined();
|
|
const created = new Date(result.sentinel.createdAt).getTime();
|
|
const expires = new Date(result.sentinel.expiresAt!).getTime();
|
|
expect(expires - created).toBeCloseTo(60000, -2);
|
|
});
|
|
});
|
|
|
|
describe("mem::sentinel-trigger", () => {
|
|
it("triggers a watching sentinel", async () => {
|
|
const sentinel = (await sdk.trigger("mem::sentinel-create", {
|
|
name: "trigger-me",
|
|
type: "approval",
|
|
})) as { success: boolean; sentinel: Sentinel };
|
|
|
|
const result = (await sdk.trigger("mem::sentinel-trigger", {
|
|
sentinelId: sentinel.sentinel.id,
|
|
result: { approvedBy: "admin" },
|
|
})) as { success: boolean; sentinel: Sentinel; unblockedCount: number };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.sentinel.status).toBe("triggered");
|
|
expect(result.sentinel.triggeredAt).toBeDefined();
|
|
expect(result.sentinel.result).toEqual({ approvedBy: "admin" });
|
|
expect(result.unblockedCount).toBe(0);
|
|
});
|
|
|
|
it("returns error when triggering already-triggered sentinel", async () => {
|
|
const sentinel = (await sdk.trigger("mem::sentinel-create", {
|
|
name: "already-fired",
|
|
type: "custom",
|
|
})) as { success: boolean; sentinel: Sentinel };
|
|
|
|
await sdk.trigger("mem::sentinel-trigger", {
|
|
sentinelId: sentinel.sentinel.id,
|
|
});
|
|
|
|
const result = (await sdk.trigger("mem::sentinel-trigger", {
|
|
sentinelId: sentinel.sentinel.id,
|
|
})) as { success: boolean; error: string };
|
|
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain("already triggered");
|
|
});
|
|
|
|
it("returns error for non-existent sentinel", async () => {
|
|
const result = (await sdk.trigger("mem::sentinel-trigger", {
|
|
sentinelId: "nonexistent_sentinel",
|
|
})) as { success: boolean; error: string };
|
|
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain("sentinel not found");
|
|
});
|
|
|
|
it("returns error when sentinelId is missing", async () => {
|
|
const result = (await sdk.trigger("mem::sentinel-trigger", {})) as {
|
|
success: boolean;
|
|
error: string;
|
|
};
|
|
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain("sentinelId is required");
|
|
});
|
|
|
|
it("unblocks gated actions when triggered", async () => {
|
|
const action = (await sdk.trigger("mem::action-create", {
|
|
title: "Blocked task",
|
|
})) as { success: boolean; action: Action };
|
|
|
|
const sentinel = (await sdk.trigger("mem::sentinel-create", {
|
|
name: "gate",
|
|
type: "approval",
|
|
linkedActionIds: [action.action.id],
|
|
})) as { success: boolean; sentinel: Sentinel };
|
|
|
|
await sdk.trigger("mem::action-update", {
|
|
actionId: action.action.id,
|
|
status: "blocked",
|
|
});
|
|
|
|
const result = (await sdk.trigger("mem::sentinel-trigger", {
|
|
sentinelId: sentinel.sentinel.id,
|
|
})) as { success: boolean; sentinel: Sentinel; unblockedCount: number };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.unblockedCount).toBe(1);
|
|
|
|
const updated = (await sdk.trigger("mem::action-get", {
|
|
actionId: action.action.id,
|
|
})) as { success: boolean; action: Action };
|
|
|
|
expect(updated.action.status).toBe("pending");
|
|
});
|
|
});
|
|
|
|
describe("mem::sentinel-cancel", () => {
|
|
it("cancels a watching sentinel", async () => {
|
|
const sentinel = (await sdk.trigger("mem::sentinel-create", {
|
|
name: "cancel-me",
|
|
type: "custom",
|
|
})) as { success: boolean; sentinel: Sentinel };
|
|
|
|
const result = (await sdk.trigger("mem::sentinel-cancel", {
|
|
sentinelId: sentinel.sentinel.id,
|
|
})) as { success: boolean; sentinel: Sentinel };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.sentinel.status).toBe("cancelled");
|
|
});
|
|
|
|
it("returns error when cancelling non-watching sentinel", async () => {
|
|
const sentinel = (await sdk.trigger("mem::sentinel-create", {
|
|
name: "already-triggered",
|
|
type: "custom",
|
|
})) as { success: boolean; sentinel: Sentinel };
|
|
|
|
await sdk.trigger("mem::sentinel-trigger", {
|
|
sentinelId: sentinel.sentinel.id,
|
|
});
|
|
|
|
const result = (await sdk.trigger("mem::sentinel-cancel", {
|
|
sentinelId: sentinel.sentinel.id,
|
|
})) as { success: boolean; error: string };
|
|
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain("cannot cancel sentinel with status");
|
|
});
|
|
|
|
it("returns error for non-existent sentinel", async () => {
|
|
const result = (await sdk.trigger("mem::sentinel-cancel", {
|
|
sentinelId: "nonexistent_sentinel",
|
|
})) as { success: boolean; error: string };
|
|
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain("sentinel not found");
|
|
});
|
|
|
|
it("returns error when sentinelId is missing", async () => {
|
|
const result = (await sdk.trigger("mem::sentinel-cancel", {})) as {
|
|
success: boolean;
|
|
error: string;
|
|
};
|
|
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain("sentinelId is required");
|
|
});
|
|
});
|
|
|
|
describe("mem::sentinel-list", () => {
|
|
beforeEach(async () => {
|
|
await sdk.trigger("mem::sentinel-create", {
|
|
name: "webhook-1",
|
|
type: "webhook",
|
|
config: { path: "/a" },
|
|
});
|
|
await sdk.trigger("mem::sentinel-create", {
|
|
name: "timer-1",
|
|
type: "timer",
|
|
config: { durationMs: 1000 },
|
|
});
|
|
await sdk.trigger("mem::sentinel-create", {
|
|
name: "approval-1",
|
|
type: "approval",
|
|
});
|
|
});
|
|
|
|
it("returns all sentinels", async () => {
|
|
const result = (await sdk.trigger("mem::sentinel-list", {})) as {
|
|
success: boolean;
|
|
sentinels: Sentinel[];
|
|
};
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.sentinels.length).toBe(3);
|
|
});
|
|
|
|
it("filters by status", async () => {
|
|
const all = (await sdk.trigger("mem::sentinel-list", {})) as {
|
|
sentinels: Sentinel[];
|
|
};
|
|
await sdk.trigger("mem::sentinel-trigger", {
|
|
sentinelId: all.sentinels[0].id,
|
|
});
|
|
|
|
const result = (await sdk.trigger("mem::sentinel-list", {
|
|
status: "triggered",
|
|
})) as { success: boolean; sentinels: Sentinel[] };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.sentinels.length).toBe(1);
|
|
expect(result.sentinels[0].status).toBe("triggered");
|
|
});
|
|
|
|
it("filters by type", async () => {
|
|
const result = (await sdk.trigger("mem::sentinel-list", {
|
|
type: "webhook",
|
|
})) as { success: boolean; sentinels: Sentinel[] };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.sentinels.length).toBe(1);
|
|
expect(result.sentinels[0].type).toBe("webhook");
|
|
});
|
|
|
|
it("filters by both status and type", async () => {
|
|
const result = (await sdk.trigger("mem::sentinel-list", {
|
|
status: "watching",
|
|
type: "approval",
|
|
})) as { success: boolean; sentinels: Sentinel[] };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.sentinels.length).toBe(1);
|
|
expect(result.sentinels[0].type).toBe("approval");
|
|
expect(result.sentinels[0].status).toBe("watching");
|
|
});
|
|
});
|
|
|
|
describe("mem::sentinel-expire", () => {
|
|
it("expires sentinels past their expiresAt", async () => {
|
|
await sdk.trigger("mem::sentinel-create", {
|
|
name: "will-expire",
|
|
type: "custom",
|
|
expiresInMs: 1,
|
|
});
|
|
|
|
await new Promise((r) => setTimeout(r, 10));
|
|
|
|
const result = (await sdk.trigger("mem::sentinel-expire", {})) as {
|
|
success: boolean;
|
|
expired: number;
|
|
};
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.expired).toBe(1);
|
|
|
|
const list = (await sdk.trigger("mem::sentinel-list", {
|
|
status: "expired",
|
|
})) as { sentinels: Sentinel[] };
|
|
expect(list.sentinels.length).toBe(1);
|
|
});
|
|
|
|
it("skips sentinels that have not expired", async () => {
|
|
await sdk.trigger("mem::sentinel-create", {
|
|
name: "not-expired",
|
|
type: "custom",
|
|
expiresInMs: 600000,
|
|
});
|
|
|
|
const result = (await sdk.trigger("mem::sentinel-expire", {})) as {
|
|
success: boolean;
|
|
expired: number;
|
|
};
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.expired).toBe(0);
|
|
});
|
|
|
|
it("skips sentinels without expiresAt", async () => {
|
|
await sdk.trigger("mem::sentinel-create", {
|
|
name: "no-expiry",
|
|
type: "custom",
|
|
});
|
|
|
|
const result = (await sdk.trigger("mem::sentinel-expire", {})) as {
|
|
success: boolean;
|
|
expired: number;
|
|
};
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.expired).toBe(0);
|
|
});
|
|
|
|
it("skips non-watching sentinels even if expired", async () => {
|
|
const sentinel = (await sdk.trigger("mem::sentinel-create", {
|
|
name: "already-cancelled",
|
|
type: "custom",
|
|
expiresInMs: 1,
|
|
})) as { success: boolean; sentinel: Sentinel };
|
|
|
|
await sdk.trigger("mem::sentinel-cancel", {
|
|
sentinelId: sentinel.sentinel.id,
|
|
});
|
|
|
|
await new Promise((r) => setTimeout(r, 10));
|
|
|
|
const result = (await sdk.trigger("mem::sentinel-expire", {})) as {
|
|
success: boolean;
|
|
expired: number;
|
|
};
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.expired).toBe(0);
|
|
});
|
|
});
|
|
|
|
describe("mem::sentinel-check", () => {
|
|
it("triggers threshold sentinel when condition is met", async () => {
|
|
await kv.set("mem:metrics", "api_calls", {
|
|
totalCalls: 150,
|
|
errorCount: 0,
|
|
avgDurationMs: 50,
|
|
});
|
|
|
|
await sdk.trigger("mem::sentinel-create", {
|
|
name: "high-traffic",
|
|
type: "threshold",
|
|
config: { metric: "api_calls", operator: "gt", value: 100 },
|
|
});
|
|
|
|
const result = (await sdk.trigger("mem::sentinel-check", {})) as {
|
|
success: boolean;
|
|
triggered: string[];
|
|
checkedCount: number;
|
|
};
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.triggered.length).toBe(1);
|
|
expect(result.checkedCount).toBe(1);
|
|
});
|
|
|
|
it("does not trigger threshold sentinel when condition is not met", async () => {
|
|
await kv.set("mem:metrics", "api_calls", {
|
|
totalCalls: 50,
|
|
errorCount: 0,
|
|
avgDurationMs: 50,
|
|
});
|
|
|
|
await sdk.trigger("mem::sentinel-create", {
|
|
name: "low-traffic",
|
|
type: "threshold",
|
|
config: { metric: "api_calls", operator: "gt", value: 100 },
|
|
});
|
|
|
|
const result = (await sdk.trigger("mem::sentinel-check", {})) as {
|
|
success: boolean;
|
|
triggered: string[];
|
|
checkedCount: number;
|
|
};
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.triggered.length).toBe(0);
|
|
});
|
|
|
|
it("returns empty triggered list when no active sentinels", async () => {
|
|
const result = (await sdk.trigger("mem::sentinel-check", {})) as {
|
|
success: boolean;
|
|
triggered: string[];
|
|
checkedCount: number;
|
|
};
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.triggered).toEqual([]);
|
|
expect(result.checkedCount).toBe(0);
|
|
});
|
|
});
|
|
});
|