0z2i6v3u5t 1.0.0

package/__tests__/integration/browser.ts

@@ -0,0 +1,133 @@
+import * as path from "path";
+import * as fs from "fs";
+import * as Puppeteer from "puppeteer";
+import { api, Process, config, utils } from "../../src/index";
+import { PackageJson } from "type-fest";
+
+const packageJSON: PackageJson = JSON.parse(
+  fs.readFileSync(path.join(__dirname, "..", "..", "package.json")).toString(),
+);
+
+let browser: Puppeteer.Browser;
+let page: Puppeteer.Page;
+let url: string;
+
+describe("browser integration tests", () => {
+  let actionhero: Process;
+
+  beforeAll(async () => {
+    actionhero = new Process();
+    await actionhero.start();
+    await api.redis.clients.client.flushdb();
+    browser = await Puppeteer.launch({
+      headless: "new",
+      args: ["--no-sandbox"],
+    });
+    page = await browser.newPage();
+  });
+
+  afterAll(async () => {
+    await browser.close();
+    await actionhero.stop();
+  });
+
+  describe("default index page", () => {
+    beforeAll(() => {
+      url = `http://localhost:${config.web!.port}`;
+    });
+
+    test("loads the page", async () => {
+      await page.goto(url);
+      await utils.sleep(1000);
+      const title = await page.$eval("h1", (e) => e.textContent);
+      expect(title).toEqual("Your Actionhero Server is working.");
+    });
+
+    test("server status is loaded", async () => {
+      await page.goto(url);
+      await page.waitForSelector("#serverName");
+      const serverName = await page.$eval("#serverName", (e) => e.textContent);
+      expect(serverName).toEqual("actionhero");
+
+      const actionheroVersion = await page.$eval(
+        "#actionheroVersion",
+        (e) => e.textContent,
+      );
+      expect(actionheroVersion).toEqual(packageJSON.version);
+    });
+  });
+
+  describe("swagger page", () => {
+    beforeAll(() => {
+      url = `http://localhost:${config.web!.port}/swagger.html`;
+    });
+
+    test("loads the page", async () => {
+      await page.goto(url);
+      await page.waitForSelector("h2");
+      const title = await page.$eval("h2", (e) => e.textContent);
+      expect(title).toMatch(/^actionhero/);
+    });
+
+    test("documentation is loaded", async () => {
+      await page.goto(url);
+      await page.waitForSelector("h3");
+      const actionNames = await page.$$eval("h3", (elements) =>
+        elements.map((e) => e.textContent),
+      );
+      expect(actionNames.sort()).toEqual([
+        "createChatRoom",
+        "status",
+        "swagger",
+      ]);
+    });
+  });
+
+  describe("chat test page", () => {
+    let sessionIDCookie: Puppeteer.Protocol.Network.Cookie;
+
+    test("I can be assigned a session on another page", async () => {
+      sessionIDCookie = (await page.cookies()).filter(
+        (c) => c.name === "sessionID",
+      )[0];
+      expect(sessionIDCookie.value).toBeTruthy();
+    });
+
+    describe("on the chat page", () => {
+      beforeAll(() => {
+        url = `http://localhost:${config.web!.port}/chat.html`;
+      });
+
+      test("can connect", async () => {
+        await page.goto(url);
+        await utils.sleep(2000);
+        const chat = await page.$eval("#chatBox", (e) => e.textContent);
+        expect(chat).toContain("Welcome to the actionhero api");
+      });
+
+      test("can chat", async () => {
+        const chatForm = await page.$("#message");
+        await chatForm!.type("hello world");
+        const chatSubmit = await page.$("#submitButton");
+        await chatSubmit!.click();
+
+        await utils.sleep(1000);
+
+        const chat = await page.$eval("#chatBox", (e) => e.textContent);
+        expect(chat).toContain("hello world");
+      });
+
+      test("has the same fingerprint", async () => {
+        const thisSessionID = (await page.cookies()).filter(
+          (c) => c.name === "sessionID",
+        )[0];
+        expect(thisSessionID.value).toEqual(sessionIDCookie.value);
+        const fingerprintFromWebSocket = await page.$eval(
+          "#fingerprint",
+          (e) => e.textContent,
+        );
+        expect(fingerprintFromWebSocket).toEqual(sessionIDCookie.value);
+      });
+    });
+  });
+});

package/__tests__/integration/ioredis-mock.ts

@@ -0,0 +1,194 @@
+const MockIORedis = require("ioredis-mock");
+
+import {
+  api,
+  cache,
+  chatRoom,
+  Process,
+  specHelper,
+  utils,
+  Task,
+  task,
+} from "./../../src/index";
+
+jest.mock("./../../src/config/redis.ts", () => ({
+  __esModule: true,
+  test: {
+    redis: () => {
+      const konstructor = MockIORedis;
+      const args = [{ port: 123, database: 1 }];
+      return {
+        _toExpand: false,
+        scanCount: 1000,
+        client: {
+          konstructor,
+          buildNew: true,
+          args,
+        },
+        subscriber: {
+          konstructor,
+          buildNew: true,
+          args,
+        },
+        tasks: {
+          konstructor,
+          buildNew: true,
+          args,
+        },
+      };
+    },
+  },
+}));
+
+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: {},
+        },
+      };
+    },
+  },
+}));
+
+const actionhero = new Process();
+
+describe("with ioredis-mock", () => {
+  beforeAll(async () => {
+    process.env.AUTOMATIC_ROUTES = "get";
+    await actionhero.start();
+  });
+
+  afterAll(async () => await actionhero.stop());
+
+  test("basic redis operations work and data is shared between the connections", async () => {
+    await api.redis.clients.client.set("__test", "abc");
+    expect(await api.redis.clients.client.get("__test")).toBe("abc");
+    expect(await api.redis.clients.tasks.get("__test")).toBe("abc");
+  });
+
+  test("redis pub-sub works between connections", async () => {
+    let message: string;
+    api.redis.clients.subscriber.subscribe("test-channel");
+    const subscription = api.redis.clients.subscriber.on(
+      "message",
+      (channel, m) => {
+        if (channel === "test-channel") message = m;
+      },
+    );
+
+    await api.redis.clients.client.publish("test-channel", "hello");
+    await utils.sleep(10);
+
+    //@ts-ignore
+    expect(message).toBe("hello");
+
+    api.redis.clients.subscriber.unsubscribe("test-channel");
+  });
+
+  test("chat works", async () => {
+    try {
+      await chatRoom.add("defaultRoom");
+    } catch {}
+
+    const client1 = await specHelper.buildConnection();
+    const client2 = await specHelper.buildConnection();
+    client1.verbs("roomAdd", "defaultRoom");
+    client2.verbs("roomAdd", "defaultRoom");
+
+    await utils.sleep(10);
+    await client1.verbs("say", ["defaultRoom", "Hi"]);
+    await utils.sleep(10);
+
+    if (!client2.messages) throw new Error("client2 has no messages");
+    const { message, room, from } =
+      client2.messages[client2.messages.length - 1];
+
+    expect(message).toEqual("Hi");
+    expect(room).toEqual("defaultRoom");
+    expect(from).toEqual(client1.id);
+  });
+
+  test("cache works", async () => {
+    await cache.save("testKey", { test: "value" });
+    const { key, value } = await cache.load("testKey");
+    expect(key).toBe("testKey");
+    expect(value).toEqual({ test: "value" });
+  });
+
+  describe("tasks", () => {
+    let taskOutput: string[] = [];
+
+    beforeAll(async () => {
+      class RegularTask extends Task {
+        constructor() {
+          super();
+          this.name = "regular";
+          this.description = "task: regular";
+          this.queue = "testQueue";
+          this.frequency = 0;
+        }
+
+        async run(params: { word: string }) {
+          taskOutput.push(params.word);
+          return params.word;
+        }
+      }
+
+      api.tasks.tasks.regularTask = new RegularTask();
+      api.tasks.jobs.regularTask = api.tasks.jobWrapper("regularTask");
+    });
+
+    beforeEach(() => {
+      taskOutput = [];
+    });
+
+    afterAll(async () => {
+      delete api.tasks.tasks.regularTask;
+      delete api.tasks.jobs.regularTask;
+    });
+
+    test("tasks work inline (quick)", async () => {
+      const response = await specHelper.runTask("regularTask", {
+        word: "test",
+      });
+      expect(response).toBe("test");
+      expect(taskOutput).toEqual(["test"]);
+    });
+
+    test("tasks work inline (full)", async () => {
+      const response = await specHelper.runFullTask("regularTask", {
+        word: "test",
+      });
+      expect(response).toBe("test");
+      expect(taskOutput).toEqual(["test"]);
+    });
+
+    test("workers and scheduler work", async () => {
+      await task.enqueueIn(1, "regularTask", { word: "test-full" });
+
+      const jobs = await task.allDelayed();
+      const times = Object.keys(jobs);
+      expect(jobs[times[0]][0]).toEqual({
+        args: [{ word: "test-full" }],
+        class: "regularTask",
+        queue: "testQueue",
+      });
+
+      await utils.sleep(1500);
+      expect(taskOutput).toEqual(["test-full"]);
+    }, 10000);
+  });
+});

package/__tests__/integration/sendBuffer.ts

@@ -0,0 +1,97 @@
+process.env.AUTOMATIC_ROUTES = "get";
+
+import axios from "axios";
+import * as stream from "stream";
+import { api, Process, config } from "./../../src/index";
+
+const actionhero = new Process();
+let url: string;
+
+describe("Server: sendBuffer", () => {
+  beforeAll(async () => {
+    await actionhero.start();
+    url = "http://localhost:" + config.web!.port;
+  });
+
+  afterAll(async () => await actionhero.stop());
+
+  beforeAll(() => {
+    api.actions.versions.sendBufferTest = [1];
+    api.actions.actions.sendBufferTest = {
+      // @ts-ignore
+      1: {
+        name: "sendBufferTest",
+        description: "sendBufferTest",
+        version: 1,
+        run: async (data) => {
+          const buffer = "Example of data buffer";
+          const bufferStream = new stream.PassThrough();
+          data.connection!.rawConnection.responseHeaders.push([
+            "Content-Disposition",
+            "attachment; filename=test.csv",
+          ]);
+          api.servers.servers.web.sendFile(
+            data.connection!,
+            // @ts-ignore
+            null,
+            bufferStream,
+            "text/csv",
+            buffer.length,
+            new Date(),
+          );
+          data.toRender = false;
+          bufferStream.end(buffer);
+        },
+      },
+    };
+
+    api.actions.versions.sendUnknownLengthBufferTest = [1];
+    api.actions.actions.sendUnknownLengthBufferTest = {
+      // @ts-ignore
+      1: {
+        name: "sendUnknownLengthBufferTest",
+        description: "sendUnknownLengthBufferTest",
+        version: 1,
+        run: async (data) => {
+          const bufferStream = new stream.PassThrough();
+          api.servers.servers.web.sendFile(
+            data.connection!,
+            // @ts-ignore
+            null,
+            bufferStream,
+            "text/plain",
+            null,
+            new Date(),
+          );
+          const buffer = "Example of unknown length data buffer";
+          data.toRender = false;
+          bufferStream.end(buffer);
+        },
+      },
+    };
+
+    api.routes.loadRoutes();
+  });
+
+  afterAll(() => {
+    delete api.actions.actions.sendBufferTest;
+    delete api.actions.versions.sendBufferTest;
+    delete api.actions.versions.sendUnknownLengthBufferTest;
+    delete api.actions.versions.sendUnknownLengthBufferTest;
+    api.routes.loadRoutes();
+  });
+
+  test("Server should sendBuffer", async () => {
+    const response = await axios.get(url + "/api/sendBufferTest");
+    expect(response.data).toEqual("Example of data buffer");
+  });
+
+  test("Server should send a stream with no specified length", async () => {
+    const { data, headers } = await axios.get(
+      url + "/api/sendUnknownLengthBufferTest",
+    );
+
+    expect(headers).not.toHaveProperty("content-length");
+    expect(data).toEqual("Example of unknown length data buffer");
+  });
+});

package/__tests__/integration/sendFile.ts

@@ -0,0 +1,24 @@
+process.env.AUTOMATIC_ROUTES = "get";
+
+import axios from "axios";
+import * as fs from "fs";
+import { Process, config } from "./../../src/index";
+
+const actionhero = new Process();
+let url: string;
+
+describe("Server: sendFile", () => {
+  beforeAll(async () => {
+    await actionhero.start();
+    url = "http://localhost:" + config.web!.port;
+  });
+
+  afterAll(async () => await actionhero.stop());
+
+  test("Server should sendFile", async () => {
+    const stats = fs.statSync(__dirname + "/../../public/logo/actionhero.png");
+    const response = await axios.get(url + "/api/sendFile");
+    expect(stats.size).toBeGreaterThanOrEqual(response.data.length);
+    expect(response.data).toContain("PNG");
+  });
+});

package/__tests__/integration/sharedFingerprint.ts

@@ -0,0 +1,82 @@
+const window = { location: {} };
+
+process.env.AUTOMATIC_ROUTES = "get";
+
+import * as _Primus from "primus";
+import axios from "axios";
+import { api, Process, config } from "./../../src/index";
+
+const actionhero = new Process();
+let ActionheroWebsocketClient: any;
+let fingerprint: string;
+let url: string;
+
+const connectClient = async (query = ""): Promise<any> => {
+  const S = _Primus.createSocket(undefined);
+  const clientSocket = new S(`http://localhost:${config.web!.port}?${query}`);
+
+  let client = new ActionheroWebsocketClient({}, clientSocket); // eslint-disable-line
+  const connectResponse = await new Promise((resolve, reject) => {
+    client.connect(
+      (error: NodeJS.ErrnoException, connectResponse: Record<string, any>) => {
+        if (error) {
+          return reject(error);
+        }
+        resolve(connectResponse);
+      },
+    );
+  });
+
+  return { client, connectResponse };
+};
+
+describe("Integration: Web Server + Websocket Socket shared fingerprint", () => {
+  beforeAll(async () => {
+    await actionhero.start();
+    await api.redis.clients.client.flushdb();
+    url = "http://localhost:" + config.web!.port;
+    ActionheroWebsocketClient = eval(
+      // @ts-ignore
+      api.servers.servers.websocket.compileActionheroWebsocketClientJS(),
+    ); // eslint-disable-line
+  });
+
+  afterAll(async () => await actionhero.stop());
+
+  test("should exist when web server been called", async () => {
+    const response = await axios.get(url + "/api/randomNumber");
+    fingerprint = response.data.requesterInformation.fingerprint;
+    const query = `${
+      (config.web!.fingerprintOptions as Record<string, any>).cookieKey
+    }=${fingerprint}`;
+    const { client, connectResponse } = await connectClient(query);
+    expect(connectResponse.status).toEqual("OK");
+    expect(connectResponse.data.id).toBeTruthy();
+    const id = connectResponse.data.id;
+    expect(api.connections.connections[id].fingerprint).toEqual(fingerprint);
+    client.disconnect();
+  });
+
+  test("should not exist when web server has not been called", async () => {
+    const { client, connectResponse } = await connectClient();
+    expect(connectResponse.status).toEqual("OK");
+    expect(connectResponse.data.id).toBeTruthy();
+    const id = connectResponse.data.id;
+    expect(api.connections.connections[id].fingerprint).not.toEqual(
+      fingerprint,
+    );
+    client.disconnect();
+  });
+
+  test("should exist as long as cookie is passed", async () => {
+    const query = `${
+      (config.web!.fingerprintOptions as Record<string, any>).cookieKey
+    }=dummyValue`;
+    const { client, connectResponse } = await connectClient(query);
+    expect(connectResponse.status).toEqual("OK");
+    expect(connectResponse.data.id).toBeTruthy();
+    const id = connectResponse.data.id;
+    expect(api.connections.connections[id].fingerprint).toEqual("dummyValue");
+    client.disconnect();
+  });
+});

package/__tests__/integration/taskFlow.ts

@@ -0,0 +1,110 @@
+jest.mock("./../../src/config/tasks.ts", () => ({
+  __esModule: true,
+  test: {
+    tasks: () => {
+      return {
+        _toExpand: false,
+        scheduler: true,
+        queues: ["*"],
+        workerLogging: {
+          failure: "error", // task failure
+          success: "info", // task success
+          start: "info",
+          end: "info",
+          cleaning_worker: "info",
+          poll: "debug",
+          job: "debug",
+          pause: "debug",
+          internalError: "error",
+          multiWorkerAction: "debug",
+        },
+        schedulerLogging: {
+          start: "info",
+          end: "info",
+          poll: "debug",
+          enqueue: "debug",
+          reEnqueue: "debug",
+          working_timestamp: "debug",
+          transferred_job: "debug",
+        },
+        timeout: 500,
+        minTaskProcessors: 1,
+        maxTaskProcessors: 1,
+        checkTimeout: 500,
+        maxEventLoopDelay: 5,
+        stuckWorkerTimeout: 1000 * 60 * 60,
+        resque_overrides: {},
+        connectionOptions: {
+          tasks: {},
+        },
+      };
+    },
+  },
+}));
+
+import * as path from "path";
+import * as fs from "fs";
+import { api, Process, utils } from "../../src";
+
+const testTaskPath = path.join(__dirname, "./../../src/tasks/test-task.ts");
+fs.writeFileSync(
+  testTaskPath,
+  `
+import {Task} from './../index'
+
+export default class MyTask extends Task {
+  constructor() {
+    super();
+    this.name = "test-task";
+    this.description = "a test";
+    this.frequency = 1;
+    this.queue = "default";
+    this.middleware = [];
+  }
+
+  async run() {
+    process.env.DID_TASK_RUN = "yes";
+  }
+}
+`,
+);
+
+describe("task integration tests", () => {
+  beforeAll(() => {
+    process.env.DID_TASK_RUN = "no";
+  });
+
+  test("the variable started as no", () => {
+    expect(process.env.DID_TASK_RUN).toBe("no");
+  });
+
+  describe("with a running server", () => {
+    let actionhero: Process;
+
+    beforeAll(async () => {
+      actionhero = new Process();
+      await actionhero.start();
+      await api.redis.clients.client.set("resque:stat:processed", 0);
+    });
+
+    afterAll(async () => {
+      await actionhero.stop();
+      fs.unlinkSync(testTaskPath);
+    });
+
+    test("the periodic task should have started", async () => {
+      const getCount = async () => {
+        const resp = await api.redis.clients.client.get(
+          "resque:stat:processed",
+        );
+        if (!resp) throw new Error("no response from redis");
+        return parseInt(resp);
+      };
+
+      while ((await getCount()) < 1) await utils.sleep(100);
+
+      expect(await getCount()).toBeGreaterThan(0);
+      expect(process.env.DID_TASK_RUN).toBe("yes");
+    });
+  });
+});

package/__tests__/jest.ts

@@ -0,0 +1,5 @@
+describe("jest", () => {
+  test("should automatically set NODE_ENV to test", () => {
+    expect(process.env.NODE_ENV).toBe("test");
+  });
+});