Skip to content

Scheduling infrastructure for absolutely everyone.

test: add unit tests for Tasker class (#26975)

Morganbca6615da965
diff --git a/packages/lib/tasker/Tasker.test.ts b/packages/lib/tasker/Tasker.test.ts
new file mode 100644
index 00000000000..bc71b1ca65f
--- /dev/null
+++ b/packages/lib/tasker/Tasker.test.ts
@@ -0,0 +1,490 @@
+import process from "node:process";
+
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+
+import type { ILogger } from "./types";
+
+vi.mock("@trigger.dev/sdk", () => ({
+ configure: vi.fn(),
+}));
+
+vi.mock("../constants", () => ({
+ ENABLE_ASYNC_TASKER: true,
+}));
+
+vi.mock("../redactError", () => ({
+ redactError: (err: unknown) => err,
+}));
+
+const createMockLogger = (): ILogger => ({
+ log: vi.fn(),
+ silly: vi.fn(),
+ trace: vi.fn(),
+ debug: vi.fn(),
+ info: vi.fn(),
+ warn: vi.fn(),
+ error: vi.fn(),
+ getSubLogger: vi.fn(),
+});
+
+interface MockTaskerInterface {
+ taskWithParams: (param1: string, param2: number, param3: { nested: boolean }) => Promise<string>;
+ simpleTask: () => Promise<void>;
+ taskThatFails: () => Promise<string>;
+}
+
+describe("Tasker", () => {
+ const originalEnv = process.env;
+
+ beforeEach(() => {
+ vi.resetModules();
+ vi.clearAllMocks();
+ process.env = { ...originalEnv };
+ });
+
+ afterEach(() => {
+ process.env = originalEnv;
+ });
+
+ describe("when async tasker is enabled", () => {
+ beforeEach(() => {
+ process.env.TRIGGER_SECRET_KEY = "test-secret-key";
+ process.env.TRIGGER_API_URL = "https://test-trigger-api.com";
+ });
+
+ it("should pass params correctly to the async tasker method", async () => {
+ const { Tasker } = await import("./Tasker");
+
+ const mockAsyncTasker: MockTaskerInterface = {
+ taskWithParams: vi.fn().mockResolvedValue("async-result"),
+ simpleTask: vi.fn().mockResolvedValue(undefined),
+ taskThatFails: vi.fn().mockRejectedValue(new Error("async failed")),
+ };
+
+ const mockSyncTasker: MockTaskerInterface = {
+ taskWithParams: vi.fn().mockResolvedValue("sync-result"),
+ simpleTask: vi.fn().mockResolvedValue(undefined),
+ taskThatFails: vi.fn().mockResolvedValue("sync-fallback-result"),
+ };
+
+ const mockLogger = createMockLogger();
+
+ class TestTasker extends Tasker<MockTaskerInterface> {
+ constructor() {
+ super({
+ asyncTasker: mockAsyncTasker,
+ syncTasker: mockSyncTasker,
+ logger: mockLogger,
+ });
+ }
+ }
+
+ const tasker = new TestTasker();
+
+ const param1 = "test-string";
+ const param2 = 42;
+ const param3 = { nested: true };
+
+ const result = await tasker.dispatch("taskWithParams", param1, param2, param3);
+
+ expect(mockAsyncTasker.taskWithParams).toHaveBeenCalledTimes(1);
+ expect(mockAsyncTasker.taskWithParams).toHaveBeenCalledWith(param1, param2, param3);
+ expect(result).toBe("async-result");
+ expect(mockSyncTasker.taskWithParams).not.toHaveBeenCalled();
+ });
+
+ it("should pass multiple params in correct order", async () => {
+ const { Tasker } = await import("./Tasker");
+
+ const receivedParams: unknown[] = [];
+ const mockAsyncTasker: MockTaskerInterface = {
+ taskWithParams: vi.fn().mockImplementation((...args) => {
+ receivedParams.push(...args);
+ return Promise.resolve("result");
+ }),
+ simpleTask: vi.fn().mockResolvedValue(undefined),
+ taskThatFails: vi.fn().mockRejectedValue(new Error("failed")),
+ };
+
+ const mockSyncTasker: MockTaskerInterface = {
+ taskWithParams: vi.fn().mockResolvedValue("sync-result"),
+ simpleTask: vi.fn().mockResolvedValue(undefined),
+ taskThatFails: vi.fn().mockResolvedValue("sync-result"),
+ };
+
+ const mockLogger = createMockLogger();
+
+ class TestTasker extends Tasker<MockTaskerInterface> {
+ constructor() {
+ super({
+ asyncTasker: mockAsyncTasker,
+ syncTasker: mockSyncTasker,
+ logger: mockLogger,
+ });
+ }
+ }
+
+ const tasker = new TestTasker();
+
+ await tasker.dispatch("taskWithParams", "first", 123, { nested: false });
+
+ expect(receivedParams).toEqual(["first", 123, { nested: false }]);
+ });
+
+ it("should fall back to sync tasker when async tasker fails", async () => {
+ const { Tasker } = await import("./Tasker");
+
+ const mockAsyncTasker: MockTaskerInterface = {
+ taskWithParams: vi.fn().mockResolvedValue("async-result"),
+ simpleTask: vi.fn().mockResolvedValue(undefined),
+ taskThatFails: vi.fn().mockRejectedValue(new Error("async tasker error")),
+ };
+
+ const mockSyncTasker: MockTaskerInterface = {
+ taskWithParams: vi.fn().mockResolvedValue("sync-result"),
+ simpleTask: vi.fn().mockResolvedValue(undefined),
+ taskThatFails: vi.fn().mockResolvedValue("sync-fallback-result"),
+ };
+
+ const mockLogger = createMockLogger();
+
+ class TestTasker extends Tasker<MockTaskerInterface> {
+ constructor() {
+ super({
+ asyncTasker: mockAsyncTasker,
+ syncTasker: mockSyncTasker,
+ logger: mockLogger,
+ });
+ }
+ }
+
+ const tasker = new TestTasker();
+
+ const result = await tasker.dispatch("taskThatFails");
+
+ expect(mockAsyncTasker.taskThatFails).toHaveBeenCalledTimes(1);
+ expect(mockSyncTasker.taskThatFails).toHaveBeenCalledTimes(1);
+ expect(result).toBe("sync-fallback-result");
+ expect(mockLogger.error).toHaveBeenCalled();
+ expect(mockLogger.warn).toHaveBeenCalledWith("Trying again with SyncTasker for 'taskThatFails'.");
+ });
+
+ it("should pass params to sync tasker fallback when async fails", async () => {
+ const { Tasker } = await import("./Tasker");
+
+ const mockAsyncTasker: MockTaskerInterface = {
+ taskWithParams: vi.fn().mockRejectedValue(new Error("async failed")),
+ simpleTask: vi.fn().mockResolvedValue(undefined),
+ taskThatFails: vi.fn().mockRejectedValue(new Error("failed")),
+ };
+
+ const syncReceivedParams: unknown[] = [];
+ const mockSyncTasker: MockTaskerInterface = {
+ taskWithParams: vi.fn().mockImplementation((...args) => {
+ syncReceivedParams.push(...args);
+ return Promise.resolve("sync-result");
+ }),
+ simpleTask: vi.fn().mockResolvedValue(undefined),
+ taskThatFails: vi.fn().mockResolvedValue("sync-result"),
+ };
+
+ const mockLogger = createMockLogger();
+
+ class TestTasker extends Tasker<MockTaskerInterface> {
+ constructor() {
+ super({
+ asyncTasker: mockAsyncTasker,
+ syncTasker: mockSyncTasker,
+ logger: mockLogger,
+ });
+ }
+ }
+
+ const tasker = new TestTasker();
+
+ const param1 = "fallback-test";
+ const param2 = 999;
+ const param3 = { nested: true };
+
+ await tasker.dispatch("taskWithParams", param1, param2, param3);
+
+ expect(syncReceivedParams).toEqual([param1, param2, param3]);
+ });
+
+ it("should throw error when both async and sync taskers fail", async () => {
+ const { Tasker } = await import("./Tasker");
+
+ const syncError = new Error("sync tasker also failed");
+ const mockAsyncTasker: MockTaskerInterface = {
+ taskWithParams: vi.fn().mockResolvedValue("async-result"),
+ simpleTask: vi.fn().mockResolvedValue(undefined),
+ taskThatFails: vi.fn().mockRejectedValue(new Error("async tasker error")),
+ };
+
+ const mockSyncTasker: MockTaskerInterface = {
+ taskWithParams: vi.fn().mockResolvedValue("sync-result"),
+ simpleTask: vi.fn().mockResolvedValue(undefined),
+ taskThatFails: vi.fn().mockRejectedValue(syncError),
+ };
+
+ const mockLogger = createMockLogger();
+
+ class TestTasker extends Tasker<MockTaskerInterface> {
+ constructor() {
+ super({
+ asyncTasker: mockAsyncTasker,
+ syncTasker: mockSyncTasker,
+ logger: mockLogger,
+ });
+ }
+ }
+
+ const tasker = new TestTasker();
+
+ await expect(tasker.dispatch("taskThatFails")).rejects.toThrow("sync tasker also failed");
+ expect(mockAsyncTasker.taskThatFails).toHaveBeenCalledTimes(1);
+ expect(mockSyncTasker.taskThatFails).toHaveBeenCalledTimes(1);
+ });
+
+ it("should log dispatch information with args", async () => {
+ const { Tasker } = await import("./Tasker");
+
+ const mockAsyncTasker: MockTaskerInterface = {
+ taskWithParams: vi.fn().mockResolvedValue("result"),
+ simpleTask: vi.fn().mockResolvedValue(undefined),
+ taskThatFails: vi.fn().mockRejectedValue(new Error("failed")),
+ };
+
+ const mockSyncTasker: MockTaskerInterface = {
+ taskWithParams: vi.fn().mockResolvedValue("sync-result"),
+ simpleTask: vi.fn().mockResolvedValue(undefined),
+ taskThatFails: vi.fn().mockResolvedValue("sync-result"),
+ };
+
+ const mockLogger = createMockLogger();
+
+ class TestTasker extends Tasker<MockTaskerInterface> {
+ constructor() {
+ super({
+ asyncTasker: mockAsyncTasker,
+ syncTasker: mockSyncTasker,
+ logger: mockLogger,
+ });
+ }
+ }
+
+ const tasker = new TestTasker();
+ const args = ["test", 123, { nested: true }] as const;
+
+ await tasker.dispatch("taskWithParams", ...args);
+
+ expect(mockLogger.info).toHaveBeenCalledWith("Safely Dispatching task 'taskWithParams'", {
+ args: ["test", 123, { nested: true }],
+ });
+ });
+ });
+
+ describe("when async tasker is disabled (missing env vars)", () => {
+ beforeEach(() => {
+ delete process.env.TRIGGER_SECRET_KEY;
+ delete process.env.TRIGGER_API_URL;
+ });
+
+ it("should use sync tasker when TRIGGER_SECRET_KEY is missing", async () => {
+ vi.resetModules();
+ const { Tasker } = await import("./Tasker");
+
+ const mockAsyncTasker: MockTaskerInterface = {
+ taskWithParams: vi.fn().mockResolvedValue("async-result"),
+ simpleTask: vi.fn().mockResolvedValue(undefined),
+ taskThatFails: vi.fn().mockRejectedValue(new Error("failed")),
+ };
+
+ const mockSyncTasker: MockTaskerInterface = {
+ taskWithParams: vi.fn().mockResolvedValue("sync-result"),
+ simpleTask: vi.fn().mockResolvedValue(undefined),
+ taskThatFails: vi.fn().mockResolvedValue("sync-result"),
+ };
+
+ const mockLogger = createMockLogger();
+
+ class TestTasker extends Tasker<MockTaskerInterface> {
+ constructor() {
+ super({
+ asyncTasker: mockAsyncTasker,
+ syncTasker: mockSyncTasker,
+ logger: mockLogger,
+ });
+ }
+ }
+
+ const tasker = new TestTasker();
+
+ const result = await tasker.dispatch("taskWithParams", "test", 1, { nested: true });
+
+ expect(result).toBe("sync-result");
+ expect(mockSyncTasker.taskWithParams).toHaveBeenCalledWith("test", 1, { nested: true });
+ });
+
+ it("should throw immediately when sync tasker fails (no fallback to itself)", async () => {
+ vi.resetModules();
+ const { Tasker } = await import("./Tasker");
+
+ const syncError = new Error("sync tasker failed");
+ const mockAsyncTasker: MockTaskerInterface = {
+ taskWithParams: vi.fn().mockResolvedValue("async-result"),
+ simpleTask: vi.fn().mockResolvedValue(undefined),
+ taskThatFails: vi.fn().mockRejectedValue(new Error("failed")),
+ };
+
+ const mockSyncTasker: MockTaskerInterface = {
+ taskWithParams: vi.fn().mockResolvedValue("sync-result"),
+ simpleTask: vi.fn().mockResolvedValue(undefined),
+ taskThatFails: vi.fn().mockRejectedValue(syncError),
+ };
+
+ const mockLogger = createMockLogger();
+
+ class TestTasker extends Tasker<MockTaskerInterface> {
+ constructor() {
+ super({
+ asyncTasker: mockAsyncTasker,
+ syncTasker: mockSyncTasker,
+ logger: mockLogger,
+ });
+ }
+ }
+
+ const tasker = new TestTasker();
+
+ await expect(tasker.dispatch("taskThatFails")).rejects.toThrow("sync tasker failed");
+ expect(mockSyncTasker.taskThatFails).toHaveBeenCalledTimes(1);
+ expect(mockLogger.warn).not.toHaveBeenCalledWith(
+ expect.stringContaining("Trying again with SyncTasker")
+ );
+ });
+
+ it("should log warning about missing env vars", async () => {
+ vi.resetModules();
+ const { Tasker } = await import("./Tasker");
+
+ const mockAsyncTasker: MockTaskerInterface = {
+ taskWithParams: vi.fn().mockResolvedValue("async-result"),
+ simpleTask: vi.fn().mockResolvedValue(undefined),
+ taskThatFails: vi.fn().mockRejectedValue(new Error("failed")),
+ };
+
+ const mockSyncTasker: MockTaskerInterface = {
+ taskWithParams: vi.fn().mockResolvedValue("sync-result"),
+ simpleTask: vi.fn().mockResolvedValue(undefined),
+ taskThatFails: vi.fn().mockResolvedValue("sync-result"),
+ };
+
+ const mockLogger = createMockLogger();
+
+ class TestTasker extends Tasker<MockTaskerInterface> {
+ constructor() {
+ super({
+ asyncTasker: mockAsyncTasker,
+ syncTasker: mockSyncTasker,
+ logger: mockLogger,
+ });
+ }
+ }
+
+ new TestTasker();
+
+ expect(mockLogger.info).toHaveBeenCalledWith(
+ "Missing env variables TRIGGER_SECRET_KEY or TRIGGER_API_URL, falling back to Sync tasker."
+ );
+ });
+ });
+
+ describe("error handling", () => {
+ beforeEach(() => {
+ process.env.TRIGGER_SECRET_KEY = "test-secret-key";
+ process.env.TRIGGER_API_URL = "https://test-trigger-api.com";
+ });
+
+ it("should log error details when async tasker fails", async () => {
+ const { Tasker } = await import("./Tasker");
+
+ const asyncError = new Error("async error message");
+ asyncError.name = "AsyncError";
+
+ const mockAsyncTasker: MockTaskerInterface = {
+ taskWithParams: vi.fn().mockResolvedValue("async-result"),
+ simpleTask: vi.fn().mockResolvedValue(undefined),
+ taskThatFails: vi.fn().mockRejectedValue(asyncError),
+ };
+
+ const mockSyncTasker: MockTaskerInterface = {
+ taskWithParams: vi.fn().mockResolvedValue("sync-result"),
+ simpleTask: vi.fn().mockResolvedValue(undefined),
+ taskThatFails: vi.fn().mockResolvedValue("sync-result"),
+ };
+
+ const mockLogger = createMockLogger();
+
+ class TestTasker extends Tasker<MockTaskerInterface> {
+ constructor() {
+ super({
+ asyncTasker: mockAsyncTasker,
+ syncTasker: mockSyncTasker,
+ logger: mockLogger,
+ });
+ }
+ }
+
+ const tasker = new TestTasker();
+
+ await tasker.dispatch("taskThatFails");
+
+ expect(mockLogger.error).toHaveBeenCalledWith(
+ "AsyncTasker failed for 'taskThatFails'. (baseURL: https://test-trigger-api.com)",
+ expect.objectContaining({
+ name: "AsyncError",
+ message: "async error message",
+ })
+ );
+ });
+
+ it("should handle non-Error objects thrown by taskers", async () => {
+ const { Tasker } = await import("./Tasker");
+
+ const mockAsyncTasker: MockTaskerInterface = {
+ taskWithParams: vi.fn().mockResolvedValue("async-result"),
+ simpleTask: vi.fn().mockResolvedValue(undefined),
+ taskThatFails: vi.fn().mockRejectedValue("string error"),
+ };
+
+ const mockSyncTasker: MockTaskerInterface = {
+ taskWithParams: vi.fn().mockResolvedValue("sync-result"),
+ simpleTask: vi.fn().mockResolvedValue(undefined),
+ taskThatFails: vi.fn().mockResolvedValue("sync-result"),
+ };
+
+ const mockLogger = createMockLogger();
+
+ class TestTasker extends Tasker<MockTaskerInterface> {
+ constructor() {
+ super({
+ asyncTasker: mockAsyncTasker,
+ syncTasker: mockSyncTasker,
+ logger: mockLogger,
+ });
+ }
+ }
+
+ const tasker = new TestTasker();
+
+ const result = await tasker.dispatch("taskThatFails");
+
+ expect(result).toBe("sync-result");
+ expect(mockLogger.error).toHaveBeenCalledWith(
+ expect.stringContaining("AsyncTasker failed"),
+ expect.objectContaining({ message: "string error" })
+ );
+ });
+ });
+});