0z2i6v3u5t 1.0.0

package/__tests__/tasks/runAction.ts

@@ -0,0 +1,37 @@
+import { Process, specHelper } from "./../../src/index";
+import { RunAction } from "../../src/tasks/runAction";
+
+describe("Test: RunAction", () => {
+  const actionhero = new Process();
+
+  beforeAll(async () => await actionhero.start());
+  afterAll(async () => await actionhero.stop());
+
+  test("can run the task without params", async () => {
+    const { randomNumber } = await specHelper.runTask<RunAction>("runAction", {
+      action: "randomNumber",
+    });
+    expect(randomNumber).toBeGreaterThanOrEqual(0);
+    expect(randomNumber).toBeLessThan(1);
+  });
+
+  test("can run the task with params", async () => {
+    const { cacheTestResults } = await specHelper.runTask<RunAction>(
+      "runAction",
+      {
+        action: "cacheTest",
+        params: { key: "testKey", value: "testValue" },
+      },
+    );
+    expect(cacheTestResults.saveResp).toBe(true);
+    expect(cacheTestResults.deleteResp).toBe(true);
+  });
+
+  test("will throw with errors", async () => {
+    await expect(
+      specHelper.runTask<RunAction>("runAction", {
+        action: "cacheTest",
+      }),
+    ).rejects.toThrow(/key is a required parameter for this action/);
+  });
+});

package/__tests__/template.ts.example

@@ -0,0 +1,20 @@
+import { Process, env, id, specHelper } from "actionhero";
+import { Status } from "../../src/actions/status";
+
+describe("actionhero Tests", () => {
+  const actionhero = new Process();
+
+  beforeAll(async () => await actionhero.start());
+  afterAll(async () => await actionhero.stop());
+
+  test("should have booted into the test env", () => {
+    expect(process.env.NODE_ENV).toEqual("test");
+    expect(env).toEqual("test");
+    expect(id).toBeTruthy();
+  });
+
+  test("can retrieve server uptime via the status action", async () => {
+    const { uptime } = await specHelper.runAction<Status>("status");
+    expect(uptime).toBeGreaterThan(0);
+  });
+});

package/__tests__/testCliCommands/hello.ts

@@ -0,0 +1,44 @@
+import { CLI, ParamsFrom } from "./../../src/index";
+
+export class HelloCliTest extends CLI {
+  name = "hello";
+  description = "I work";
+  inputs = {
+    name: {
+      required: false,
+      requiredValue: true,
+      default: "World",
+    },
+    title: {
+      letter: "t",
+      required: true,
+      default: "Dr.",
+      formatter: (val: string) => {
+        return `${val}.`;
+      },
+      validator: (val: string) => {
+        const parts = val.split(".");
+        if (parts.length > 2) throw new Error("too many periods");
+      },
+    },
+    countries: {
+      variadic: true as true,
+      formatter: (val: string) => `${val}!`,
+      validator: (val: string) => {
+        if (val.length > 0 && val[0].toUpperCase() !== val[0])
+          throw new Error("country not capitalized");
+      },
+    },
+  };
+
+  async run({ params }: { params: Partial<ParamsFrom<HelloCliTest>> }) {
+    const sayHello = (title: string, name: string, countries: string[]) =>
+      console.log(
+        `Hello, ${title} ${name} ${
+          countries ? `(${countries.join(" ")})` : ""
+        }`,
+      );
+    sayHello(params.title!, params.name!, params.countries!);
+    return true;
+  }
+}

package/__tests__/testPlugin/public/plugin.html

@@ -0,0 +1 @@
+<h1>PLUGIN!<h1>

package/__tests__/testPlugin/src/actions/pluginAction.ts

@@ -0,0 +1,14 @@
+import { Action } from "../../../../src/index";
+
+export default class PluginAction extends Action {
+  constructor() {
+    super();
+    this.name = "pluginAction";
+    this.description = "pluginAction";
+    this.outputExample = {};
+  }
+
+  async run({ response }) {
+    response.cool = true;
+  }
+};

package/__tests__/testPlugin/src/bin/hello.ts

@@ -0,0 +1,22 @@
+import { CLI } from "../../../../src/index";
+
+export class Hello extends CLI {
+  constructor() {
+    super();
+    this.name = "hello";
+    this.description = "I say hello";
+    this.inputs={
+      name: {
+        required: true,
+        description: 'Who we are greeting',
+        letter: 'g',
+        default: 'Actionhero'
+    }
+    }
+  }
+
+  async run({params}) {
+    console.log(`Hello, ${params.name}`);
+    return true;
+  }
+}

package/__tests__/testPlugin/src/initializers/pluginInitializer.ts

@@ -0,0 +1,17 @@
+import { api, Initializer } from "../../../../src/index";
+
+export class PluginInitializer extends Initializer {
+  constructor() {
+    super();
+    this.name = "pluginInitializer";
+  }
+
+  async initialize() {
+    api.pluginInitializer = { here: true };
+  }
+
+  async stop() {
+    // this seems silly, but is needed for testing, as we never clear properties on the API object
+    delete api.pluginInitializer;
+  }
+}

package/__tests__/testPlugin/src/tasks/pluginTask.ts

@@ -0,0 +1,15 @@
+import { Task } from "../../../../src/index";
+
+export class PluginTask extends Task {
+  constructor() {
+    super();
+    this.name = "pluginTask";
+    this.description = "pluginTask";
+    this.frequency = 0;
+    this.queue = "default";
+  }
+
+  async run(params) {
+    return true;
+  }
+}

package/__tests__/testPlugin/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "rootDir": ".",
+    "outDir": "./dist",
+    "allowJs": true,
+    "module": "commonjs",
+    "target": "es2018"
+  },
+  "include": ["./src/**/*"]
+}

package/__tests__/utils/utils.ts

@@ -0,0 +1,492 @@
+import * as glob from "glob";
+import * as path from "path";
+import { config, utils } from "./../../src/index";
+
+describe("Utils", () => {
+  describe("util.sleep", () => {
+    test("it sleeps", async () => {
+      const start = new Date().getTime();
+      await utils.sleep(100);
+      const end = new Date().getTime();
+      expect(end - start).toBeGreaterThanOrEqual(99);
+      expect(end - start).toBeLessThan(200);
+    });
+  });
+
+  describe("utils.arrayUnique", () => {
+    test("works", () => {
+      const a = [1, 2, 3, 3, 4, 4, 4, 5, 5, 5];
+      expect(utils.arrayUnique(a)).toEqual([1, 2, 3, 4, 5]);
+    });
+  });
+
+  describe("utils.collapseObjectToArray", () => {
+    test("fails with numerical keys", () => {
+      const o = { 0: "a", 1: "b" };
+      const response = utils.collapseObjectToArray(o);
+      expect(response).toEqual(["a", "b"]);
+    });
+
+    test("fails with non-numerical keys", () => {
+      const o = { a: 1 };
+      const response = utils.collapseObjectToArray(o);
+      expect(response).toEqual(false);
+    });
+  });
+
+  describe("utils.hashMerge", () => {
+    const A = { a: 1, b: 2 };
+    const B = { b: -2, c: 3 };
+    const C = { a: 1, b: { m: 10, n: 11 } };
+    const D = { a: 1, b: { n: 111, o: 22, p: {} } };
+    const E = { b: {} };
+    const N = { b: null } as Record<string, any>;
+    const U = { b: undefined } as Record<string, any>;
+
+    test("simple", () => {
+      const Z = utils.hashMerge(A, B);
+      expect(Z.a).toEqual(1);
+      expect(Z.b).toEqual(-2);
+      expect(Z.c).toEqual(3);
+    });
+
+    test("directional", () => {
+      const Z = utils.hashMerge(B, A);
+      expect(Z.a).toEqual(1);
+      expect(Z.b).toEqual(2);
+      expect(Z.c).toEqual(3);
+    });
+
+    test("nested", () => {
+      const Z = utils.hashMerge(C, D);
+      expect(Z.a).toEqual(1);
+      expect(Z.b.m).toEqual(10);
+      expect(Z.b.n).toEqual(111);
+      expect(Z.b.o).toEqual(22);
+      expect(Z.b.p).toEqual({});
+    });
+
+    test("empty01", () => {
+      const Z = utils.hashMerge(E, D);
+      expect(Z.a).toEqual(1);
+      expect(Z.b.n).toEqual(111);
+      expect(Z.b.o).toEqual(22);
+      expect(Z.b.p).toEqual({});
+    });
+
+    test("empty10", () => {
+      const Z = utils.hashMerge(D, E);
+      expect(Z.a).toEqual(1);
+      expect(Z.b.n).toEqual(111);
+      expect(Z.b.o).toEqual(22);
+      expect(Z.b.p).toEqual({});
+    });
+
+    test("chained", () => {
+      const Z = utils.hashMerge(utils.hashMerge(C, E), D);
+      expect(Z.a).toEqual(1);
+      expect(Z.b.m).toEqual(10);
+      expect(Z.b.n).toEqual(111);
+      expect(Z.b.o).toEqual(22);
+      expect(Z.b.p).toEqual({});
+    });
+
+    test("null", () => {
+      const Z = utils.hashMerge(A, N);
+      expect(Z.a).toEqual(1);
+      expect(Z.b).toBeUndefined();
+    });
+
+    test("undefined", () => {
+      const Z = utils.hashMerge(A, U);
+      expect(Z.a).toEqual(1);
+      expect(Z.b).toEqual(2);
+    });
+  });
+
+  describe("eventLoopDelay", () => {
+    test("works", async () => {
+      const delay = await utils.eventLoopDelay(10000);
+      expect(delay).toBeGreaterThan(0);
+      expect(delay).toBeLessThan(1);
+    });
+  });
+
+  describe("#parseHeadersForClientAddress", () => {
+    test("only x-real-ip, port is null", () => {
+      const headers = {
+        "x-real-ip": "10.11.12.13",
+      };
+      const { ip, port } = utils.parseHeadersForClientAddress(headers);
+      expect(ip).toEqual("10.11.12.13");
+      expect(port).toBeFalsy();
+    });
+    test("load balancer, x-forwarded-for format", () => {
+      const headers = {
+        "x-forwarded-for": "35.36.37.38",
+        "x-forwarded-port": "80",
+      };
+      const { ip, port } = utils.parseHeadersForClientAddress(headers);
+      expect(ip).toEqual("35.36.37.38");
+      expect(port).toEqual("80");
+    });
+  });
+
+  describe("#parseIPv6URI", () => {
+    test("address and port", () => {
+      const uri = "[2604:4480::5]:8080";
+      const parts = utils.parseIPv6URI(uri);
+      expect(parts.host).toEqual("2604:4480::5");
+      expect(parts.port).toEqual(8080);
+    });
+
+    test("address without port", () => {
+      const uri = "2604:4480::5";
+      const parts = utils.parseIPv6URI(uri);
+      expect(parts.host).toEqual("2604:4480::5");
+      expect(parts.port).toEqual(80);
+    });
+
+    test("full uri", () => {
+      const uri = "http://[2604:4480::5]:8080/foo/bar";
+      const parts = utils.parseIPv6URI(uri);
+      expect(parts.host).toEqual("2604:4480::5");
+      expect(parts.port).toEqual(8080);
+    });
+
+    test("failing address", () => {
+      const uri = "[2604:4480:z:5]:80";
+      try {
+        const parts = utils.parseIPv6URI(uri);
+        console.log(parts);
+      } catch (e) {
+        expect(e.message).toEqual("failed to parse address");
+      }
+    });
+
+    test("should parse locally scoped ipv6 URIs without port", () => {
+      const uri = "fe80::1ff:fe23:4567:890a%eth2";
+      const parts = utils.parseIPv6URI(uri);
+      expect(parts.host).toEqual("fe80::1ff:fe23:4567:890a%eth2");
+      expect(parts.port).toEqual(80);
+    });
+
+    test("should parse locally scoped ipv6 URIs with port", () => {
+      const uri = "[fe80::1ff:fe23:4567:890a%eth2]:8080";
+      const parts = utils.parseIPv6URI(uri);
+      expect(parts.host).toEqual("fe80::1ff:fe23:4567:890a%eth2");
+      expect(parts.port).toEqual(8080);
+    });
+  });
+
+  describe("utils.arrayStartingMatch", () => {
+    test("finds matching arrays", () => {
+      const a = [1, 2, 3];
+      const b = [1, 2, 3, 4, 5];
+      const numberResult = utils.arrayStartingMatch(a, b);
+      expect(numberResult).toBe(true);
+
+      const c = ["a", "b", "c"];
+      const d = ["a", "b", "c", "d", "e"];
+      const stringResult = utils.arrayStartingMatch(c, d);
+      expect(stringResult).toBe(true);
+    });
+
+    test("finds non-matching arrays", () => {
+      const a = [1, 3];
+      const b = [1, 2, 3, 4, 5];
+      const numberResult = utils.arrayStartingMatch(a, b);
+      expect(numberResult).toBe(false);
+
+      const c = ["a", "b", "c"];
+      const d = ["a", "b", "d", "e"];
+      const stringResult = utils.arrayStartingMatch(c, d);
+      expect(stringResult).toBe(false);
+    });
+
+    test("does not pass with empty arrays; first", () => {
+      const a: number[] = [];
+      const b = [1, 2, 3, 4, 5];
+      const result = utils.arrayStartingMatch(a, b);
+      expect(result).toBe(false);
+    });
+
+    test("does not pass with empty arrays; second", () => {
+      const a = [1, 2, 3, 4, 5];
+      const b: number[] = [];
+      const result = utils.arrayStartingMatch(a, b);
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("utils.replaceDistWithSrc", () => {
+    test("it replaces paths from dist to src", () => {
+      const p = `${config.general!.paths.action[0]}/new-actions/test.ts`;
+      const withDist = utils.replaceDistWithSrc(p);
+      expect(withDist).toMatch("/src/actions/new-actions/test.ts");
+    });
+  });
+
+  describe("utils.filterObjectForLogging", () => {
+    beforeEach(() => {
+      config.logger!.maxLogArrayLength = 100;
+      expect(config.general!.filteredParams.length).toEqual(0);
+    });
+
+    afterEach(() => {
+      // after each test, empty the array
+      config.general!.filteredParams = [];
+      config.logger!.maxLogArrayLength = 10;
+    });
+
+    const testInput = {
+      p1: 1,
+      p2: "s3cr3t",
+      o1: {
+        o1p1: 1,
+        o1p2: "also-s3cr3t",
+        o2: {
+          o2p1: "this is ok",
+          o2p2: "extremely-s3cr3t",
+        },
+      },
+      o2: {
+        name: "same as o1`s inner object!",
+        o2p1: "nothing secret",
+      },
+      a1: ["a", "b", "c"],
+      a2: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
+    };
+
+    test("can filter top level params, no matter the type", () => {
+      const inputs = JSON.parse(JSON.stringify(testInput)); // quick deep Clone
+      (config.general!.filteredParams as string[]).push("p1", "p2", "o2");
+      const filteredParams = utils.filterObjectForLogging(inputs);
+      expect(filteredParams.p1).toEqual("[FILTERED]");
+      expect(filteredParams.p2).toEqual("[FILTERED]");
+      expect(filteredParams.o2).toEqual("[FILTERED]"); // entire object filtered
+      expect(filteredParams.o1).toEqual(testInput.o1); // unchanged
+      expect(filteredParams.a1).toEqual(testInput.a1); // unchanged
+      expect(filteredParams.a2).toEqual(testInput.a2); // unchanged
+    });
+
+    test("will not filter things that do not exist", () => {
+      // Identity
+      const inputs = JSON.parse(JSON.stringify(testInput)); // quick deep Clone
+      const filteredParams = utils.filterObjectForLogging(inputs);
+      expect(filteredParams).toEqual(testInput);
+
+      (config.general!.filteredParams as string[]).push(
+        "p3",
+        "p4",
+        "o1.o3",
+        "o1.o2.p1",
+      );
+      const filteredParams2 = utils.filterObjectForLogging(inputs);
+      expect(filteredParams2).toEqual(testInput);
+      expect(filteredParams.a1).toEqual(testInput.a1); // unchanged
+      expect(filteredParams.a2).toEqual(testInput.a2); // unchanged
+    });
+
+    test("can filter a single level dot notation", () => {
+      const inputs = JSON.parse(JSON.stringify(testInput)); // quick deep Clone
+      (config.general!.filteredParams as string[]).push(
+        "p1",
+        "o1.o1p1",
+        "somethingNotExist",
+      );
+      const filteredParams = utils.filterObjectForLogging(inputs);
+      expect(filteredParams.p1).toEqual("[FILTERED]");
+      expect(filteredParams.o1.o1p1).toEqual("[FILTERED]");
+      // Unchanged things
+      expect(filteredParams.p2).toEqual(testInput.p2);
+      expect(filteredParams.o1.o1p2).toEqual(testInput.o1.o1p2);
+      expect(filteredParams.o1.o2).toEqual(testInput.o1.o2);
+      expect(filteredParams.o2).toEqual(testInput.o2);
+      expect(filteredParams.a1).toEqual(testInput.a1);
+      expect(filteredParams.a2).toEqual(testInput.a2);
+    });
+
+    test("can filter two levels deep", () => {
+      const inputs = JSON.parse(JSON.stringify(testInput)); // quick deep Clone
+      (config.general!.filteredParams as string[]).push(
+        "p2",
+        "o1.o2.o2p1",
+        "o1.o2.notThere",
+      );
+      const filteredParams = utils.filterObjectForLogging(inputs);
+      expect(filteredParams.p2).toEqual("[FILTERED]");
+      expect(filteredParams.o1.o2.o2p1).toEqual("[FILTERED]");
+      // Unchanged things
+      expect(filteredParams.p1).toEqual(testInput.p1);
+      expect(filteredParams.o1.o1p1).toEqual(testInput.o1.o1p1);
+      expect(filteredParams.o1.o2.o2p2).toEqual(testInput.o1.o2.o2p2);
+      expect(filteredParams.a1).toEqual(testInput.a1);
+      expect(filteredParams.a2).toEqual(testInput.a2);
+    });
+
+    test("can filter with a function rather than an array", () => {
+      const inputs = JSON.parse(JSON.stringify(testInput)); // quick deep Clone
+      config.general!.filteredParams = () => {
+        return ["p1", "p2", "o2"];
+      };
+
+      const filteredParams = utils.filterObjectForLogging(inputs);
+      expect(filteredParams.p1).toEqual("[FILTERED]");
+      expect(filteredParams.p2).toEqual("[FILTERED]");
+      expect(filteredParams.o2).toEqual("[FILTERED]"); // entire object filtered
+      // Unchanged things
+      expect(filteredParams.o1).toEqual(testInput.o1);
+      expect(filteredParams.a1).toEqual(testInput.a1);
+      expect(filteredParams.a2).toEqual(testInput.a2);
+    });
+
+    test("short arrays will be displayed as-is", () => {
+      config.logger!.maxLogArrayLength = 100;
+      const inputs = JSON.parse(JSON.stringify(testInput)); // quick deep Clone
+      const filteredParams = utils.filterObjectForLogging(inputs);
+      expect(filteredParams.a1).toEqual(testInput.a1);
+      expect(filteredParams.a2).toEqual(testInput.a2);
+    });
+
+    test("long arrays will be collected", () => {
+      config.logger!.maxLogArrayLength = 10;
+      const inputs = JSON.parse(JSON.stringify(testInput)); // quick deep Clone
+      const filteredParams = utils.filterObjectForLogging(inputs);
+      expect(filteredParams.a1).toEqual(testInput.a1);
+      expect(filteredParams.a2).toEqual("11 items");
+    });
+  });
+
+  describe("utils.filterResponseForLogging", () => {
+    beforeEach(() => {
+      config.logger!.maxLogArrayLength = 100;
+      expect(config.general!.filteredResponse.length).toEqual(0);
+    });
+
+    afterEach(() => {
+      // after each test, empty the array
+      config.general!.filteredResponse = [];
+      config.logger!.maxLogArrayLength = 10;
+    });
+
+    const testInput = {
+      p1: 1,
+      p2: "s3cr3t",
+      o1: {
+        o1p1: 1,
+        o1p2: "also-s3cr3t",
+        o2: {
+          o2p1: "this is ok",
+          o2p2: "extremely-s3cr3t",
+        },
+      },
+      o2: {
+        name: "same as o1`s inner object!",
+        o2p1: "nothing secret",
+      },
+      a1: ["a", "b", "c"],
+      a2: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
+    };
+
+    test("can filter top level params, no matter the type", () => {
+      const inputs = JSON.parse(JSON.stringify(testInput)); // quick deep Clone
+      (config.general!.filteredResponse as string[]).push("p1", "p2", "o2");
+      const filteredResponse = utils.filterResponseForLogging(inputs);
+      expect(filteredResponse.p1).toEqual("[FILTERED]");
+      expect(filteredResponse.p2).toEqual("[FILTERED]");
+      expect(filteredResponse.o2).toEqual("[FILTERED]"); // entire object filtered
+      expect(filteredResponse.o1).toEqual(testInput.o1); // unchanged
+      expect(filteredResponse.a1).toEqual(testInput.a1); // unchanged
+      expect(filteredResponse.a2).toEqual(testInput.a2); // unchanged
+    });
+
+    test("will not filter things that do not exist", () => {
+      // Identity
+      const inputs = JSON.parse(JSON.stringify(testInput)); // quick deep Clone
+      const filteredResponse = utils.filterResponseForLogging(inputs);
+      expect(filteredResponse).toEqual(testInput);
+
+      (config.general!.filteredResponse as string[]).push(
+        "p3",
+        "p4",
+        "o1.o3",
+        "o1.o2.p1",
+      );
+      const filteredResponse2 = utils.filterResponseForLogging(inputs);
+      expect(filteredResponse2).toEqual(testInput);
+      expect(filteredResponse2.a1).toEqual(testInput.a1); // unchanged
+      expect(filteredResponse2.a2).toEqual(testInput.a2); // unchanged
+    });
+
+    test("can filter a single level dot notation", () => {
+      const inputs = JSON.parse(JSON.stringify(testInput)); // quick deep Clone
+      (config.general!.filteredResponse as string[]).push(
+        "p1",
+        "o1.o1p1",
+        "somethingNotExist",
+      );
+      const filteredResponse = utils.filterResponseForLogging(inputs);
+      expect(filteredResponse.p1).toEqual("[FILTERED]");
+      expect(filteredResponse.o1.o1p1).toEqual("[FILTERED]");
+      // Unchanged things
+      expect(filteredResponse.p2).toEqual(testInput.p2);
+      expect(filteredResponse.o1.o1p2).toEqual(testInput.o1.o1p2);
+      expect(filteredResponse.o1.o2).toEqual(testInput.o1.o2);
+      expect(filteredResponse.o2).toEqual(testInput.o2);
+      expect(filteredResponse.a1).toEqual(testInput.a1);
+      expect(filteredResponse.a2).toEqual(testInput.a2);
+    });
+
+    test("can filter two levels deep", () => {
+      const inputs = JSON.parse(JSON.stringify(testInput)); // quick deep Clone
+      (config.general!.filteredResponse as string[]).push(
+        "p2",
+        "o1.o2.o2p1",
+        "o1.o2.notThere",
+      );
+      const filteredResponse = utils.filterResponseForLogging(inputs);
+      expect(filteredResponse.p2).toEqual("[FILTERED]");
+      expect(filteredResponse.o1.o2.o2p1).toEqual("[FILTERED]");
+      // Unchanged things
+      expect(filteredResponse.p1).toEqual(testInput.p1);
+      expect(filteredResponse.o1.o1p1).toEqual(testInput.o1.o1p1);
+      expect(filteredResponse.o1.o2.o2p2).toEqual(testInput.o1.o2.o2p2);
+      expect(filteredResponse.a1).toEqual(testInput.a1);
+      expect(filteredResponse.a2).toEqual(testInput.a2);
+    });
+
+    test("can filter with a function rather than an array", () => {
+      const inputs = JSON.parse(JSON.stringify(testInput)); // quick deep Clone
+      config.general!.filteredResponse = () => {
+        return ["p1", "p2", "o2"];
+      };
+
+      const filteredResponse = utils.filterResponseForLogging(inputs);
+      expect(filteredResponse.p1).toEqual("[FILTERED]");
+      expect(filteredResponse.p2).toEqual("[FILTERED]");
+      expect(filteredResponse.o2).toEqual("[FILTERED]"); // entire object filtered
+      expect(filteredResponse.o1).toEqual(testInput.o1); // unchanged
+      expect(filteredResponse.a1).toEqual(testInput.a1);
+      expect(filteredResponse.a2).toEqual(testInput.a2);
+    });
+
+    test("long arrays will be collected", () => {
+      config.logger!.maxLogArrayLength = 10;
+      const inputs = JSON.parse(JSON.stringify(testInput)); // quick deep Clone
+      const filteredResponse = utils.filterResponseForLogging(inputs);
+      expect(filteredResponse.a1).toEqual(testInput.a1);
+      expect(filteredResponse.a2).toEqual("11 items");
+    });
+
+    test("safeGlobSync to match normal glob.sync", () => {
+      const directory = __dirname; // if it is windows platform includes backslash (\\)
+      const pattern = "/**/*.ts";
+      const normalResult = glob.sync(directory.replace(/\\/g, "/") + pattern); // do not use path.join
+
+      const safeResult = utils.safeGlobSync(path.join(directory, pattern));
+
+      expect(normalResult).toEqual(safeResult);
+    });
+  });
+});