add some tests for new stuff

Author: chrishagglund-ship-it

jest.config.mjs

@@ -21,6 +21,7 @@ export default {
     "^@/(.*)$": "<rootDir>/src/$1",
     "^@open-api/(.*)$": "<rootDir>/src/open-api/$1",
     "^@test-utils/(.*)$": "<rootDir>/src/integration-tests/utils/$1",
+    "^(.*)\\.js$": "$1",
   },
   transform: {
     "^.+\\.tsx?$": [

src/sdk/clients/worker/events/__tests__/EventDispatcher.test.ts

@@ -9,6 +9,7 @@ import type {
   TaskExecutionFailure,
   TaskUpdateCompleted,
   TaskUpdateFailure,
+  TaskPaused,
 } from "../types";
 
 describe("EventDispatcher", () => {
@@ -143,6 +144,7 @@ describe("EventDispatcher", () => {
       onTaskExecutionFailure: jest.fn<() => void>(),
       onTaskUpdateCompleted: jest.fn<() => void>(),
       onTaskUpdateFailure: jest.fn<() => void>(),
+      onTaskPaused: jest.fn<() => void>(),
     };
 
     dispatcher.register(listener);
@@ -231,6 +233,14 @@ describe("EventDispatcher", () => {
     };
     await dispatcher.publishTaskUpdateFailure(updateFailure);
     expect(listener.onTaskUpdateFailure).toHaveBeenCalledWith(updateFailure);
+
+    // Test TaskPaused
+    const taskPaused: TaskPaused = {
+      taskType: "test-task",
+      timestamp: new Date(),
+    };
+    await dispatcher.publishTaskPaused(taskPaused);
+    expect(listener.onTaskPaused).toHaveBeenCalledWith(taskPaused);
   });
 
   test("should have zero overhead when no listeners registered", async () => {

src/sdk/createConductorClient/helpers/__tests__/fetchWithRetry.test.ts

@@ -1,5 +1,6 @@
-import { jest, expect, describe, it, beforeEach } from "@jest/globals";
+import { jest, expect, describe, it, beforeEach, afterEach } from "@jest/globals";
 import { retryFetch, wrapFetchWithRetry, applyTimeout } from "../fetchWithRetry";
+import * as httpObserver from "@/sdk/worker/metrics/httpObserver";
 
 const createMockResponse = (status: number, body = ""): Response =>
   new Response(body, { status, statusText: `Status ${status}` });
@@ -525,4 +526,107 @@ describe("fetchWithRetry", () => {
       expect(result.status).toBe(200);
     });
   });
+
+  // ─── wrapFetchWithRetry metrics recording ───────────────────────────
+
+  describe("wrapFetchWithRetry metrics", () => {
+    const mockRecordApiRequestTime = jest.fn<
+      (m: string, u: string, s: string, d: number) => void
+    >();
+
+    beforeEach(() => {
+      mockRecordApiRequestTime.mockClear();
+      httpObserver.setHttpMetricsObserver({
+        recordApiRequestTime: mockRecordApiRequestTime,
+        recordWorkflowInputSize: jest.fn(),
+        recordWorkflowStartError: jest.fn(),
+      });
+    });
+
+    afterEach(() => {
+      httpObserver.setHttpMetricsObserver(undefined);
+    });
+
+    it("should record API request time on successful response", async () => {
+      mockFetch.mockResolvedValue(createMockResponse(200));
+
+      const wrappedFetch = wrapFetchWithRetry(mockFetch);
+      await wrappedFetch("http://test.com/api/tasks", { method: "POST" });
+
+      expect(mockRecordApiRequestTime).toHaveBeenCalledTimes(1);
+      const [method, uri, status, duration] =
+        mockRecordApiRequestTime.mock.calls[0];
+      expect(method).toBe("POST");
+      expect(uri).toBe("/api/tasks");
+      expect(status).toBe("200");
+      expect(duration).toBeGreaterThanOrEqual(0);
+    });
+
+    it("should record status '0' on network failure", async () => {
+      mockFetch.mockRejectedValue(new Error("ECONNRESET"));
+
+      const wrappedFetch = wrapFetchWithRetry(mockFetch, {
+        maxTransportRetries: 0,
+      });
+
+      await expect(
+        wrappedFetch("http://test.com/api/workflow")
+      ).rejects.toThrow("ECONNRESET");
+
+      expect(mockRecordApiRequestTime).toHaveBeenCalledTimes(1);
+      const [method, uri, status] =
+        mockRecordApiRequestTime.mock.calls[0];
+      expect(method).toBe("GET");
+      expect(uri).toBe("/api/workflow");
+      expect(status).toBe("0");
+    });
+
+    it("should extract method and URI from string URL", async () => {
+      mockFetch.mockResolvedValue(createMockResponse(201));
+
+      const wrappedFetch = wrapFetchWithRetry(mockFetch);
+      await wrappedFetch("http://example.com/tasks/123", { method: "PUT" });
+
+      expect(mockRecordApiRequestTime).toHaveBeenCalledTimes(1);
+      const [method, uri] = mockRecordApiRequestTime.mock.calls[0];
+      expect(method).toBe("PUT");
+      expect(uri).toBe("/tasks/123");
+    });
+
+    it("should extract method and URI from Request object", async () => {
+      mockFetch.mockResolvedValue(createMockResponse(200));
+
+      const wrappedFetch = wrapFetchWithRetry(mockFetch);
+      const request = new Request("http://example.com/api/metadata", {
+        method: "DELETE",
+      });
+      await wrappedFetch(request);
+
+      expect(mockRecordApiRequestTime).toHaveBeenCalledTimes(1);
+      const [method, uri] = mockRecordApiRequestTime.mock.calls[0];
+      expect(method).toBe("DELETE");
+      expect(uri).toBe("/api/metadata");
+    });
+
+    it("should not break fetch when no observer is registered", async () => {
+      httpObserver.setHttpMetricsObserver(undefined);
+
+      mockFetch.mockResolvedValue(createMockResponse(200));
+      const wrappedFetch = wrapFetchWithRetry(mockFetch);
+      const result = await wrappedFetch("http://test.com");
+
+      expect(result.status).toBe(200);
+    });
+
+    it("should default method to GET when init has no method", async () => {
+      mockFetch.mockResolvedValue(createMockResponse(200));
+
+      const wrappedFetch = wrapFetchWithRetry(mockFetch);
+      await wrappedFetch("http://test.com/path");
+
+      expect(mockRecordApiRequestTime).toHaveBeenCalledTimes(1);
+      const [method] = mockRecordApiRequestTime.mock.calls[0];
+      expect(method).toBe("GET");
+    });
+  });
 });

src/sdk/worker/metrics/__tests__/CanonicalMetricsCollector.test.ts

@@ -318,4 +318,116 @@ describe("CanonicalMetricsCollector", () => {
       await expect(collector.stop()).resolves.toBeUndefined();
     });
   });
+
+  describe("default argument handling", () => {
+    it("recordUncaughtException with no arg should default to 'Error'", () => {
+      collector.recordUncaughtException();
+      const text = collector.toPrometheusText();
+      expect(text).toContain('thread_uncaught_exceptions_total{exception="Error"} 1');
+    });
+
+    it("recordWorkflowStartError with no args should default both labels", () => {
+      collector.recordWorkflowStartError();
+      const text = collector.toPrometheusText();
+      expect(text).toContain('workflow_start_error_total{workflowType="",exception="Error"} 1');
+    });
+
+    it("recordWorkflowStartError with only workflowType should default exception", () => {
+      collector.recordWorkflowStartError("my_wf");
+      const text = collector.toPrometheusText();
+      expect(text).toContain('workflow_start_error_total{workflowType="my_wf",exception="Error"} 1');
+    });
+
+    it("recordExternalPayloadUsed with missing optional args should default to empty strings", () => {
+      collector.recordExternalPayloadUsed("TASK_OUTPUT");
+      const text = collector.toPrometheusText();
+      expect(text).toContain('external_payload_used_total{entityName="",operation="",payloadType="TASK_OUTPUT"} 1');
+    });
+
+    it("recordTaskAckError with no exception arg should default to 'Error'", () => {
+      collector.recordTaskAckError("task_a");
+      const text = collector.toPrometheusText();
+      expect(text).toContain('task_ack_error_total{taskType="task_a",exception="Error"} 1');
+    });
+
+    it("recordWorkflowInputSize with no version should default to empty string", () => {
+      collector.recordWorkflowInputSize("my_wf", 1000);
+      const text = collector.toPrometheusText();
+      expect(text).toContain('workflow_input_size_bytes_sum{workflowType="my_wf",version=""} 1000');
+    });
+  });
+
+  describe("execution completion without outputSizeBytes", () => {
+    it("should not emit task_result_size_bytes when outputSizeBytes is undefined", () => {
+      collector.onTaskExecutionCompleted({
+        taskType: "task_a",
+        taskId: "t1",
+        workerId: "w1",
+        durationMs: 200,
+        timestamp: new Date(),
+      });
+
+      const text = collector.toPrometheusText();
+      expect(text).toContain("task_execute_time_seconds");
+      expect(text).not.toContain("task_result_size_bytes");
+    });
+  });
+
+  describe("output helpers without prom-client", () => {
+    it("getContentType should return plain text fallback", () => {
+      expect(collector.getContentType()).toBe(
+        "text/plain; version=0.0.4; charset=utf-8"
+      );
+    });
+
+    it("toPrometheusTextAsync should fall back to sync text", async () => {
+      collector.onPollStarted({
+        taskType: "t",
+        workerId: "w",
+        pollCount: 1,
+        timestamp: new Date(),
+      });
+      const asyncText = await collector.toPrometheusTextAsync();
+      const syncText = collector.toPrometheusText();
+      expect(asyncText).toBe(syncText);
+    });
+
+    it("toPrometheusText should ignore _prefix argument", () => {
+      collector.onPollStarted({
+        taskType: "t",
+        workerId: "w",
+        pollCount: 1,
+        timestamp: new Date(),
+      });
+      const text = collector.toPrometheusText("some_prefix");
+      expect(text).not.toContain("some_prefix");
+      expect(text).toContain("task_poll_total{");
+    });
+  });
+
+  describe("active_workers gauge on failure", () => {
+    it("should decrement active_workers on task execution failure", () => {
+      collector.onTaskExecutionStarted({
+        taskType: "task_a",
+        taskId: "t1",
+        workerId: "w1",
+        timestamp: new Date(),
+      });
+
+      let text = collector.toPrometheusText();
+      expect(text).toContain('active_workers{taskType="task_a"} 1');
+
+      collector.onTaskExecutionFailure({
+        taskType: "task_a",
+        taskId: "t1",
+        workerId: "w1",
+        cause: new Error("fail"),
+        durationMs: 100,
+        timestamp: new Date(),
+      });
+
+      text = collector.toPrometheusText();
+      expect(text).toContain('active_workers{taskType="task_a"} 0');
+    });
+  });
 });