0z2i6v3u5t 1.0.0

package/__tests__/core/middleware.ts

@@ -0,0 +1,427 @@
+import {
+  api,
+  Process,
+  config,
+  action,
+  utils,
+  specHelper,
+  ActionProcessor,
+  Connection,
+} from "./../../src";
+
+const actionhero = new Process();
+let defaultMiddlewarePriority: number;
+
+describe("Core: Middleware", () => {
+  beforeAll(async () => await actionhero.start());
+  afterAll(async () => await actionhero.stop());
+
+  beforeAll(() => {
+    defaultMiddlewarePriority = config!.general!
+      .defaultMiddlewarePriority as number;
+  });
+
+  afterEach(() => {
+    api.actions.middleware = {};
+    api.actions.globalMiddleware = [];
+  });
+
+  describe("action preProcessors", () => {
+    test("can define a global preProcessor and it can append the connection", async () => {
+      action.addMiddleware({
+        name: "test middleware",
+        global: true,
+        preProcessor: (data: ActionProcessor<any>) => {
+          data.response._preProcessorNote = "note";
+        },
+      });
+
+      const { _preProcessorNote, error } =
+        await specHelper.runAction<any>("randomNumber");
+      expect(error).toBeUndefined();
+      expect(_preProcessorNote).toEqual("note");
+    });
+
+    test("can define an async global preProcessor and it can append the connection", async () => {
+      action.addMiddleware({
+        name: "test middleware",
+        global: true,
+        preProcessor: async (data: ActionProcessor<any>) => {
+          await new Promise((resolve) => {
+            setTimeout(resolve, 100);
+          });
+          data.response._preProcessorNote = "slept";
+        },
+      });
+
+      const { _preProcessorNote, error } =
+        await specHelper.runAction<any>("randomNumber");
+      expect(error).toBeUndefined();
+      expect(_preProcessorNote).toEqual("slept");
+    });
+
+    test("can define a local preProcessor and it will not append the connection when not applied to the action", async () => {
+      action.addMiddleware({
+        name: "test middleware",
+        global: false,
+        preProcessor: (data: ActionProcessor<any>) => {
+          data.response._preProcessorNote = "note";
+        },
+      });
+
+      const { _preProcessorNote, error } =
+        await specHelper.runAction<any>("randomNumber");
+      expect(error).toBeUndefined();
+      expect(_preProcessorNote).toBeUndefined();
+    });
+
+    describe("middleware can read properties of the action template", () => {
+      const sessions: any[] = [];
+
+      beforeAll(() => {
+        api.actions.versions.authAction = [1];
+        api.actions.actions.authAction = {
+          1: {
+            name: "authAction",
+            description: "I am a test",
+            version: 1,
+            //@ts-ignore
+            authenticated: true,
+            run: async ({ response, session }) => {
+              sessions.push(session);
+              response!.thing = "stuff";
+            },
+          },
+        };
+      });
+
+      afterAll(() => {
+        delete api.actions.actions.authAction;
+        delete api.actions.versions.authAction;
+      });
+
+      test("can read action template properties", async () => {
+        action.addMiddleware({
+          name: "auth middleware",
+          global: true,
+          preProcessor: (data: ActionProcessor<any>) => {
+            if (data.actionTemplate.authenticated === true) {
+              data.response.authenticatedAction = true;
+            } else {
+              data.response.authenticatedAction = false;
+            }
+          },
+        });
+
+        const randomResponse = await specHelper.runAction<any>("randomNumber");
+        expect(randomResponse.authenticatedAction).toEqual(false);
+
+        const authResponse = await specHelper.runAction<any>("authAction");
+        expect(authResponse.authenticatedAction).toEqual(true);
+      });
+
+      test("middleware can add data to the session", async () => {
+        action.addMiddleware({
+          name: "session middleware",
+          global: true,
+          preProcessor: async (data: ActionProcessor<any>) => {
+            data.session = { id: "abc123" };
+          },
+        });
+
+        await specHelper.runAction("authAction");
+        const lastSession = sessions.pop();
+        expect(lastSession.id).toBe("abc123");
+      });
+    });
+
+    test("preProcessors with priorities run in the right order", async () => {
+      // first priority
+      action.addMiddleware({
+        name: "first test middleware",
+        global: true,
+        priority: 1,
+        preProcessor: (data: ActionProcessor<any>) => {
+          data.response._processorNoteFirst = "first";
+          data.response._processorNoteEarly = "first";
+          data.response._processorNoteLate = "first";
+          data.response._processorNoteDefault = "first";
+        },
+      });
+
+      // lower number priority (runs sooner)
+      action.addMiddleware({
+        name: "early test middleware",
+        global: true,
+        priority: defaultMiddlewarePriority - 1,
+        preProcessor: (data: ActionProcessor<any>) => {
+          data.response._processorNoteEarly = "early";
+          data.response._processorNoteLate = "early";
+          data.response._processorNoteDefault = "early";
+        },
+      });
+
+      // old style "default" priority
+      action.addMiddleware({
+        name: "default test middleware",
+        global: true,
+        preProcessor: (data: ActionProcessor<any>) => {
+          data.response._processorNoteLate = "default";
+          data.response._processorNoteDefault = "default";
+        },
+      });
+
+      // higher number priority (runs later)
+      action.addMiddleware({
+        name: "late test middleware",
+        global: true,
+        priority: defaultMiddlewarePriority + 1,
+        preProcessor: (data: ActionProcessor<any>) => {
+          data.response._processorNoteLate = "late";
+        },
+      });
+
+      const response = await specHelper.runAction<any>("randomNumber");
+      expect(response._processorNoteFirst).toEqual("first");
+      expect(response._processorNoteEarly).toEqual("early");
+      expect(response._processorNoteDefault).toEqual("default");
+      expect(response._processorNoteLate).toEqual("late");
+    });
+
+    test("multiple preProcessors with same priority are executed", async () => {
+      action.addMiddleware({
+        name: "first test middleware",
+        global: true,
+        priority: defaultMiddlewarePriority - 1,
+        preProcessor: (data: ActionProcessor<any>) => {
+          data.response._processorNoteFirst = "first";
+        },
+      });
+
+      action.addMiddleware({
+        name: "late test middleware",
+        global: true,
+        priority: defaultMiddlewarePriority - 1,
+        preProcessor: (data: ActionProcessor<any>) => {
+          data.response._processorNoteSecond = "second";
+        },
+      });
+
+      const response = await specHelper.runAction<any>("randomNumber");
+      expect(response._processorNoteFirst).toEqual("first");
+      expect(response._processorNoteSecond).toEqual("second");
+    });
+
+    test("postProcessors can append the connection", async () => {
+      action.addMiddleware({
+        name: "test middleware",
+        global: true,
+        postProcessor: (data: ActionProcessor<any>) => {
+          data.response._postProcessorNote = "note";
+        },
+      });
+
+      const response = await specHelper.runAction<any>("randomNumber");
+      expect(response._postProcessorNote).toEqual("note");
+    });
+
+    test("postProcessors with priorities run in the right order", async () => {
+      // first priority
+      action.addMiddleware({
+        name: "first test middleware",
+        global: true,
+        priority: 1,
+        postProcessor: (data: ActionProcessor<any>) => {
+          data.response._processorNoteFirst = "first";
+          data.response._processorNoteEarly = "first";
+          data.response._processorNoteLate = "first";
+          data.response._processorNoteDefault = "first";
+        },
+      });
+
+      // lower number priority (runs sooner)
+      action.addMiddleware({
+        name: "early test middleware",
+        global: true,
+        priority: defaultMiddlewarePriority - 1,
+        postProcessor: (data: ActionProcessor<any>) => {
+          data.response._processorNoteEarly = "early";
+          data.response._processorNoteLate = "early";
+          data.response._processorNoteDefault = "early";
+        },
+      });
+
+      // old style "default" priority
+      action.addMiddleware({
+        name: "default test middleware",
+        global: true,
+        postProcessor: (data: ActionProcessor<any>) => {
+          data.response._processorNoteLate = "default";
+          data.response._processorNoteDefault = "default";
+        },
+      });
+
+      // higher number priority (runs later)
+      action.addMiddleware({
+        name: "late test middleware",
+        global: true,
+        priority: defaultMiddlewarePriority + 1,
+        postProcessor: (data: ActionProcessor<any>) => {
+          data.response._processorNoteLate = "late";
+        },
+      });
+
+      const response = await specHelper.runAction<any>("randomNumber");
+      expect(response._processorNoteFirst).toEqual("first");
+      expect(response._processorNoteEarly).toEqual("early");
+      expect(response._processorNoteDefault).toEqual("default");
+      expect(response._processorNoteLate).toEqual("late");
+    });
+
+    test("multiple postProcessors with same priority are executed", async () => {
+      action.addMiddleware({
+        name: "first middleware",
+        global: true,
+        priority: defaultMiddlewarePriority - 1,
+        postProcessor: (data: ActionProcessor<any>) => {
+          data.response._processorNoteFirst = "first";
+        },
+      });
+
+      action.addMiddleware({
+        name: "second middleware",
+        global: true,
+        priority: defaultMiddlewarePriority - 1,
+        postProcessor: (data: ActionProcessor<any>) => {
+          data.response._processorNoteSecond = "second";
+        },
+      });
+
+      const response = await specHelper.runAction<any>("randomNumber");
+      expect(response._processorNoteFirst).toEqual("first");
+      expect(response._processorNoteSecond).toEqual("second");
+    });
+
+    test("preProcessors can block actions", async () => {
+      action.addMiddleware({
+        name: "test middleware",
+        global: true,
+        preProcessor: function () {
+          throw new Error("BLOCKED");
+        },
+      });
+
+      const { randomNumber, error } =
+        await specHelper.runAction<any>("randomNumber");
+      expect(error).toEqual("Error: BLOCKED");
+      expect(randomNumber).toBeUndefined();
+    });
+
+    test("postProcessors can modify toRender", async () => {
+      action.addMiddleware({
+        name: "test middleware",
+        global: true,
+        postProcessor: (data: ActionProcessor<any>) => {
+          data.toRender = false;
+        },
+      });
+
+      await new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve(null);
+        }, 1000);
+        specHelper.runAction("randomNumber").then(() => {
+          throw new Error("should.not.get.here");
+        });
+      });
+    });
+  });
+
+  describe("connection sync create/destroy callbacks", () => {
+    let connection: Connection;
+    beforeEach(() => {
+      api.connections.middleware = {};
+      api.connections.globalMiddleware = [];
+    });
+
+    afterEach(() => {
+      api.connections.middleware = {};
+      api.connections.globalMiddleware = [];
+    });
+
+    test("can create callbacks on connection creation", async () => {
+      let middlewareRan = false;
+      api.connections.addMiddleware({
+        name: "connection middleware",
+        create: (_connection: Connection) => {
+          middlewareRan = true;
+          //@ts-ignore
+          _connection["touched"] = "connect";
+        },
+      });
+
+      connection = await specHelper.buildConnection();
+
+      expect(middlewareRan).toEqual(true);
+      //@ts-ignore
+      expect(connection["touched"]).toEqual("connect");
+    });
+
+    test("can create callbacks on connection destroy", async () => {
+      let middlewareRan = false;
+      api.connections.addMiddleware({
+        name: "connection middleware",
+        destroy: (_connection: Connection) => {
+          middlewareRan = true;
+          //@ts-ignore
+          expect(_connection["touched"]).toEqual("connect");
+        },
+      });
+
+      connection.destroy();
+      expect(middlewareRan).toEqual(true);
+    });
+  });
+
+  describe("connection async create/destroy callbacks", () => {
+    beforeEach(() => {
+      api.connections.middleware = {};
+      api.connections.globalMiddleware = [];
+    });
+
+    afterEach(() => {
+      api.connections.middleware = {};
+      api.connections.globalMiddleware = [];
+    });
+
+    test("can create async callbacks on connection create/destroy", async () => {
+      let middlewareRan = false;
+      let middlewareDestroyRan = false;
+
+      api.connections.addMiddleware({
+        name: "connection middleware",
+        create: async (_connection: Connection) => {
+          middlewareRan = true;
+          await utils.sleep(1);
+          //@ts-ignore
+          _connection["longProcessResult"] = true;
+        },
+        destroy: async (_connection: Connection) => {
+          await utils.sleep(1);
+          middlewareDestroyRan = true;
+        },
+      });
+
+      const connection = await specHelper.buildConnection();
+
+      // create
+      expect(middlewareRan).toEqual(true);
+      //@ts-ignore
+      expect(connection["longProcessResult"]).toEqual(true);
+
+      // destroy
+      await connection.destroy();
+      expect(middlewareDestroyRan).toEqual(true);
+    });
+  });
+});

package/__tests__/core/plugins/partialPlugin.ts

@@ -0,0 +1,94 @@
+import * as path from "path";
+import * as ChildProcess from "child_process";
+
+process.env.ACTIONHERO_CONFIG_OVERRIDES = JSON.stringify({
+  plugins: {
+    testPlugin: {
+      path: path.join(__dirname, "..", "..", "testPlugin"),
+      actions: false,
+      tasks: false,
+      servers: false,
+      initializers: false,
+      public: false,
+      cli: false,
+    },
+  },
+});
+
+import { api, Process, specHelper } from "../../../src/index";
+
+const actionhero = new Process();
+
+async function exec(
+  command: string,
+  args: Record<string, any>,
+): Promise<{
+  error?: NodeJS.ErrnoException;
+  stdout?: string;
+  stderr?: string;
+}> {
+  return new Promise((resolve, reject) => {
+    ChildProcess.exec(command, args, (error, stdout, stderr) => {
+      if (error) {
+        return reject(error);
+      }
+      return resolve({ stdout: stdout.toString(), stderr: stderr.toString() });
+    });
+  });
+}
+
+describe("Core: Plugins", () => {
+  describe("with plugin sections ignored", () => {
+    beforeAll(async () => {
+      await actionhero.start();
+    });
+
+    afterAll(async () => {
+      await actionhero.stop();
+    });
+
+    test("will not load an action from an un-loaded plugin", async () => {
+      const response = await specHelper.runAction("pluginAction");
+      expect(response.error).toMatch(/unknown action or invalid apiVersion/);
+    });
+
+    test("will not load a task from an un-loaded plugin", () => {
+      expect(api.tasks.tasks.pluginTask).not.toBeTruthy();
+      expect(api.tasks.jobs.pluginTask).not.toBeTruthy();
+    });
+
+    test("will not load an initializer from an un-loaded plugin", () => {
+      expect(api.pluginInitializer).not.toBeTruthy();
+    });
+
+    // test('will not load a server from an un-loaded plugin')
+
+    test("will not serve static files from an un-loaded plugin", async () => {
+      const file = await specHelper.getStaticFile("plugin.html");
+      expect(file.error).toMatch(/file is not found/);
+    });
+
+    test(
+      "will not load CLI command from an un-loaded plugin",
+      async () => {
+        const { stdout: helpResponse, stderr: error1 } = await exec(
+          "./node_modules/.bin/ts-node ./src/bin/actionhero.ts help",
+          { env: process.env },
+        );
+        expect(error1).toEqual("");
+        expect(helpResponse).not.toContain("hello");
+
+        try {
+          await exec(
+            "./node_modules/.bin/ts-node ./src/bin/actionhero.ts hello",
+            { env: process.env },
+          );
+          throw new Error("should not get here");
+        } catch (error) {
+          expect(error.toString()).toMatch(/unknown command 'hello'/);
+        }
+      },
+      30 * 1000,
+    );
+  });
+});

package/__tests__/core/plugins/withPlugin.ts

@@ -0,0 +1,88 @@
+import * as path from "path";
+import * as ChildProcess from "child_process";
+
+process.env.ACTIONHERO_CONFIG_OVERRIDES = JSON.stringify({
+  plugins: {
+    testPlugin: { path: path.join(__dirname, "..", "..", "testPlugin") },
+  },
+});
+
+import { api, Process, specHelper } from "../../../src/index";
+
+const actionhero = new Process();
+
+async function exec(
+  command: string,
+  args: Record<string, any>,
+): Promise<{
+  error?: NodeJS.ErrnoException;
+  stdout?: string;
+  stderr?: string;
+}> {
+  return new Promise((resolve, reject) => {
+    ChildProcess.exec(command, args, (error, stdout, stderr) => {
+      if (error) {
+        return reject(error);
+      }
+      return resolve({ stdout: stdout.toString(), stderr: stderr.toString() });
+    });
+  });
+}
+
+describe("Core: Plugins", () => {
+  describe("with plugin", () => {
+    beforeAll(async () => {
+      await actionhero.start();
+    });
+
+    afterAll(async () => {
+      delete process.env.ACTIONHERO_CONFIG_OVERRIDES;
+      await actionhero.stop();
+    });
+
+    test("can load an action from a plugin", async () => {
+      const response = await specHelper.runAction<any>("pluginAction");
+      expect(response.error).toBeUndefined();
+      expect(response.cool).toEqual(true);
+    });
+
+    test("can load a task from a plugin", () => {
+      expect(api.tasks.tasks.pluginTask).toBeTruthy();
+      expect(api.tasks.jobs.pluginTask).toBeTruthy();
+    });
+
+    test("can load an initializer from a plugin", () => {
+      expect(api.pluginInitializer.here).toEqual(true);
+    });
+
+    test.todo("can load a server from a plugin");
+
+    test("can serve static files from a plugin", async () => {
+      const file = await specHelper.getStaticFile("plugin.html");
+      expect(file.content).toEqual("<h1>PLUGIN!<h1>\n");
+      expect(file.mime).toEqual("text/html");
+    });
+
+    test(
+      "can load CLI command from a plugin",
+      async () => {
+        const env = process.env;
+
+        const { stdout: helpResponse, stderr: error1 } = await exec(
+          "./node_modules/.bin/ts-node ./src/bin/actionhero.ts help",
+          { env },
+        );
+        expect(error1).toEqual("");
+        expect(helpResponse).toContain("hello");
+
+        const { stdout: helloResponse, stderr: error2 } = await exec(
+          "./node_modules/.bin/ts-node ./src/bin/actionhero.ts hello",
+          { env },
+        );
+        expect(error2).toEqual("");
+        expect(helloResponse).toContain("Hello, Actionhero");
+      },
+      30 * 1000,
+    );
+  });
+});

package/__tests__/core/plugins/withoutPlugin.ts

@@ -0,0 +1,81 @@
+import * as ChildProcess from "child_process";
+
+process.env.ACTIONHERO_CONFIG_OVERRIDES = JSON.stringify({
+  plugins: {},
+});
+
+import { api, Process, specHelper } from "../../../src/index";
+
+const actionhero = new Process();
+
+async function exec(
+  command: string,
+  args: Record<string, any>,
+): Promise<{
+  error?: NodeJS.ErrnoException;
+  stdout?: string;
+  stderr?: string;
+}> {
+  return new Promise((resolve, reject) => {
+    ChildProcess.exec(command, args, (error, stdout, stderr) => {
+      if (error) {
+        return reject(error);
+      }
+      return resolve({ stdout: stdout.toString(), stderr: stderr.toString() });
+    });
+  });
+}
+
+describe("Core: Plugins", () => {
+  describe("without plugin", () => {
+    beforeAll(async () => {
+      await actionhero.start();
+    });
+
+    afterAll(async () => {
+      await actionhero.stop();
+    });
+
+    test("will not load an action from an un-loaded plugin", async () => {
+      const response = await specHelper.runAction("pluginAction");
+      expect(response.error).toMatch(/unknown action or invalid apiVersion/);
+    });
+
+    test("will not load a task from an un-loaded plugin", () => {
+      expect(api.tasks.tasks.pluginTask).not.toBeTruthy();
+      expect(api.tasks.jobs.pluginTask).not.toBeTruthy();
+    });
+
+    test("will not load an initializer from an un-loaded plugin", () => {
+      expect(api.pluginInitializer).not.toBeTruthy();
+    });
+
+    // test('will not load a server from an un-loaded plugin')
+    test("will not serve static files from an un-loaded plugin", async () => {
+      const file = await specHelper.getStaticFile("plugin.html");
+      expect(file.error).toMatch(/file is not found/);
+    });
+
+    test(
+      "will not load CLI command from an un-loaded plugin",
+      async () => {
+        const { stdout: helpResponse, stderr: error1 } = await exec(
+          "./node_modules/.bin/ts-node ./src/bin/actionhero.ts help",
+          { env: process.env },
+        );
+        expect(error1).toEqual("");
+        expect(helpResponse).not.toContain("hello");
+        try {
+          await exec(
+            "./node_modules/.bin/ts-node ./src/bin/actionhero.ts hello",
+            { env: process.env },
+          );
+          throw new Error("should not get here");
+        } catch (error) {
+          expect(error.toString()).toMatch(/unknown command 'hello'/);
+        }
+      },
+      30 * 1000,
+    );
+  });
+});