0z2i6v3u5t 1.0.0

package/__tests__/core/tasks/customQueueFunction.ts

@@ -0,0 +1,67 @@
+import { api, Process, utils, config } from "./../../../src/index";
+
+const actionhero = new Process();
+let taskOutput = [];
+const queue = "testQueue";
+
+jest.mock("./../../../src/config/tasks.ts", () => ({
+  __esModule: true,
+  test: {
+    tasks: () => {
+      return {
+        _toExpand: false,
+
+        scheduler: false,
+        queues: async () => {
+          await new Promise((resolve) => setTimeout(resolve, 100));
+          return ["queueA", "queueB"];
+        },
+        workerLogging: {},
+        schedulerLogging: {},
+        timeout: 100,
+        checkTimeout: 50,
+        minTaskProcessors: 1,
+        maxTaskProcessors: 1,
+        maxEventLoopDelay: 5,
+        stuckWorkerTimeout: 1000 * 60 * 60,
+        connectionOptions: {
+          tasks: {},
+        },
+      };
+    },
+  },
+}));
+
+describe("Core: Tasks", () => {
+  describe("custom queues function", () => {
+    beforeAll(async () => {
+      await actionhero.start();
+      api.resque.multiWorker.options.connection!.redis!.setMaxListeners(100);
+    });
+
+    afterAll(async () => {
+      config.tasks!.queues = [];
+
+      api.resque.multiWorker.options.minTaskProcessors = 0;
+      api.resque.multiWorker.options.maxTaskProcessors = 0;
+
+      await actionhero.stop();
+    });
+
+    beforeEach(async () => {
+      taskOutput = [];
+      await api.resque.queue.connection.redis.flushdb();
+    });
+
+    test("normal tasks work", async () => {
+      api.resque.multiWorker.start();
+      await utils.sleep(2000);
+
+      expect(api.resque.multiWorker.workers[0].queues).toEqual([
+        "queueA",
+        "queueB",
+      ]);
+      await api.resque.multiWorker.stop();
+    });
+  });
+});

package/__tests__/core/tasks/fullWorkerFlow.ts

@@ -0,0 +1,199 @@
+import { api, Process, Task, utils, config, task } from "./../../../src/index";
+
+const actionhero = new Process();
+let taskOutput: any[] = [];
+const queue = "testQueue";
+
+jest.mock("./../../../src/config/tasks.ts", () => ({
+  __esModule: true,
+  test: {
+    tasks: () => {
+      return {
+        scheduler: true,
+        queues: ["*"],
+        workerLogging: {},
+        schedulerLogging: {},
+        timeout: 100,
+        checkTimeout: 50,
+        minTaskProcessors: 1,
+        maxTaskProcessors: 1,
+        maxEventLoopDelay: 5,
+        stuckWorkerTimeout: 1000 * 60 * 60,
+        connectionOptions: {
+          tasks: {},
+        },
+      };
+    },
+  },
+}));
+
+describe("Core: Tasks", () => {
+  describe("full worker flow", () => {
+    beforeAll(async () => {
+      await actionhero.start();
+      api.resque.multiWorker.options.connection!.redis!.setMaxListeners(100);
+
+      class RegularTask extends Task {
+        constructor() {
+          super();
+          this.name = "regular";
+          this.description = "task: regular";
+          this.queue = queue;
+          this.frequency = 0;
+        }
+
+        run(params: Record<string, any>) {
+          taskOutput.push(params.word);
+          return params.word;
+        }
+      }
+
+      class PeriodicTask extends Task {
+        constructor() {
+          super();
+          this.name = "periodicTask";
+          this.description = "task: periodicTask";
+          this.queue = queue;
+          this.frequency = 100;
+        }
+
+        async run() {
+          taskOutput.push("periodicTask");
+          return "periodicTask";
+        }
+      }
+
+      class SlowTask extends Task {
+        constructor() {
+          super();
+          this.name = "slowTask";
+          this.description = "task: slowTask";
+          this.queue = queue;
+          this.frequency = 0;
+        }
+
+        async run() {
+          await utils.sleep(5000);
+          taskOutput.push("slowTask");
+          return "slowTask";
+        }
+      }
+
+      api.tasks.tasks.regularTask = new RegularTask();
+      api.tasks.tasks.periodicTask = new PeriodicTask();
+      api.tasks.tasks.slowTask = new SlowTask();
+
+      api.tasks.jobs.regularTask = api.tasks.jobWrapper("regularTask");
+      api.tasks.jobs.periodicTask = api.tasks.jobWrapper("periodicTask");
+      api.tasks.jobs.slowTask = api.tasks.jobWrapper("slowTask");
+    });
+
+    afterAll(async () => {
+      delete api.tasks.tasks.regularTask;
+      delete api.tasks.tasks.periodicTask;
+      delete api.tasks.tasks.slowTask;
+      delete api.tasks.jobs.regularTask;
+      delete api.tasks.jobs.periodicTask;
+      delete api.tasks.jobs.slowTask;
+
+      config.tasks!.queues = [];
+
+      api.resque.multiWorker.options.minTaskProcessors = 0;
+      api.resque.multiWorker.options.maxTaskProcessors = 0;
+
+      await actionhero.stop();
+    });
+
+    beforeEach(async () => {
+      taskOutput = [];
+      await api.resque.queue.connection.redis.flushdb();
+    });
+
+    afterEach(async () => {
+      await api.resque.stopScheduler();
+      await api.resque.stopMultiWorker();
+    });
+
+    test("normal tasks work", async () => {
+      await task.enqueue("regularTask", { word: "first" });
+      config.tasks!.queues = ["*"];
+      api.resque.multiWorker.start();
+
+      await utils.sleep(500);
+
+      expect(taskOutput[0]).toEqual("first");
+      await api.resque.multiWorker.stop();
+    });
+
+    test("delayed tasks work", async () => {
+      await task.enqueueIn(100, "regularTask", { word: "delayed" });
+
+      config.tasks!.queues = ["*"];
+      config.tasks!.scheduler = true;
+      await api.resque.startScheduler();
+      await api.resque.multiWorker.start();
+
+      await utils.sleep(1500);
+      expect(taskOutput[0]).toEqual("delayed");
+      await api.resque.multiWorker.stop();
+      await api.resque.stopScheduler();
+    });
+
+    test("recurrent tasks work", async () => {
+      await task.enqueueRecurrentTask("periodicTask");
+
+      config.tasks!.queues = ["*"];
+      config.tasks!.scheduler = true;
+      await api.resque.startScheduler();
+      await api.resque.multiWorker.start();
+
+      await utils.sleep(1500);
+      expect(taskOutput[0]).toEqual("periodicTask");
+      expect(taskOutput[1]).toEqual("periodicTask");
+      expect(taskOutput[2]).toEqual("periodicTask");
+      // the task may have run more than 3 times, we just want to ensure that it happened more than once
+      await api.resque.multiWorker.stop();
+      await api.resque.stopScheduler();
+    });
+
+    test("enqueuing the same task multiple times does not produce an error", async () => {
+      await task.enqueueRecurrentTask("periodicTask");
+      await task.enqueueRecurrentTask("periodicTask"); // does not throw
+      await task.enqueueRecurrentTask("periodicTask"); // does not throw
+
+      const taskTimes = await task.allDelayed();
+      expect(Object.keys(taskTimes).length).toBe(1);
+      const tasks = Object.values(taskTimes)[0];
+      expect(tasks.length).toBe(1);
+    });
+
+    test("trying to run an unknown job will return a failure, but not crash the server", async () => {
+      await new Promise(async (resolve) => {
+        config.tasks!.queues = ["*"];
+
+        const listener = async (
+          workerId: number,
+          queue: string,
+          job: any,
+          f: Error,
+          duration: number,
+        ) => {
+          expect(queue).toEqual(queue);
+          expect(job.class).toEqual("someCrazyTask");
+          expect(job.queue).toEqual("testQueue");
+          expect(String(f)).toEqual(
+            'Error: No job defined for class "someCrazyTask"',
+          );
+          api.resque.multiWorker.removeListener("failure", listener);
+          await api.resque.multiWorker.stop();
+          return resolve(null);
+        };
+
+        api.resque.multiWorker.on("failure", listener);
+
+        await api.resque.queue.enqueue(queue, "someCrazyTask");
+        api.resque.multiWorker.start();
+      });
+    });
+  });
+});