0z2i6v3u5t 1.0.0

package/__tests__/actions/recursiveAction.ts

@@ -0,0 +1,16 @@
+import { Process, specHelper } from "./../../src/index";
+import { RecursiveAction } from "../../src/actions/recursiveAction";
+
+describe("Action: recursiveAction", () => {
+  const actionhero = new Process();
+  beforeAll(async () => await actionhero.start());
+  afterAll(async () => await actionhero.stop());
+
+  test("merges its own response with the randomNumber response", async () => {
+    const response =
+      await specHelper.runAction<RecursiveAction>("recursiveAction");
+    expect(response.local).toEqual(true);
+    expect(response.randomNumber).toBeGreaterThanOrEqual(0);
+    expect(response.stringRandomNumber).toMatch(/Your random number is/);
+  });
+});

package/__tests__/actions/sleepTest.ts

@@ -0,0 +1,24 @@
+import { Process, specHelper } from "./../../src/index";
+import { SleepTest } from "../../src/actions/sleepTest";
+
+describe("Action: sleepTest", () => {
+  const actionhero = new Process();
+  beforeAll(async () => await actionhero.start());
+  afterAll(async () => await actionhero.stop());
+
+  test("will return data from an async action", async () => {
+    const { sleepDuration } =
+      await specHelper.runAction<SleepTest>("sleepTest");
+    expect(sleepDuration).toEqual(1000);
+  });
+
+  test("can change sleepDuration", async () => {
+    const { sleepDuration } = await specHelper.runAction<SleepTest>(
+      "sleepTest",
+      {
+        sleepDuration: 100,
+      },
+    );
+    expect(sleepDuration).toEqual(100);
+  });
+});

package/__tests__/actions/status.ts

@@ -0,0 +1,17 @@
+import { Process, specHelper } from "./../../src/index";
+import { Status } from "../../src/actions/status";
+
+describe("Action: status", () => {
+  const actionhero = new Process();
+  beforeAll(async () => await actionhero.start());
+  afterAll(async () => await actionhero.stop());
+
+  test("returns node status", async () => {
+    const { id, problems, name, error } =
+      await specHelper.runAction<Status>("status");
+    expect(error).toBeUndefined();
+    expect(problems).toHaveLength(0);
+    expect(id).toEqual(`test-server-${process.env.JEST_WORKER_ID || 0}`);
+    expect(name).toEqual("actionhero");
+  });
+});

package/__tests__/actions/swagger.ts

@@ -0,0 +1,76 @@
+process.env.AUTOMATIC_ROUTES = "get";
+
+import { Process, specHelper, config, api } from "./../../src/index";
+import { Swagger } from "../../src/actions/swagger";
+
+describe("Action: swagger", () => {
+  const actionhero = new Process();
+  let originalRoutes: typeof api.routes.routes;
+
+  beforeAll(async () => {
+    await actionhero.start();
+
+    originalRoutes = api.routes.routes;
+    api.actions.versions.multiParamTestAction = [1];
+    api.actions.actions.multiParamTestAction = {
+      // @ts-ignore
+      1: {
+        name: "multiParamTestAction",
+        description: "I am a multiple param test action",
+        inputs: {
+          one: { required: true },
+          two: { required: true },
+          three: { required: true },
+          four: { required: true },
+        },
+        outputExample: {},
+        run: async (data) => {
+          if (data.response) data.response.success = true;
+        },
+      },
+    };
+
+    api.routes.loadRoutes({
+      get: [
+        {
+          path: "/v:apiVersion/one/:one/two/:two/three/:three/four/:four",
+          action: "multiParamTestAction",
+        },
+      ],
+    });
+  });
+
+  afterAll(async () => {
+    await actionhero.stop();
+
+    api.routes.routes = originalRoutes;
+    delete api.actions.versions.multiParamTestAction;
+    delete api.actions.actions.multiParamTestAction;
+  });
+
+  test("automatic routes is enabled", () => {
+    config.web && expect(config.web.automaticRoutes).toEqual(["get"]);
+  });
+
+  test("returns the correct parts", async () => {
+    const { paths, basePath, host } =
+      await specHelper.runAction<Swagger>("swagger");
+
+    expect(basePath).toBe("/api/");
+    expect(host).toMatch(/localhost/);
+    expect(Object.keys(paths).length).toEqual(11); // 10 actions + custom multiParamTestAction path
+
+    const multiParamPath =
+      paths["/one/{one}/two/{two}/three/{three}/four/{four}"];
+    expect(multiParamPath).toBeDefined();
+    expect(multiParamPath.get.summary).toBe(
+      "I am a multiple param test action",
+    );
+    expect(multiParamPath.get.parameters.map((p) => p.name).sort()).toEqual([
+      "four",
+      "one",
+      "three",
+      "two",
+    ]);
+  });
+});

package/__tests__/actions/validationTest.ts

@@ -0,0 +1,63 @@
+import { Process, specHelper } from "./../../src/index";
+import { ValidationTest } from "../../src/actions/validationTest";
+
+describe("Action: validationTest", () => {
+  const actionhero = new Process();
+  beforeAll(async () => await actionhero.start());
+  afterAll(async () => await actionhero.stop());
+
+  test("fails with no params", async () => {
+    const { error } = await specHelper.runAction<ValidationTest>(
+      "validationTest",
+      {},
+    );
+    expect(error).toEqual(
+      "Error: string is a required parameter for this action",
+    );
+  });
+
+  test("fails with a number", async () => {
+    const { error } = await specHelper.runAction<ValidationTest>(
+      "validationTest",
+      {
+        string: 87,
+      },
+    );
+    expect(error).toEqual(
+      'Error: Input for parameter "string" failed validation!',
+    );
+  });
+
+  test("fails with generalized validation error message", async () => {
+    const { error } = await specHelper.runAction<ValidationTest>(
+      "validationTest",
+      {
+        string: "hello",
+        number: "invalid number",
+      },
+    );
+    expect(error).toEqual("Error: Param number is not a valid number!");
+  });
+
+  test("fails with generalized formatter error message", async () => {
+    const { error } = await specHelper.runAction<ValidationTest>(
+      "validationTest",
+      {
+        string: "hello",
+        number: 123,
+      },
+    );
+    expect(error).toEqual("Error: Failed formatting number correctly!");
+  });
+
+  test("works with a string", async () => {
+    const { string } = await specHelper.runAction<ValidationTest>(
+      "validationTest",
+      {
+        string: "hello",
+        ValidationTest,
+      },
+    );
+    expect(string).toEqual("hello");
+  });
+});

package/__tests__/cli/cli.ts

@@ -0,0 +1,126 @@
+import * as ChildProcess from "child_process";
+import * as path from "path";
+
+async function exec(
+  command: string,
+  args: Record<string, any>,
+): Promise<{
+  error?: NodeJS.ErrnoException;
+  stdout?: string;
+}> {
+  return new Promise((resolve, reject) => {
+    ChildProcess.exec(command, args, (error, stdout, stderr) => {
+      if (error) return reject(error);
+      if (stderr) return reject(stderr);
+      return resolve({ stdout: stdout.toString() });
+    });
+  });
+}
+
+describe("cli commands", () => {
+  const env = {
+    ...process.env,
+    ACTIONHERO_CONFIG_OVERRIDES: JSON.stringify({
+      general: {
+        paths: {
+          cli: [path.join(__dirname, "..", "testCliCommands")],
+        },
+      },
+    }),
+  };
+
+  test(
+    "new commands appear in help",
+    async () => {
+      const { stdout } = await exec(
+        "./node_modules/.bin/ts-node ./src/bin/actionhero.ts help",
+        { env },
+      );
+      expect(stdout).toContain("hello");
+    },
+    30 * 1000,
+  );
+
+  test(
+    "can run",
+    async () => {
+      const { stdout } = await exec(
+        "./node_modules/.bin/ts-node ./src/bin/actionhero.ts hello",
+        { env },
+      );
+      expect(stdout).toContain("Hello, Dr. World");
+    },
+    30 * 1000,
+  );
+
+  test(
+    "can format inputs",
+    async () => {
+      const { stdout } = await exec(
+        "./node_modules/.bin/ts-node ./src/bin/actionhero.ts hello -t Mr --name Worldwide ",
+        { env },
+      );
+      expect(stdout).toContain("Hello, Mr. Worldwide");
+    },
+    30 * 1000,
+  );
+
+  test(
+    "can require a value when optional inputs are specified",
+    async () => {
+      await expect(
+        exec(
+          "./node_modules/.bin/ts-node ./src/bin/actionhero.ts hello --name",
+          {
+            env,
+          },
+        ),
+      ).rejects.toThrow(/error: option '--name <name>' argument missing/);
+    },
+    30 * 1000,
+  );
+
+  test(
+    "can validate inputs",
+    async () => {
+      await expect(
+        exec(
+          "./node_modules/.bin/ts-node ./src/bin/actionhero.ts hello -t Esq. --name Worldwide ",
+          { env },
+        ),
+      ).rejects.toThrow(
+        /error: option '-t, --title <title>' argument 'Esq.' is invalid. too many periods/,
+      );
+    },
+    30 * 1000,
+  );
+
+  test(
+    "can format variadic inputs individually",
+    async () => {
+      const { stdout } = await exec(
+        "./node_modules/.bin/ts-node ./src/bin/actionhero.ts hello --title Mr --name Worldwide --countries France Italy Germany USA",
+        { env },
+      );
+      expect(stdout).toContain(
+        "Hello, Mr. Worldwide (France! Italy! Germany! USA!)",
+      );
+    },
+    30 * 1000,
+  );
+
+  test(
+    "can validate variadic inputs individually",
+    async () => {
+      await expect(
+        exec(
+          "./node_modules/.bin/ts-node ./src/bin/actionhero.ts hello --title Mr --name Worldwide --countries France italy",
+          { env },
+        ),
+      ).rejects.toThrow(
+        /error: option '--countries \[countries...\]' argument 'italy' is invalid. country not capitalized/,
+      );
+    },
+    30 * 1000,
+  );
+});