0z2i6v3u5t 1.0.0

package/__tests__/core/process.ts

@@ -0,0 +1,42 @@
+import { Process, api } from "./../../src";
+
+const actionhero = new Process();
+
+describe("Core", () => {
+  describe("Process", () => {
+    test("a new process can be created", () => {
+      expect(actionhero.initialized).toBe(false);
+      expect(actionhero.started).toBe(false);
+      expect(actionhero.stopped).toBe(false);
+    });
+
+    test("a new process can be initialized", async () => {
+      await actionhero.initialize();
+      expect(actionhero.initialized).toBe(true);
+      expect(actionhero.started).toBe(false);
+      expect(actionhero.stopped).toBe(false);
+    });
+
+    test("a new process can be started", async () => {
+      await actionhero.start();
+      expect(actionhero.initialized).toBe(true);
+      expect(actionhero.started).toBe(true);
+      expect(actionhero.stopped).toBe(false);
+    });
+
+    test("a new process can be stopped", async () => {
+      await actionhero.stop("some reason");
+      expect(actionhero.stopReasons).toEqual(["some reason"]);
+      expect(actionhero.initialized).toBe(false);
+      expect(actionhero.started).toBe(false);
+      expect(actionhero.stopped).toBe(true);
+    });
+
+    test("the process is injected into the global API import", () => {
+      //@ts-ignore
+      actionhero["testProperty"] = { a: 1 };
+      //@ts-ignore
+      expect(api.process["testProperty"]).toEqual({ a: 1 });
+    });
+  });
+});

package/__tests__/core/specHelper.ts

@@ -0,0 +1,330 @@
+import { api, Connection, Process, specHelper, task } from "./../../src";
+import { RandomNumber } from "../../src/actions/randomNumber";
+import { SleepTest } from "../../src/actions/sleepTest";
+
+const actionhero = new Process();
+
+describe("Core: specHelper", () => {
+  beforeAll(async () => await actionhero.start());
+  afterAll(async () => await actionhero.stop());
+
+  test("can make a request with just params", async () => {
+    const { randomNumber } =
+      await specHelper.runAction<RandomNumber>("randomNumber");
+    expect(randomNumber).toBeGreaterThanOrEqual(0);
+    expect(randomNumber).toBeLessThan(1);
+  });
+
+  test("will stack up messages received", async () => {
+    const connection = await specHelper.buildConnection();
+    connection.params.thing = "stuff";
+    const { error } = await specHelper.runAction("x", connection);
+    if (!connection.messages) throw new Error("no connection.messages");
+    expect(connection.messages).toHaveLength(2);
+    expect(connection.messages[0].welcome).toEqual(
+      "Welcome to the actionhero api",
+    );
+    expect(connection.messages[1].error).toEqual(
+      "Error: unknown action or invalid apiVersion",
+    );
+    expect(error).toEqual("Error: unknown action or invalid apiVersion");
+  });
+
+  describe("metadata, type-safety, and errors", () => {
+    beforeAll(() => {
+      api.actions.versions.stringResponseTestAction = [1];
+      api.actions.actions.stringResponseTestAction = {
+        //@ts-ignore
+        1: {
+          name: "stringResponseTestAction",
+          description: "stringResponseTestAction",
+          version: 1,
+          run: async (data) => {
+            //@ts-ignore
+            data.response = "something response";
+          },
+        },
+      };
+
+      api.actions.versions.stringErrorTestAction = [1];
+      api.actions.actions.stringErrorTestAction = {
+        //@ts-ignore
+        1: {
+          name: "stringErrorTestAction",
+          description: "stringErrorTestAction",
+          version: 1,
+          run: (data) => {
+            //@ts-ignore
+            data.response = "something response";
+            throw new Error("some error");
+          },
+        },
+      };
+
+      api.actions.versions.arrayResponseTestAction = [1];
+      api.actions.actions.arrayResponseTestAction = {
+        //@ts-ignore
+        1: {
+          name: "arrayResponseTestAction",
+          description: "arrayResponseTestAction",
+          version: 1,
+          run: async (data) => {
+            data.response = [1, 2, 3];
+          },
+        },
+      };
+
+      api.actions.versions.arrayErrorTestAction = [1];
+      api.actions.actions.arrayErrorTestAction = {
+        //@ts-ignore
+        1: {
+          name: "arrayErrorTestAction",
+          description: "arrayErrorTestAction",
+          version: 1,
+          run: (data) => {
+            data.response = [1, 2, 3];
+            throw new Error("some error");
+          },
+        },
+      };
+    });
+
+    afterAll(() => {
+      delete api.actions.actions.stringResponseTestAction;
+      delete api.actions.versions.stringResponseTestAction;
+      delete api.actions.actions.stringErrorTestAction;
+      delete api.actions.versions.stringErrorTestAction;
+      delete api.actions.actions.arrayResponseTestAction;
+      delete api.actions.versions.arrayResponseTestAction;
+      delete api.actions.actions.arrayErrorTestAction;
+      delete api.actions.versions.arrayErrorTestAction;
+    });
+
+    describe("happy-path", () => {
+      test("if the response payload is an object, it appends metadata", async () => {
+        const response =
+          await specHelper.runAction<RandomNumber>("randomNumber");
+        expect(response.error).toBeUndefined();
+        expect(response.randomNumber).toBeTruthy();
+        expect(response.messageId).toBeTruthy();
+        expect(response.serverInformation!.serverName).toEqual("actionhero");
+        expect(response.requesterInformation!.remoteIP).toEqual("testServer");
+      });
+
+      test("if the response payload is a string, it maintains type", async () => {
+        const response = await specHelper.runAction("stringResponseTestAction");
+        expect(response).toEqual("something response");
+        expect(response.error).toBeUndefined();
+        expect(response.messageId).toBeUndefined();
+        expect(response.serverInformation).toBeUndefined();
+        expect(response.requesterInformation).toBeUndefined();
+      });
+
+      test("if the response payload is a array, it maintains type", async () => {
+        const response = await specHelper.runAction("arrayResponseTestAction");
+        expect(response).toEqual([1, 2, 3]);
+        expect(response.error).toBeUndefined();
+        expect(response.messageId).toBeUndefined();
+        expect(response.serverInformation).toBeUndefined();
+        expect(response.requesterInformation).toBeUndefined();
+      });
+    });
+
+    describe("disabling metadata", () => {
+      beforeAll(() => {
+        api.specHelper.returnMetadata = false;
+      });
+      afterAll(() => {
+        api.specHelper.returnMetadata = true;
+      });
+
+      test("if the response payload is an object, it should not append metadata", async () => {
+        const response =
+          await specHelper.runAction<RandomNumber>("randomNumber");
+        expect(response.error).toBeUndefined();
+        expect(response.randomNumber).toBeTruthy();
+        expect(response.messageId).toBeUndefined();
+        expect(response.serverInformation).toBeUndefined();
+        expect(response.requesterInformation).toBeUndefined();
+      });
+    });
+
+    describe("errors", () => {
+      test("if the response payload is an object and there is an error, it appends metadata", async () => {
+        const response = await specHelper.runAction("x");
+        expect(response.error).toEqual(
+          "Error: unknown action or invalid apiVersion",
+        );
+        expect(response.messageId).toBeTruthy();
+        expect(response.serverInformation!.serverName).toEqual("actionhero");
+        expect(response.requesterInformation!.remoteIP).toEqual("testServer");
+      });
+
+      test("if the response payload is a string, just the error will be returned", async () => {
+        const response = await specHelper.runAction("stringErrorTestAction");
+        expect(response).toEqual("Error: some error");
+        expect(response.messageId).toBeUndefined();
+        expect(response.serverInformation).toBeUndefined();
+        expect(response.requesterInformation).toBeUndefined();
+      });
+
+      test("if the response payload is a array, just the error will be returned", async () => {
+        const response = await specHelper.runAction("arrayErrorTestAction");
+        expect(response).toEqual("Error: some error");
+        expect(response.messageId).toBeUndefined();
+        expect(response.serverInformation).toBeUndefined();
+        expect(response.requesterInformation).toBeUndefined();
+      });
+    });
+  });
+
+  describe("test responses", () => {
+    test("will not report a broken test as a broken action (sync)", async () => {
+      const response = await specHelper.runAction<RandomNumber>("randomNumber");
+      try {
+        //@ts-ignore
+        response.not.a.real.thing();
+        throw new Error("should not get here");
+      } catch (e) {
+        expect(String(e)).toContain("TypeError: Cannot read");
+      }
+    });
+
+    test("will not report a broken test as a broken action (async)", async () => {
+      const response = await specHelper.runAction<SleepTest>("sleepTest");
+      try {
+        //@ts-ignore
+        response.not.a.real.thing();
+        throw new Error("should not get here");
+      } catch (e) {
+        expect(String(e)).toContain("TypeError: Cannot read");
+      }
+    });
+
+    test("messageId can be configurable", async () => {
+      const response = await specHelper.runAction("randomNumber", {
+        messageId: "aaa",
+      });
+      expect(response.messageId).toEqual("aaa");
+    });
+  });
+
+  describe("files", () => {
+    test("can request file data", async () => {
+      const data = await specHelper.getStaticFile("simple.html");
+      expect(data.error).toBeUndefined();
+      expect(data.content).toContain("<h1>Actionhero</h1>");
+      expect(data.mime).toEqual("text/html");
+      expect(data.length).toEqual(101);
+    });
+
+    test("missing files", async () => {
+      const data = await specHelper.getStaticFile("missing.html");
+      expect(data.error).toEqual("that file is not found");
+      expect(data.mime).toEqual("text/html");
+      expect(data.content).toBeNull();
+    });
+  });
+
+  describe("persistent test connections", () => {
+    let connection: Connection;
+    let connId: string;
+    const messageIds: string[] = [];
+
+    test("can make a request with a specified connection", async () => {
+      connection = await specHelper.buildConnection();
+      connection.params = {
+        key: "someKey",
+        value: "someValue",
+      };
+
+      connId = connection.id;
+
+      const response = await specHelper.runAction("cacheTest", connection);
+      messageIds.push(response.messageId!);
+      expect(connection.messages).toHaveLength(2);
+      expect(connId).toEqual(connection.id);
+      expect(connection.fingerprint).toEqual(connId);
+    });
+
+    test("can make second request", async () => {
+      const response = await specHelper.runAction("randomNumber", connection);
+      messageIds.push(response.messageId!);
+      expect(connection.messages).toHaveLength(3);
+      expect(connId).toEqual(connection.id);
+      expect(connection.fingerprint).toEqual(connId);
+    });
+
+    test("will generate new ids and fingerprints for a new connection", async () => {
+      const response = await specHelper.runAction("randomNumber");
+      messageIds.push(response.messageId!);
+      expect(response.requesterInformation!.id).not.toEqual(connId);
+      expect(response.requesterInformation!.fingerprint).not.toEqual(connId);
+    });
+
+    test("message ids are unique", () => {
+      expect(messageIds).toHaveLength(3);
+      expect(messageIds[0]).not.toEqual(messageIds[1]);
+      expect(messageIds[1]).not.toEqual(messageIds[2]);
+    });
+  });
+
+  describe("tasks", () => {
+    let taskRan = false;
+    beforeAll(() => {
+      api.tasks.tasks.testTask = {
+        name: "testTask",
+        description: "task: test: " + Math.random(),
+        queue: "default",
+        frequency: 0,
+        plugins: [],
+        pluginOptions: {},
+        run: async () => {
+          taskRan = true;
+          return "OK";
+        },
+      };
+
+      api.tasks.jobs.testTask = api.tasks.jobWrapper("testTask");
+    });
+
+    afterAll(() => {
+      delete api.testOutput;
+      delete api.tasks.tasks.testTask;
+    });
+
+    test("can run tasks", async () => {
+      const response = await specHelper.runTask("testTask", {});
+      expect(response).toEqual("OK");
+      expect(taskRan).toEqual(true);
+    });
+
+    describe("flushed redis", () => {
+      beforeEach(async () => {
+        await api.redis.clients.client.flushdb();
+      });
+
+      test("findEnqueuedTasks (normal queues)", async () => {
+        await task.enqueue("testTask", { a: 1 });
+        const foundTasks = await specHelper.findEnqueuedTasks("testTask");
+        expect(foundTasks.length).toBe(1);
+        expect(foundTasks[0].args[0]).toEqual({ a: 1 });
+      });
+
+      test("findEnqueuedTasks (delayed queues)", async () => {
+        await task.enqueueIn(1, "testTask", { a: 1 });
+        const foundTasks = await specHelper.findEnqueuedTasks("testTask");
+        expect(foundTasks.length).toBe(1);
+        expect(foundTasks[0].args[0]).toEqual({ a: 1 });
+      });
+
+      test("deleteEnqueuedTasks", async () => {
+        await task.enqueue("testTask", { a: 1 });
+        await task.enqueueAt(10, "testTask", { a: 1 });
+        await specHelper.deleteEnqueuedTasks("testTask", { a: 1 });
+        const foundTasks = await specHelper.findEnqueuedTasks("testTask");
+        expect(foundTasks.length).toBe(0);
+      });
+    });
+  });
+});

package/__tests__/core/staticFile/compression.ts

@@ -0,0 +1,99 @@
+import axios, { AxiosError } from "axios";
+import { Process, config } from "./../../../src/index";
+
+const actionhero = new Process();
+let url: string;
+
+jest.mock("./../../../src/config/web.ts", () => ({
+  __esModule: true,
+  test: {
+    web: () => {
+      return {
+        compress: true,
+        enabled: true,
+        secure: false,
+        urlPathForActions: "api",
+        urlPathForFiles: "public",
+        rootEndpointType: "file",
+        port: 18080 + parseInt(process.env.JEST_WORKER_ID || "0"),
+        matchExtensionMime: true,
+        metadataOptions: {
+          serverInformation: true,
+          requesterInformation: false,
+        },
+        fingerprintOptions: {
+          cookieKey: "sessionID",
+        },
+      };
+    },
+  },
+}));
+
+describe("Core", () => {
+  describe("static file", () => {
+    beforeAll(async () => {
+      await actionhero.start();
+      url =
+        "http://localhost:" +
+        config.web!.port +
+        "/" +
+        config.web!.urlPathForFiles;
+    });
+
+    afterAll(async () => {
+      await actionhero.stop();
+    });
+
+    describe("Compression", () => {
+      test("should respect accept-encoding header priority with gzip as first in a list of encodings", async () => {
+        const response = await axios.get(url + "/simple.html", {
+          headers: { "Accept-Encoding": "gzip, deflate, sdch, br" },
+          decompress: false,
+        });
+
+        expect(response.status).toEqual(200);
+        expect(response.headers["content-encoding"]).toEqual("gzip");
+      });
+
+      test("should respect accept-encoding header priority with deflate as second in a list of encodings", async () => {
+        const response = await axios.get(url + "/simple.html", {
+          headers: { "Accept-Encoding": "br, deflate, gzip" },
+          decompress: false,
+        });
+
+        expect(response.status).toEqual(200);
+        expect(response.headers["content-encoding"]).toEqual("deflate"); // br is not a currently supported encoding
+      });
+
+      test("should respect accept-encoding header priority with gzip as only option", async () => {
+        const response = await axios.get(url + "/simple.html", {
+          headers: { "Accept-Encoding": "gzip" },
+          decompress: false,
+        });
+
+        expect(response.status).toEqual(200);
+        expect(response.headers["content-encoding"]).toEqual("gzip");
+      });
+
+      test("should not encode content without a valid a supported value in accept-encoding header", async () => {
+        const response = await axios.get(url + "/simple.html", {
+          headers: { "Accept-Encoding": "sdch, br" },
+          decompress: false,
+        });
+
+        expect(response.status).toEqual(200);
+        expect(response.headers["content-encoding"]).toBeUndefined();
+      });
+
+      test("should not encode content without accept-encoding header", async () => {
+        const response = await axios.get(url + "/simple.html", {
+          headers: { "Accept-Encoding": "" },
+          decompress: false,
+        });
+
+        expect(response.status).toEqual(200);
+        expect(response.headers["content-encoding"]).toBeUndefined();
+      });
+    });
+  });
+});

package/__tests__/core/staticFile/staticFile.ts

@@ -0,0 +1,180 @@
+import axios, { AxiosError } from "axios";
+import * as child_process from "child_process";
+import { Process, config, utils, specHelper } from "../../../src/index";
+
+const actionhero = new Process();
+let url: string;
+
+async function exec(command: string) {
+  return new Promise((resolve, reject) => {
+    child_process.exec(command, (error, stdout, stderr) => {
+      if (error) {
+        return reject(error);
+      }
+      return resolve({ stdout, stderr });
+    });
+  });
+}
+
+describe("Core", () => {
+  describe("static file", () => {
+    beforeAll(async () => {
+      await actionhero.start();
+      if (config.web) {
+        url =
+          "http://localhost:" +
+          config.web.port +
+          "/" +
+          config.web.urlPathForFiles;
+      }
+    });
+
+    afterAll(async () => {
+      await actionhero.stop();
+    });
+
+    test("file: an HTML file", async () => {
+      const response = await specHelper.getStaticFile("simple.html");
+      expect(response.mime).toEqual("text/html");
+      expect(response.content).toContain("<h1>Actionhero</h1>");
+    });
+
+    test("file: 404 pages", async () => {
+      const response = await specHelper.getStaticFile("someRandomFile");
+      expect(response.error).toEqual("that file is not found");
+      expect(response.content).toBeNull();
+    });
+
+    test("I should not see files outside of the public dir", async () => {
+      const response = await specHelper.getStaticFile("../config/config.json");
+      expect(response.error).toEqual("that file is not found");
+      expect(response.content).toBeNull();
+    });
+
+    test("file: sub paths should work", async () => {
+      const response = await specHelper.getStaticFile("logo/actionhero.png");
+      expect(response.mime).toEqual("image/png");
+      expect(response.length).toEqual(59273);
+      // wacky per-OS encoding issues I guess?
+      expect(response.content.length).toBeGreaterThanOrEqual(50000);
+      expect(response.content.length).toBeLessThan(60000);
+    });
+
+    test("should send back the cache-control header", async () => {
+      const response = await axios.get(url + "/simple.html");
+      expect(response.status).toEqual(200);
+      expect(response.headers["cache-control"]).toBeTruthy();
+    });
+
+    test("should send back the etag header", async () => {
+      const response = await axios.get(url + "/simple.html");
+      expect(response.status).toEqual(200);
+      expect(response.headers.etag).toBeTruthy();
+    });
+
+    test('should send back a 304 if the header "if-modified-since" is present and condition matches', async () => {
+      const response = await axios.get(url + "/simple.html");
+      expect(response.status).toEqual(200);
+
+      try {
+        await axios(url + "/simple.html", {
+          headers: { "If-Modified-Since": new Date().toUTCString() },
+        });
+        throw new Error("should not get here");
+      } catch (error) {
+        if (error instanceof AxiosError) {
+          expect(error.toString()).toMatch(/304/);
+        } else throw error;
+      }
+    });
+
+    test("should send back a 304 if the ETAG header is present", async () => {
+      const response = await axios.get(url + "/simple.html");
+      expect(response.status).toEqual(200);
+      expect(response.data).toContain("<h1>Actionhero</h1>");
+      expect(response.headers.etag).toBeTruthy();
+
+      const etag = response.headers.etag;
+      const options = {
+        headers: { "If-None-Match": etag },
+        resolveWithFullResponse: true,
+      };
+
+      try {
+        await axios(url + "/simple.html", options);
+        throw new Error("should not get here");
+      } catch (error) {
+        if (error instanceof AxiosError) {
+          expect(error.toString()).toMatch(/304/);
+        } else throw error;
+      }
+    });
+
+    test("should send a different etag for other files", async () => {
+      const response = await axios.get(url + "/simple.html");
+      expect(response.status).toEqual(200);
+      expect(response.headers.etag).toBeTruthy();
+      const etag = response.headers.etag;
+
+      const secondResponse = await axios.get(url + "/index.html");
+      expect(secondResponse.status).toEqual(200);
+      expect(secondResponse.headers.etag).toBeTruthy();
+      const etagTwo = secondResponse.headers.etag;
+      expect(etagTwo).not.toEqual(etag);
+    });
+
+    test('should send back the file if the header "if-modified-since" is present but condition does not match', async () => {
+      const response = await axios.get(url + "/simple.html");
+      expect(response.status).toEqual(200);
+      const lastModified = new Date(response.headers["last-modified"]);
+      const delay = 24 * 1000 * 3600;
+
+      const secondResponse = await axios(url + "/simple.html", {
+        headers: {
+          "If-Modified-Since": new Date(
+            lastModified.getTime() - delay,
+          ).toUTCString(),
+        },
+      });
+
+      expect(secondResponse.status).toEqual(200);
+      expect(secondResponse.data.length).toBeGreaterThan(1);
+    });
+
+    if (process.platform === "win32") {
+      console.log(
+        "*** CANNOT RUN FILE DESCRIPTOR TESTS ON WINDOWS.  Sorry. ***",
+      );
+    } else {
+      describe("do not leave open file descriptors ", () => {
+        const lsofChk = async () => {
+          //@ts-ignore
+          const { stdout } = await exec('lsof -n -P|grep "/simple.html"|wc -l');
+          return stdout.trim();
+        };
+
+        test("closes all descriptors on statusCode 200 responses", async () => {
+          const response = await axios.get(url + "/simple.html");
+          expect(response.status).toEqual(200);
+          await utils.sleep(100);
+          expect(await lsofChk()).toEqual("0");
+        }, 30000);
+
+        test("closes all descriptors on statusCode 304 responses", async () => {
+          try {
+            await axios.get(url + "/simple.html", {
+              headers: { "if-none-match": "*" },
+            });
+            throw new Error("should return 304");
+          } catch (error) {
+            if (error instanceof AxiosError) {
+              expect(error.response?.status).toEqual(304);
+              await utils.sleep(100);
+              expect(await lsofChk()).toEqual("0");
+            } else throw error;
+          }
+        }, 30000);
+      });
+    }
+  });
+});