doc-detective 1.0.1 → 1.0.3

package/README.md

@@ -6,7 +6,7 @@ Doc Detective ingests text files, parses them for test actions, then executes th
 
 This project handles test parsing and web-based UI testing--it doesn't support results reporting or notifications. This framework is a part of testing infrastructures and needs to be complimented by other components.
 
-Doc Detective uses `puppeteer` to install, launch, and drive Chromium to perform tests. `puppeteer` removes the requirement to manually configure a local web browser and enables easy screenshotting and video recording.
+Doc Detective uses `puppeteer` to install, launch, and drive Chromium to perform tests. `puppeteer` removes the requirement to manually configure a local web browser and enables easy screenshotting and video recording. In the event `puppeteer` fails to launch Chromium, Doc Detective tries to fall back to local installs of Chromium, Chrome, and Firefox.
 
 **Note:** By default, `puppeteer`'s Chromium doesn't run in Docker containers, which means that `puppeteer` doesn't work either. Don't run Doc Detective in a Docker container unless you first confirm that you have a custom implementation of headless Chrome/Chromium functional in the container. The approved answer to [this question](https://askubuntu.com/questions/79280/how-to-install-chrome-browser-properly-via-command-line) works for me, but it may not work in all environments.
 
@@ -18,8 +18,6 @@ You can use Doc Detective as an [NPM package](#npm-package) or a standalone [CLI
 
 Doc Detective integrates with Node projects as an NPM package. When using the NPM package, you must specify all options in the `run()` method's `config` argument, which is a JSON object with the same structure as [config.json](https://github.com/hawkeyexl/doc-detective/blob/master/sample/config.json).
 
-0.  Install prerequisites:
-    - [FFmpeg](https://ffmpeg.org/) (Only required if you want the [Start recording](#start-recording) action to output GIFs. Not required for MP4 output.)
 1.  In a terminal, navigate to your Node project, then install Doc Detective:
 
     ```bash
@@ -45,7 +43,6 @@ You can run Doc Detective as a standalone CLI tool. When running as a CLI tool,
 0.  Install prerequisites:
 
     - [Node.js](https://nodejs.org/)
-    - [FFmpeg](https://ffmpeg.org/) (Only required if you want the [Start recording](#start-recording) action to output GIFs. Not required for MP4 output.)
 
 1.  In a terminal, clone the repo and install dependencies:
 
@@ -124,7 +121,7 @@ Advanced format:
   "type": {
     "keys": "$SHORTHAIR_CAT_SEARCH",
     "trailingSpecialKey": "Enter",
-    "envs": "./sample/variables.env"
+    "env": "./sample/variables.env"
   }
 }
 ```
@@ -189,7 +186,7 @@ Advanced format with an environment variable:
   "css": "input#password",
   "keys": "$PASSWORD",
   "trailingSpecialKey": "Enter",
-  "envs": "./sample/variables.env"
+  "env": "./sample/variables.env"
 }
 ```
 
@@ -258,9 +255,33 @@ Format:
 }
 ```
 
+### HTTP request
+
+Perform a generic HTTP request, for example to a REST API. Checks if the server returns an acceptable status code. If `uri` doesn't include a protocol, the protocol defaults to HTTPS. If `statusCodes` isn't specified, defaults to `[200]`.
+
+Format:
+
+```json
+{
+  "action": "httpRequest",
+  "uri": "https://www.api-server.com",
+  "method": "post",
+  "requestHeaders": {
+    "header": "value"
+  },
+  "requestParams": {
+    "param": "value"
+  },
+  "requestData": {
+    "field": "value"
+  },
+  "statusCodes": [ 200 ]
+}
+```
+
 ### Check a link
 
-Check if a link returns an acceptable status code from a GET request. If `uri` doesn't include a protocol, the protocol defaults to HTTPS. If `statuscodes` isn't specified, defaults to `[200]`.
+Check if a link returns an acceptable status code from a GET request. If `uri` doesn't include a protocol, the protocol defaults to HTTPS. If `statusCodes` isn't specified, defaults to `[200]`.
 
 Format:
 
@@ -276,7 +297,7 @@ Format:
 
 Start recording the current browser viewport. Must be followed by a `stopRecording` action. Supported extensions: .mp4, .gif
 
-**Note:** `.gif` format is **not** recommended. Because of file format and encoding differences, `.gif` files tend to be ~6.5 times larger than `.mp4` files, and with lower visual fidelity. But if `.gif` is a hard requirement for you, it's here. Creating `.gif` files requires `ffmpeg` installed on the machine that runs Doc Detective and also creates `.mp4` files of the recordings.
+**Note:** `.gif` format is **not** recommended. Because of file format and encoding differences, `.gif` files tend to be ~6.5 times larger than `.mp4` files, and with lower visual fidelity. But if `.gif` is a hard requirement for you, it's here.
 
 Format:
 
@@ -521,22 +542,24 @@ Analytics reporting is off by default. If you want to make extra sure that Doc D
 
 **Note:** Updating Doc Detective may revert any modified code, so be ready to make code edits repeatedly.
 
-## Potential future features
+## Potential future updates
 
-- Browser auto-detection and fallback.
-- Improved default config experience.
-- Environment variable overrides for config options.
 - Docker image with bundled Chromium/Chrome/Firefox.
 - New/upgraded test actions:
-  - New: Curl commands. (Support substitution/setting env vars. Only check for `200 OK`.)
   - New: Test if a referenced image (such as an icon) is present in the captured screenshot.
+  - Upgrade: `httpRequest` response data validation.
+  - Upgrade: `httpRequest` response header validation.
+  - Upgrade: Additional `httpRequest` input sanitization.
   - Upgrade: `screenshot` and `startRecording` boolean for whether to perform the action or not if the expected output file already exists.
-  - Upgrade: `startRecording` to remove MP4 when the output is a GIF.
   - Upgrade: `startRecording` and `stopRecording` to support start, stop, and intermediate test action state image matching to track differences between video captures from different runs.
   - Upgrade: `startRecording` to store the output file in a different location if a recorded action fails. This could help with debugging.
 - In-content test framing to identify when content is covered by a test defined in another file. This could enable content coverage analysis.
 - Suggest tests by parsing document text.
   - Automatically insert suggested tests based on document text.
+  - Detailed field descriptions per action.
+- Refactor tests into individual files.
+- Rewrite cross-action recording status tracking.
+
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doc-detective",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Unit test documentation (and record videos of those tests).",
   "main": "src/index.js",
   "scripts": {
@@ -24,6 +24,7 @@
   },
   "homepage": "https://github.com/hawkeyexl/doc-detective#readme",
   "dependencies": {
+    "@ffmpeg-installer/ffmpeg": "^1.1.0",
     "axios": "^0.27.2",
     "dotenv": "^16.0.2",
     "n-readlines": "^1.0.1",

package/sample/config.json

@@ -2,6 +2,8 @@
   "env": "sample/variables.env",
   "input": "sample/doc-content.md",
   "output": "sample/results.json",
+  "setup": "",
+  "cleanup": "",
   "recursive": true,
   "testExtensions": [
     ".md",

package/sample/tests.json

@@ -85,6 +85,13 @@
           "statusCodes": [
             200
           ]
+        },
+        {
+          "action": "httpRequest",
+          "uri": "$URL",
+          "statusCodes": [
+            200
+          ]
         }
       ]
     }

package/src/config.json

@@ -2,6 +2,8 @@
   "env": "",
   "input": ".",
   "output": "./results.json",
+  "setup": "",
+  "cleanup": "",
   "recursive": true,
   "testExtensions": [
     ".md",

package/src/index.js

@@ -40,8 +40,6 @@ async function main(config, argv) {
 
   // Run tests
   const results = await runTests(config, tests);
-  log(config, "debug", `RESULTS:`);
-  log(config, "debug", results);
 
   // Output
   outputResults(config, results);

package/src/lib/analytics.js

@@ -483,7 +483,7 @@ async function sendAnalytics(config, results) {
         .then(() => {
           log(
             config,
-            "info",
+            "debug",
             `Sucessfully sent analytics to ${server.displayname}.`
           );
         })

package/src/lib/tests/httpRequest.js

@@ -0,0 +1,208 @@
+const axios = require("axios");
+const { setEnvs } = require("../utils");
+
+exports.httpRequest = httpRequest;
+
+async function httpRequest(action) {
+  const methods = ["get", "post", "put", "patch", "delete"];
+
+  let status;
+  let description;
+  let result;
+  let uri;
+  let method;
+  let statusCodes = [];
+  let request = {};
+  let response;
+  let defaultPayload = {
+    uri: "",
+    method: "GET",
+    headers: {},
+    params: {},
+    requestData: {},
+    responseData: {},
+    statusCodes: ["200"],
+  };
+
+  // Load environment variables
+  if (action.env) {
+    let result = await setEnvs(action.env);
+    if (result.status === "FAIL") return { result };
+  }
+
+  // URI
+  //// Define
+  if (action.uri[0] === "$") {
+    uri = process.env[action.uri.substring(1)];
+  } else {
+    uri = action.uri || defaultPayload.uri;
+  }
+  //// Validate
+  if (!uri || typeof uri != "string") {
+    //Fail
+  } else if (uri.indexOf("://") < 0) {
+    // Insert HTTPS if no protocol present
+    uri = `https://${uri}`;
+  }
+  //// Set request
+  request.url = uri;
+
+  // Method
+  //// Define
+  if (action.method && action.method[0] === "$") {
+    method = process.env[action.method.substring(1)];
+  } else {
+    method = action.method || defaultPayload.method;
+  }
+  //// Sanitize
+  method = method.toLowerCase();
+  //// Validate
+  if (!method || typeof method != "string" || methods.indexOf(method) < 0) {
+    // No/undefined method, method isn't a string, method isn't an accepted enum
+    status = "FAIL";
+    description = `Invalid HTTP method: ${method}`;
+    result = { status, description };
+    return { result };
+  }
+  //// Set request
+  request.method = method;
+
+  // Headers
+  if (action.headers && JSON.stringify(action.headers) != "{}") {
+    //// Define
+    if (action.headers[0] === "$") {
+      headers = process.env[action.headers.substring(1)];
+      headers = JSON.parse(headers);
+    } else {
+      headers = action.headers || defaultPayload.headers;
+    }
+    //// Validate
+    //// Set request
+    if (JSON.stringify(headers) != "{}") request.headers = headers;
+  }
+
+  // Params
+  if (action.params && JSON.stringify(action.params) != "{}") {
+    //// Define
+    if (action.params[0] === "$") {
+      params = process.env[action.params.substring(1)];
+      params = JSON.parse(params);
+    } else {
+      params = action.params || defaultPayload.params;
+    }
+    //// Validate
+    //// Set request
+    if (params != {}) request.params = params;
+  }
+
+  // requestData
+  if (action.requestData) {
+    //// Define
+    if (action.requestData[0] === "$") {
+      requestData = process.env[action.requestData.substring(1)];
+      requestData = JSON.parse(requestData);
+    } else {
+      requestData = action.requestData || defaultPayload.requestData;
+    }
+    //// Validate
+    //// Set request
+    if (requestData != {}) request.data = requestData;
+  }
+
+  // // responseData
+  // //// Define
+  // if (action.responseData && action.responseData[0] === "$") {
+  //   responseData = process.env[action.responseData.substring(1)];
+  // } else {
+  //   responseData = action.responseData || defaultPayload.responseData;
+  // }
+  // //// Validate
+
+  // Status codes
+  //// Define
+  statusCodes = action.statusCodes || defaultPayload.statusCodes;
+  //// Sanitize
+  for (i = 0; i < statusCodes.length; i++) {
+    if (typeof statusCodes[i] === "string")
+      statusCodes[i] = Number(statusCodes[i]);
+  }
+  //// Validate
+  if (statusCodes === []) statusCodes = defaultPayload.statusCodes;
+
+  // Send request
+  response = await axios(request)
+    .then((response) => {
+      return response;
+    })
+    .catch((error) => {
+      return { error };
+    });
+
+  // If request returned an error
+  if (response.error) {
+    status = "FAIL";
+    description = `Error: ${JSON.stringify(response.error.response)}`;
+    result = { status, description };
+    return { result };
+  }
+
+  // Compare status codes
+  if (statusCodes.indexOf(response.status) >= 0) {
+    status = "PASS";
+    description = `Returned ${response.status}.`;
+  } else {
+    status = "FAIL";
+    description = `Returned ${
+      response.status
+    }. Expected one of ${JSON.stringify(statusCodes)}`;
+  }
+
+  // // Compare response and responseData
+  // if (JSON.stringify(responseData) != "{}") {
+  //   dataComparison = containsJsonValues(responseData, response.data);
+  //   if ((dataComparison.result.status = "PASS")) {
+  //     status = "PASS";
+  //     description =
+  //       description +
+  //       ` Expected response data was present in actual response data.`;
+  //   } else {
+  //     status = "FAIL";
+  //     description = description + " " + dataComparison.result.description;
+  //   }
+  // }
+
+  description = description.trim();
+  result = { status, description };
+  return { result };
+}
+
+function containsJsonValues(expected, actual) {
+  let status = "PASS";
+  let description = "";
+  Object.keys(expected).forEach((key) => {
+    if (!actual.hasOwnProperty(key)) {
+      // Key doesn't exist in actual
+      description =
+        description + `The '${key}' key did't exist in returned JSON. `;
+      status = "FAIL";
+    } else if (typeof expected[key] === "object") {
+      // Nested object recursion
+      result = containsJsonValues(expected[key], actual[key]);
+      if (result.result.status === "FAIL") status = "FAIL";
+      if (result.result.description != "")
+        description = description + " " + result.result.description;
+    } else if (expected[key] != actual[key]) {
+      // Actual value doesn't match expected
+      description =
+        description +
+        `The '${key}' key did't match the expected value. Expected: ${expected[key]}. Actual: ${actual[key]}. `;
+      status = "FAIL";
+    }
+
+    if (status === "FAIL") {
+      description = description.trim();
+    }
+  });
+  result = { status, description };
+  return { result };
+}

package/src/lib/tests.js

@@ -11,9 +11,27 @@ const PNG = require("pngjs").PNG;
 const pixelmatch = require("pixelmatch");
 const uuid = require("uuid");
 const axios = require("axios");
+const { httpRequest } = require("./tests/httpRequest");
 
 exports.runTests = runTests;
 
+const defaultBrowserPaths = {
+  linux: [
+    "/usr/bin/chromium-browser",
+    "/usr/bin/google-chrome",
+    "/usr/bin/firefox",
+  ],
+  darwin: [
+    "/Applications/Chromium.app/Contents/MacOS/Chromium",
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Firefox.app/Contents/MacOS/firefox-bin",
+  ],
+  win32: [
+    "C:/Program Files/Google/Chrome/Application/chrome.exe",
+    "C:/Program Files/Mozilla Firefox/firefox.exe",
+  ],
+};
+
 async function runTests(config, tests) {
   // Instantiate browser
   let browserConfig = {
@@ -27,14 +45,49 @@ async function runTests(config, tests) {
     },
   };
   try {
+    log(config, "debug", "Launching browser.");
     browser = await puppeteer.launch(browserConfig);
   } catch {
-    log(config,"error","Couldn't open browser.");
-    exit(1);
+    if (
+      process.platform === "linux" ||
+      process.platform === "darwin" ||
+      process.platform === "win32"
+    ) {
+      for (i = 0; i < defaultBrowserPaths[process.platform].length; i++) {
+        if (fs.existsSync(defaultBrowserPaths[process.platform][i])) {
+          log(
+            config,
+            "debug",
+            `Attempting browser fallback: ${
+              defaultBrowserPaths[process.platform][i]
+            }`
+          );
+          browserConfig.executablePath =
+            defaultBrowserPaths[process.platform][i];
+          try {
+            browser = await puppeteer.launch(browserConfig);
+            break;
+          } catch {}
+        }
+        if (i === defaultBrowserPaths[process.platform].length) {
+          log(
+            config,
+            "error",
+            "Couldn't open browser. Failed browser fallback."
+          );
+          exit(1);
+        }
+      }
+    } else {
+      log(config, "error", "Couldn't open browser.");
+      exit(1);
+    }
   }
 
   // Iterate tests
+  log(config, "info", "Running tests.");
   for (const test of tests.tests) {
+    log(config, "debug", `TEST: ${test.id}`);
     let pass = 0;
     let warning = 0;
     let fail = 0;
@@ -45,6 +98,7 @@ async function runTests(config, tests) {
     await installMouseHelper(page);
     // Iterate through actions
     for (const action of test.actions) {
+      log(config, "debug", `ACTION: ${JSON.stringify(action)}`);
       action.result = await runAction(config, action, page, videoDetails);
       if (action.result.videoDetails) {
         videoDetails = action.result.videoDetails;
@@ -53,6 +107,7 @@ async function runTests(config, tests) {
       if (action.result.status === "FAIL") fail++;
       if (action.result.status === "WARNING") warning++;
       if (action.result.status === "PASS") pass++;
+      log(config, "debug", `RESULT: ${action.result.status}. ${action.result.description}`);
     }
 
     // Close open recorders/pages
@@ -188,9 +243,13 @@ async function runAction(config, action, page, videoDetails) {
     case "checkLink":
       result = await checkLink(action);
       break;
+    case "httpRequest":
+      result = await httpRequest(action);
+      break;
   }
   return result;
 }
+
 async function checkLink(action) {
   let status;
   let description;

package/src/lib/utils.js

@@ -50,6 +50,16 @@ function setArgs(args) {
       description: "Path for a JSON file of test result output.",
       type: "string",
     })
+    .option("setup", {
+      description:
+        "Path to a file or directory to parse for tests to run before 'input' tests. Useful for preparing environments to perform tests.",
+      type: "string",
+    })
+    .option("cleanup", {
+      description:
+        "Path to a file or directory to parse for tests to run after 'input' tests. Useful for resetting environments after tests run.",
+      type: "string",
+    })
     .option("recursive", {
       alias: "r",
       description:
@@ -122,7 +132,8 @@ function setArgs(args) {
 function setLogLevel(config, argv) {
   let logLevel = "";
   let enums = ["debug", "info", "warning", "error", "silent"];
-  logLevel = argv.logLevel || process.env.DOC_LOG_LEVEL || config.logLevel || "info";
+  logLevel =
+    argv.logLevel || process.env.DOC_LOG_LEVEL || config.logLevel || "info";
   logLevel = String(logLevel).toLowerCase();
   if (enums.indexOf(logLevel) >= 0) {
     config.logLevel = logLevel;
@@ -159,7 +170,7 @@ function selectConfig(config, argv) {
     log(config, "debug", "Loaded config from function parameter.");
   } else {
     // Default
-    config = defaultConfig;
+    config = JSON.parse(JSON.stringify(defaultConfig));
     setLogLevel(config, argv);
     log(
       config,
@@ -172,16 +183,18 @@ function selectConfig(config, argv) {
 
 function setEnv(config, argv) {
   config.env = argv.env || process.env.DOC_ENV_PATH || config.env;
-  config.env = path.resolve(config.env);
-  if (config.env && fs.existsSync(config.env)) {
-    let envResult = setEnvs(config.env);
-    if (envResult.status === "PASS")
-      log(config, "debug", `Env file set: ${config.env}`);
-    if (envResult.status === "FAIL")
-      log(config, "warning", `File format issue. Can't load env file.`);
-  } else if (config.env && !fs.existsSync(config.env)) {
-    log(config, "warning", `Invalid file path. Can't load env file.`);
-  } else if (!config.env) {
+  if (config.env) {
+    config.env = path.resolve(config.env);
+    if (fs.existsSync(config.env)) {
+      let envResult = setEnvs(config.env);
+      if (envResult.status === "PASS")
+        log(config, "debug", `Env file set: ${config.env}`);
+      if (envResult.status === "FAIL")
+        log(config, "warning", `File format issue. Can't load env file.`);
+    } else {
+      log(config, "warning", `Invalid file path. Can't load env file.`);
+    }
+  } else {
     log(config, "debug", "No env file specified.");
   }
   return config;
@@ -189,9 +202,17 @@ function setEnv(config, argv) {
 
 function setInput(config, argv) {
   config.input = argv.input || process.env.DOC_INPUT_PATH || config.input;
-  config.input = path.resolve(config.input);
-  if (fs.existsSync(config.input)) {
-    log(config, "debug", `Input path set: ${config.input}`);
+  if (config.input) {
+    config.input = path.resolve(config.input);
+    if (fs.existsSync(config.input)) {
+      log(config, "debug", `Input path set: ${config.input}`);
+    } else {
+      log(
+        config,
+        "warning",
+        `Invalid input path. Reverted to default: ${config.input}`
+      );
+    }
   } else {
     config.input = path.resolve(defaultConfig.input);
     log(
@@ -210,6 +231,40 @@ function setOutput(config, argv) {
   return config;
 }
 
+function setSetup(config, argv) {
+  config.setup = argv.setup || process.env.DOC_SETUP || config.setup;
+  if (config.setup === "") {
+    log(config, "debug", `No setup tests.`);
+    return config;
+  } else {
+    config.setup = path.resolve(config.setup);
+    if (fs.existsSync(config.setup)) {
+      log(config, "debug", `Setup tests path set: ${config.setup}`);
+    } else {
+      config.setup = defaultConfig.setup;
+      log(config, "warning", `Invalid setup tests path.`);
+    }
+    return config;
+  }
+}
+
+function setCleanup(config, argv) {
+  config.cleanup = argv.cleanup || process.env.DOC_CLEANUP || config.cleanup;
+  if (config.cleanup === "") {
+    log(config, "debug", `No cleanup tests.`);
+    return config;
+  } else {
+    config.cleanup = path.resolve(config.cleanup);
+    if (fs.existsSync(config.cleanup)) {
+      log(config, "debug", `Cleanup tests path set: ${config.cleanup}`);
+    } else {
+      config.cleanup = defaultConfig.cleanup;
+      log(config, "warning", `Invalid cleanup tests path.`);
+    }
+    return config;
+  }
+}
+
 function setMediaDirectory(config, argv) {
   config.mediaDirectory =
     argv.mediaDir ||
@@ -320,24 +375,24 @@ function setBrowserPath(config, argv) {
     argv.browserPath ||
     process.env.DOC_BROWSER_PATH ||
     config.browserOptions.path;
-    if (config.browserOptions.path === "") {
-      log(config, "debug", `Browser set to default Chromium install.`);
-      return config;
+  if (config.browserOptions.path === "") {
+    log(config, "debug", `Browser set to default Chromium install.`);
+    return config;
+  } else {
+    config.browserOptions.path = path.resolve(config.browserOptions.path);
+    if (fs.existsSync(config.browserOptions.path)) {
+      log(config, "debug", `Browser path set: ${config.browserOptions.path}`);
     } else {
-      config.browserOptions.path = path.resolve(config.browserOptions.path);
-      if (fs.existsSync(config.browserOptions.path)) {
-          log(config, "debug", `Browser path set: ${config.browserOptions.path}`);
-      } else {
-          config.browserOptions.path = defaultConfig.browserOptions.path;
-          log(
-          config,
-          "warning",
-          `Invalid browser path. Reverted to default Chromium install.`
-          );
-      }
-      return config;
+      config.browserOptions.path = defaultConfig.browserOptions.path;
+      log(
+        config,
+        "warning",
+        `Invalid browser path. Reverted to default Chromium install.`
+      );
     }
+    return config;
   }
+}
 
 function setBrowserHeight(config, argv) {
   config.browserOptions.height =
@@ -467,8 +522,6 @@ function setAnalyticsServers(config, argv) {
 }
 
 function setConfig(config, argv) {
-  config = setLogLevel(config, argv);
-
   config = selectConfig(config, argv);
 
   config = setEnv(config, argv);
@@ -477,6 +530,10 @@ function setConfig(config, argv) {
 
   config = setOutput(config, argv);
 
+  config = setSetup(config, argv);
+
+  config = setCleanup(config, argv);
+
   config = setMediaDirectory(config, argv);
 
   config = setRecursion(config, argv);
@@ -506,49 +563,59 @@ function setConfig(config, argv) {
 function setFiles(config) {
   let dirs = [];
   let files = [];
+  let sequence = [];
 
   // Validate input
-  const input = path.resolve(config.input);
-  let isFile = fs.statSync(input).isFile();
-  let isDir = fs.statSync(input).isDirectory();
-  if (!isFile && !isDir) {
-    log(config, "error", "Input isn't a valid file or directory.");
-    exit(1);
-  }
-
-  // Parse input
-  if (isFile) {
-    // if single file specified
-    files[0] = input;
-    return files;
-  } else if (isDir) {
-    // Load files from drectory
-    dirs[0] = input;
-    for (let i = 0; i < dirs.length; i++) {
-      fs.readdirSync(dirs[i]).forEach((object) => {
-        let content = path.resolve(dirs[i] + "/" + object);
-        let isFile = fs.statSync(content).isFile();
-        let isDir = fs.statSync(content).isDirectory();
-        if (isFile) {
-          // is a file
+  const setup = config.setup;
+  if (setup) sequence.push(setup);
+  const input = config.input;
+  sequence.push(input);
+  const cleanup = config.cleanup;
+  if (cleanup) sequence.push(cleanup);
+
+  for (s = 0; s < sequence.length; s++) {
+    let isFile = fs.statSync(sequence[s]).isFile();
+    let isDir = fs.statSync(sequence[s]).isDirectory();
+
+    // Parse input
+    if (
+      // Is a file
+      isFile &&
+      // Isn't present in files array already
+      files.indexOf(sequence[s]) < 0 &&
+      // No extension filter or extension included in filter
+      (config.testExtensions === "" ||
+        config.testExtensions.includes(path.extname(sequence[s])))
+    ) {
+      files.push(sequence[s]);
+    } else if (isDir) {
+      // Load files from directory
+      dirs = [];
+      dirs[0] = sequence[s];
+      for (let i = 0; i < dirs.length; i++) {
+        fs.readdirSync(dirs[i]).forEach((object) => {
+          let content = path.resolve(dirs[i] + "/" + object);
+          let isFile = fs.statSync(content).isFile();
+          let isDir = fs.statSync(content).isDirectory();
           if (
-            // No specified extension filter list, or file extension is present in extension filter list.
-            config.testExtensions === "" ||
-            config.testExtensions.includes(path.extname(content))
+            // Is a file
+            isFile &&
+            // Isn't present in files array already
+            files.indexOf(s) < 0 &&
+            // No extension filter or extension included in filter
+            (config.testExtensions === "" ||
+              config.testExtensions.includes(path.extname(content)))
           ) {
             files.push(content);
-          }
-        } else if (isDir) {
-          // is a directory
-          if (config.recursive) {
+          } else if (isDir && config.recursive) {
             // recursive set to true
             dirs.push(content);
           }
-        }
-      });
+        });
+      }
     }
-    return files;
   }
+  return files;
 }
 
 // Parse files for tests
@@ -621,16 +688,22 @@ async function outputResults(config, results) {
   fs.writeFile(config.output, data, (err) => {
     if (err) throw err;
   });
+  log(config, "info", "RESULTS:");
+  log(config, "info", results);
+  log(config, "info", `See detailed results at ${config.output}`);
 }
 
 async function convertToGif(config, input, fps, width) {
+  const ffmpegPath = require("@ffmpeg-installer/ffmpeg").path;
+
   if (!fs.existsSync(input)) return { error: "Invalid input." };
   let output = path.join(
     path.parse(input).dir,
     path.parse(input).name + ".gif"
   );
   if (!fps) fps = 15;
-  let command = `ffmpeg -nostats -loglevel 0 -y -i ${input} -vf "fps=${fps},scale=${width}:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" -loop 0 ${output}`;
+
+  let command = `${ffmpegPath} -nostats -loglevel 0 -y -i ${input} -vf "fps=${fps},scale=${width}:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" -loop 0 ${output}`;
   exec(command, (error, stdout, stderr) => {
     if (error) {
       log(config, "debug", error.message);
@@ -641,6 +714,13 @@ async function convertToGif(config, input, fps, width) {
       return { stderr };
     }
     log(config, "debug", stdout);
+    fs.unlink(input, function (err) {
+      if (err) {
+        log(config, "warning", `Couldn't delete intermediate file: ${input}`);
+      } else {
+        log(config, "debug", `Deleted intermediate file: ${input}`);
+      }
+    });
     return { stdout };
   });
   return output;