@q1k-oss/btree-workflows 0.0.1 → 0.0.2

package/src/actions/http-request.test.ts

@@ -1,784 +0,0 @@
-/**
- * HttpRequest Node Tests
- */
-
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { ScopedBlackboard } from "../blackboard.js";
-import { Registry } from "../registry.js";
-import { type TemporalContext, type BtreeActivities, NodeStatus } from "../types.js";
-import { HttpRequest, type HttpRequestConfig } from "./http-request.js";
-
-describe("HttpRequest Node", () => {
-  let blackboard: ScopedBlackboard;
-  let registry: Registry;
-
-  beforeEach(() => {
-    blackboard = new ScopedBlackboard();
-    registry = new Registry();
-    vi.clearAllMocks();
-  });
-
-  describe("Construction and validation", () => {
-    it("should create node with valid config", () => {
-      const node = new HttpRequest({
-        id: "test",
-        url: "https://api.example.com/data",
-        outputKey: "response",
-      });
-
-      expect(node).toBeDefined();
-      expect(node.id).toBe("test");
-    });
-
-    it("should require url", () => {
-      expect(() => {
-        new HttpRequest({
-          id: "test",
-          outputKey: "response",
-        } as HttpRequestConfig);
-      }).toThrow(/requires url/i);
-    });
-
-    it("should require outputKey", () => {
-      expect(() => {
-        new HttpRequest({
-          id: "test",
-          url: "https://api.example.com/data",
-        } as HttpRequestConfig);
-      }).toThrow(/requires outputKey/i);
-    });
-
-    it("should accept optional method, headers, body, timeout, and retry", () => {
-      const node = new HttpRequest({
-        id: "test",
-        url: "https://api.example.com/data",
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: { key: "value" },
-        timeout: 5000,
-        retry: { maxAttempts: 3, backoffMs: 1000 },
-        outputKey: "response",
-      });
-
-      expect(node).toBeDefined();
-    });
-
-    it("should default method to GET", () => {
-      const node = new HttpRequest({
-        id: "test",
-        url: "https://api.example.com/data",
-        outputKey: "response",
-      });
-
-      expect(node).toBeDefined();
-    });
-  });
-
-  describe("Activity requirement", () => {
-    it("should fail without fetchUrl activity", async () => {
-      const context: TemporalContext = {
-        blackboard,
-        treeRegistry: registry,
-        timestamp: Date.now(),
-        deltaTime: 0,
-        activities: undefined,
-      };
-
-      const node = new HttpRequest({
-        id: "test",
-        url: "https://api.example.com/data",
-        outputKey: "response",
-      });
-
-      const status = await node.tick(context);
-
-      expect(status).toBe(NodeStatus.FAILURE);
-      expect(node.lastError).toContain("requires activities.fetchUrl");
-    });
-
-    it("should fail when activities object exists but fetchUrl is missing", async () => {
-      const context: TemporalContext = {
-        blackboard,
-        treeRegistry: registry,
-        timestamp: Date.now(),
-        deltaTime: 0,
-        activities: {
-          executePieceAction: vi.fn(),
-          // fetchUrl is not provided
-        } as BtreeActivities,
-      };
-
-      const node = new HttpRequest({
-        id: "test",
-        url: "https://api.example.com/data",
-        outputKey: "response",
-      });
-
-      const status = await node.tick(context);
-
-      expect(status).toBe(NodeStatus.FAILURE);
-      expect(node.lastError).toContain("requires activities.fetchUrl");
-    });
-  });
-
-  describe("Execution with activity", () => {
-    it("should make GET request via activity", async () => {
-      const mockFetchActivity = vi.fn().mockResolvedValue({
-        status: 200,
-        headers: { "content-type": "application/json" },
-        data: { id: 1, name: "Test" },
-      });
-
-      const context: TemporalContext = {
-        blackboard,
-        treeRegistry: registry,
-        timestamp: Date.now(),
-        deltaTime: 0,
-        activities: {
-          executePieceAction: vi.fn(),
-          fetchUrl: mockFetchActivity,
-        },
-      };
-
-      const node = new HttpRequest({
-        id: "test",
-        url: "https://api.example.com/users/1",
-        method: "GET",
-        outputKey: "userData",
-      });
-
-      const status = await node.tick(context);
-
-      expect(status).toBe(NodeStatus.SUCCESS);
-      expect(mockFetchActivity).toHaveBeenCalledWith(
-        expect.objectContaining({
-          url: "https://api.example.com/users/1",
-          method: "GET",
-        })
-      );
-    });
-
-    it("should make POST request with body", async () => {
-      const mockFetchActivity = vi.fn().mockResolvedValue({
-        status: 201,
-        headers: { "content-type": "application/json" },
-        data: { id: 123, success: true },
-      });
-
-      const context: TemporalContext = {
-        blackboard,
-        treeRegistry: registry,
-        timestamp: Date.now(),
-        deltaTime: 0,
-        activities: {
-          executePieceAction: vi.fn(),
-          fetchUrl: mockFetchActivity,
-        },
-      };
-
-      const node = new HttpRequest({
-        id: "test",
-        url: "https://api.example.com/orders",
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: { product: "Widget", quantity: 5 },
-        outputKey: "orderResponse",
-      });
-
-      const status = await node.tick(context);
-
-      expect(status).toBe(NodeStatus.SUCCESS);
-      expect(mockFetchActivity).toHaveBeenCalledWith(
-        expect.objectContaining({
-          url: "https://api.example.com/orders",
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: { product: "Widget", quantity: 5 },
-        })
-      );
-    });
-
-    it("should store response in blackboard", async () => {
-      const responseData = { users: [{ id: 1 }, { id: 2 }] };
-      const mockFetchActivity = vi.fn().mockResolvedValue({
-        status: 200,
-        headers: { "content-type": "application/json" },
-        data: responseData,
-      });
-
-      const context: TemporalContext = {
-        blackboard,
-        treeRegistry: registry,
-        timestamp: Date.now(),
-        deltaTime: 0,
-        activities: {
-          executePieceAction: vi.fn(),
-          fetchUrl: mockFetchActivity,
-        },
-      };
-
-      const node = new HttpRequest({
-        id: "test",
-        url: "https://api.example.com/users",
-        outputKey: "apiResponse",
-      });
-
-      await node.tick(context);
-
-      const stored = blackboard.get("apiResponse") as {
-        status: number;
-        headers: Record<string, string>;
-        data: unknown;
-      };
-      expect(stored.status).toBe(200);
-      expect(stored.headers).toEqual({ "content-type": "application/json" });
-      expect(stored.data).toEqual(responseData);
-    });
-
-    it("should resolve URL from input", async () => {
-      const mockFetchActivity = vi.fn().mockResolvedValue({
-        status: 200,
-        headers: {},
-        data: {},
-      });
-
-      const context: TemporalContext = {
-        blackboard,
-        treeRegistry: registry,
-        timestamp: Date.now(),
-        deltaTime: 0,
-        input: { userId: "abc123" },
-        activities: {
-          executePieceAction: vi.fn(),
-          fetchUrl: mockFetchActivity,
-        },
-      };
-
-      const node = new HttpRequest({
-        id: "test",
-        url: "https://api.example.com/users/${input.userId}",
-        outputKey: "response",
-      });
-
-      await node.tick(context);
-
-      expect(mockFetchActivity).toHaveBeenCalledWith(
-        expect.objectContaining({
-          url: "https://api.example.com/users/abc123",
-        })
-      );
-    });
-
-    it("should resolve URL from blackboard", async () => {
-      blackboard.set("apiEndpoint", "https://custom-api.example.com");
-
-      const mockFetchActivity = vi.fn().mockResolvedValue({
-        status: 200,
-        headers: {},
-        data: {},
-      });
-
-      const context: TemporalContext = {
-        blackboard,
-        treeRegistry: registry,
-        timestamp: Date.now(),
-        deltaTime: 0,
-        activities: {
-          executePieceAction: vi.fn(),
-          fetchUrl: mockFetchActivity,
-        },
-      };
-
-      const node = new HttpRequest({
-        id: "test",
-        url: "${bb.apiEndpoint}/data",
-        outputKey: "response",
-      });
-
-      await node.tick(context);
-
-      expect(mockFetchActivity).toHaveBeenCalledWith(
-        expect.objectContaining({
-          url: "https://custom-api.example.com/data",
-        })
-      );
-    });
-
-    it("should resolve headers from blackboard", async () => {
-      blackboard.set("accessToken", "secret-token-123");
-
-      const mockFetchActivity = vi.fn().mockResolvedValue({
-        status: 200,
-        headers: {},
-        data: {},
-      });
-
-      const context: TemporalContext = {
-        blackboard,
-        treeRegistry: registry,
-        timestamp: Date.now(),
-        deltaTime: 0,
-        activities: {
-          executePieceAction: vi.fn(),
-          fetchUrl: mockFetchActivity,
-        },
-      };
-
-      const node = new HttpRequest({
-        id: "test",
-        url: "https://api.example.com/protected",
-        headers: {
-          Authorization: "Bearer ${bb.accessToken}",
-        },
-        outputKey: "response",
-      });
-
-      await node.tick(context);
-
-      expect(mockFetchActivity).toHaveBeenCalledWith(
-        expect.objectContaining({
-          headers: {
-            Authorization: "Bearer secret-token-123",
-          },
-        })
-      );
-    });
-
-    it("should resolve body from blackboard and input", async () => {
-      blackboard.set("cartItems", [{ productId: 1 }, { productId: 2 }]);
-
-      const mockFetchActivity = vi.fn().mockResolvedValue({
-        status: 201,
-        headers: {},
-        data: { orderId: "ORD-001" },
-      });
-
-      const context: TemporalContext = {
-        blackboard,
-        treeRegistry: registry,
-        timestamp: Date.now(),
-        deltaTime: 0,
-        input: { customerId: "CUST-123" },
-        activities: {
-          executePieceAction: vi.fn(),
-          fetchUrl: mockFetchActivity,
-        },
-      };
-
-      const node = new HttpRequest({
-        id: "test",
-        url: "https://api.example.com/orders",
-        method: "POST",
-        body: {
-          customerId: "${input.customerId}",
-          items: "${bb.cartItems}",
-        },
-        outputKey: "response",
-      });
-
-      await node.tick(context);
-
-      expect(mockFetchActivity).toHaveBeenCalledWith(
-        expect.objectContaining({
-          body: {
-            customerId: "CUST-123",
-            items: [{ productId: 1 }, { productId: 2 }],
-          },
-        })
-      );
-    });
-
-    it("should pass timeout to activity", async () => {
-      const mockFetchActivity = vi.fn().mockResolvedValue({
-        status: 200,
-        headers: {},
-        data: {},
-      });
-
-      const context: TemporalContext = {
-        blackboard,
-        treeRegistry: registry,
-        timestamp: Date.now(),
-        deltaTime: 0,
-        activities: {
-          executePieceAction: vi.fn(),
-          fetchUrl: mockFetchActivity,
-        },
-      };
-
-      const node = new HttpRequest({
-        id: "test",
-        url: "https://api.example.com/data",
-        timeout: 5000,
-        outputKey: "response",
-      });
-
-      await node.tick(context);
-
-      expect(mockFetchActivity).toHaveBeenCalledWith(
-        expect.objectContaining({
-          timeout: 5000,
-        })
-      );
-    });
-
-    it("should parse JSON string response when responseType is json", async () => {
-      const mockFetchActivity = vi.fn().mockResolvedValue({
-        status: 200,
-        headers: { "content-type": "application/json" },
-        data: '{"key": "value"}',
-      });
-
-      const context: TemporalContext = {
-        blackboard,
-        treeRegistry: registry,
-        timestamp: Date.now(),
-        deltaTime: 0,
-        activities: {
-          executePieceAction: vi.fn(),
-          fetchUrl: mockFetchActivity,
-        },
-      };
-
-      const node = new HttpRequest({
-        id: "test",
-        url: "https://api.example.com/data",
-        responseType: "json",
-        outputKey: "response",
-      });
-
-      await node.tick(context);
-
-      const stored = blackboard.get("response") as { data: unknown };
-      expect(stored.data).toEqual({ key: "value" });
-    });
-
-    it("should keep text response as-is when responseType is text", async () => {
-      const mockFetchActivity = vi.fn().mockResolvedValue({
-        status: 200,
-        headers: { "content-type": "text/plain" },
-        data: "Plain text response",
-      });
-
-      const context: TemporalContext = {
-        blackboard,
-        treeRegistry: registry,
-        timestamp: Date.now(),
-        deltaTime: 0,
-        activities: {
-          executePieceAction: vi.fn(),
-          fetchUrl: mockFetchActivity,
-        },
-      };
-
-      const node = new HttpRequest({
-        id: "test",
-        url: "https://api.example.com/data",
-        responseType: "text",
-        outputKey: "response",
-      });
-
-      await node.tick(context);
-
-      const stored = blackboard.get("response") as { data: unknown };
-      expect(stored.data).toBe("Plain text response");
-    });
-
-    it("should handle activity errors", async () => {
-      const mockFetchActivity = vi.fn().mockRejectedValue(
-        new Error("Network error: Connection refused")
-      );
-
-      const context: TemporalContext = {
-        blackboard,
-        treeRegistry: registry,
-        timestamp: Date.now(),
-        deltaTime: 0,
-        activities: {
-          executePieceAction: vi.fn(),
-          fetchUrl: mockFetchActivity,
-        },
-      };
-
-      const node = new HttpRequest({
-        id: "test",
-        url: "https://api.example.com/data",
-        outputKey: "response",
-      });
-
-      const status = await node.tick(context);
-
-      expect(status).toBe(NodeStatus.FAILURE);
-      expect(node.lastError).toContain("Network error");
-    });
-
-    it("should return FAILURE for 4xx status codes", async () => {
-      const mockFetchActivity = vi.fn().mockResolvedValue({
-        status: 404,
-        headers: {},
-        data: { error: "Not found" },
-      });
-
-      const context: TemporalContext = {
-        blackboard,
-        treeRegistry: registry,
-        timestamp: Date.now(),
-        deltaTime: 0,
-        activities: {
-          executePieceAction: vi.fn(),
-          fetchUrl: mockFetchActivity,
-        },
-      };
-
-      const node = new HttpRequest({
-        id: "test",
-        url: "https://api.example.com/missing",
-        outputKey: "response",
-      });
-
-      const status = await node.tick(context);
-
-      expect(status).toBe(NodeStatus.FAILURE);
-      // Response should still be stored
-      const stored = blackboard.get("response") as { status: number };
-      expect(stored.status).toBe(404);
-    });
-
-    it("should return FAILURE for 5xx status codes", async () => {
-      const mockFetchActivity = vi.fn().mockResolvedValue({
-        status: 500,
-        headers: {},
-        data: { error: "Internal server error" },
-      });
-
-      const context: TemporalContext = {
-        blackboard,
-        treeRegistry: registry,
-        timestamp: Date.now(),
-        deltaTime: 0,
-        activities: {
-          executePieceAction: vi.fn(),
-          fetchUrl: mockFetchActivity,
-        },
-      };
-
-      const node = new HttpRequest({
-        id: "test",
-        url: "https://api.example.com/error",
-        outputKey: "response",
-      });
-
-      const status = await node.tick(context);
-
-      expect(status).toBe(NodeStatus.FAILURE);
-    });
-
-    it("should return SUCCESS for 2xx status codes", async () => {
-      for (const statusCode of [200, 201, 204]) {
-        const mockFetchActivity = vi.fn().mockResolvedValue({
-          status: statusCode,
-          headers: {},
-          data: {},
-        });
-
-        const context: TemporalContext = {
-          blackboard,
-          treeRegistry: registry,
-          timestamp: Date.now(),
-          deltaTime: 0,
-          activities: {
-            executePieceAction: vi.fn(),
-            fetchUrl: mockFetchActivity,
-          },
-        };
-
-        const node = new HttpRequest({
-          id: `test-${statusCode}`,
-          url: "https://api.example.com/data",
-          outputKey: `response-${statusCode}`,
-        });
-
-        const status = await node.tick(context);
-        expect(status).toBe(NodeStatus.SUCCESS);
-      }
-    });
-  });
-
-  describe("Retry functionality", () => {
-    it("should retry on failure up to maxAttempts", async () => {
-      const mockFetchActivity = vi
-        .fn()
-        .mockRejectedValueOnce(new Error("Temporary failure 1"))
-        .mockRejectedValueOnce(new Error("Temporary failure 2"))
-        .mockResolvedValueOnce({
-          status: 200,
-          headers: {},
-          data: { success: true },
-        });
-
-      const context: TemporalContext = {
-        blackboard,
-        treeRegistry: registry,
-        timestamp: Date.now(),
-        deltaTime: 0,
-        activities: {
-          executePieceAction: vi.fn(),
-          fetchUrl: mockFetchActivity,
-        },
-      };
-
-      const node = new HttpRequest({
-        id: "test",
-        url: "https://api.example.com/flaky",
-        retry: {
-          maxAttempts: 3,
-          backoffMs: 10, // Use small backoff for testing
-        },
-        outputKey: "response",
-      });
-
-      const status = await node.tick(context);
-
-      expect(status).toBe(NodeStatus.SUCCESS);
-      expect(mockFetchActivity).toHaveBeenCalledTimes(3);
-    });
-
-    it("should fail after exhausting all retry attempts", async () => {
-      const mockFetchActivity = vi.fn().mockRejectedValue(
-        new Error("Persistent failure")
-      );
-
-      const context: TemporalContext = {
-        blackboard,
-        treeRegistry: registry,
-        timestamp: Date.now(),
-        deltaTime: 0,
-        activities: {
-          executePieceAction: vi.fn(),
-          fetchUrl: mockFetchActivity,
-        },
-      };
-
-      const node = new HttpRequest({
-        id: "test",
-        url: "https://api.example.com/broken",
-        retry: {
-          maxAttempts: 3,
-          backoffMs: 10,
-        },
-        outputKey: "response",
-      });
-
-      const status = await node.tick(context);
-
-      expect(status).toBe(NodeStatus.FAILURE);
-      expect(mockFetchActivity).toHaveBeenCalledTimes(3);
-      expect(node.lastError).toContain("Persistent failure");
-    });
-
-    it("should not retry when retry config is not provided", async () => {
-      const mockFetchActivity = vi.fn().mockRejectedValue(
-        new Error("Single failure")
-      );
-
-      const context: TemporalContext = {
-        blackboard,
-        treeRegistry: registry,
-        timestamp: Date.now(),
-        deltaTime: 0,
-        activities: {
-          executePieceAction: vi.fn(),
-          fetchUrl: mockFetchActivity,
-        },
-      };
-
-      const node = new HttpRequest({
-        id: "test",
-        url: "https://api.example.com/data",
-        outputKey: "response",
-      });
-
-      const status = await node.tick(context);
-
-      expect(status).toBe(NodeStatus.FAILURE);
-      expect(mockFetchActivity).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe("Node lifecycle", () => {
-    it("should clone correctly", () => {
-      const node = new HttpRequest({
-        id: "original",
-        url: "https://api.example.com/data",
-        method: "POST",
-        headers: { "X-Custom": "header" },
-        outputKey: "response",
-      });
-
-      const cloned = node.clone() as HttpRequest;
-
-      expect(cloned.id).toBe("original");
-    });
-
-    it("should reset status correctly", async () => {
-      const context: TemporalContext = {
-        blackboard,
-        treeRegistry: registry,
-        timestamp: Date.now(),
-        deltaTime: 0,
-        // No activities - will fail
-      };
-
-      const node = new HttpRequest({
-        id: "test",
-        url: "https://api.example.com/data",
-        outputKey: "response",
-      });
-
-      await node.tick(context);
-      expect(node.status()).toBe(NodeStatus.FAILURE);
-
-      node.reset();
-      expect(node.status()).toBe(NodeStatus.IDLE);
-      expect(node.lastError).toBeUndefined();
-    });
-  });
-
-  describe("HTTP methods", () => {
-    const methods = ["GET", "POST", "PUT", "DELETE", "PATCH"] as const;
-
-    for (const method of methods) {
-      it(`should support ${method} method`, async () => {
-        const mockFetchActivity = vi.fn().mockResolvedValue({
-          status: 200,
-          headers: {},
-          data: {},
-        });
-
-        const context: TemporalContext = {
-          blackboard,
-          treeRegistry: registry,
-          timestamp: Date.now(),
-          deltaTime: 0,
-          activities: {
-            executePieceAction: vi.fn(),
-            fetchUrl: mockFetchActivity,
-          },
-        };
-
-        const node = new HttpRequest({
-          id: `test-${method}`,
-          url: "https://api.example.com/data",
-          method,
-          outputKey: "response",
-        });
-
-        await node.tick(context);
-
-        expect(mockFetchActivity).toHaveBeenCalledWith(
-          expect.objectContaining({ method })
-        );
-      });
-    }
-  });
-});