No Implicit Any (#639)

* No Implicit Any

* tests passing

* check for run_at

* rename test

__tests__/core/connection.ts

@@ -1,4 +1,4 @@
-import * as Ioredis from "ioredis";
+import * as IORedis from "ioredis";
 import { Connection } from "../../src";
 import specHelper from "../utils/specHelper";
 
@@ -21,6 +21,7 @@ describe("connection", () => {
   test("it has loaded Lua commands", async () => {
     const connection = new Connection(specHelper.cleanConnectionDetails());
     await connection.connect();
+    //@ts-ignore
     expect(typeof connection.redis["popAndStoreJob"]).toBe("function");
     connection.end();
   });
@@ -33,10 +34,10 @@ describe("connection", () => {
       await connection.connect();
     });
 
-    let prefixedConnection;
-    let prefixedRedis;
+    let prefixedConnection: Connection;
+    let prefixedRedis: IORedis.Redis;
     beforeAll(async () => {
-      prefixedRedis = new Ioredis(null, null, {
+      prefixedRedis = new IORedis(null, null, {
         keyPrefix: "customNamespace:",
         db: db,
       });

__tests__/core/connectionError.ts

@@ -1,7 +1,7 @@
 import { Connection } from "../../src";
 import specHelper from "../utils/specHelper";
 
-describe("queue", () => {
+describe("connection error", () => {
   test("can provide an error if connection failed", async () => {
     await new Promise(async (resolve) => {
       const connectionDetails = {

__tests__/core/multiWorker.ts

@@ -7,7 +7,7 @@ const checkTimeout = specHelper.timeout / 10;
 const minTaskProcessors = 1;
 const maxTaskProcessors = 5;
 
-const blockingSleep = (naptime) => {
+const blockingSleep = (naptime: number) => {
   let sleeping = true;
   const now = new Date();
   let alarm;
@@ -23,7 +23,7 @@ const blockingSleep = (naptime) => {
 
 const jobs = {
   slowSleepJob: {
-    plugins: [],
+    plugins: [] as string[],
     pluginOptions: {},
     perform: async () => {
       await new Promise((resolve) => {
@@ -34,7 +34,7 @@ const jobs = {
     },
   },
   slowCPUJob: {
-    plugins: [],
+    plugins: [] as string[],
     pluginOptions: {},
     perform: async () => {
       blockingSleep(1000);

__tests__/core/queue.ts

@@ -1,4 +1,10 @@
-import { Queue, Worker } from "../../src";
+import {
+  ParsedJob,
+  ParsedFailedJobPayload,
+  Queue,
+  Worker,
+  Job,
+} from "../../src";
 import specHelper from "../utils/specHelper";
 let queue: Queue;
 
@@ -50,13 +56,13 @@ describe("queue", () => {
       );
       expect(String(score)).toBe("10");
 
-      let obj = await specHelper.redis.lpop(
+      const str = await specHelper.redis.lpop(
         specHelper.namespace + ":delayed:" + "10"
       );
-      expect(obj).toBeDefined();
-      obj = JSON.parse(obj);
-      expect(obj.class).toBe("someJob");
-      expect(obj.args).toEqual([1, 2, 3]);
+      expect(str).toBeDefined();
+      const job = JSON.parse(str) as ParsedJob;
+      expect(job.class).toBe("someJob");
+      expect(job.args).toEqual([1, 2, 3]);
     });
 
     test("can add delayed job whose timestamp is a string (enqueueAt)", async () => {
@@ -68,13 +74,13 @@ describe("queue", () => {
       );
       expect(String(score)).toBe("10");
 
-      let obj = await specHelper.redis.lpop(
+      let str = await specHelper.redis.lpop(
         specHelper.namespace + ":delayed:" + "10"
       );
-      expect(obj).toBeDefined();
-      obj = JSON.parse(obj);
-      expect(obj.class).toBe("someJob");
-      expect(obj.args).toEqual([1, 2, 3]);
+      expect(str).toBeDefined();
+      const job = JSON.parse(str) as ParsedJob;
+      expect(job.class).toBe("someJob");
+      expect(job.args).toEqual([1, 2, 3]);
     });
 
     test("will not enqueue a delayed job at the same time with matching params with error", async () => {
@@ -108,17 +114,17 @@ describe("queue", () => {
       await queue.enqueueIn(5 * 1000, specHelper.queue, "someJob", [1, 2, 3]);
       const score = await specHelper.redis.zscore(
         specHelper.namespace + ":delayed_queue_schedule",
-        now
+        now.toString()
       );
       expect(String(score)).toBe(String(now));
 
-      let obj = await specHelper.redis.lpop(
+      let str = await specHelper.redis.lpop(
         specHelper.namespace + ":delayed:" + now
       );
-      expect(obj).toBeDefined();
-      obj = JSON.parse(obj);
-      expect(obj.class).toBe("someJob");
-      expect(obj.args).toEqual([1, 2, 3]);
+      expect(str).toBeDefined();
+      const job = JSON.parse(str) as ParsedJob;
+      expect(job.class).toBe("someJob");
+      expect(job.args).toEqual([1, 2, 3]);
     });
 
     test("can add a delayed job whose time is a string (enqueueIn)", async () => {
@@ -128,17 +134,17 @@ describe("queue", () => {
       await queue.enqueueIn(time, specHelper.queue, "someJob", [1, 2, 3]);
       const score = await specHelper.redis.zscore(
         specHelper.namespace + ":delayed_queue_schedule",
-        now
+        now.toString()
       );
       expect(String(score)).toBe(String(now));
 
-      let obj = await specHelper.redis.lpop(
+      let str = await specHelper.redis.lpop(
         specHelper.namespace + ":delayed:" + now
       );
-      expect(obj).toBeDefined();
-      obj = JSON.parse(obj);
-      expect(obj.class).toBe("someJob");
-      expect(obj.args).toEqual([1, 2, 3]);
+      expect(str).toBeDefined();
+      const job = JSON.parse(str) as ParsedJob;
+      expect(job.class).toBe("someJob");
+      expect(job.args).toEqual([1, 2, 3]);
     });
 
     test("can get the number of jobs currently enqueued", async () => {
@@ -165,7 +171,7 @@ describe("queue", () => {
         [1, 2, 3]
       );
       expect(timestamps.length).toBe(1);
-      expect(timestamps[0]).toBe("10");
+      expect(timestamps[0]).toBe(10);
     });
 
     test("will not match previously scheduled jobs with differnt args", async () => {
@@ -367,7 +373,7 @@ describe("queue", () => {
 
     describe("failed job managment", () => {
       beforeEach(async () => {
-        const errorPayload = function (id) {
+        const errorPayload = function (id: number) {
           return JSON.stringify({
             worker: "busted-worker-" + id,
             queue: "busted-queue",
@@ -494,8 +500,8 @@ describe("queue", () => {
     });
 
     describe("worker status", () => {
-      let workerA;
-      let workerB;
+      let workerA: Worker;
+      let workerB: Worker;
       const timeout = 500;
 
       const jobs = {
@@ -505,7 +511,7 @@ describe("queue", () => {
               setTimeout(resolve, timeout);
             });
           },
-        },
+        } as Job<any>,
       };
 
       beforeEach(async () => {
@@ -599,10 +605,10 @@ describe("queue", () => {
             expect(cleanData.workerA.payload.class).toBe("slowJob");
             expect(cleanData.workerA.payload.args[0].a).toBe(1);
 
-            let failedData = await specHelper.redis.rpop(
+            let str = await specHelper.redis.rpop(
               specHelper.namespace + ":" + "failed"
             );
-            failedData = JSON.parse(failedData);
+            const failedData = JSON.parse(str) as ParsedFailedJobPayload;
             expect(failedData.queue).toBe(specHelper.queue);
             expect(failedData.exception).toBe(
               "Worker Timeout (killed manually)"

__tests__/core/scheduler.ts

@@ -1,4 +1,10 @@
-import { Queue, Scheduler, Worker } from "../../src";
+import {
+  Queue,
+  Scheduler,
+  Worker,
+  Job,
+  ParsedFailedJobPayload,
+} from "../../src";
 import specHelper from "../utils/specHelper";
 
 let scheduler: Scheduler;
@@ -118,7 +124,7 @@ describe("scheduler", () => {
       });
 
       describe("stuck workers", () => {
-        let worker;
+        let worker: Worker;
         const jobs = {
           stuck: {
             perform: async function () {
@@ -128,7 +134,7 @@ describe("scheduler", () => {
                 clearTimeout(this.pingTimer);
               });
             },
-          },
+          } as Job<any>,
         };
 
         beforeAll(async () => {
@@ -154,7 +160,7 @@ describe("scheduler", () => {
             await worker.start();
 
             const workers = await queue.allWorkingOn();
-            const h = {};
+            const h: { [key: string]: any } = {};
             h[worker.name] = "started";
             expect(workers).toEqual(h);
 
@@ -174,10 +180,10 @@ describe("scheduler", () => {
                 expect(await queue.allWorkingOn()).toEqual({});
 
                 // check the failed list
-                let failed = await specHelper.redis.rpop(
+                const str = await specHelper.redis.rpop(
                   specHelper.namespace + ":" + "failed"
                 );
-                failed = JSON.parse(failed);
+                const failed = JSON.parse(str) as ParsedFailedJobPayload;
                 expect(failed.queue).toBe("stuckJobs");
                 expect(failed.exception).toBe(
                   "Worker Timeout (killed manually)"

__tests__/core/worker.ts

@@ -1,39 +1,41 @@
-import { Queue, Worker } from "../../src";
+import { ParsedFailedJobPayload, Job, Queue, Worker } from "../../src";
 import specHelper from "../utils/specHelper";
 
-const jobs = {
+const jobs: { [key: string]: Job<any> } = {
   add: {
     perform: (a, b) => {
       return a + b;
     },
-  },
+  } as Job<any>,
+  //@ts-ignore
   badAdd: {
     perform: () => {
       throw new Error("Blue Smoke");
     },
-  },
+  } as Job<any>,
   messWithData: {
     perform: (a) => {
       a.data = "new thing";
       return a;
     },
-  },
+  } as Job<any>,
   async: {
     perform: async () => {
       await new Promise((resolve) => {
         setTimeout(resolve, 100);
       });
       return "yay";
     },
-  },
+  } as Job<any>,
   twoSeconds: {
     perform: async () => {
       await new Promise((resolve) => {
         setTimeout(resolve, 1000 * 2);
       });
       return "slow";
     },
-  },
+  } as Job<any>,
+  //@ts-ignore
   quickDefine: async () => {
     return "ok";
   },
@@ -268,10 +270,10 @@ describe("worker", () => {
         });
 
         test("will place failed jobs in the failed queue", async () => {
-          let data = await specHelper.redis.rpop(
+          let str = await specHelper.redis.rpop(
             specHelper.namespace + ":" + "failed"
           );
-          data = JSON.parse(data);
+          const data = JSON.parse(str) as ParsedFailedJobPayload;
           expect(data.queue).toBe(specHelper.queue);
           expect(data.exception).toBe("Error");
           expect(data.error).toBe('No job defined for class "somethingFake"');

__tests__/integration/ioredis-mock.ts

@@ -1,7 +1,10 @@
-import { Queue, Worker, Scheduler } from "../../src";
-import * as RedisMock from "ioredis-mock";
+import { Queue, Worker, Scheduler, Job } from "../../src";
 import specHelper from "../utils/specHelper";
 
+// import * as RedisMock from "ioredis-mock"; // TYPE HACK!
+import * as IORedis from "ioredis";
+const RedisMock: typeof IORedis = require("ioredis-mock");
+
 // for ioredis-mock, we need to re-use a shared connection
 // setting "pkg" is important!
 const REDIS = new RedisMock();
@@ -13,7 +16,7 @@ const jobs = {
       const response = a + b;
       return response;
     },
-  },
+  } as Job<any>,
 };
 
 describe("testing with ioredis-mock package", () => {
@@ -28,18 +31,12 @@ describe("testing with ioredis-mock package", () => {
   });
 
   test("a queue can be created", async () => {
-    queue = new Queue(
-      { connection: connectionDetails, queues: ["math"] },
-      jobs
-    );
+    queue = new Queue({ connection: connectionDetails }, jobs);
     await queue.connect();
   });
 
   test("a scheduler can be created", async () => {
-    scheduler = new Scheduler(
-      { connection: connectionDetails, queues: ["math"] },
-      jobs
-    );
+    scheduler = new Scheduler({ connection: connectionDetails }, jobs);
     await scheduler.connect();
     // await scheduler.start();
   });