convert tests to typescript

bin/faktory-work

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 
-const faktory = require('../');
-const program = require('../lib/cli');
+const faktory = require("../lib/faktory");
+console.log(faktory);
+process.exit(0);
+const program = require("../lib/cli");
 
 faktory.work(program).catch((error) => {
   console.error(error);

package.json

@@ -8,9 +8,11 @@
   "scripts": {
     "watch": "tsc -w",
     "build": "tsc",
-    "test": "nyc --cache ava --serial",
+    "clean": "rm -rf lib/*",
+    "test": "nyc --cache ava src/__tests__/*",
+    "test:watch": "npm run test -- -w",
     "coverage": "nyc report --reporter=html",
-    "lint": "eslint lib",
+    "lint": "eslint src",
     "htmldocs": "jsdoc . lib -d docs --readme README.md --pedantic",
     "docs": "jsdoc2md --files lib/*.js --template docs/template.hbs > docs/api.md",
     "preversion": "npm run lint && npm run test && npm run docs",
@@ -36,14 +38,22 @@
   },
   "ava": {
     "verbose": true,
-    "timeout": "5s"
+    "serial": true,
+    "timeout": "5s",
+    "typescript": {
+      "rewritePaths": {
+        "src/": "lib/"
+      }
+    }
   },
   "engines": {
     "node": ">=7"
   },
   "devDependencies": {
+    "@ava/typescript": "^1.1.1",
     "@types/node": "^14.0.11",
-    "ava": "^0.25.0",
+    "@types/uuid": "^8.0.0",
+    "ava": "^3.8.2",
     "coveralls": "3.1.0",
     "eslint": "^4.10",
     "eslint-config-airbnb-base": "13.2.0",

src/__tests__/_helper.ts

@@ -0,0 +1,125 @@
+import { TestInterface } from 'ava';
+import { Socket, createServer, Server } from 'net';
+const uuid = require('uuid/v4');
+import getPort from 'get-port';
+import Client from '../client';
+import { JobPayload, PartialJobPayload } from "../job";
+import { Command } from "../connection";
+
+export type ServerControl = {
+  socket: Socket;
+  command?: string;
+  data?: string;
+};
+
+export const mockServer = () => {
+  const server = createServer();
+
+  server.on("connection", (socket) => {
+    server
+      .once("HELLO", ({ socket }: ServerControl) => socket.write("+OK\r\n"))
+      .on("END", ({ socket }: ServerControl) => socket.destroy());
+
+    socket.on("data", (chunk) => {
+      const string = chunk.toString();
+      const [command] = string.replace(/\r\n$/, "").split(" ", 1);
+      const rawData = string.replace(`${command} `, "");
+      let data = rawData;
+      try {
+        data = JSON.parse(rawData);
+      } catch (_) {}
+      server.emit(command, <ServerControl>{ command, data, socket });
+      server.emit("*", <ServerControl>{ command, data, socket });
+    });
+
+    socket.write('+HI {"v":2,"s":"abc","i":3}\r\n');
+    server.emit("HI");
+  });
+  return server;
+};
+
+export const mocked = async (fn: (server: Server, port: number) => any | void) => {
+  const server = mockServer();
+  const port = await getPort();
+  server.listen(port, "127.0.0.1");
+  try {
+    return fn(server, port);
+  } finally {
+    await new Promise((resolve) => server.close(() => resolve()));
+  }
+};
+
+mocked.ok = () => ({ socket }: ServerControl) => {
+  socket.write("+OK\r\n");
+};
+
+mocked.fail = mocked.ok;
+
+mocked.beat = (state?: string) => ({ socket }: ServerControl) => {
+  if (!state) {
+    socket.write("+OK\r\n");
+  } else {
+    const json = JSON.stringify({ state });
+    socket.write(`$${json.length}\r\n${json}\r\n`);
+  }
+};
+mocked.fetch = (job: JobPayload | null) => ({ socket }: ServerControl) => {
+  if (job) {
+    const string = JSON.stringify(job);
+    socket.write(`$${string.length}\r\n${string}\r\n`);
+  } else {
+    socket.write("$-1\r\n");
+  }
+};
+
+mocked.info = () => ({ socket }: ServerControl) => {
+  const json = JSON.stringify({
+    queues: [],
+    faktory: {},
+    server_utc_time: Date.now(),
+  });
+  socket.write(`$${json.length}\r\n${json}\r\n`);
+};
+
+export const sleep = (ms: number, value: any = true) => {
+  return new Promise((resolve) => setTimeout(() => resolve(value), ms));
+};
+
+export const randQueue = (label: string = "test") => {
+  return `${label}-${uuid().slice(0, 6)}`;
+};
+
+export const createJob = (...args: any[]): PartialJobPayload => {
+  return {
+    jobtype: "testJob",
+    queue: randQueue(),
+    args,
+  };
+};
+
+export const push = async (
+  { args, queue, jobtype }: { args?: any[], queue?: string, jobtype?: string } = {}
+) => {
+  const client = new Client();
+
+  const job = client.job(jobtype || "test");
+  job.queue = queue || randQueue();
+  job.args = args || [];
+
+  await job.push();
+
+  client.close();
+
+  return job;
+};
+
+export const flush = () => new Client().flush();
+
+export function registerCleaner(test: TestInterface) {
+  test.beforeEach(async () => {
+    await flush();
+  });
+  test.afterEach.always(async () => {
+    await flush();
+  });
+}