@useatlas/create 0.0.6 → 0.0.7

package/templates/docker/src/lib/tools/actions/__tests__/handler.test.ts

@@ -1,681 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import {
-  handleAction,
-  approveAction,
-  denyAction,
-  getAction,
-  listPendingActions,
-  buildActionRequest,
-  getActionConfig,
-  _resetActionStore,
-} from "../handler";
-import { loadConfig, _resetConfig } from "@atlas/api/lib/config";
-import { withRequestContext } from "@atlas/api/lib/logger";
-import { _resetPool } from "@atlas/api/lib/db/internal";
-
-/**
- * Action handler tests — memory-only path (no DATABASE_URL).
- *
- * We delete DATABASE_URL and reset the pg pool so hasInternalDB() returns
- * false. All persistence goes through the in-memory Map fallback.
- */
-
-const origDbUrl = process.env.DATABASE_URL;
-
-beforeEach(() => {
-  delete process.env.DATABASE_URL;
-  delete process.env.ATLAS_ACTIONS_ENABLED;
-  delete process.env.ATLAS_ACTION_APPROVAL;
-  _resetPool(null);
-  _resetActionStore();
-  _resetConfig();
-});
-
-afterEach(() => {
-  delete process.env.ATLAS_ACTIONS_ENABLED;
-  delete process.env.ATLAS_ACTION_APPROVAL;
-  if (origDbUrl) {
-    process.env.DATABASE_URL = origDbUrl;
-  } else {
-    delete process.env.DATABASE_URL;
-  }
-  _resetPool(null);
-  _resetActionStore();
-  _resetConfig();
-});
-
-// ---------------------------------------------------------------------------
-// buildActionRequest
-// ---------------------------------------------------------------------------
-
-describe("buildActionRequest()", () => {
-  it("returns a request with UUID id and all fields", () => {
-    const request = buildActionRequest({
-      actionType: "slack:send",
-      target: "#general",
-      summary: "Send greeting to #general",
-      payload: { channel: "C123", text: "Hello" },
-      reversible: false,
-    });
-
-    expect(request.id).toMatch(
-      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/,
-    );
-    expect(request.actionType).toBe("slack:send");
-    expect(request.target).toBe("#general");
-    expect(request.summary).toBe("Send greeting to #general");
-    expect(request.payload).toEqual({ channel: "C123", text: "Hello" });
-    expect(request.reversible).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// handleAction — manual (default)
-// ---------------------------------------------------------------------------
-
-describe("handleAction()", () => {
-  it("returns pending_approval when approval mode is manual (default)", async () => {
-    const request = buildActionRequest({
-      actionType: "slack:send",
-      target: "#general",
-      summary: "Send message",
-      payload: { text: "hi" },
-      reversible: false,
-    });
-
-    const result = await withRequestContext(
-      { requestId: "req-1", user: { id: "u1", label: "user@test.com", mode: "managed" } },
-      () => handleAction(request, async () => "done"),
-    );
-
-    expect(result.status).toBe("pending_approval");
-    expect(result.actionId).toBe(request.id);
-    if (result.status === "pending_approval") {
-      expect(result.summary).toBe("Send message");
-    }
-  });
-
-  it("auto-approves and executes when config sets auto approval", async () => {
-    process.env.ATLAS_ACTIONS_ENABLED = "true";
-    process.env.ATLAS_ACTION_APPROVAL = "auto";
-    await loadConfig("/tmp/handler-test-nonexistent");
-
-    const request = buildActionRequest({
-      actionType: "slack:send",
-      target: "#general",
-      summary: "Send message",
-      payload: { text: "hi" },
-      reversible: false,
-    });
-
-    const result = await withRequestContext(
-      { requestId: "req-2", user: { id: "u1", label: "user@test.com", mode: "managed" } },
-      () => handleAction(request, async (payload) => ({ sent: true, text: payload.text })),
-    );
-
-    expect(result.status).toBe("auto_approved");
-    expect(result.actionId).toBe(request.id);
-    if (result.status === "auto_approved") {
-      expect(result.result).toEqual({ sent: true, text: "hi" });
-    }
-  });
-
-  it("returns error when auto-approve execution throws", async () => {
-    process.env.ATLAS_ACTIONS_ENABLED = "true";
-    process.env.ATLAS_ACTION_APPROVAL = "auto";
-    await loadConfig("/tmp/handler-test-nonexistent");
-
-    const request = buildActionRequest({
-      actionType: "slack:send",
-      target: "#general",
-      summary: "Send message",
-      payload: { text: "hi" },
-      reversible: false,
-    });
-
-    const result = await withRequestContext(
-      { requestId: "req-3", user: { id: "u1", label: "user@test.com", mode: "managed" } },
-      () =>
-        handleAction(request, async () => {
-          throw new Error("Slack API down");
-        }),
-    );
-
-    expect(result.status).toBe("error");
-    if (result.status === "error") {
-      expect(result.error).toBe("Slack API down");
-    }
-  });
-
-  it("persists the action to the in-memory store", async () => {
-    const request = buildActionRequest({
-      actionType: "test:action",
-      target: "target-1",
-      summary: "Test action",
-      payload: { key: "val" },
-      reversible: true,
-    });
-
-    await withRequestContext(
-      { requestId: "req-4", user: { id: "u2", label: "admin@test.com", mode: "simple-key" } },
-      () => handleAction(request, async () => "ok"),
-    );
-
-    const stored = await getAction(request.id);
-    expect(stored).not.toBeNull();
-    expect(stored!.action_type).toBe("test:action");
-    expect(stored!.status).toBe("pending");
-    expect(stored!.requested_by).toBe("u2");
-    expect(stored!.auth_mode).toBe("simple-key");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// approveAction
-// ---------------------------------------------------------------------------
-
-describe("approveAction()", () => {
-  it("approves a pending action and executes the function", async () => {
-    const request = buildActionRequest({
-      actionType: "slack:send",
-      target: "#general",
-      summary: "Send message",
-      payload: { text: "hi" },
-      reversible: false,
-    });
-
-    await withRequestContext({ requestId: "req-5" }, () =>
-      handleAction(request, async (payload) => ({ sent: true, text: payload.text })),
-    );
-
-    const result = await approveAction(
-      request.id,
-      "admin-1",
-      async (payload) => ({ sent: true, text: payload.text }),
-    );
-
-    expect(result).not.toBeNull();
-    expect(result!.status).toBe("executed");
-    expect(result!.approved_by).toBe("admin-1");
-    expect(result!.result).toEqual({ sent: true, text: "hi" });
-    expect(result!.executed_at).not.toBeNull();
-  });
-
-  it("returns null for an already-resolved action (CAS)", async () => {
-    const request = buildActionRequest({
-      actionType: "slack:send",
-      target: "#general",
-      summary: "Send message",
-      payload: { text: "hi" },
-      reversible: false,
-    });
-
-    await withRequestContext({ requestId: "req-6" }, () =>
-      handleAction(request, async () => "done"),
-    );
-
-    // First approval succeeds
-    const first = await approveAction(request.id, "admin-1", async () => "ok");
-    expect(first).not.toBeNull();
-
-    // Second approval fails (CAS — status is no longer "pending")
-    const second = await approveAction(request.id, "admin-2", async () => "ok again");
-    expect(second).toBeNull();
-  });
-
-  it("returns failed entry when executor throws during approval", async () => {
-    const request = buildActionRequest({
-      actionType: "slack:send",
-      target: "#general",
-      summary: "Send message",
-      payload: { text: "hi" },
-      reversible: false,
-    });
-
-    await withRequestContext({ requestId: "req-7" }, () =>
-      handleAction(request, async () => "done"),
-    );
-
-    const result = await approveAction(request.id, "admin-1", async () => {
-      throw new Error("execution failed");
-    });
-
-    expect(result).not.toBeNull();
-    expect(result!.status).toBe("failed");
-    expect(result!.error).toBe("execution failed");
-  });
-
-  it("approves without executing when no executeFn is provided and no registered executor", async () => {
-    const request = buildActionRequest({
-      actionType: "unregistered:action",
-      target: "target",
-      summary: "Test",
-      payload: {},
-      reversible: false,
-    });
-
-    // Reset the store so the executor registered by handleAction is cleared
-    await withRequestContext({ requestId: "req-8" }, () =>
-      handleAction(request, async () => "done"),
-    );
-    // Clear executor registry but keep memory store
-    _resetActionStore();
-    // Re-insert the pending entry manually via another handleAction
-    const request2 = buildActionRequest({
-      actionType: "no-executor:action",
-      target: "target",
-      summary: "Test 2",
-      payload: {},
-      reversible: false,
-    });
-    await withRequestContext({ requestId: "req-8b" }, () =>
-      handleAction(request2, async () => "done"),
-    );
-    // Clear only the executor registry
-    // Since _resetActionStore clears both, we need a different approach.
-    // Instead, approve with an explicit undefined executeFn and rely on
-    // the registered executor from handleAction.
-    // Let's test the simpler path: approve with explicit executeFn=undefined
-    // and getActionExecutor returns the one registered by handleAction.
-    // Actually the executor IS registered by handleAction for request2's actionType.
-    // So let's just test that approve with no executeFn uses the registered one.
-    const result = await approveAction(request2.id, "admin-1");
-    expect(result).not.toBeNull();
-    expect(result!.status).toBe("executed");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// denyAction
-// ---------------------------------------------------------------------------
-
-describe("denyAction()", () => {
-  it("denies a pending action with a reason", async () => {
-    const request = buildActionRequest({
-      actionType: "slack:send",
-      target: "#general",
-      summary: "Send message",
-      payload: { text: "hi" },
-      reversible: false,
-    });
-
-    await withRequestContext({ requestId: "req-9" }, () =>
-      handleAction(request, async () => "done"),
-    );
-
-    const result = await denyAction(request.id, "admin-1", "Not approved by policy");
-
-    expect(result).not.toBeNull();
-    expect(result!.status).toBe("denied");
-    expect(result!.approved_by).toBe("admin-1");
-    expect(result!.error).toBe("Not approved by policy");
-    expect(result!.resolved_at).not.toBeNull();
-  });
-
-  it("denies without a reason", async () => {
-    const request = buildActionRequest({
-      actionType: "slack:send",
-      target: "#general",
-      summary: "Send message",
-      payload: { text: "hi" },
-      reversible: false,
-    });
-
-    await withRequestContext({ requestId: "req-10" }, () =>
-      handleAction(request, async () => "done"),
-    );
-
-    const result = await denyAction(request.id, "admin-1");
-
-    expect(result).not.toBeNull();
-    expect(result!.status).toBe("denied");
-    expect(result!.error).toBeNull();
-  });
-
-  it("returns null for an already-resolved action (CAS)", async () => {
-    const request = buildActionRequest({
-      actionType: "slack:send",
-      target: "#general",
-      summary: "Send message",
-      payload: { text: "hi" },
-      reversible: false,
-    });
-
-    await withRequestContext({ requestId: "req-11" }, () =>
-      handleAction(request, async () => "done"),
-    );
-
-    // First denial succeeds
-    const first = await denyAction(request.id, "admin-1", "No");
-    expect(first).not.toBeNull();
-
-    // Second denial fails (CAS)
-    const second = await denyAction(request.id, "admin-2", "Also no");
-    expect(second).toBeNull();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// getAction
-// ---------------------------------------------------------------------------
-
-describe("getAction()", () => {
-  it("returns action by ID", async () => {
-    const request = buildActionRequest({
-      actionType: "test:get",
-      target: "t1",
-      summary: "Get test",
-      payload: { a: 1 },
-      reversible: false,
-    });
-
-    await withRequestContext({ requestId: "req-12" }, () =>
-      handleAction(request, async () => "done"),
-    );
-
-    const action = await getAction(request.id);
-    expect(action).not.toBeNull();
-    expect(action!.id).toBe(request.id);
-    expect(action!.action_type).toBe("test:get");
-    expect(action!.payload).toEqual({ a: 1 });
-  });
-
-  it("returns null for unknown ID", async () => {
-    const action = await getAction("nonexistent-id-12345");
-    expect(action).toBeNull();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// listPendingActions
-// ---------------------------------------------------------------------------
-
-describe("listPendingActions()", () => {
-  it("lists pending actions", async () => {
-    const r1 = buildActionRequest({
-      actionType: "a:1",
-      target: "t1",
-      summary: "Action 1",
-      payload: {},
-      reversible: false,
-    });
-    const r2 = buildActionRequest({
-      actionType: "a:2",
-      target: "t2",
-      summary: "Action 2",
-      payload: {},
-      reversible: false,
-    });
-
-    await withRequestContext({ requestId: "req-13" }, async () => {
-      await handleAction(r1, async () => "done");
-      await handleAction(r2, async () => "done");
-    });
-
-    const pending = await listPendingActions();
-    expect(pending).toHaveLength(2);
-    // Sorted by requested_at DESC
-    expect(pending.map((p) => p.action_type)).toContain("a:1");
-    expect(pending.map((p) => p.action_type)).toContain("a:2");
-  });
-
-  it("filters by status", async () => {
-    const r1 = buildActionRequest({
-      actionType: "a:1",
-      target: "t1",
-      summary: "Action 1",
-      payload: {},
-      reversible: false,
-    });
-    const r2 = buildActionRequest({
-      actionType: "a:2",
-      target: "t2",
-      summary: "Action 2",
-      payload: {},
-      reversible: false,
-    });
-
-    await withRequestContext({ requestId: "req-14" }, async () => {
-      await handleAction(r1, async () => "done");
-      await handleAction(r2, async () => "done");
-    });
-
-    // Deny r1 so it has status "denied"
-    await denyAction(r1.id, "admin", "No");
-
-    // Only pending
-    const pending = await listPendingActions({ status: "pending" });
-    expect(pending).toHaveLength(1);
-    expect(pending[0].action_type).toBe("a:2");
-
-    // Only denied
-    const denied = await listPendingActions({ status: "denied" });
-    expect(denied).toHaveLength(1);
-    expect(denied[0].action_type).toBe("a:1");
-  });
-
-  it("returns empty array when no actions match", async () => {
-    const pending = await listPendingActions();
-    expect(pending).toEqual([]);
-  });
-
-  it("respects limit option", async () => {
-    // Create 5 pending actions
-    for (let i = 0; i < 5; i++) {
-      const r = buildActionRequest({
-        actionType: `a:${i}`,
-        target: `t${i}`,
-        summary: `Action ${i}`,
-        payload: {},
-        reversible: false,
-      });
-      await withRequestContext({ requestId: `req-limit-${i}` }, () =>
-        handleAction(r, async () => "done"),
-      );
-    }
-
-    const limited = await listPendingActions({ limit: 3 });
-    expect(limited).toHaveLength(3);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// getActionConfig
-// ---------------------------------------------------------------------------
-
-describe("getActionConfig()", () => {
-  it("returns manual as default when no config is loaded", () => {
-    const config = getActionConfig("slack:send");
-    expect(config.approval).toBe("manual");
-    expect(config.timeout).toBeUndefined();
-    expect(config.maxPerConversation).toBeUndefined();
-  });
-
-  it("uses defaultApproval parameter as fallback when no config is loaded", () => {
-    const config = getActionConfig("slack:send", "auto");
-    expect(config.approval).toBe("auto");
-  });
-
-  it("applies config defaults when loaded from env", async () => {
-    process.env.ATLAS_ACTIONS_ENABLED = "true";
-    process.env.ATLAS_ACTION_APPROVAL = "auto";
-    await loadConfig("/tmp/handler-test-nonexistent");
-
-    const config = getActionConfig("slack:send");
-    expect(config.approval).toBe("auto");
-  });
-
-  it("config defaults override the defaultApproval parameter", async () => {
-    process.env.ATLAS_ACTIONS_ENABLED = "true";
-    process.env.ATLAS_ACTION_APPROVAL = "auto";
-    await loadConfig("/tmp/handler-test-nonexistent");
-
-    // Even though we pass "manual" as defaultApproval, config says "auto"
-    const config = getActionConfig("slack:send", "manual");
-    expect(config.approval).toBe("auto");
-  });
-
-  it("per-action config override takes precedence over defaults", async () => {
-    // Load config with defaults.approval = "manual" and "slack:send" = "auto"
-    // We can't easily load a config file in tests, so we'll use loadConfig
-    // which falls back to env vars. For per-action overrides, we need to
-    // use a real config file. Instead, test getActionConfig with a loaded config.
-    // Alternatively, use the env-based approach and then manually set a config.
-    //
-    // Since configFromEnv only sets defaults and doesn't support per-action
-    // overrides via env, we test this using validateAndResolve + direct config.
-    const { validateAndResolve, _resetConfig: resetCfg } = await import("@atlas/api/lib/config");
-    resetCfg();
-
-    // Simulate loading a config with per-action override
-    const resolved = validateAndResolve({
-      actions: {
-        defaults: { approval: "manual" },
-        "slack:send": { approval: "auto" },
-      },
-    });
-
-    // Manually set the config by loading from env then overriding
-    // We can't easily inject a config. Instead, test through loadConfig
-    // with an atlas.config.ts file. For now, verify that validateAndResolve
-    // correctly resolves the per-action config, which getActionConfig reads.
-    expect(resolved.actions).toBeDefined();
-    expect(resolved.actions!.defaults?.approval).toBe("manual");
-    expect((resolved.actions!["slack:send"] as { approval: string }).approval).toBe("auto");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// handleAction — admin-only
-// ---------------------------------------------------------------------------
-
-describe("handleAction() — admin-only", () => {
-  it("returns pending_approval when approval mode is admin-only", async () => {
-    process.env.ATLAS_ACTIONS_ENABLED = "true";
-    process.env.ATLAS_ACTION_APPROVAL = "admin-only";
-    await loadConfig("/tmp/handler-test-nonexistent");
-
-    const request = buildActionRequest({
-      actionType: "admin:action",
-      target: "resource-1",
-      summary: "Admin action",
-      payload: { key: "val" },
-      reversible: false,
-    });
-
-    const result = await withRequestContext(
-      { requestId: "req-admin-1", user: { id: "u1", label: "user@test.com", mode: "managed" } },
-      () => handleAction(request, async () => "done"),
-    );
-
-    expect(result.status).toBe("pending_approval");
-    expect(result.actionId).toBe(request.id);
-    if (result.status === "pending_approval") {
-      expect(result.summary).toBe("Admin action");
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// handleAction — conversationId option
-// ---------------------------------------------------------------------------
-
-describe("handleAction() — conversationId", () => {
-  it("persists conversationId when provided in opts", async () => {
-    const request = buildActionRequest({
-      actionType: "test:conv",
-      target: "target-1",
-      summary: "Test with conversationId",
-      payload: {},
-      reversible: false,
-    });
-
-    await withRequestContext(
-      { requestId: "req-conv-1", user: { id: "u1", label: "user@test.com", mode: "managed" } },
-      () => handleAction(request, async () => "done", { conversationId: "conv-abc-123" }),
-    );
-
-    const stored = await getAction(request.id);
-    expect(stored).not.toBeNull();
-    expect(stored!.conversation_id).toBe("conv-abc-123");
-  });
-
-  it("conversation_id is null when opts.conversationId is not provided", async () => {
-    const request = buildActionRequest({
-      actionType: "test:no-conv",
-      target: "target-2",
-      summary: "No conversationId",
-      payload: {},
-      reversible: false,
-    });
-
-    await withRequestContext(
-      { requestId: "req-conv-2", user: { id: "u1", label: "user@test.com", mode: "managed" } },
-      () => handleAction(request, async () => "done"),
-    );
-
-    const stored = await getAction(request.id);
-    expect(stored).not.toBeNull();
-    expect(stored!.conversation_id).toBeNull();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// listPendingActions — userId filter
-// ---------------------------------------------------------------------------
-
-describe("listPendingActions() — userId filter", () => {
-  it("filters actions by userId", async () => {
-    const r1 = buildActionRequest({
-      actionType: "a:user1",
-      target: "t1",
-      summary: "User 1 action",
-      payload: {},
-      reversible: false,
-    });
-    const r2 = buildActionRequest({
-      actionType: "a:user2",
-      target: "t2",
-      summary: "User 2 action",
-      payload: {},
-      reversible: false,
-    });
-
-    await withRequestContext(
-      { requestId: "req-u1", user: { id: "u1", label: "u1@test.com", mode: "managed" } },
-      () => handleAction(r1, async () => "done"),
-    );
-    await withRequestContext(
-      { requestId: "req-u2", user: { id: "u2", label: "u2@test.com", mode: "managed" } },
-      () => handleAction(r2, async () => "done"),
-    );
-
-    const u1Actions = await listPendingActions({ userId: "u1" });
-    expect(u1Actions).toHaveLength(1);
-    expect(u1Actions[0].action_type).toBe("a:user1");
-    expect(u1Actions[0].requested_by).toBe("u1");
-
-    const u2Actions = await listPendingActions({ userId: "u2" });
-    expect(u2Actions).toHaveLength(1);
-    expect(u2Actions[0].action_type).toBe("a:user2");
-    expect(u2Actions[0].requested_by).toBe("u2");
-  });
-
-  it("returns empty when userId has no matching actions", async () => {
-    const r1 = buildActionRequest({
-      actionType: "a:other",
-      target: "t1",
-      summary: "Other user",
-      payload: {},
-      reversible: false,
-    });
-
-    await withRequestContext(
-      { requestId: "req-other", user: { id: "other", label: "other@test.com", mode: "managed" } },
-      () => handleAction(r1, async () => "done"),
-    );
-
-    const results = await listPendingActions({ userId: "nonexistent" });
-    expect(results).toEqual([]);
-  });
-});