eleventy-test 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Denperidge
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,56 @@
+# eleventy-test
+Eleventy is hands-down my favourite static site generator. I also make [plugins for it](https://github.com/search?q=owner%3ADenperidge%20topic%3Aeleventy-plugin&type=repositories)! So [after a while of brute forcing my Eleventy testing](https://github.com/Denperidge/eleventy-auto-cache-buster/tree/14787bebe3bb73f4c6bd971196f3bec87812044f/tests), I thought an easier solution should exist. Hopefully this is that!
+- Build using multiple Eleventy versions & configurations for your tests (called scenarios) seperately. Returns the file contents per scenario output for easy access during testing.
+- Compatible with any test framework or method.
+- Automatic installation of latest/specific Eleventy version (if not found locally).
+- Aside from the Eleventy versions used to test, this package itself has **zero** dependencies when installing.
+
+Want to see how it is in action? For the dogfooding fans, you can see this library in action in this [library's tests](tests/)!
+
+## How-to
+### Use the plugin
+1. Install the plugin
+   ```bash
+   npm install --save-dev eleventy-test
+   yarn add -D eleventy-test
+   ```
+2. Create `${projectRoot}/tests/scenarios/`
+3. Create a subdirectory for each scenario you wish to set up. The directory name should start with the *exact* (1.0.2) or *major* (1) version. The format should be one of the following:
+    - `${projectRoot}/tests/scenarios/${eleventyVersion}--${label}/`
+    - `${projectRoot}/tests/scenarios/${eleventyVersion}/`
+3. Add an Eleventy configuration file to the scenario
+4. Use the buildScenarios function and its output as needed
+    ```js
+    import { buildScenarios } from "eleventy-test";
+    import test from "ava";
+
+    // omit the second parameter to return as array
+    const resultsAsDict = await buildScenarios(cwd(), false);
+
+    test("Check if index.html is consistent across builds", t => {
+        t.deepEqual(
+            results["3--example"].getFileContent("/index.html"), 
+            results["3.0.0--identical-example"].getFileContent("/index.html"));
+    });
+    ```
+
+And that's it! eleventy-test will handle installing the right versons and reading (and caching) the file contents back to you.
+
+
+> Note: you might want to add `eleventy-test-out/` to your .gitignore file!
+
+### Run/develop/test locally
+This require Node.js & yarn to be installed.
+```bash
+git clone https://github.com/Denperidge/eleventy-test
+cd eleventy-test
+yarn install
+
+yarn watch  # Watch for changes
+yarn build  # Build
+yarn start  # Run built js as module (see bottom of index.ts require.main === module)
+yarn test  # Run the tests from tests/test.mjs
+```
+
+## License
+This project is licensed under the [MIT License](LICENSE).

package/dist/ScenarioOutput.d.ts

@@ -0,0 +1,12 @@
+export declare function recursiveFindFiles(dir: string, files?: string[]): string[];
+export default class ScenarioOutput {
+    eleventyOutputDir: string;
+    title: string;
+    private _files;
+    private cache;
+    constructor(pEleventyOutputDir: string, pTitle: string);
+    get files(): {
+        [key: string]: () => string;
+    };
+    getFileContent(filename: any): string;
+}

package/dist/eleventyUtils.d.ts

@@ -0,0 +1,9 @@
+import ScenarioOutput from "./ScenarioOutput";
+export declare function ensureEleventyExists(projectRoot: string, eleventyVersion: string): string;
+export declare function buildEleventy({ eleventyVersion, scenarioDir, scenarioName, projectRoot, globalInputDir }: {
+    eleventyVersion: any;
+    scenarioDir: any;
+    scenarioName: any;
+    projectRoot?: string;
+    globalInputDir: any;
+}): Promise<ScenarioOutput>;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import ScenarioOutput from "./ScenarioOutput";
+export * from "./eleventyUtils";
+export declare function buildScenarios(projectRoot: string, returnArray?: true): Promise<ScenarioOutput[]>;
+export declare function buildScenarios(projectRoot: string, returnArray?: false): Promise<{
+    [key: string]: ScenarioOutput;
+}>;

package/dist/index.js

@@ -0,0 +1,199 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  buildEleventy: () => buildEleventy,
+  buildScenarios: () => buildScenarios,
+  ensureEleventyExists: () => ensureEleventyExists
+});
+module.exports = __toCommonJS(src_exports);
+var import_process2 = require("process");
+var import_path3 = require("path");
+var import_fs3 = require("fs");
+
+// src/eleventyUtils.ts
+var import_child_process = require("child_process");
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+var import_process = require("process");
+
+// src/ScenarioOutput.ts
+var import_path = require("path");
+var import_fs = require("fs");
+function recursiveFindFiles(dir, files = []) {
+  const foundDirs = [];
+  (0, import_fs.readdirSync)(dir).forEach((name) => {
+    const path = (0, import_path.join)(dir, name);
+    const stat = (0, import_fs.lstatSync)(path);
+    if (stat.isDirectory()) {
+      foundDirs.push(path);
+    } else if (stat.isFile()) {
+      files.push(path);
+    }
+  });
+  foundDirs.forEach((dir2) => {
+    files = recursiveFindFiles(dir2, files);
+  });
+  return files;
+}
+var ScenarioOutput = class {
+  eleventyOutputDir;
+  title;
+  _files;
+  cache;
+  constructor(pEleventyOutputDir, pTitle) {
+    this._files = {};
+    this.cache = {};
+    this.title = pTitle;
+    this.eleventyOutputDir = pEleventyOutputDir;
+    recursiveFindFiles(this.eleventyOutputDir).forEach((filepath) => {
+      this._files[filepath.replace(this.eleventyOutputDir, "")] = function() {
+        return (0, import_fs.readFileSync)(filepath, { encoding: "utf-8" });
+      };
+    });
+  }
+  get files() {
+    return this._files;
+  }
+  getFileContent(filename) {
+    if (!Object.keys(this.cache).includes(filename)) {
+      this.cache[filename] = this._files[filename]();
+    }
+    return this.cache[filename];
+  }
+};
+
+// src/eleventyUtils.ts
+function ensureEleventyExists(projectRoot, eleventyVersion) {
+  const eleventyDir = (0, import_path2.join)(projectRoot, "node_modules/@11ty/eleventy" + eleventyVersion);
+  if ((0, import_fs2.existsSync)(eleventyDir)) {
+    return eleventyDir;
+  } else {
+    console.log("Not existing!", eleventyVersion);
+    if ((0, import_fs2.existsSync)((0, import_path2.join)(projectRoot, "package-lock.json"))) {
+      throw Error("not implemented");
+    } else if ((0, import_fs2.existsSync)((0, import_path2.join)(projectRoot, "yarn.lock"))) {
+      try {
+        (0, import_child_process.execSync)(`yarn add -D @11ty/eleventy${eleventyVersion}@npm:@11ty/eleventy@${eleventyVersion}`, { cwd: projectRoot });
+      } catch (e) {
+        console.error(`Couldn't install eleventy ${eleventyVersion} using yarn`);
+        throw e;
+      }
+      return eleventyDir;
+    } else {
+      throw new Error("Could not determine package manager");
+    }
+  }
+}
+async function buildEleventy({
+  eleventyVersion,
+  scenarioDir,
+  scenarioName,
+  projectRoot = (0, import_process.cwd)(),
+  globalInputDir
+}) {
+  return new Promise((resolve, reject) => {
+    const eleventyDir = ensureEleventyExists(projectRoot, eleventyVersion);
+    const bin = JSON.parse(
+      (0, import_fs2.readFileSync)(
+        (0, import_path2.join)(eleventyDir, "package.json"),
+        { encoding: "utf-8" }
+      )
+    ).bin.eleventy;
+    const pathToBin = (0, import_path2.join)(eleventyDir, bin);
+    const scenarioInputDir = (0, import_path2.join)(scenarioDir, "input");
+    const inputDir = (0, import_fs2.existsSync)(scenarioInputDir) ? scenarioInputDir : globalInputDir;
+    if (inputDir == void 0) {
+      throw Error("inputDir is undefined!");
+    }
+    const outputDir = (0, import_path2.join)(scenarioDir, "eleventy-test-out");
+    (0, import_fs2.rmSync)(outputDir, { force: true, recursive: true });
+    try {
+      const out = (0, import_child_process.fork)(
+        pathToBin,
+        ["--input", inputDir, "--output", outputDir],
+        { cwd: scenarioDir }
+      );
+      out.on("message", (msg) => {
+        console.log(msg);
+      });
+      out.on("close", (code) => {
+        const output = new ScenarioOutput(outputDir, scenarioName);
+        resolve(output);
+      });
+    } catch (e) {
+      throw e;
+    }
+  });
+}
+
+// src/index.ts
+var DIR_BASE = "tests";
+var DIR_SCENARIOS = (0, import_path3.join)(DIR_BASE, "scenarios");
+var DIR_INPUT = (0, import_path3.join)(DIR_BASE, "input");
+async function buildScenarios(projectRoot = (0, import_process2.cwd)(), returnArray = true) {
+  return new Promise(async (resolve, reject) => {
+    const scenariosDir = (0, import_path3.join)(projectRoot, DIR_SCENARIOS);
+    const globalInputDir = (0, import_fs3.existsSync)((0, import_path3.join)(projectRoot, DIR_INPUT)) ? (0, import_path3.join)(projectRoot, DIR_INPUT) : void 0;
+    const scenarioDirs = (0, import_fs3.readdirSync)(scenariosDir);
+    const scenarioOutputs = [];
+    for (let i = 0; i < scenarioDirs.length; i++) {
+      const scenarioDirname = scenarioDirs[i];
+      const scenarioDir = (0, import_path3.join)(scenariosDir, scenarioDirname);
+      let scenarioEleventyVersion = scenarioDirname.includes("--") ? scenarioDirname.split("--")[0] : scenarioDirname;
+      if (scenarioEleventyVersion.length < 5) {
+        const scenarioMajorVersion = scenarioDirname[0];
+        const versions = await (await fetch("https://api.github.com/repos/11ty/eleventy/tags")).json();
+        for (let i2 = 0; i2 < versions.length; i2++) {
+          const version = versions[i2];
+          if (!version.name.includes("-") && version.name[1] == scenarioMajorVersion) {
+            scenarioEleventyVersion = version.name.substring(1);
+            break;
+          }
+        }
+      }
+      scenarioOutputs.push(await buildEleventy({
+        eleventyVersion: scenarioEleventyVersion,
+        scenarioName: scenarioDirname,
+        globalInputDir,
+        projectRoot,
+        scenarioDir
+      }));
+    }
+    if (returnArray) {
+      resolve(scenarioOutputs);
+    } else {
+      const returnDict = {};
+      scenarioOutputs.forEach((scenarioOutput) => {
+        returnDict[scenarioOutput.title] = scenarioOutput;
+      });
+      resolve(returnDict);
+    }
+  });
+}
+if (require.main === module) {
+  buildScenarios((0, import_process2.cwd)());
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildEleventy,
+  buildScenarios,
+  ensureEleventyExists
+});

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "eleventy-test",
+  "version": "0.1.0",
+  "description": "Multi-configuration testing for Eleventy plugins",
+  "license": "MIT",
+  "repository": "https://github.com/Denperidge/eleventy-test.git",
+  "author": "Denperidge",
+  "main": "dist/index.js",
+  "files": ["dist/*"],
+  "scripts": {
+    "start": "node dist/index.js",
+    "watch": "npm-run-all --parallel 'build:js --watch' 'build:types -w'",
+    "build": "yarn build:js && yarn build:types",
+    "build:js": "esbuild src/index.ts --bundle --outfile=dist/index.js --platform=node",
+    "build:types": "tsc --declaration src/index.ts --emitDeclarationOnly --outDir ./dist",
+    "test": "ava tests/test.mjs --timeout=30s"
+  },
+  "devDependencies": {
+    "@11ty/eleventy1.0.2": "npm:@11ty/eleventy@1.0.2",
+    "@11ty/eleventy2.0.0-canary.8": "npm:@11ty/eleventy@2.0.0-canary.8",
+    "@11ty/eleventy2.0.1": "npm:@11ty/eleventy@2.0.1",
+    "@11ty/eleventy3.0.0": "npm:@11ty/eleventy@3.0.0",
+    "@types/node": "^22.10.1",
+    "ava": "^6.2.0",
+    "esbuild": "^0.24.0",
+    "jsdom": "^25.0.1",
+    "npm-run-all": "^4.1.5",
+    "typescript": "^5.7.2"
+  }
+}