@markedjs/testutils 17.0.1-1 → 17.0.1-2

package/lib/get-tests.d.ts

@@ -0,0 +1,19 @@
+import { Tests } from "./types.js";
+/**
+ * Get tests from a directory or file
+ * @param dirs Can be a string or an array of strings
+ * @returns The return type will match the input, a tests object or an array of tests objects
+ */
+export declare function getTests(dir: string[]): Promise<Tests[]>;
+export declare function getTests(dir: string): Promise<Tests>;
+/**
+ * Get all marked tests
+ * @returns All marked spec tests
+ */
+export declare function getAllMarkedSpecTests(): Promise<{
+    CommonMark: Tests;
+    GFM: Tests;
+    New: Tests;
+    Original: Tests;
+    ReDOS: Tests;
+}>;

package/lib/get-tests.js

@@ -0,0 +1,28 @@
+import { loadTests } from "./load-tests.js";
+import { resolve } from "node:path";
+export async function getTests(dirs) {
+    if (Array.isArray(dirs)) {
+        return await Promise.all(dirs.map((dir) => loadTests(dir)));
+    }
+    return await loadTests(dirs);
+}
+/**
+ * Get all marked tests
+ * @returns All marked spec tests
+ */
+export async function getAllMarkedSpecTests() {
+    const tests = await getTests([
+        resolve("./node_modules/marked-repo/test/specs/commonmark"),
+        resolve("./node_modules/marked-repo/test/specs/gfm"),
+        resolve("./node_modules/marked-repo/test/specs/new"),
+        resolve("./node_modules/marked-repo/test/specs/original"),
+        resolve("./node_modules/marked-repo/test/specs/redos"),
+    ]);
+    return {
+        CommonMark: tests[0],
+        GFM: tests[1],
+        New: tests[2],
+        Original: tests[3],
+        ReDOS: tests[4],
+    };
+}

package/lib/helpers.d.ts

@@ -0,0 +1 @@
+export declare function resolvePath(p: string): string;

package/lib/helpers.js

@@ -0,0 +1,6 @@
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export function resolvePath(p) {
+    return resolve(__dirname, p);
+}

package/lib/html-differ.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Check if html will display the same
+ * @param actual The actual HTML
+ * @param expected The expected HTML
+ * @returns HTML is the same
+ */
+export declare function htmlIsEqual(actual: string, expected: string): boolean;
+/**
+ * Get the first difference between actual and expected HTML
+ * @param actual The actual HTML
+ * @param expected The expected HTML
+ * @param padding The number of characters to show around the first difference
+ * @returns An object with the characters around the index of the first difference in the expected and actual strings
+ */
+export declare function firstDiff(actual: string, expected: string, padding?: number): {
+    actual: string;
+    expected: string;
+};

package/lib/html-differ.js

@@ -0,0 +1,57 @@
+import { HtmlDiffer } from "@markedjs/html-differ";
+const htmlDiffer = new HtmlDiffer({
+    ignoreSelfClosingSlash: true,
+    ignoreComments: false,
+});
+/**
+ * Check if html will display the same
+ * @param actual The actual HTML
+ * @param expected The expected HTML
+ * @returns HTML is the same
+ */
+export function htmlIsEqual(actual, expected) {
+    return htmlDiffer.isEqual(actual, expected);
+}
+/**
+ * Get the first difference between actual and expected HTML
+ * @param actual The actual HTML
+ * @param expected The expected HTML
+ * @param padding The number of characters to show around the first difference
+ * @returns An object with the characters around the index of the first difference in the expected and actual strings
+ */
+export function firstDiff(actual, expected, padding = 30) {
+    const diffHtml = htmlDiffer.diffHtml(actual, expected);
+    const result = diffHtml.reduce((obj, diff) => {
+        if (diff.added) {
+            if (obj.firstIndex === null) {
+                obj.firstIndex = obj.expected.length;
+            }
+            obj.expected += diff.value;
+        }
+        else if (diff.removed) {
+            if (obj.firstIndex === null) {
+                obj.firstIndex = obj.actual.length;
+            }
+            obj.actual += diff.value;
+        }
+        else {
+            obj.actual += diff.value;
+            obj.expected += diff.value;
+        }
+        return obj;
+    }, {
+        firstIndex: null,
+        actual: "",
+        expected: "",
+    });
+    if (result.firstIndex === null) {
+        return {
+            actual: "",
+            expected: "",
+        };
+    }
+    return {
+        actual: result.actual.substring(result.firstIndex - padding, result.firstIndex + padding),
+        expected: result.expected.substring(result.firstIndex - padding, result.firstIndex + padding),
+    };
+}

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./get-tests.js";
+export * from "./html-differ.js";
+export * from "./output-table.js";
+export * from "./run-tests.js";
+export * from "./types.js";

package/lib/index.js

@@ -0,0 +1,5 @@
+export * from "./get-tests.js";
+export * from "./html-differ.js";
+export * from "./output-table.js";
+export * from "./run-tests.js";
+export * from "./types.js";

package/lib/load-tests.d.ts

@@ -0,0 +1,2 @@
+import { Tests } from "./types.js";
+export declare function loadTests(fileOrDir: string): Promise<Tests>;

package/lib/load-tests.js

@@ -0,0 +1,78 @@
+import fs from "node:fs";
+import path from "node:path";
+import fm from "front-matter";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+export async function loadTests(fileOrDir) {
+    const isFile = fs.statSync(fileOrDir).isFile();
+    const files = isFile ? [path.basename(fileOrDir)] : fs.readdirSync(fileOrDir);
+    const dir = isFile ? path.dirname(fileOrDir) : fileOrDir;
+    const obj = {};
+    for (const file of files) {
+        const ext = path.extname(file);
+        const name = path.basename(file, ext);
+        const absFile = path.join(dir, file);
+        let specs = [];
+        switch (ext) {
+            case ".md": {
+                const content = fm(fs.readFileSync(absFile, "utf8"));
+                const skip = content.attributes.skip;
+                delete content.attributes.skip;
+                const only = content.attributes.only;
+                delete content.attributes.only;
+                specs.push({
+                    section: name,
+                    markdown: content.body,
+                    html: fs.readFileSync(absFile.replace(/[^.]+$/, "html"), "utf8"),
+                    options: content.attributes,
+                    only,
+                    skip,
+                });
+                break;
+            }
+            case ".js":
+            case ".mjs":
+            case ".cjs":
+            case ".json": {
+                let json;
+                try {
+                    // try require first
+                    json = await require(absFile);
+                }
+                catch (err) {
+                    if (typeof err === "object" &&
+                        err !== null &&
+                        "code" in err &&
+                        err.code !== "ERR_REQUIRE_ESM") {
+                        throw err;
+                    }
+                    // must import esm
+                    json = await import(absFile);
+                }
+                specs = specs.concat(json);
+                break;
+            }
+            default:
+            // do nothing
+        }
+        for (let i = 0; i < specs.length; i++) {
+            const spec = specs[i];
+            if (!spec.section) {
+                spec.section = `${name}[${i}]`;
+            }
+            if (!obj[spec.section]) {
+                obj[spec.section] = {
+                    total: 0,
+                    pass: 0,
+                    specs: [],
+                };
+            }
+            obj[spec.section].total++;
+            if (!spec.shouldFail) {
+                obj[spec.section].pass++;
+            }
+            obj[spec.section].specs.push(spec);
+        }
+    }
+    return obj;
+}

package/lib/output-table.d.ts

@@ -0,0 +1,7 @@
+import { Tests } from "./types.js";
+/**
+ * Display a table in stdout that lists the sections and what percentage of the tests are not marked shouldFail
+ * @param title The title to display above the table
+ * @param tests The tests to display a table for
+ */
+export declare function outputCompletionTable(title: string, tests: Tests): void;

package/lib/output-table.js

@@ -0,0 +1,28 @@
+/**
+ * Display a table in stdout that lists the sections and what percentage of the tests are not marked shouldFail
+ * @param title The title to display above the table
+ * @param tests The tests to display a table for
+ */
+export function outputCompletionTable(title, tests) {
+    let longestName = 0;
+    let maxTests = 0;
+    for (const section in tests) {
+        longestName = Math.max(section.length, longestName);
+        maxTests = Math.max(tests[section].total, maxTests);
+    }
+    const maxTestsLen = ("" + maxTests).length;
+    const spaces = maxTestsLen * 2 + longestName + 11;
+    console.log("-".padEnd(spaces + 4, "-"));
+    console.log(`| ${title
+        .padStart(Math.ceil((spaces + title.length) / 2))
+        .padEnd(spaces)} |`);
+    console.log(`| ${" ".padEnd(spaces)} |`);
+    for (const section in tests) {
+        console.log(`| ${section.padEnd(longestName)} ${("" + tests[section].pass).padStart(maxTestsLen)} of ${("" + tests[section].total).padStart(maxTestsLen)} ${((100 * tests[section].pass) /
+            tests[section].total)
+            .toFixed()
+            .padStart(4)}% |`);
+    }
+    console.log("-".padEnd(spaces + 4, "-"));
+    console.log();
+}

package/lib/run-tests.d.ts

@@ -0,0 +1,25 @@
+import { Marked, MarkedExtension } from "marked";
+import { Tests } from "./types.js";
+interface RunTestsOptions {
+    tests?: Tests | string;
+    defaultMarkedOptions?: MarkedExtension;
+    parse?: (markedown: string, options: MarkedExtension, addExtension: (marked: Marked) => void) => string | Promise<string>;
+    addExtension?: (marked: Marked) => void;
+    isEqual?: (actual: string, expected: string) => boolean;
+    diff?: (actual: string, expected: string, padding?: number) => {
+        actual: string;
+        expected: string;
+    };
+}
+/**
+ * Run spec tests
+ */
+export declare function runTests({ tests, defaultMarkedOptions, parse, addExtension, isEqual, diff, }?: RunTestsOptions): Promise<void>;
+/**
+ * Run all marked specs with an added extension and optionally output completion table
+ */
+export declare function runAllMarkedSpecTests({ addExtension, outputCompletionTables, }?: {
+    addExtension?: (marked: Marked) => void;
+    outputCompletionTables?: boolean;
+}): Promise<void>;
+export {};

package/lib/run-tests.js

@@ -0,0 +1,100 @@
+import { htmlIsEqual, firstDiff } from "./html-differ.js";
+import { getTests, getAllMarkedSpecTests } from "./get-tests.js";
+import nodeTest from "node:test";
+import assert from "node:assert";
+import { Marked } from "marked";
+import { outputCompletionTable } from "./output-table.js";
+/**
+ * Run spec tests
+ */
+export async function runTests({ tests = {}, defaultMarkedOptions = {}, parse = parseMarked, addExtension = () => { }, isEqual = htmlIsEqual, diff = firstDiff, } = {}) {
+    if (typeof tests === "string") {
+        tests = await getTests(tests);
+    }
+    for (const section of Object.keys(tests)) {
+        const sectionTests = tests[section];
+        const hasOnly = sectionTests.specs.some((test) => test.only);
+        await nodeTest(section, { only: hasOnly }, async (t) => {
+            for (const test of sectionTests.specs) {
+                const options = {
+                    ...defaultMarkedOptions,
+                    ...(test.options || {}),
+                };
+                const example = test.example ? " example " + test.example : "";
+                const passFail = test.shouldFail ? "fail" : "pass";
+                if (typeof options.silent === "undefined") {
+                    options.silent = true;
+                }
+                await t.test(`${section} should ${passFail}${example}`, {
+                    only: test.only,
+                    skip: test.skip,
+                }, async () => {
+                    const before = process.hrtime();
+                    const parsed = await parse(test.markdown, options, addExtension);
+                    const elapsed = process.hrtime(before);
+                    const pass = isEqual(parsed, test.html);
+                    if (test.shouldFail) {
+                        assert.ok(!pass, `${test.markdown}\n------\n\nExpected: Should Fail`);
+                    }
+                    else if (options.renderExact) {
+                        assert.strictEqual(test.html, parsed);
+                    }
+                    else {
+                        const testDiff = diff(parsed, test.html);
+                        assert.ok(pass, `Expected: ${testDiff.expected}\n  Actual: ${testDiff.actual}`);
+                    }
+                    if (!options.async && elapsed[0] > 0) {
+                        const s = (elapsed[0] + elapsed[1] * 1e-9).toFixed(3);
+                        assert.fail(`took too long: ${s}s`);
+                    }
+                });
+            }
+        });
+    }
+}
+/**
+ * Run all marked specs with an added extension and optionally output completion table
+ */
+export async function runAllMarkedSpecTests({ addExtension = () => { }, outputCompletionTables = true, } = {}) {
+    const specTests = await getAllMarkedSpecTests();
+    await Promise.all(Object.keys(specTests).map((title) => {
+        const tests = specTests[title];
+        switch (title) {
+            case "CommonMark":
+                if (outputCompletionTables) {
+                    outputCompletionTable(title, tests);
+                }
+                return runTests({
+                    tests,
+                    defaultMarkedOptions: { gfm: false, pedantic: false },
+                    addExtension,
+                });
+            case "GFM":
+                if (outputCompletionTables) {
+                    outputCompletionTable(title, tests);
+                }
+                return runTests({
+                    tests,
+                    defaultMarkedOptions: { gfm: true, pedantic: false },
+                    addExtension,
+                });
+            case "New":
+                return runTests({ tests, addExtension });
+            case "Original":
+                return runTests({
+                    tests,
+                    defaultMarkedOptions: { gfm: false, pedantic: true },
+                    addExtension,
+                });
+            case "ReDOS":
+                return runTests({ tests, addExtension });
+            default:
+                throw new Error("invalid title");
+        }
+    }));
+}
+function parseMarked(markdown, options, addExtension) {
+    const marked = new Marked(options);
+    addExtension(marked);
+    return marked.parse(markdown);
+}

package/lib/types.d.ts

@@ -0,0 +1,19 @@
+import { MarkedExtension } from "marked";
+export interface Spec {
+    section: string;
+    markdown: string;
+    html: string;
+    options?: MarkedExtension & {
+        renderExact?: boolean;
+    };
+    only?: boolean;
+    skip?: boolean;
+    example?: string;
+    shouldFail?: boolean;
+}
+export interface TestSection {
+    total: number;
+    pass: number;
+    specs: Spec[];
+}
+export type Tests = Record<string, TestSection>;

package/lib/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markedjs/testutils",
-  "version": "17.0.1-1",
+  "version": "17.0.1-2",
   "description": "Test utilities for marked and marked extensions",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",