@progress/kendo-e2e/dist/rendering/matchers.js

Kendo UI end-to-end test utilities.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.toMatchFromHtml = toMatchFromHtml;
exports.toMatchSpec = toMatchSpec;
exports.toMatchFromHtmlWithPassed = toMatchFromHtmlWithPassed;
exports.toMatchSpecWithPassed = toMatchSpecWithPassed;
exports.generateReport = generateReport;
const _1 = require(".");
function toMatchFromHtml(markup, expected, comparerOptions) {
    const result = (0, _1.compareHtml)(markup, expected, comparerOptions);
    const pass = result.passed.length > 0 &&
        result.missing.length === 0 &&
        result.extra.length === 0;
    return {
        pass,
        message: generateReport.bind(null, {
            comparerResult: result,
        }),
    };
}
function toMatchSpec(markup, spec, specOptions, comparerOptions) {
    const expected = (0, _1.specToHtml)(spec, specOptions);
    return toMatchFromHtml(markup, expected, comparerOptions);
}
function toMatchFromHtmlWithPassed(markup, passed = 0, expected, comparerOptions) {
    const result = (0, _1.compareHtml)(markup, expected, comparerOptions);
    const pass = result.passed.length === passed &&
        result.missing.length === 0 &&
        result.extra.length === 0;
    return {
        pass,
        message: generateReport.bind(null, {
            comparerResult: result,
            passed: passed,
        }),
    };
}
function toMatchSpecWithPassed(markup, passed = 0, spec, specOptions, comparerOptions) {
    const expected = (0, _1.specToHtml)(spec, specOptions);
    return toMatchFromHtmlWithPassed(markup, passed, expected, comparerOptions);
}
function generateReport({ comparerResult, passed }) {
    const allExpectedSelectors = comparerResult.expectedSelectors.reduce((acc, curr) => {
        return [...acc, ...curr.split(" ")];
    }, []);
    const allActualSelectors = comparerResult.actualSelectors.reduce((acc, curr) => {
        return [...acc, ...curr.split(" ")];
    }, []);
    const differentSelectors = findDifferences(comparerResult);
    const extra = comparerResult.extra
        .filter((sel) => differentSelectors.map((diff) => diff.actual).includes(sel) ===
        false)
        .map((selector) => {
        const strippedSelector = stripSelector(selector, allExpectedSelectors);
        return [strippedSelector, selector];
    });
    const missing = comparerResult.missing
        .filter((sel) => differentSelectors
        .map((diff) => diff.expected)
        .includes(sel) === false)
        .map((selector) => {
        const strippedSelector = stripSelector(selector, allActualSelectors);
        return [strippedSelector, selector];
    });
    const passedFailedMessage = passed && passed !== comparerResult.passed.length
        ? `| ${Colors.FgRed}Expected: ${Colors.Bright}${passed}${Colors.Reset}`
        : "";
    const passedMessage = `\n${Colors.FgYellow}Passed Selectors: ${comparerResult.passed.length} ${passedFailedMessage}`;
    const differenceMessage = generateDifferencesMsg(differentSelectors) || "";
    const extraMessage = genExtraMsg(extra) || "";
    const missingMessage = genMissingMsg(missing) || "";
    const separator = `${Colors.FgYellow + Colors.Dim}${"-".repeat(50)}${Colors.Reset}`;
    const messages = [
        passedMessage,
        differenceMessage,
        extraMessage,
        missingMessage,
    ]
        .map((msg) => msg ? `${msg}\n\n${Colors.FgYellow + Colors.Dim}${separator}` : "")
        .join("\n");
    return `${Colors.FgYellow}Spec Reporter:\n${separator}${messages}${Colors.Reset}`;
}
function findDifferences(comparerResult) {
    const differentSelectors = [];
    let actualIdx = 0;
    let expectedIdx = 0;
    while (actualIdx < comparerResult.actualSelectors.length &&
        expectedIdx < comparerResult.expectedSelectors.length) {
        if (comparerResult.extra.includes(comparerResult.actualSelectors[actualIdx]) &&
            comparerResult.missing.includes(comparerResult.expectedSelectors[expectedIdx])) {
            differentSelectors.push(compareSelectors([
                comparerResult.actualSelectors[actualIdx],
                comparerResult.expectedSelectors[expectedIdx],
            ]));
            actualIdx++;
            expectedIdx++;
            continue;
        }
        if (comparerResult.extra.includes(comparerResult.actualSelectors[actualIdx])) {
            actualIdx++;
            continue;
        }
        if (comparerResult.missing.includes(comparerResult.expectedSelectors[expectedIdx])) {
            expectedIdx++;
            continue;
        }
        actualIdx++;
        expectedIdx++;
    }
    return differentSelectors;
}
function compareSelectors([actual, expected]) {
    const actualParts = actual.split(" ");
    const expectedParts = expected.split(" ");
    const differentSelectors = actualParts.reduce((acc, curr, idx) => {
        if (curr !== expectedParts[idx]) {
            return [...acc, [curr, expectedParts[idx]]];
        }
        return acc;
    }, []);
    return {
        actual,
        expected,
        differences: {
            actual: differentSelectors.map((diff) => diff[0]),
            expected: differentSelectors.map((diff) => diff[1]),
        },
    };
}
function stripSelector(selector, selectors) {
    return selector.split(" ").reduce((acc, curr) => {
        if (selectors.includes(curr)) {
            return acc;
        }
        return curr;
    }, "");
}
function genExtraMsg(extra) {
    if (extra.length > 0) {
        return `${Colors.FgYellow}Extra Selectors Found:

${extra
            .map(([strippedSelector, extraSelector]) => `${Colors.Dim + Colors.FgYellow}${extraSelector.replace(strippedSelector, `${Colors.Reset}${Colors.Bright}${Colors.FgRed}${strippedSelector}`)}`)
            .join("\n\n")}`;
    }
}
function genMissingMsg(missing) {
    if (missing.length > 0) {
        return `${Colors.FgYellow}Missing Selectors Found:

${missing
            .map(([strippedSelector, missingSelector]) => `${Colors.Dim + Colors.FgYellow}${missingSelector.replace(strippedSelector, `${Colors.Reset}${Colors.Bright}${Colors.FgRed}${strippedSelector}`)}`)
            .join("\n\n")}`;
    }
}
function generateDifferencesMsg(differentSelectors) {
    if (differentSelectors.length > 0) {
        return `${Colors.FgYellow}Different Selectors Found (Actual/Expected):
${differentSelectors
            .map((diff) => `
${Colors.Dim}${decorateParts(diff.actual, diff.differences.actual, Colors.FgRed)}
${Colors.Dim}${decorateParts(diff.expected, diff.differences.expected, Colors.FgYellow)}
`)
            .join("\n-----")}`;
    }
}
function decorateParts(selector, parts, color) {
    let result;
    parts.forEach((part) => {
        result = selector.replace(part, `${Colors.Reset}${Colors.Bright}${color}${part}${Colors.Dim}${Colors.FgYellow}`);
    });
    return result;
}
const Colors = {
    Reset: "\x1b[0m",
    Bright: "\x1b[1m",
    Dim: "\x1b[2m",
    Underscore: "\x1b[4m",
    Blink: "\x1b[5m",
    Reverse: "\x1b[7m",
    Hidden: "\x1b[8m",
    FgBlack: "\x1b[30m",
    FgRed: "\x1b[31m",
    FgGreen: "\x1b[32m",
    FgYellow: "\x1b[33m",
    FgBlue: "\x1b[34m",
    FgMagenta: "\x1b[35m",
    FgCyan: "\x1b[36m",
    FgWhite: "\x1b[37m",
    FgGray: "\x1b[90m",
};
//# sourceMappingURL=matchers.js.map