Adds delay enqueue hooks

__tests__/core/pluginRunner.ts

@@ -0,0 +1,261 @@
+import specHelper from "../utils/specHelper";
+import { Queue, Worker, Job } from "../../src";
+import { HooksPlugin } from "../utils/custom-plugin";
+import { RunPlugins } from "../../src/core/pluginRunner";
+
+describe("plugin runner", () => {
+  const jobs = {
+    //@ts-ignore
+    myJob: {
+      plugins: [HooksPlugin],
+      perform: async () => {
+        throw new Error("should not get here");
+      },
+    } as Job<any>,
+  };
+
+  describe("queue hooks", () => {
+    const queue = new Queue(
+      {
+        connection: specHelper.cleanConnectionDetails(),
+        queue: specHelper.queue,
+      },
+      jobs
+    );
+
+    describe("beforeEnqueue", () => {
+      test("it will not permit adding properties to args", async () => {
+        HooksPlugin.prototype.beforeEnqueue = async function () {
+          this.args.push(3);
+          return true;
+        };
+
+        await expect(
+          RunPlugins(
+            queue,
+            "beforeEnqueue",
+            "myJob",
+            specHelper.queue,
+            jobs.myJob,
+            [1, 2]
+          )
+        ).rejects.toThrow(TypeError);
+      });
+
+      test("it will not permit adding properties to nested args", async () => {
+        HooksPlugin.prototype.beforeEnqueue = async function () {
+          this.args[0].a.b = true;
+          return true;
+        };
+
+        await expect(
+          RunPlugins(
+            queue,
+            "beforeEnqueue",
+            "myJob",
+            specHelper.queue,
+            jobs.myJob,
+            [{ a: {} }]
+          )
+        ).rejects.toThrow(TypeError);
+      });
+    });
+
+    describe("afterEnqueue", () => {
+      test("it will not permit adding properties to args", async () => {
+        HooksPlugin.prototype.afterEnqueue = async function () {
+          this.args.push(3);
+          return true;
+        };
+
+        await expect(
+          RunPlugins(
+            queue,
+            "afterEnqueue",
+            "myJob",
+            specHelper.queue,
+            jobs.myJob,
+            [1, 2]
+          )
+        ).rejects.toThrow(TypeError);
+      });
+
+      test("it will not permit adding properties to nested args", async () => {
+        HooksPlugin.prototype.afterEnqueue = async function () {
+          this.args[0].a.b = true;
+          return true;
+        };
+
+        await expect(
+          RunPlugins(
+            queue,
+            "afterEnqueue",
+            "myJob",
+            specHelper.queue,
+            jobs.myJob,
+            [{ a: {} }]
+          )
+        ).rejects.toThrow(TypeError);
+      });
+    });
+
+    describe("beforeDelayEnqueue", () => {
+      test("it will not permit adding properties to args", async () => {
+        HooksPlugin.prototype.beforeDelayEnqueue = async function () {
+          this.args.push(3);
+          return true;
+        };
+
+        await expect(
+          RunPlugins(
+            queue,
+            "beforeDelayEnqueue",
+            "myJob",
+            specHelper.queue,
+            jobs.myJob,
+            [1, 2]
+          )
+        ).rejects.toThrow(TypeError);
+      });
+
+      test("it will not permit adding properties to nested args", async () => {
+        HooksPlugin.prototype.beforeDelayEnqueue = async function () {
+          this.args[0].a.b = true;
+          return true;
+        };
+
+        await expect(
+          RunPlugins(
+            queue,
+            "beforeDelayEnqueue",
+            "myJob",
+            specHelper.queue,
+            jobs.myJob,
+            [{ a: {} }]
+          )
+        ).rejects.toThrow(TypeError);
+      });
+    });
+
+    describe("afterDelayEnqueue", () => {
+      test("it will not permit adding properties to args", async () => {
+        HooksPlugin.prototype.afterDelayEnqueue = async function () {
+          this.args.push(3);
+          return true;
+        };
+
+        await expect(
+          RunPlugins(
+            queue,
+            "afterDelayEnqueue",
+            "myJob",
+            specHelper.queue,
+            jobs.myJob,
+            [1, 2]
+          )
+        ).rejects.toThrow(TypeError);
+      });
+
+      test("it will not permit adding properties to nested args", async () => {
+        HooksPlugin.prototype.afterDelayEnqueue = async function () {
+          this.args[0].a.b = true;
+          return true;
+        };
+
+        await expect(
+          RunPlugins(
+            queue,
+            "afterDelayEnqueue",
+            "myJob",
+            specHelper.queue,
+            jobs.myJob,
+            [{ a: {} }]
+          )
+        ).rejects.toThrow(TypeError);
+      });
+    });
+  });
+
+  describe("worker hooks", () => {
+    const worker = new Worker(
+      { connection: specHelper.connectionDetails, queues: [specHelper.queue] },
+      {}
+    );
+
+    describe("beforePerform", () => {
+      test("it will not permit adding properties to args", async () => {
+        HooksPlugin.prototype.beforePerform = async function () {
+          this.args.push(3);
+          return true;
+        };
+
+        await expect(
+          RunPlugins(
+            worker,
+            "beforePerform",
+            "myJob",
+            specHelper.queue,
+            jobs.myJob,
+            [1, 2]
+          )
+        ).rejects.toThrow(TypeError);
+      });
+
+      test("it will not permit adding properties to nested args", async () => {
+        HooksPlugin.prototype.beforePerform = async function () {
+          this.args[0].a.b = true;
+          return true;
+        };
+
+        await expect(
+          RunPlugins(
+            worker,
+            "beforePerform",
+            "myJob",
+            specHelper.queue,
+            jobs.myJob,
+            [{ a: {} }]
+          )
+        ).rejects.toThrow(TypeError);
+      });
+    });
+
+    describe("afterPerform", () => {
+      test("it will not permit adding properties to args", async () => {
+        HooksPlugin.prototype.afterPerform = async function () {
+          this.args.push(3);
+          return true;
+        };
+
+        await expect(
+          RunPlugins(
+            worker,
+            "afterPerform",
+            "myJob",
+            specHelper.queue,
+            jobs.myJob,
+            [1, 2]
+          )
+        ).rejects.toThrow(TypeError);
+      });
+
+      test("it will not permit adding properties to nested args", async () => {
+        HooksPlugin.prototype.afterPerform = async function () {
+          this.args[0].a.b = true;
+          return true;
+        };
+
+        await expect(
+          RunPlugins(
+            worker,
+            "afterPerform",
+            "myJob",
+            specHelper.queue,
+            jobs.myJob,
+            [{ a: {} }]
+          )
+        ).rejects.toThrow(TypeError);
+      });
+    });
+  });
+});

__tests__/integration/functions.ts

@@ -0,0 +1,36 @@
+import { LockArgs, DeepMerge } from "../../src/utils/functions";
+
+describe("utility helpers", () => {
+  describe("LockArgs", () => {
+    test("should return an array", () => {
+      expect(LockArgs({ a: 1 })).toEqual([{ a: 1 }]);
+    });
+
+    test("should return a sealed array", () => {
+      const locked = LockArgs({ a: 1 });
+      expect(Object.isSealed(locked)).toEqual(true);
+    });
+
+    test("should seal nested property values", () => {
+      const locked = LockArgs({ a: [{ b: true }] });
+      expect(Object.isSealed(locked[0].a[0].b)).toEqual(true);
+    });
+  });
+
+  describe("DeepMerge", () => {
+    test("should override existing properties on target object", () => {
+      const target = [{ a: 1, b: 2 }];
+      const merge = [{ a: 8, c: 3 }];
+      expect(DeepMerge(target, merge)).toEqual([{ a: 8, b: 2, c: 3 }]);
+    });
+
+    test("should override existing nested properties on target object", () => {
+      const target = [{ a: [{ b: 1 }] }];
+      const merge = [{ a: [{ b: 2 }] }, "new property"];
+      expect(DeepMerge(target, merge)).toEqual([
+        { a: [{ b: 2 }] },
+        "new property",
+      ]);
+    });
+  });
+});

__tests__/plugins/queueLock.ts

@@ -7,10 +7,18 @@ class NeverRunPlugin extends Plugin {
     return true;
   }
 
+  async beforeDelayEnqueue() {
+    return true;
+  }
+
   async afterEnqueue() {
     return true;
   }
 
+  async afterDelayEnqueue() {
+    return true;
+  }
+
   async beforePerform() {
     return false;
   }

__tests__/utils/custom-plugin.ts

@@ -6,10 +6,18 @@ export class CustomPlugin extends Plugin {
     return false;
   }
 
+  async beforeDelayEnqueue() {
+    return false;
+  }
+
   async afterEnqueue() {
     return false;
   }
 
+  async afterDelayEnqueue() {
+    return false;
+  }
+
   async beforePerform() {
     return false;
   }
@@ -18,3 +26,29 @@ export class CustomPlugin extends Plugin {
     return false;
   }
 }
+
+export class HooksPlugin extends Plugin {
+  async beforeEnqueue() {
+    return true;
+  }
+
+  async beforeDelayEnqueue() {
+    return true;
+  }
+
+  async afterEnqueue() {
+    return true;
+  }
+
+  async afterDelayEnqueue() {
+    return true;
+  }
+
+  async beforePerform() {
+    return true;
+  }
+
+  async afterPerform() {
+    return true;
+  }
+}