Implement comprehensive frontend integration testing with Playwright
- Add Playwright E2E testing framework with cross-browser support (Chrome, Firefox) - Create authentication helpers for CalDAV server integration - Implement calendar interaction helpers with event creation, drag-and-drop, and view switching - Add comprehensive drag-and-drop test suite with event cleanup - Configure CI/CD integration with Gitea Actions for headless testing - Support both local development and CI environments with proper dependency management - Include video recording, screenshots, and HTML reporting for test debugging - Handle Firefox-specific timing and interaction challenges with force clicks and timeouts 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Connor Johnstone
338
frontend/e2e/node_modules/playwright/lib/matchers/expect.js
generated
vendored
Normal file
338
frontend/e2e/node_modules/playwright/lib/matchers/expect.js
generated
vendored
Normal file
@@ -0,0 +1,338 @@
|
||||
"use strict";
|
||||
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);
|
||||
var expect_exports = {};
|
||||
__export(expect_exports, {
|
||||
expect: () => expect,
|
||||
mergeExpects: () => mergeExpects,
|
||||
printReceivedStringContainExpectedResult: () => printReceivedStringContainExpectedResult,
|
||||
printReceivedStringContainExpectedSubstring: () => printReceivedStringContainExpectedSubstring
|
||||
});
|
||||
module.exports = __toCommonJS(expect_exports);
|
||||
var import_utils = require("playwright-core/lib/utils");
|
||||
var import_matcherHint = require("./matcherHint");
|
||||
var import_matchers = require("./matchers");
|
||||
var import_toMatchAriaSnapshot = require("./toMatchAriaSnapshot");
|
||||
var import_toMatchSnapshot = require("./toMatchSnapshot");
|
||||
var import_expectBundle = require("../common/expectBundle");
|
||||
var import_globals = require("../common/globals");
|
||||
var import_util = require("../util");
|
||||
var import_testInfo = require("../worker/testInfo");
|
||||
const printSubstring = (val) => val.replace(/"|\\/g, "\\$&");
|
||||
const printReceivedStringContainExpectedSubstring = (received, start, length) => (0, import_expectBundle.RECEIVED_COLOR)(
|
||||
'"' + printSubstring(received.slice(0, start)) + (0, import_expectBundle.INVERTED_COLOR)(printSubstring(received.slice(start, start + length))) + printSubstring(received.slice(start + length)) + '"'
|
||||
);
|
||||
const printReceivedStringContainExpectedResult = (received, result) => result === null ? (0, import_expectBundle.printReceived)(received) : printReceivedStringContainExpectedSubstring(
|
||||
received,
|
||||
result.index,
|
||||
result[0].length
|
||||
);
|
||||
function createMatchers(actual, info, prefix) {
|
||||
return new Proxy((0, import_expectBundle.expect)(actual), new ExpectMetaInfoProxyHandler(info, prefix));
|
||||
}
|
||||
const userMatchersSymbol = Symbol("userMatchers");
|
||||
function qualifiedMatcherName(qualifier, matcherName) {
|
||||
return qualifier.join(":") + "$" + matcherName;
|
||||
}
|
||||
function createExpect(info, prefix, userMatchers) {
|
||||
const expectInstance = new Proxy(import_expectBundle.expect, {
|
||||
apply: function(target, thisArg, argumentsList) {
|
||||
const [actual, messageOrOptions] = argumentsList;
|
||||
const message = (0, import_utils.isString)(messageOrOptions) ? messageOrOptions : messageOrOptions?.message || info.message;
|
||||
const newInfo = { ...info, message };
|
||||
if (newInfo.poll) {
|
||||
if (typeof actual !== "function")
|
||||
throw new Error("`expect.poll()` accepts only function as a first argument");
|
||||
newInfo.poll.generator = actual;
|
||||
}
|
||||
return createMatchers(actual, newInfo, prefix);
|
||||
},
|
||||
get: function(target, property) {
|
||||
if (property === "configure")
|
||||
return configure;
|
||||
if (property === "extend") {
|
||||
return (matchers) => {
|
||||
const qualifier = [...prefix, (0, import_utils.createGuid)()];
|
||||
const wrappedMatchers = {};
|
||||
for (const [name, matcher] of Object.entries(matchers)) {
|
||||
wrappedMatchers[name] = wrapPlaywrightMatcherToPassNiceThis(matcher);
|
||||
const key = qualifiedMatcherName(qualifier, name);
|
||||
wrappedMatchers[key] = wrappedMatchers[name];
|
||||
Object.defineProperty(wrappedMatchers[key], "name", { value: name });
|
||||
}
|
||||
import_expectBundle.expect.extend(wrappedMatchers);
|
||||
return createExpect(info, qualifier, { ...userMatchers, ...matchers });
|
||||
};
|
||||
}
|
||||
if (property === "soft") {
|
||||
return (actual, messageOrOptions) => {
|
||||
return configure({ soft: true })(actual, messageOrOptions);
|
||||
};
|
||||
}
|
||||
if (property === userMatchersSymbol)
|
||||
return userMatchers;
|
||||
if (property === "poll") {
|
||||
return (actual, messageOrOptions) => {
|
||||
const poll = (0, import_utils.isString)(messageOrOptions) ? {} : messageOrOptions || {};
|
||||
return configure({ _poll: poll })(actual, messageOrOptions);
|
||||
};
|
||||
}
|
||||
return import_expectBundle.expect[property];
|
||||
}
|
||||
});
|
||||
const configure = (configuration) => {
|
||||
const newInfo = { ...info };
|
||||
if ("message" in configuration)
|
||||
newInfo.message = configuration.message;
|
||||
if ("timeout" in configuration)
|
||||
newInfo.timeout = configuration.timeout;
|
||||
if ("soft" in configuration)
|
||||
newInfo.isSoft = configuration.soft;
|
||||
if ("_poll" in configuration) {
|
||||
newInfo.poll = configuration._poll ? { ...info.poll, generator: () => {
|
||||
} } : void 0;
|
||||
if (typeof configuration._poll === "object") {
|
||||
newInfo.poll.timeout = configuration._poll.timeout ?? newInfo.poll.timeout;
|
||||
newInfo.poll.intervals = configuration._poll.intervals ?? newInfo.poll.intervals;
|
||||
}
|
||||
}
|
||||
return createExpect(newInfo, prefix, userMatchers);
|
||||
};
|
||||
return expectInstance;
|
||||
}
|
||||
let matcherCallContext;
|
||||
function setMatcherCallContext(context) {
|
||||
matcherCallContext = context;
|
||||
}
|
||||
function takeMatcherCallContext() {
|
||||
try {
|
||||
return matcherCallContext;
|
||||
} finally {
|
||||
matcherCallContext = void 0;
|
||||
}
|
||||
}
|
||||
const defaultExpectTimeout = 5e3;
|
||||
function wrapPlaywrightMatcherToPassNiceThis(matcher) {
|
||||
return function(...args) {
|
||||
const { isNot, promise, utils } = this;
|
||||
const context = takeMatcherCallContext();
|
||||
const timeout = context?.expectInfo.timeout ?? context?.testInfo?._projectInternal?.expect?.timeout ?? defaultExpectTimeout;
|
||||
const newThis = {
|
||||
isNot,
|
||||
promise,
|
||||
utils,
|
||||
timeout,
|
||||
_stepInfo: context?.step
|
||||
};
|
||||
newThis.equals = throwUnsupportedExpectMatcherError;
|
||||
return matcher.call(newThis, ...args);
|
||||
};
|
||||
}
|
||||
function throwUnsupportedExpectMatcherError() {
|
||||
throw new Error("It looks like you are using custom expect matchers that are not compatible with Playwright. See https://aka.ms/playwright/expect-compatibility");
|
||||
}
|
||||
import_expectBundle.expect.setState({ expand: false });
|
||||
const customAsyncMatchers = {
|
||||
toBeAttached: import_matchers.toBeAttached,
|
||||
toBeChecked: import_matchers.toBeChecked,
|
||||
toBeDisabled: import_matchers.toBeDisabled,
|
||||
toBeEditable: import_matchers.toBeEditable,
|
||||
toBeEmpty: import_matchers.toBeEmpty,
|
||||
toBeEnabled: import_matchers.toBeEnabled,
|
||||
toBeFocused: import_matchers.toBeFocused,
|
||||
toBeHidden: import_matchers.toBeHidden,
|
||||
toBeInViewport: import_matchers.toBeInViewport,
|
||||
toBeOK: import_matchers.toBeOK,
|
||||
toBeVisible: import_matchers.toBeVisible,
|
||||
toContainText: import_matchers.toContainText,
|
||||
toContainClass: import_matchers.toContainClass,
|
||||
toHaveAccessibleDescription: import_matchers.toHaveAccessibleDescription,
|
||||
toHaveAccessibleName: import_matchers.toHaveAccessibleName,
|
||||
toHaveAccessibleErrorMessage: import_matchers.toHaveAccessibleErrorMessage,
|
||||
toHaveAttribute: import_matchers.toHaveAttribute,
|
||||
toHaveClass: import_matchers.toHaveClass,
|
||||
toHaveCount: import_matchers.toHaveCount,
|
||||
toHaveCSS: import_matchers.toHaveCSS,
|
||||
toHaveId: import_matchers.toHaveId,
|
||||
toHaveJSProperty: import_matchers.toHaveJSProperty,
|
||||
toHaveRole: import_matchers.toHaveRole,
|
||||
toHaveText: import_matchers.toHaveText,
|
||||
toHaveTitle: import_matchers.toHaveTitle,
|
||||
toHaveURL: import_matchers.toHaveURL,
|
||||
toHaveValue: import_matchers.toHaveValue,
|
||||
toHaveValues: import_matchers.toHaveValues,
|
||||
toHaveScreenshot: import_toMatchSnapshot.toHaveScreenshot,
|
||||
toMatchAriaSnapshot: import_toMatchAriaSnapshot.toMatchAriaSnapshot,
|
||||
toPass: import_matchers.toPass
|
||||
};
|
||||
const customMatchers = {
|
||||
...customAsyncMatchers,
|
||||
toMatchSnapshot: import_toMatchSnapshot.toMatchSnapshot
|
||||
};
|
||||
class ExpectMetaInfoProxyHandler {
|
||||
constructor(info, prefix) {
|
||||
this._info = { ...info };
|
||||
this._prefix = prefix;
|
||||
}
|
||||
get(target, matcherName, receiver) {
|
||||
let matcher = Reflect.get(target, matcherName, receiver);
|
||||
if (typeof matcherName !== "string")
|
||||
return matcher;
|
||||
let resolvedMatcherName = matcherName;
|
||||
for (let i = this._prefix.length; i > 0; i--) {
|
||||
const qualifiedName = qualifiedMatcherName(this._prefix.slice(0, i), matcherName);
|
||||
if (Reflect.has(target, qualifiedName)) {
|
||||
matcher = Reflect.get(target, qualifiedName, receiver);
|
||||
resolvedMatcherName = qualifiedName;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (matcher === void 0)
|
||||
throw new Error(`expect: Property '${matcherName}' not found.`);
|
||||
if (typeof matcher !== "function") {
|
||||
if (matcherName === "not")
|
||||
this._info.isNot = !this._info.isNot;
|
||||
return new Proxy(matcher, this);
|
||||
}
|
||||
if (this._info.poll) {
|
||||
if (customAsyncMatchers[matcherName] || matcherName === "resolves" || matcherName === "rejects")
|
||||
throw new Error(`\`expect.poll()\` does not support "${matcherName}" matcher.`);
|
||||
matcher = (...args) => pollMatcher(resolvedMatcherName, this._info, this._prefix, ...args);
|
||||
}
|
||||
return (...args) => {
|
||||
const testInfo = (0, import_globals.currentTestInfo)();
|
||||
setMatcherCallContext({ expectInfo: this._info, testInfo });
|
||||
if (!testInfo)
|
||||
return matcher.call(target, ...args);
|
||||
const customMessage = this._info.message || "";
|
||||
const argsSuffix = computeArgsSuffix(matcherName, args);
|
||||
const defaultTitle = `${this._info.poll ? "poll " : ""}${this._info.isSoft ? "soft " : ""}${this._info.isNot ? "not " : ""}${matcherName}${argsSuffix}`;
|
||||
const title = customMessage || `Expect ${(0, import_utils.escapeWithQuotes)(defaultTitle, '"')}`;
|
||||
const apiName = `expect${this._info.poll ? ".poll " : ""}${this._info.isSoft ? ".soft " : ""}${this._info.isNot ? ".not" : ""}.${matcherName}${argsSuffix}`;
|
||||
const stackFrames = (0, import_util.filteredStackTrace)((0, import_utils.captureRawStack)());
|
||||
const category = matcherName === "toPass" || this._info.poll ? "test.step" : "expect";
|
||||
const stepInfo = {
|
||||
category,
|
||||
apiName,
|
||||
title,
|
||||
params: args[0] ? { expected: args[0] } : void 0,
|
||||
infectParentStepsWithError: this._info.isSoft
|
||||
};
|
||||
const step = testInfo._addStep(stepInfo);
|
||||
const reportStepError = (isAsync, e) => {
|
||||
const jestError = (0, import_matcherHint.isJestError)(e) ? e : null;
|
||||
const expectError = jestError ? new import_matcherHint.ExpectError(jestError, customMessage, stackFrames) : void 0;
|
||||
if (jestError?.matcherResult.suggestedRebaseline) {
|
||||
step.complete({ suggestedRebaseline: jestError?.matcherResult.suggestedRebaseline });
|
||||
return;
|
||||
}
|
||||
const error = expectError ?? e;
|
||||
step.complete({ error });
|
||||
if (!isAsync || !expectError) {
|
||||
if (this._info.isSoft)
|
||||
testInfo._failWithError(error);
|
||||
else
|
||||
throw error;
|
||||
return;
|
||||
}
|
||||
return (async () => {
|
||||
const recoveryResult = await step.recoverFromStepError(expectError);
|
||||
if (recoveryResult.status === "recovered")
|
||||
return recoveryResult.value;
|
||||
if (this._info.isSoft)
|
||||
testInfo._failWithError(expectError);
|
||||
else
|
||||
throw expectError;
|
||||
})();
|
||||
};
|
||||
const finalizer = () => {
|
||||
step.complete({});
|
||||
};
|
||||
try {
|
||||
setMatcherCallContext({ expectInfo: this._info, testInfo, step: step.info });
|
||||
const callback = () => matcher.call(target, ...args);
|
||||
const result = (0, import_utils.currentZone)().with("stepZone", step).run(callback);
|
||||
if (result instanceof Promise)
|
||||
return result.then(finalizer).catch(reportStepError.bind(null, true));
|
||||
finalizer();
|
||||
return result;
|
||||
} catch (e) {
|
||||
void reportStepError(false, e);
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
async function pollMatcher(qualifiedMatcherName2, info, prefix, ...args) {
|
||||
const testInfo = (0, import_globals.currentTestInfo)();
|
||||
const poll = info.poll;
|
||||
const timeout = poll.timeout ?? info.timeout ?? testInfo?._projectInternal?.expect?.timeout ?? defaultExpectTimeout;
|
||||
const { deadline, timeoutMessage } = testInfo ? testInfo._deadlineForMatcher(timeout) : import_testInfo.TestInfoImpl._defaultDeadlineForMatcher(timeout);
|
||||
const result = await (0, import_utils.pollAgainstDeadline)(async () => {
|
||||
if (testInfo && (0, import_globals.currentTestInfo)() !== testInfo)
|
||||
return { continuePolling: false, result: void 0 };
|
||||
const innerInfo = {
|
||||
...info,
|
||||
isSoft: false,
|
||||
// soft is outside of poll, not inside
|
||||
poll: void 0
|
||||
};
|
||||
const value = await poll.generator();
|
||||
try {
|
||||
let matchers = createMatchers(value, innerInfo, prefix);
|
||||
if (info.isNot)
|
||||
matchers = matchers.not;
|
||||
matchers[qualifiedMatcherName2](...args);
|
||||
return { continuePolling: false, result: void 0 };
|
||||
} catch (error) {
|
||||
return { continuePolling: true, result: error };
|
||||
}
|
||||
}, deadline, poll.intervals ?? [100, 250, 500, 1e3]);
|
||||
if (result.timedOut) {
|
||||
const message = result.result ? [
|
||||
result.result.message,
|
||||
"",
|
||||
`Call Log:`,
|
||||
`- ${timeoutMessage}`
|
||||
].join("\n") : timeoutMessage;
|
||||
throw new Error(message);
|
||||
}
|
||||
}
|
||||
function computeArgsSuffix(matcherName, args) {
|
||||
let value = "";
|
||||
if (matcherName === "toHaveScreenshot")
|
||||
value = (0, import_toMatchSnapshot.toHaveScreenshotStepTitle)(...args);
|
||||
return value ? `(${value})` : "";
|
||||
}
|
||||
const expect = createExpect({}, [], {}).extend(customMatchers);
|
||||
function mergeExpects(...expects) {
|
||||
let merged = expect;
|
||||
for (const e of expects) {
|
||||
const internals = e[userMatchersSymbol];
|
||||
if (!internals)
|
||||
continue;
|
||||
merged = merged.extend(internals);
|
||||
}
|
||||
return merged;
|
||||
}
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
0 && (module.exports = {
|
||||
expect,
|
||||
mergeExpects,
|
||||
printReceivedStringContainExpectedResult,
|
||||
printReceivedStringContainExpectedSubstring
|
||||
});
|
||||
63
frontend/e2e/node_modules/playwright/lib/matchers/matcherHint.js
generated
vendored
Normal file
63
frontend/e2e/node_modules/playwright/lib/matchers/matcherHint.js
generated
vendored
Normal file
@@ -0,0 +1,63 @@
|
||||
"use strict";
|
||||
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);
|
||||
var matcherHint_exports = {};
|
||||
__export(matcherHint_exports, {
|
||||
ExpectError: () => ExpectError,
|
||||
isJestError: () => isJestError,
|
||||
kNoElementsFoundError: () => kNoElementsFoundError,
|
||||
matcherHint: () => matcherHint
|
||||
});
|
||||
module.exports = __toCommonJS(matcherHint_exports);
|
||||
var import_utils = require("playwright-core/lib/utils");
|
||||
const kNoElementsFoundError = "<element(s) not found>";
|
||||
function matcherHint(state, locator, matcherName, expression, actual, matcherOptions, timeout, expectedReceivedString, preventExtraStatIndent = false) {
|
||||
let header = state.utils.matcherHint(matcherName, expression, actual, matcherOptions).replace(/ \/\/ deep equality/, "") + " failed\n\n";
|
||||
const extraSpace = preventExtraStatIndent ? "" : " ";
|
||||
if (locator)
|
||||
header += `Locator: ${extraSpace}${String(locator)}
|
||||
`;
|
||||
if (expectedReceivedString)
|
||||
header += `${expectedReceivedString}
|
||||
`;
|
||||
if (timeout)
|
||||
header += `Timeout: ${extraSpace}${timeout}ms
|
||||
`;
|
||||
return header;
|
||||
}
|
||||
class ExpectError extends Error {
|
||||
constructor(jestError, customMessage, stackFrames) {
|
||||
super("");
|
||||
this.name = jestError.name;
|
||||
this.message = jestError.message;
|
||||
this.matcherResult = jestError.matcherResult;
|
||||
if (customMessage)
|
||||
this.message = customMessage + "\n\n" + this.message;
|
||||
this.stack = this.name + ": " + this.message + "\n" + (0, import_utils.stringifyStackFrames)(stackFrames).join("\n");
|
||||
}
|
||||
}
|
||||
function isJestError(e) {
|
||||
return e instanceof Error && "matcherResult" in e;
|
||||
}
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
0 && (module.exports = {
|
||||
ExpectError,
|
||||
isJestError,
|
||||
kNoElementsFoundError,
|
||||
matcherHint
|
||||
});
|
||||
360
frontend/e2e/node_modules/playwright/lib/matchers/matchers.js
generated
vendored
Normal file
360
frontend/e2e/node_modules/playwright/lib/matchers/matchers.js
generated
vendored
Normal file
@@ -0,0 +1,360 @@
|
||||
"use strict";
|
||||
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);
|
||||
var matchers_exports = {};
|
||||
__export(matchers_exports, {
|
||||
toBeAttached: () => toBeAttached,
|
||||
toBeChecked: () => toBeChecked,
|
||||
toBeDisabled: () => toBeDisabled,
|
||||
toBeEditable: () => toBeEditable,
|
||||
toBeEmpty: () => toBeEmpty,
|
||||
toBeEnabled: () => toBeEnabled,
|
||||
toBeFocused: () => toBeFocused,
|
||||
toBeHidden: () => toBeHidden,
|
||||
toBeInViewport: () => toBeInViewport,
|
||||
toBeOK: () => toBeOK,
|
||||
toBeVisible: () => toBeVisible,
|
||||
toContainClass: () => toContainClass,
|
||||
toContainText: () => toContainText,
|
||||
toHaveAccessibleDescription: () => toHaveAccessibleDescription,
|
||||
toHaveAccessibleErrorMessage: () => toHaveAccessibleErrorMessage,
|
||||
toHaveAccessibleName: () => toHaveAccessibleName,
|
||||
toHaveAttribute: () => toHaveAttribute,
|
||||
toHaveCSS: () => toHaveCSS,
|
||||
toHaveClass: () => toHaveClass,
|
||||
toHaveCount: () => toHaveCount,
|
||||
toHaveId: () => toHaveId,
|
||||
toHaveJSProperty: () => toHaveJSProperty,
|
||||
toHaveRole: () => toHaveRole,
|
||||
toHaveText: () => toHaveText,
|
||||
toHaveTitle: () => toHaveTitle,
|
||||
toHaveURL: () => toHaveURL,
|
||||
toHaveValue: () => toHaveValue,
|
||||
toHaveValues: () => toHaveValues,
|
||||
toPass: () => toPass
|
||||
});
|
||||
module.exports = __toCommonJS(matchers_exports);
|
||||
var import_utils = require("playwright-core/lib/utils");
|
||||
var import_utils2 = require("playwright-core/lib/utils");
|
||||
var import_util = require("../util");
|
||||
var import_toBeTruthy = require("./toBeTruthy");
|
||||
var import_toEqual = require("./toEqual");
|
||||
var import_toHaveURL = require("./toHaveURL");
|
||||
var import_toMatchText = require("./toMatchText");
|
||||
var import_config = require("../common/config");
|
||||
var import_globals = require("../common/globals");
|
||||
var import_testInfo = require("../worker/testInfo");
|
||||
function toBeAttached(locator, options) {
|
||||
const attached = !options || options.attached === void 0 || options.attached;
|
||||
const expected = attached ? "attached" : "detached";
|
||||
const arg = attached ? "" : "{ attached: false }";
|
||||
return import_toBeTruthy.toBeTruthy.call(this, "toBeAttached", locator, "Locator", expected, arg, async (isNot, timeout) => {
|
||||
return await locator._expect(attached ? "to.be.attached" : "to.be.detached", { isNot, timeout });
|
||||
}, options);
|
||||
}
|
||||
function toBeChecked(locator, options) {
|
||||
const checked = options?.checked;
|
||||
const indeterminate = options?.indeterminate;
|
||||
const expectedValue = {
|
||||
checked,
|
||||
indeterminate
|
||||
};
|
||||
let expected;
|
||||
let arg;
|
||||
if (options?.indeterminate) {
|
||||
expected = "indeterminate";
|
||||
arg = `{ indeterminate: true }`;
|
||||
} else {
|
||||
expected = options?.checked === false ? "unchecked" : "checked";
|
||||
arg = options?.checked === false ? `{ checked: false }` : "";
|
||||
}
|
||||
return import_toBeTruthy.toBeTruthy.call(this, "toBeChecked", locator, "Locator", expected, arg, async (isNot, timeout) => {
|
||||
return await locator._expect("to.be.checked", { isNot, timeout, expectedValue });
|
||||
}, options);
|
||||
}
|
||||
function toBeDisabled(locator, options) {
|
||||
return import_toBeTruthy.toBeTruthy.call(this, "toBeDisabled", locator, "Locator", "disabled", "", async (isNot, timeout) => {
|
||||
return await locator._expect("to.be.disabled", { isNot, timeout });
|
||||
}, options);
|
||||
}
|
||||
function toBeEditable(locator, options) {
|
||||
const editable = !options || options.editable === void 0 || options.editable;
|
||||
const expected = editable ? "editable" : "readOnly";
|
||||
const arg = editable ? "" : "{ editable: false }";
|
||||
return import_toBeTruthy.toBeTruthy.call(this, "toBeEditable", locator, "Locator", expected, arg, async (isNot, timeout) => {
|
||||
return await locator._expect(editable ? "to.be.editable" : "to.be.readonly", { isNot, timeout });
|
||||
}, options);
|
||||
}
|
||||
function toBeEmpty(locator, options) {
|
||||
return import_toBeTruthy.toBeTruthy.call(this, "toBeEmpty", locator, "Locator", "empty", "", async (isNot, timeout) => {
|
||||
return await locator._expect("to.be.empty", { isNot, timeout });
|
||||
}, options);
|
||||
}
|
||||
function toBeEnabled(locator, options) {
|
||||
const enabled = !options || options.enabled === void 0 || options.enabled;
|
||||
const expected = enabled ? "enabled" : "disabled";
|
||||
const arg = enabled ? "" : "{ enabled: false }";
|
||||
return import_toBeTruthy.toBeTruthy.call(this, "toBeEnabled", locator, "Locator", expected, arg, async (isNot, timeout) => {
|
||||
return await locator._expect(enabled ? "to.be.enabled" : "to.be.disabled", { isNot, timeout });
|
||||
}, options);
|
||||
}
|
||||
function toBeFocused(locator, options) {
|
||||
return import_toBeTruthy.toBeTruthy.call(this, "toBeFocused", locator, "Locator", "focused", "", async (isNot, timeout) => {
|
||||
return await locator._expect("to.be.focused", { isNot, timeout });
|
||||
}, options);
|
||||
}
|
||||
function toBeHidden(locator, options) {
|
||||
return import_toBeTruthy.toBeTruthy.call(this, "toBeHidden", locator, "Locator", "hidden", "", async (isNot, timeout) => {
|
||||
return await locator._expect("to.be.hidden", { isNot, timeout });
|
||||
}, options);
|
||||
}
|
||||
function toBeVisible(locator, options) {
|
||||
const visible = !options || options.visible === void 0 || options.visible;
|
||||
const expected = visible ? "visible" : "hidden";
|
||||
const arg = visible ? "" : "{ visible: false }";
|
||||
return import_toBeTruthy.toBeTruthy.call(this, "toBeVisible", locator, "Locator", expected, arg, async (isNot, timeout) => {
|
||||
return await locator._expect(visible ? "to.be.visible" : "to.be.hidden", { isNot, timeout });
|
||||
}, options);
|
||||
}
|
||||
function toBeInViewport(locator, options) {
|
||||
return import_toBeTruthy.toBeTruthy.call(this, "toBeInViewport", locator, "Locator", "in viewport", "", async (isNot, timeout) => {
|
||||
return await locator._expect("to.be.in.viewport", { isNot, expectedNumber: options?.ratio, timeout });
|
||||
}, options);
|
||||
}
|
||||
function toContainText(locator, expected, options = {}) {
|
||||
if (Array.isArray(expected)) {
|
||||
return import_toEqual.toEqual.call(this, "toContainText", locator, "Locator", async (isNot, timeout) => {
|
||||
const expectedText = (0, import_utils.serializeExpectedTextValues)(expected, { matchSubstring: true, normalizeWhiteSpace: true, ignoreCase: options.ignoreCase });
|
||||
return await locator._expect("to.contain.text.array", { expectedText, isNot, useInnerText: options.useInnerText, timeout });
|
||||
}, expected, { ...options, contains: true });
|
||||
} else {
|
||||
return import_toMatchText.toMatchText.call(this, "toContainText", locator, "Locator", async (isNot, timeout) => {
|
||||
const expectedText = (0, import_utils.serializeExpectedTextValues)([expected], { matchSubstring: true, normalizeWhiteSpace: true, ignoreCase: options.ignoreCase });
|
||||
return await locator._expect("to.have.text", { expectedText, isNot, useInnerText: options.useInnerText, timeout });
|
||||
}, expected, options);
|
||||
}
|
||||
}
|
||||
function toHaveAccessibleDescription(locator, expected, options) {
|
||||
return import_toMatchText.toMatchText.call(this, "toHaveAccessibleDescription", locator, "Locator", async (isNot, timeout) => {
|
||||
const expectedText = (0, import_utils.serializeExpectedTextValues)([expected], { ignoreCase: options?.ignoreCase, normalizeWhiteSpace: true });
|
||||
return await locator._expect("to.have.accessible.description", { expectedText, isNot, timeout });
|
||||
}, expected, options);
|
||||
}
|
||||
function toHaveAccessibleName(locator, expected, options) {
|
||||
return import_toMatchText.toMatchText.call(this, "toHaveAccessibleName", locator, "Locator", async (isNot, timeout) => {
|
||||
const expectedText = (0, import_utils.serializeExpectedTextValues)([expected], { ignoreCase: options?.ignoreCase, normalizeWhiteSpace: true });
|
||||
return await locator._expect("to.have.accessible.name", { expectedText, isNot, timeout });
|
||||
}, expected, options);
|
||||
}
|
||||
function toHaveAccessibleErrorMessage(locator, expected, options) {
|
||||
return import_toMatchText.toMatchText.call(this, "toHaveAccessibleErrorMessage", locator, "Locator", async (isNot, timeout) => {
|
||||
const expectedText = (0, import_utils.serializeExpectedTextValues)([expected], { ignoreCase: options?.ignoreCase, normalizeWhiteSpace: true });
|
||||
return await locator._expect("to.have.accessible.error.message", { expectedText, isNot, timeout });
|
||||
}, expected, options);
|
||||
}
|
||||
function toHaveAttribute(locator, name, expected, options) {
|
||||
if (!options) {
|
||||
if (typeof expected === "object" && !(0, import_utils.isRegExp)(expected)) {
|
||||
options = expected;
|
||||
expected = void 0;
|
||||
}
|
||||
}
|
||||
if (expected === void 0) {
|
||||
return import_toBeTruthy.toBeTruthy.call(this, "toHaveAttribute", locator, "Locator", "have attribute", "", async (isNot, timeout) => {
|
||||
return await locator._expect("to.have.attribute", { expressionArg: name, isNot, timeout });
|
||||
}, options);
|
||||
}
|
||||
return import_toMatchText.toMatchText.call(this, "toHaveAttribute", locator, "Locator", async (isNot, timeout) => {
|
||||
const expectedText = (0, import_utils.serializeExpectedTextValues)([expected], { ignoreCase: options?.ignoreCase });
|
||||
return await locator._expect("to.have.attribute.value", { expressionArg: name, expectedText, isNot, timeout });
|
||||
}, expected, options);
|
||||
}
|
||||
function toHaveClass(locator, expected, options) {
|
||||
if (Array.isArray(expected)) {
|
||||
return import_toEqual.toEqual.call(this, "toHaveClass", locator, "Locator", async (isNot, timeout) => {
|
||||
const expectedText = (0, import_utils.serializeExpectedTextValues)(expected);
|
||||
return await locator._expect("to.have.class.array", { expectedText, isNot, timeout });
|
||||
}, expected, options, true);
|
||||
} else {
|
||||
return import_toMatchText.toMatchText.call(this, "toHaveClass", locator, "Locator", async (isNot, timeout) => {
|
||||
const expectedText = (0, import_utils.serializeExpectedTextValues)([expected]);
|
||||
return await locator._expect("to.have.class", { expectedText, isNot, timeout });
|
||||
}, expected, options);
|
||||
}
|
||||
}
|
||||
function toContainClass(locator, expected, options) {
|
||||
if (Array.isArray(expected)) {
|
||||
if (expected.some((e) => (0, import_utils.isRegExp)(e)))
|
||||
throw new Error(`"expected" argument in toContainClass cannot contain RegExp values`);
|
||||
return import_toEqual.toEqual.call(this, "toContainClass", locator, "Locator", async (isNot, timeout) => {
|
||||
const expectedText = (0, import_utils.serializeExpectedTextValues)(expected);
|
||||
return await locator._expect("to.contain.class.array", { expectedText, isNot, timeout });
|
||||
}, expected, options, true);
|
||||
} else {
|
||||
if ((0, import_utils.isRegExp)(expected))
|
||||
throw new Error(`"expected" argument in toContainClass cannot be a RegExp value`);
|
||||
return import_toMatchText.toMatchText.call(this, "toContainClass", locator, "Locator", async (isNot, timeout) => {
|
||||
const expectedText = (0, import_utils.serializeExpectedTextValues)([expected]);
|
||||
return await locator._expect("to.contain.class", { expectedText, isNot, timeout });
|
||||
}, expected, options);
|
||||
}
|
||||
}
|
||||
function toHaveCount(locator, expected, options) {
|
||||
return import_toEqual.toEqual.call(this, "toHaveCount", locator, "Locator", async (isNot, timeout) => {
|
||||
return await locator._expect("to.have.count", { expectedNumber: expected, isNot, timeout });
|
||||
}, expected, options);
|
||||
}
|
||||
function toHaveCSS(locator, name, expected, options) {
|
||||
return import_toMatchText.toMatchText.call(this, "toHaveCSS", locator, "Locator", async (isNot, timeout) => {
|
||||
const expectedText = (0, import_utils.serializeExpectedTextValues)([expected]);
|
||||
return await locator._expect("to.have.css", { expressionArg: name, expectedText, isNot, timeout });
|
||||
}, expected, options);
|
||||
}
|
||||
function toHaveId(locator, expected, options) {
|
||||
return import_toMatchText.toMatchText.call(this, "toHaveId", locator, "Locator", async (isNot, timeout) => {
|
||||
const expectedText = (0, import_utils.serializeExpectedTextValues)([expected]);
|
||||
return await locator._expect("to.have.id", { expectedText, isNot, timeout });
|
||||
}, expected, options);
|
||||
}
|
||||
function toHaveJSProperty(locator, name, expected, options) {
|
||||
return import_toEqual.toEqual.call(this, "toHaveJSProperty", locator, "Locator", async (isNot, timeout) => {
|
||||
return await locator._expect("to.have.property", { expressionArg: name, expectedValue: expected, isNot, timeout });
|
||||
}, expected, options);
|
||||
}
|
||||
function toHaveRole(locator, expected, options) {
|
||||
if (!(0, import_utils.isString)(expected))
|
||||
throw new Error(`"role" argument in toHaveRole must be a string`);
|
||||
return import_toMatchText.toMatchText.call(this, "toHaveRole", locator, "Locator", async (isNot, timeout) => {
|
||||
const expectedText = (0, import_utils.serializeExpectedTextValues)([expected]);
|
||||
return await locator._expect("to.have.role", { expectedText, isNot, timeout });
|
||||
}, expected, options);
|
||||
}
|
||||
function toHaveText(locator, expected, options = {}) {
|
||||
if (Array.isArray(expected)) {
|
||||
return import_toEqual.toEqual.call(this, "toHaveText", locator, "Locator", async (isNot, timeout) => {
|
||||
const expectedText = (0, import_utils.serializeExpectedTextValues)(expected, { normalizeWhiteSpace: true, ignoreCase: options.ignoreCase });
|
||||
return await locator._expect("to.have.text.array", { expectedText, isNot, useInnerText: options?.useInnerText, timeout });
|
||||
}, expected, options);
|
||||
} else {
|
||||
return import_toMatchText.toMatchText.call(this, "toHaveText", locator, "Locator", async (isNot, timeout) => {
|
||||
const expectedText = (0, import_utils.serializeExpectedTextValues)([expected], { normalizeWhiteSpace: true, ignoreCase: options.ignoreCase });
|
||||
return await locator._expect("to.have.text", { expectedText, isNot, useInnerText: options?.useInnerText, timeout });
|
||||
}, expected, options);
|
||||
}
|
||||
}
|
||||
function toHaveValue(locator, expected, options) {
|
||||
return import_toMatchText.toMatchText.call(this, "toHaveValue", locator, "Locator", async (isNot, timeout) => {
|
||||
const expectedText = (0, import_utils.serializeExpectedTextValues)([expected]);
|
||||
return await locator._expect("to.have.value", { expectedText, isNot, timeout });
|
||||
}, expected, options);
|
||||
}
|
||||
function toHaveValues(locator, expected, options) {
|
||||
return import_toEqual.toEqual.call(this, "toHaveValues", locator, "Locator", async (isNot, timeout) => {
|
||||
const expectedText = (0, import_utils.serializeExpectedTextValues)(expected);
|
||||
return await locator._expect("to.have.values", { expectedText, isNot, timeout });
|
||||
}, expected, options);
|
||||
}
|
||||
function toHaveTitle(page, expected, options = {}) {
|
||||
return import_toMatchText.toMatchText.call(this, "toHaveTitle", page, "Page", async (isNot, timeout) => {
|
||||
const expectedText = (0, import_utils.serializeExpectedTextValues)([expected], { normalizeWhiteSpace: true });
|
||||
return await page.mainFrame()._expect("to.have.title", { expectedText, isNot, timeout });
|
||||
}, expected, { receiverLabel: "page", ...options });
|
||||
}
|
||||
function toHaveURL(page, expected, options) {
|
||||
if (typeof expected === "function")
|
||||
return import_toHaveURL.toHaveURLWithPredicate.call(this, page, expected, options);
|
||||
const baseURL = page.context()._options.baseURL;
|
||||
expected = typeof expected === "string" ? (0, import_utils.constructURLBasedOnBaseURL)(baseURL, expected) : expected;
|
||||
return import_toMatchText.toMatchText.call(this, "toHaveURL", page, "Page", async (isNot, timeout) => {
|
||||
const expectedText = (0, import_utils.serializeExpectedTextValues)([expected], { ignoreCase: options?.ignoreCase });
|
||||
return await page.mainFrame()._expect("to.have.url", { expectedText, isNot, timeout });
|
||||
}, expected, { receiverLabel: "page", ...options });
|
||||
}
|
||||
async function toBeOK(response) {
|
||||
const matcherName = "toBeOK";
|
||||
(0, import_util.expectTypes)(response, ["APIResponse"], matcherName);
|
||||
const contentType = response.headers()["content-type"];
|
||||
const isTextEncoding = contentType && (0, import_utils.isTextualMimeType)(contentType);
|
||||
const [log, text] = this.isNot === response.ok() ? await Promise.all([
|
||||
response._fetchLog(),
|
||||
isTextEncoding ? response.text() : null
|
||||
]) : [];
|
||||
const message = () => this.utils.matcherHint(matcherName, void 0, "", { isNot: this.isNot }) + (0, import_util.callLogText)(log) + (text === null ? "" : `
|
||||
Response text:
|
||||
${import_utils2.colors.dim(text?.substring(0, 1e3) || "")}`);
|
||||
const pass = response.ok();
|
||||
return { message, pass };
|
||||
}
|
||||
async function toPass(callback, options = {}) {
|
||||
const testInfo = (0, import_globals.currentTestInfo)();
|
||||
const timeout = (0, import_config.takeFirst)(options.timeout, testInfo?._projectInternal.expect?.toPass?.timeout, 0);
|
||||
const intervals = (0, import_config.takeFirst)(options.intervals, testInfo?._projectInternal.expect?.toPass?.intervals, [100, 250, 500, 1e3]);
|
||||
const { deadline, timeoutMessage } = testInfo ? testInfo._deadlineForMatcher(timeout) : import_testInfo.TestInfoImpl._defaultDeadlineForMatcher(timeout);
|
||||
const result = await (0, import_utils.pollAgainstDeadline)(async () => {
|
||||
if (testInfo && (0, import_globals.currentTestInfo)() !== testInfo)
|
||||
return { continuePolling: false, result: void 0 };
|
||||
try {
|
||||
await callback();
|
||||
return { continuePolling: !!this.isNot, result: void 0 };
|
||||
} catch (e) {
|
||||
return { continuePolling: !this.isNot, result: e };
|
||||
}
|
||||
}, deadline, intervals);
|
||||
if (result.timedOut) {
|
||||
const message = result.result ? [
|
||||
result.result.message,
|
||||
"",
|
||||
`Call Log:`,
|
||||
`- ${timeoutMessage}`
|
||||
].join("\n") : timeoutMessage;
|
||||
return { message: () => message, pass: !!this.isNot };
|
||||
}
|
||||
return { pass: !this.isNot, message: () => "" };
|
||||
}
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
0 && (module.exports = {
|
||||
toBeAttached,
|
||||
toBeChecked,
|
||||
toBeDisabled,
|
||||
toBeEditable,
|
||||
toBeEmpty,
|
||||
toBeEnabled,
|
||||
toBeFocused,
|
||||
toBeHidden,
|
||||
toBeInViewport,
|
||||
toBeOK,
|
||||
toBeVisible,
|
||||
toContainClass,
|
||||
toContainText,
|
||||
toHaveAccessibleDescription,
|
||||
toHaveAccessibleErrorMessage,
|
||||
toHaveAccessibleName,
|
||||
toHaveAttribute,
|
||||
toHaveCSS,
|
||||
toHaveClass,
|
||||
toHaveCount,
|
||||
toHaveId,
|
||||
toHaveJSProperty,
|
||||
toHaveRole,
|
||||
toHaveText,
|
||||
toHaveTitle,
|
||||
toHaveURL,
|
||||
toHaveValue,
|
||||
toHaveValues,
|
||||
toPass
|
||||
});
|
||||
71
frontend/e2e/node_modules/playwright/lib/matchers/toBeTruthy.js
generated
vendored
Normal file
71
frontend/e2e/node_modules/playwright/lib/matchers/toBeTruthy.js
generated
vendored
Normal file
@@ -0,0 +1,71 @@
|
||||
"use strict";
|
||||
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);
|
||||
var toBeTruthy_exports = {};
|
||||
__export(toBeTruthy_exports, {
|
||||
toBeTruthy: () => toBeTruthy
|
||||
});
|
||||
module.exports = __toCommonJS(toBeTruthy_exports);
|
||||
var import_util = require("../util");
|
||||
var import_matcherHint = require("./matcherHint");
|
||||
async function toBeTruthy(matcherName, receiver, receiverType, expected, arg, query, options = {}) {
|
||||
(0, import_util.expectTypes)(receiver, [receiverType], matcherName);
|
||||
const matcherOptions = {
|
||||
isNot: this.isNot,
|
||||
promise: this.promise
|
||||
};
|
||||
const timeout = options.timeout ?? this.timeout;
|
||||
const { matches: pass, log, timedOut, received } = await query(!!this.isNot, timeout);
|
||||
if (pass === !this.isNot) {
|
||||
return {
|
||||
name: matcherName,
|
||||
message: () => "",
|
||||
pass,
|
||||
expected
|
||||
};
|
||||
}
|
||||
const notFound = received === import_matcherHint.kNoElementsFoundError ? received : void 0;
|
||||
let printedReceived;
|
||||
let printedExpected;
|
||||
if (pass) {
|
||||
printedExpected = `Expected: not ${expected}`;
|
||||
printedReceived = `Received: ${notFound ? import_matcherHint.kNoElementsFoundError : expected}`;
|
||||
} else {
|
||||
printedExpected = `Expected: ${expected}`;
|
||||
printedReceived = `Received: ${notFound ? import_matcherHint.kNoElementsFoundError : received}`;
|
||||
}
|
||||
const message = () => {
|
||||
const header = (0, import_matcherHint.matcherHint)(this, receiver, matcherName, "locator", arg, matcherOptions, timedOut ? timeout : void 0, `${printedExpected}
|
||||
${printedReceived}`);
|
||||
const logText = (0, import_util.callLogText)(log);
|
||||
return `${header}${logText}`;
|
||||
};
|
||||
return {
|
||||
message,
|
||||
pass,
|
||||
actual: received,
|
||||
name: matcherName,
|
||||
expected,
|
||||
log,
|
||||
timeout: timedOut ? timeout : void 0
|
||||
};
|
||||
}
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
0 && (module.exports = {
|
||||
toBeTruthy
|
||||
});
|
||||
94
frontend/e2e/node_modules/playwright/lib/matchers/toEqual.js
generated
vendored
Normal file
94
frontend/e2e/node_modules/playwright/lib/matchers/toEqual.js
generated
vendored
Normal file
@@ -0,0 +1,94 @@
|
||||
"use strict";
|
||||
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);
|
||||
var toEqual_exports = {};
|
||||
__export(toEqual_exports, {
|
||||
toEqual: () => toEqual
|
||||
});
|
||||
module.exports = __toCommonJS(toEqual_exports);
|
||||
var import_utils = require("playwright-core/lib/utils");
|
||||
var import_util = require("../util");
|
||||
var import_matcherHint = require("./matcherHint");
|
||||
const EXPECTED_LABEL = "Expected";
|
||||
const RECEIVED_LABEL = "Received";
|
||||
async function toEqual(matcherName, receiver, receiverType, query, expected, options = {}, messagePreventExtraStatIndent) {
|
||||
(0, import_util.expectTypes)(receiver, [receiverType], matcherName);
|
||||
const matcherOptions = {
|
||||
comment: options.contains ? "" : "deep equality",
|
||||
isNot: this.isNot,
|
||||
promise: this.promise
|
||||
};
|
||||
const timeout = options.timeout ?? this.timeout;
|
||||
const { matches: pass, received, log, timedOut } = await query(!!this.isNot, timeout);
|
||||
if (pass === !this.isNot) {
|
||||
return {
|
||||
name: matcherName,
|
||||
message: () => "",
|
||||
pass,
|
||||
expected
|
||||
};
|
||||
}
|
||||
let printedReceived;
|
||||
let printedExpected;
|
||||
let printedDiff;
|
||||
if (pass) {
|
||||
printedExpected = `Expected: not ${this.utils.printExpected(expected)}`;
|
||||
printedReceived = `Received: ${this.utils.printReceived(received)}`;
|
||||
} else if (Array.isArray(expected) && Array.isArray(received)) {
|
||||
const normalizedExpected = expected.map((exp, index) => {
|
||||
const rec = received[index];
|
||||
if ((0, import_utils.isRegExp)(exp))
|
||||
return exp.test(rec) ? rec : exp;
|
||||
return exp;
|
||||
});
|
||||
printedDiff = this.utils.printDiffOrStringify(
|
||||
normalizedExpected,
|
||||
received,
|
||||
EXPECTED_LABEL,
|
||||
RECEIVED_LABEL,
|
||||
false
|
||||
);
|
||||
} else {
|
||||
printedDiff = this.utils.printDiffOrStringify(
|
||||
expected,
|
||||
received,
|
||||
EXPECTED_LABEL,
|
||||
RECEIVED_LABEL,
|
||||
false
|
||||
);
|
||||
}
|
||||
const message = () => {
|
||||
const details = printedDiff || `${printedExpected}
|
||||
${printedReceived}`;
|
||||
const header = (0, import_matcherHint.matcherHint)(this, receiver, matcherName, "locator", void 0, matcherOptions, timedOut ? timeout : void 0, details, messagePreventExtraStatIndent);
|
||||
return `${header}${(0, import_util.callLogText)(log)}`;
|
||||
};
|
||||
return {
|
||||
actual: received,
|
||||
expected,
|
||||
message,
|
||||
name: matcherName,
|
||||
pass,
|
||||
log,
|
||||
timeout: timedOut ? timeout : void 0
|
||||
};
|
||||
}
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
0 && (module.exports = {
|
||||
toEqual
|
||||
});
|
||||
117
frontend/e2e/node_modules/playwright/lib/matchers/toHaveURL.js
generated
vendored
Normal file
117
frontend/e2e/node_modules/playwright/lib/matchers/toHaveURL.js
generated
vendored
Normal file
@@ -0,0 +1,117 @@
|
||||
"use strict";
|
||||
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);
|
||||
var toHaveURL_exports = {};
|
||||
__export(toHaveURL_exports, {
|
||||
toHaveURLWithPredicate: () => toHaveURLWithPredicate
|
||||
});
|
||||
module.exports = __toCommonJS(toHaveURL_exports);
|
||||
var import_utils = require("playwright-core/lib/utils");
|
||||
var import_utils2 = require("playwright-core/lib/utils");
|
||||
var import_expect = require("./expect");
|
||||
var import_matcherHint = require("./matcherHint");
|
||||
var import_expectBundle = require("../common/expectBundle");
|
||||
async function toHaveURLWithPredicate(page, expected, options) {
|
||||
const matcherName = "toHaveURL";
|
||||
const expression = "page";
|
||||
const matcherOptions = {
|
||||
isNot: this.isNot,
|
||||
promise: this.promise
|
||||
};
|
||||
if (typeof expected !== "function") {
|
||||
throw new Error(
|
||||
[
|
||||
// Always display `expected` in expectation place
|
||||
(0, import_matcherHint.matcherHint)(this, void 0, matcherName, expression, void 0, matcherOptions, void 0, void 0, true),
|
||||
`${import_utils2.colors.bold("Matcher error")}: ${(0, import_expectBundle.EXPECTED_COLOR)("expected")} value must be a string, regular expression, or predicate`,
|
||||
this.utils.printWithType("Expected", expected, this.utils.printExpected)
|
||||
].join("\n\n")
|
||||
);
|
||||
}
|
||||
const timeout = options?.timeout ?? this.timeout;
|
||||
const baseURL = page.context()._options.baseURL;
|
||||
let conditionSucceeded = false;
|
||||
let lastCheckedURLString = void 0;
|
||||
try {
|
||||
await page.mainFrame().waitForURL(
|
||||
(url) => {
|
||||
lastCheckedURLString = url.toString();
|
||||
if (options?.ignoreCase) {
|
||||
return !this.isNot === (0, import_utils.urlMatches)(
|
||||
baseURL?.toLocaleLowerCase(),
|
||||
lastCheckedURLString.toLocaleLowerCase(),
|
||||
expected
|
||||
);
|
||||
}
|
||||
return !this.isNot === (0, import_utils.urlMatches)(baseURL, lastCheckedURLString, expected);
|
||||
},
|
||||
{ timeout }
|
||||
);
|
||||
conditionSucceeded = true;
|
||||
} catch (e) {
|
||||
conditionSucceeded = false;
|
||||
}
|
||||
if (conditionSucceeded)
|
||||
return { name: matcherName, pass: !this.isNot, message: () => "" };
|
||||
return {
|
||||
name: matcherName,
|
||||
pass: this.isNot,
|
||||
message: () => toHaveURLMessage(
|
||||
this,
|
||||
matcherName,
|
||||
expression,
|
||||
expected,
|
||||
lastCheckedURLString,
|
||||
this.isNot,
|
||||
true,
|
||||
timeout
|
||||
),
|
||||
actual: lastCheckedURLString,
|
||||
timeout
|
||||
};
|
||||
}
|
||||
function toHaveURLMessage(state, matcherName, expression, expected, received, pass, didTimeout, timeout) {
|
||||
const matcherOptions = {
|
||||
isNot: state.isNot,
|
||||
promise: state.promise
|
||||
};
|
||||
const receivedString = received || "";
|
||||
const messagePrefix = (0, import_matcherHint.matcherHint)(state, void 0, matcherName, expression, void 0, matcherOptions, didTimeout ? timeout : void 0, void 0, true);
|
||||
let printedReceived;
|
||||
let printedExpected;
|
||||
let printedDiff;
|
||||
if (typeof expected === "function") {
|
||||
printedExpected = `Expected predicate to ${!state.isNot ? "succeed" : "fail"}`;
|
||||
printedReceived = `Received string: ${(0, import_expectBundle.printReceived)(receivedString)}`;
|
||||
} else {
|
||||
if (pass) {
|
||||
printedExpected = `Expected pattern: not ${state.utils.printExpected(expected)}`;
|
||||
const formattedReceived = (0, import_expect.printReceivedStringContainExpectedResult)(receivedString, null);
|
||||
printedReceived = `Received string: ${formattedReceived}`;
|
||||
} else {
|
||||
const labelExpected = `Expected ${typeof expected === "string" ? "string" : "pattern"}`;
|
||||
printedDiff = state.utils.printDiffOrStringify(expected, receivedString, labelExpected, "Received string", false);
|
||||
}
|
||||
}
|
||||
const resultDetails = printedDiff ? printedDiff : printedExpected + "\n" + printedReceived;
|
||||
return messagePrefix + resultDetails;
|
||||
}
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
0 && (module.exports = {
|
||||
toHaveURLWithPredicate
|
||||
});
|
||||
163
frontend/e2e/node_modules/playwright/lib/matchers/toMatchAriaSnapshot.js
generated
vendored
Normal file
163
frontend/e2e/node_modules/playwright/lib/matchers/toMatchAriaSnapshot.js
generated
vendored
Normal file
@@ -0,0 +1,163 @@
|
||||
"use strict";
|
||||
var __create = Object.create;
|
||||
var __defProp = Object.defineProperty;
|
||||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||||
var __getProtoOf = Object.getPrototypeOf;
|
||||
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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
||||
// If the importer is in node compatibility mode or this is not an ESM
|
||||
// file that has been converted to a CommonJS file using a Babel-
|
||||
// compatible transform (i.e. "__esModule" has not been set), then set
|
||||
// "default" to the CommonJS "module.exports" for node compatibility.
|
||||
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
||||
mod
|
||||
));
|
||||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
||||
var toMatchAriaSnapshot_exports = {};
|
||||
__export(toMatchAriaSnapshot_exports, {
|
||||
toMatchAriaSnapshot: () => toMatchAriaSnapshot
|
||||
});
|
||||
module.exports = __toCommonJS(toMatchAriaSnapshot_exports);
|
||||
var import_fs = __toESM(require("fs"));
|
||||
var import_path = __toESM(require("path"));
|
||||
var import_utils = require("playwright-core/lib/utils");
|
||||
var import_matcherHint = require("./matcherHint");
|
||||
var import_expectBundle = require("../common/expectBundle");
|
||||
var import_util = require("../util");
|
||||
var import_expect = require("./expect");
|
||||
var import_globals = require("../common/globals");
|
||||
async function toMatchAriaSnapshot(receiver, expectedParam, options = {}) {
|
||||
const matcherName = "toMatchAriaSnapshot";
|
||||
const testInfo = (0, import_globals.currentTestInfo)();
|
||||
if (!testInfo)
|
||||
throw new Error(`toMatchAriaSnapshot() must be called during the test`);
|
||||
if (testInfo._projectInternal.ignoreSnapshots)
|
||||
return { pass: !this.isNot, message: () => "", name: "toMatchAriaSnapshot", expected: "" };
|
||||
const updateSnapshots = testInfo.config.updateSnapshots;
|
||||
const matcherOptions = {
|
||||
isNot: this.isNot,
|
||||
promise: this.promise
|
||||
};
|
||||
let expected;
|
||||
let timeout;
|
||||
let expectedPath;
|
||||
if ((0, import_utils.isString)(expectedParam)) {
|
||||
expected = expectedParam;
|
||||
timeout = options.timeout ?? this.timeout;
|
||||
} else {
|
||||
const legacyPath = testInfo._resolveSnapshotPaths("aria", expectedParam?.name, "dontUpdateSnapshotIndex", ".yml").absoluteSnapshotPath;
|
||||
expectedPath = testInfo._resolveSnapshotPaths("aria", expectedParam?.name, "updateSnapshotIndex").absoluteSnapshotPath;
|
||||
if (!await (0, import_util.fileExistsAsync)(expectedPath) && await (0, import_util.fileExistsAsync)(legacyPath))
|
||||
expectedPath = legacyPath;
|
||||
expected = await import_fs.default.promises.readFile(expectedPath, "utf8").catch(() => "");
|
||||
timeout = expectedParam?.timeout ?? this.timeout;
|
||||
}
|
||||
const generateMissingBaseline = updateSnapshots === "missing" && !expected;
|
||||
if (generateMissingBaseline) {
|
||||
if (this.isNot) {
|
||||
const message2 = `Matchers using ".not" can't generate new baselines`;
|
||||
return { pass: this.isNot, message: () => message2, name: "toMatchAriaSnapshot" };
|
||||
} else {
|
||||
expected = `- none "Generating new baseline"`;
|
||||
}
|
||||
}
|
||||
expected = unshift(expected);
|
||||
const { matches: pass, received, log, timedOut } = await receiver._expect("to.match.aria", { expectedValue: expected, isNot: this.isNot, timeout });
|
||||
const typedReceived = received;
|
||||
const matcherHintWithExpect = (expectedReceivedString) => {
|
||||
return (0, import_matcherHint.matcherHint)(this, receiver, matcherName, "locator", void 0, matcherOptions, timedOut ? timeout : void 0, expectedReceivedString);
|
||||
};
|
||||
const notFound = typedReceived === import_matcherHint.kNoElementsFoundError;
|
||||
if (notFound) {
|
||||
return {
|
||||
pass: this.isNot,
|
||||
message: () => matcherHintWithExpect(`Expected: ${this.utils.printExpected(expected)}
|
||||
Received: ${(0, import_expectBundle.EXPECTED_COLOR)("<element not found>")}`) + (0, import_util.callLogText)(log),
|
||||
name: "toMatchAriaSnapshot",
|
||||
expected
|
||||
};
|
||||
}
|
||||
const receivedText = typedReceived.raw;
|
||||
const message = () => {
|
||||
if (pass) {
|
||||
const receivedString = notFound ? receivedText : (0, import_expect.printReceivedStringContainExpectedSubstring)(receivedText, receivedText.indexOf(expected), expected.length);
|
||||
const expectedReceivedString = `Expected: not ${this.utils.printExpected(expected)}
|
||||
Received: ${receivedString}`;
|
||||
return matcherHintWithExpect(expectedReceivedString) + (0, import_util.callLogText)(log);
|
||||
} else {
|
||||
const labelExpected = `Expected`;
|
||||
const expectedReceivedString = notFound ? `${labelExpected}: ${this.utils.printExpected(expected)}
|
||||
Received: ${receivedText}` : this.utils.printDiffOrStringify(expected, receivedText, labelExpected, "Received", false);
|
||||
return matcherHintWithExpect(expectedReceivedString) + (0, import_util.callLogText)(log);
|
||||
}
|
||||
};
|
||||
if (!this.isNot) {
|
||||
if (updateSnapshots === "all" || updateSnapshots === "changed" && pass === this.isNot || generateMissingBaseline) {
|
||||
if (expectedPath) {
|
||||
await import_fs.default.promises.mkdir(import_path.default.dirname(expectedPath), { recursive: true });
|
||||
await import_fs.default.promises.writeFile(expectedPath, typedReceived.regex, "utf8");
|
||||
const relativePath = import_path.default.relative(process.cwd(), expectedPath);
|
||||
if (updateSnapshots === "missing") {
|
||||
const message2 = `A snapshot doesn't exist at ${relativePath}, writing actual.`;
|
||||
testInfo._hasNonRetriableError = true;
|
||||
testInfo._failWithError(new Error(message2));
|
||||
} else {
|
||||
const message2 = `A snapshot is generated at ${relativePath}.`;
|
||||
console.log(message2);
|
||||
}
|
||||
return { pass: true, message: () => "", name: "toMatchAriaSnapshot" };
|
||||
} else {
|
||||
const suggestedRebaseline = `\`
|
||||
${(0, import_utils.escapeTemplateString)(indent(typedReceived.regex, "{indent} "))}
|
||||
{indent}\``;
|
||||
if (updateSnapshots === "missing") {
|
||||
const message2 = "A snapshot is not provided, generating new baseline.";
|
||||
testInfo._hasNonRetriableError = true;
|
||||
testInfo._failWithError(new Error(message2));
|
||||
}
|
||||
return { pass: false, message: () => "", name: "toMatchAriaSnapshot", suggestedRebaseline };
|
||||
}
|
||||
}
|
||||
}
|
||||
return {
|
||||
name: matcherName,
|
||||
expected,
|
||||
message,
|
||||
pass,
|
||||
actual: received,
|
||||
log,
|
||||
timeout: timedOut ? timeout : void 0
|
||||
};
|
||||
}
|
||||
function unshift(snapshot) {
|
||||
const lines = snapshot.split("\n");
|
||||
let whitespacePrefixLength = 100;
|
||||
for (const line of lines) {
|
||||
if (!line.trim())
|
||||
continue;
|
||||
const match = line.match(/^(\s*)/);
|
||||
if (match && match[1].length < whitespacePrefixLength)
|
||||
whitespacePrefixLength = match[1].length;
|
||||
}
|
||||
return lines.filter((t) => t.trim()).map((line) => line.substring(whitespacePrefixLength)).join("\n");
|
||||
}
|
||||
function indent(snapshot, indent2) {
|
||||
return snapshot.split("\n").map((line) => indent2 + line).join("\n");
|
||||
}
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
0 && (module.exports = {
|
||||
toMatchAriaSnapshot
|
||||
});
|
||||
338
frontend/e2e/node_modules/playwright/lib/matchers/toMatchSnapshot.js
generated
vendored
Normal file
338
frontend/e2e/node_modules/playwright/lib/matchers/toMatchSnapshot.js
generated
vendored
Normal file
@@ -0,0 +1,338 @@
|
||||
"use strict";
|
||||
var __create = Object.create;
|
||||
var __defProp = Object.defineProperty;
|
||||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||||
var __getProtoOf = Object.getPrototypeOf;
|
||||
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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
||||
// If the importer is in node compatibility mode or this is not an ESM
|
||||
// file that has been converted to a CommonJS file using a Babel-
|
||||
// compatible transform (i.e. "__esModule" has not been set), then set
|
||||
// "default" to the CommonJS "module.exports" for node compatibility.
|
||||
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
||||
mod
|
||||
));
|
||||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
||||
var toMatchSnapshot_exports = {};
|
||||
__export(toMatchSnapshot_exports, {
|
||||
toHaveScreenshot: () => toHaveScreenshot,
|
||||
toHaveScreenshotStepTitle: () => toHaveScreenshotStepTitle,
|
||||
toMatchSnapshot: () => toMatchSnapshot
|
||||
});
|
||||
module.exports = __toCommonJS(toMatchSnapshot_exports);
|
||||
var import_fs = __toESM(require("fs"));
|
||||
var import_path = __toESM(require("path"));
|
||||
var import_utils = require("playwright-core/lib/utils");
|
||||
var import_utils2 = require("playwright-core/lib/utils");
|
||||
var import_utilsBundle = require("playwright-core/lib/utilsBundle");
|
||||
var import_util = require("../util");
|
||||
var import_matcherHint = require("./matcherHint");
|
||||
var import_globals = require("../common/globals");
|
||||
const NonConfigProperties = [
|
||||
"clip",
|
||||
"fullPage",
|
||||
"mask",
|
||||
"maskColor",
|
||||
"omitBackground",
|
||||
"timeout"
|
||||
];
|
||||
class SnapshotHelper {
|
||||
constructor(testInfo, matcherName, locator, anonymousSnapshotExtension, configOptions, nameOrOptions, optOptions) {
|
||||
let name;
|
||||
if (Array.isArray(nameOrOptions) || typeof nameOrOptions === "string") {
|
||||
name = nameOrOptions;
|
||||
this.options = { ...optOptions };
|
||||
} else {
|
||||
const { name: nameFromOptions, ...options } = nameOrOptions;
|
||||
this.options = options;
|
||||
name = nameFromOptions;
|
||||
}
|
||||
this.name = Array.isArray(name) ? name.join(import_path.default.sep) : name || "";
|
||||
const resolvedPaths = testInfo._resolveSnapshotPaths(matcherName === "toHaveScreenshot" ? "screenshot" : "snapshot", name, "updateSnapshotIndex", anonymousSnapshotExtension);
|
||||
this.expectedPath = resolvedPaths.absoluteSnapshotPath;
|
||||
this.attachmentBaseName = resolvedPaths.relativeOutputPath;
|
||||
const outputBasePath = testInfo._getOutputPath(resolvedPaths.relativeOutputPath);
|
||||
this.legacyExpectedPath = (0, import_util.addSuffixToFilePath)(outputBasePath, "-expected");
|
||||
this.previousPath = (0, import_util.addSuffixToFilePath)(outputBasePath, "-previous");
|
||||
this.actualPath = (0, import_util.addSuffixToFilePath)(outputBasePath, "-actual");
|
||||
this.diffPath = (0, import_util.addSuffixToFilePath)(outputBasePath, "-diff");
|
||||
const filteredConfigOptions = { ...configOptions };
|
||||
for (const prop of NonConfigProperties)
|
||||
delete filteredConfigOptions[prop];
|
||||
this.options = {
|
||||
...filteredConfigOptions,
|
||||
...this.options
|
||||
};
|
||||
if (this.options._comparator) {
|
||||
this.options.comparator = this.options._comparator;
|
||||
delete this.options._comparator;
|
||||
}
|
||||
if (this.options.maxDiffPixels !== void 0 && this.options.maxDiffPixels < 0)
|
||||
throw new Error("`maxDiffPixels` option value must be non-negative integer");
|
||||
if (this.options.maxDiffPixelRatio !== void 0 && (this.options.maxDiffPixelRatio < 0 || this.options.maxDiffPixelRatio > 1))
|
||||
throw new Error("`maxDiffPixelRatio` option value must be between 0 and 1");
|
||||
this.matcherName = matcherName;
|
||||
this.locator = locator;
|
||||
this.updateSnapshots = testInfo.config.updateSnapshots;
|
||||
this.mimeType = import_utilsBundle.mime.getType(import_path.default.basename(this.expectedPath)) ?? "application/octet-stream";
|
||||
this.comparator = (0, import_utils.getComparator)(this.mimeType);
|
||||
this.testInfo = testInfo;
|
||||
this.kind = this.mimeType.startsWith("image/") ? "Screenshot" : "Snapshot";
|
||||
}
|
||||
createMatcherResult(message, pass, log) {
|
||||
const unfiltered = {
|
||||
name: this.matcherName,
|
||||
expected: this.expectedPath,
|
||||
actual: this.actualPath,
|
||||
diff: this.diffPath,
|
||||
pass,
|
||||
message: () => message,
|
||||
log
|
||||
};
|
||||
return Object.fromEntries(Object.entries(unfiltered).filter(([_, v]) => v !== void 0));
|
||||
}
|
||||
handleMissingNegated() {
|
||||
const isWriteMissingMode = this.updateSnapshots !== "none";
|
||||
const message = `A snapshot doesn't exist at ${this.expectedPath}${isWriteMissingMode ? `, matchers using ".not" won't write them automatically.` : "."}`;
|
||||
return this.createMatcherResult(message, true);
|
||||
}
|
||||
handleDifferentNegated() {
|
||||
return this.createMatcherResult("", false);
|
||||
}
|
||||
handleMatchingNegated() {
|
||||
const message = [
|
||||
import_utils2.colors.red(`${this.kind} comparison failed:`),
|
||||
"",
|
||||
indent("Expected result should be different from the actual one.", " ")
|
||||
].join("\n");
|
||||
return this.createMatcherResult(message, true);
|
||||
}
|
||||
handleMissing(actual, step) {
|
||||
const isWriteMissingMode = this.updateSnapshots !== "none";
|
||||
if (isWriteMissingMode)
|
||||
writeFileSync(this.expectedPath, actual);
|
||||
step?._attachToStep({ name: (0, import_util.addSuffixToFilePath)(this.attachmentBaseName, "-expected"), contentType: this.mimeType, path: this.expectedPath });
|
||||
writeFileSync(this.actualPath, actual);
|
||||
step?._attachToStep({ name: (0, import_util.addSuffixToFilePath)(this.attachmentBaseName, "-actual"), contentType: this.mimeType, path: this.actualPath });
|
||||
const message = `A snapshot doesn't exist at ${this.expectedPath}${isWriteMissingMode ? ", writing actual." : "."}`;
|
||||
if (this.updateSnapshots === "all" || this.updateSnapshots === "changed") {
|
||||
console.log(message);
|
||||
return this.createMatcherResult(message, true);
|
||||
}
|
||||
if (this.updateSnapshots === "missing") {
|
||||
this.testInfo._hasNonRetriableError = true;
|
||||
this.testInfo._failWithError(new Error(message));
|
||||
return this.createMatcherResult("", true);
|
||||
}
|
||||
return this.createMatcherResult(message, false);
|
||||
}
|
||||
handleDifferent(actual, expected, previous, diff, header, diffError, log, step) {
|
||||
const output = [`${header}${indent(diffError, " ")}`];
|
||||
if (this.name) {
|
||||
output.push("");
|
||||
output.push(` Snapshot: ${this.name}`);
|
||||
}
|
||||
if (expected !== void 0) {
|
||||
writeFileSync(this.legacyExpectedPath, expected);
|
||||
step?._attachToStep({ name: (0, import_util.addSuffixToFilePath)(this.attachmentBaseName, "-expected"), contentType: this.mimeType, path: this.expectedPath });
|
||||
}
|
||||
if (previous !== void 0) {
|
||||
writeFileSync(this.previousPath, previous);
|
||||
step?._attachToStep({ name: (0, import_util.addSuffixToFilePath)(this.attachmentBaseName, "-previous"), contentType: this.mimeType, path: this.previousPath });
|
||||
}
|
||||
if (actual !== void 0) {
|
||||
writeFileSync(this.actualPath, actual);
|
||||
step?._attachToStep({ name: (0, import_util.addSuffixToFilePath)(this.attachmentBaseName, "-actual"), contentType: this.mimeType, path: this.actualPath });
|
||||
}
|
||||
if (diff !== void 0) {
|
||||
writeFileSync(this.diffPath, diff);
|
||||
step?._attachToStep({ name: (0, import_util.addSuffixToFilePath)(this.attachmentBaseName, "-diff"), contentType: this.mimeType, path: this.diffPath });
|
||||
}
|
||||
if (log?.length)
|
||||
output.push((0, import_util.callLogText)(log));
|
||||
else
|
||||
output.push("");
|
||||
return this.createMatcherResult(output.join("\n"), false, log);
|
||||
}
|
||||
handleMatching() {
|
||||
return this.createMatcherResult("", true);
|
||||
}
|
||||
}
|
||||
function toMatchSnapshot(received, nameOrOptions = {}, optOptions = {}) {
|
||||
const testInfo = (0, import_globals.currentTestInfo)();
|
||||
if (!testInfo)
|
||||
throw new Error(`toMatchSnapshot() must be called during the test`);
|
||||
if (received instanceof Promise)
|
||||
throw new Error("An unresolved Promise was passed to toMatchSnapshot(), make sure to resolve it by adding await to it.");
|
||||
if (testInfo._projectInternal.ignoreSnapshots)
|
||||
return { pass: !this.isNot, message: () => "", name: "toMatchSnapshot", expected: nameOrOptions };
|
||||
const configOptions = testInfo._projectInternal.expect?.toMatchSnapshot || {};
|
||||
const helper = new SnapshotHelper(
|
||||
testInfo,
|
||||
"toMatchSnapshot",
|
||||
void 0,
|
||||
"." + determineFileExtension(received),
|
||||
configOptions,
|
||||
nameOrOptions,
|
||||
optOptions
|
||||
);
|
||||
if (this.isNot) {
|
||||
if (!import_fs.default.existsSync(helper.expectedPath))
|
||||
return helper.handleMissingNegated();
|
||||
const isDifferent = !!helper.comparator(received, import_fs.default.readFileSync(helper.expectedPath), helper.options);
|
||||
return isDifferent ? helper.handleDifferentNegated() : helper.handleMatchingNegated();
|
||||
}
|
||||
if (!import_fs.default.existsSync(helper.expectedPath))
|
||||
return helper.handleMissing(received, this._stepInfo);
|
||||
const expected = import_fs.default.readFileSync(helper.expectedPath);
|
||||
if (helper.updateSnapshots === "all") {
|
||||
if (!(0, import_utils.compareBuffersOrStrings)(received, expected))
|
||||
return helper.handleMatching();
|
||||
writeFileSync(helper.expectedPath, received);
|
||||
console.log(helper.expectedPath + " is not the same, writing actual.");
|
||||
return helper.createMatcherResult(helper.expectedPath + " running with --update-snapshots, writing actual.", true);
|
||||
}
|
||||
if (helper.updateSnapshots === "changed") {
|
||||
const result2 = helper.comparator(received, expected, helper.options);
|
||||
if (!result2)
|
||||
return helper.handleMatching();
|
||||
writeFileSync(helper.expectedPath, received);
|
||||
console.log(helper.expectedPath + " does not match, writing actual.");
|
||||
return helper.createMatcherResult(helper.expectedPath + " running with --update-snapshots, writing actual.", true);
|
||||
}
|
||||
const result = helper.comparator(received, expected, helper.options);
|
||||
if (!result)
|
||||
return helper.handleMatching();
|
||||
const receiver = (0, import_utils.isString)(received) ? "string" : "Buffer";
|
||||
const header = (0, import_matcherHint.matcherHint)(this, void 0, "toMatchSnapshot", receiver, void 0, void 0, void 0);
|
||||
return helper.handleDifferent(received, expected, void 0, result.diff, header, result.errorMessage, void 0, this._stepInfo);
|
||||
}
|
||||
function toHaveScreenshotStepTitle(nameOrOptions = {}, optOptions = {}) {
|
||||
let name;
|
||||
if (typeof nameOrOptions === "object" && !Array.isArray(nameOrOptions))
|
||||
name = nameOrOptions.name;
|
||||
else
|
||||
name = nameOrOptions;
|
||||
return Array.isArray(name) ? name.join(import_path.default.sep) : name || "";
|
||||
}
|
||||
async function toHaveScreenshot(pageOrLocator, nameOrOptions = {}, optOptions = {}) {
|
||||
const testInfo = (0, import_globals.currentTestInfo)();
|
||||
if (!testInfo)
|
||||
throw new Error(`toHaveScreenshot() must be called during the test`);
|
||||
if (testInfo._projectInternal.ignoreSnapshots)
|
||||
return { pass: !this.isNot, message: () => "", name: "toHaveScreenshot", expected: nameOrOptions };
|
||||
(0, import_util.expectTypes)(pageOrLocator, ["Page", "Locator"], "toHaveScreenshot");
|
||||
const [page, locator] = pageOrLocator.constructor.name === "Page" ? [pageOrLocator, void 0] : [pageOrLocator.page(), pageOrLocator];
|
||||
const configOptions = testInfo._projectInternal.expect?.toHaveScreenshot || {};
|
||||
const helper = new SnapshotHelper(testInfo, "toHaveScreenshot", locator, void 0, configOptions, nameOrOptions, optOptions);
|
||||
if (!helper.expectedPath.toLowerCase().endsWith(".png"))
|
||||
throw new Error(`Screenshot name "${import_path.default.basename(helper.expectedPath)}" must have '.png' extension`);
|
||||
(0, import_util.expectTypes)(pageOrLocator, ["Page", "Locator"], "toHaveScreenshot");
|
||||
const style = await loadScreenshotStyles(helper.options.stylePath);
|
||||
const timeout = helper.options.timeout ?? this.timeout;
|
||||
const expectScreenshotOptions = {
|
||||
locator,
|
||||
animations: helper.options.animations ?? "disabled",
|
||||
caret: helper.options.caret ?? "hide",
|
||||
clip: helper.options.clip,
|
||||
fullPage: helper.options.fullPage,
|
||||
mask: helper.options.mask,
|
||||
maskColor: helper.options.maskColor,
|
||||
omitBackground: helper.options.omitBackground,
|
||||
scale: helper.options.scale ?? "css",
|
||||
style,
|
||||
isNot: !!this.isNot,
|
||||
timeout,
|
||||
comparator: helper.options.comparator,
|
||||
maxDiffPixels: helper.options.maxDiffPixels,
|
||||
maxDiffPixelRatio: helper.options.maxDiffPixelRatio,
|
||||
threshold: helper.options.threshold
|
||||
};
|
||||
const hasSnapshot = import_fs.default.existsSync(helper.expectedPath);
|
||||
if (this.isNot) {
|
||||
if (!hasSnapshot)
|
||||
return helper.handleMissingNegated();
|
||||
expectScreenshotOptions.expected = await import_fs.default.promises.readFile(helper.expectedPath);
|
||||
const isDifferent = !(await page._expectScreenshot(expectScreenshotOptions)).errorMessage;
|
||||
return isDifferent ? helper.handleDifferentNegated() : helper.handleMatchingNegated();
|
||||
}
|
||||
if (helper.updateSnapshots === "none" && !hasSnapshot)
|
||||
return helper.createMatcherResult(`A snapshot doesn't exist at ${helper.expectedPath}.`, false);
|
||||
const receiver = locator ? "locator" : "page";
|
||||
if (!hasSnapshot) {
|
||||
const { actual: actual2, previous: previous2, diff: diff2, errorMessage: errorMessage2, log: log2, timedOut: timedOut2 } = await page._expectScreenshot(expectScreenshotOptions);
|
||||
if (errorMessage2) {
|
||||
const header2 = (0, import_matcherHint.matcherHint)(this, locator, "toHaveScreenshot", receiver, void 0, void 0, timedOut2 ? timeout : void 0);
|
||||
return helper.handleDifferent(actual2, void 0, previous2, diff2, header2, errorMessage2, log2, this._stepInfo);
|
||||
}
|
||||
return helper.handleMissing(actual2, this._stepInfo);
|
||||
}
|
||||
const expected = await import_fs.default.promises.readFile(helper.expectedPath);
|
||||
expectScreenshotOptions.expected = helper.updateSnapshots === "all" ? void 0 : expected;
|
||||
const { actual, previous, diff, errorMessage, log, timedOut } = await page._expectScreenshot(expectScreenshotOptions);
|
||||
const writeFiles = () => {
|
||||
writeFileSync(helper.expectedPath, actual);
|
||||
writeFileSync(helper.actualPath, actual);
|
||||
console.log(helper.expectedPath + " is re-generated, writing actual.");
|
||||
return helper.createMatcherResult(helper.expectedPath + " running with --update-snapshots, writing actual.", true);
|
||||
};
|
||||
if (!errorMessage) {
|
||||
if (helper.updateSnapshots === "all" && actual && (0, import_utils.compareBuffersOrStrings)(actual, expected)) {
|
||||
console.log(helper.expectedPath + " is re-generated, writing actual.");
|
||||
return writeFiles();
|
||||
}
|
||||
return helper.handleMatching();
|
||||
}
|
||||
if (helper.updateSnapshots === "changed" || helper.updateSnapshots === "all")
|
||||
return writeFiles();
|
||||
const header = (0, import_matcherHint.matcherHint)(this, void 0, "toHaveScreenshot", receiver, void 0, void 0, timedOut ? timeout : void 0);
|
||||
return helper.handleDifferent(actual, expectScreenshotOptions.expected, previous, diff, header, errorMessage, log, this._stepInfo);
|
||||
}
|
||||
function writeFileSync(aPath, content) {
|
||||
import_fs.default.mkdirSync(import_path.default.dirname(aPath), { recursive: true });
|
||||
import_fs.default.writeFileSync(aPath, content);
|
||||
}
|
||||
function indent(lines, tab) {
|
||||
return lines.replace(/^(?=.+$)/gm, tab);
|
||||
}
|
||||
function determineFileExtension(file) {
|
||||
if (typeof file === "string")
|
||||
return "txt";
|
||||
if (compareMagicBytes(file, [137, 80, 78, 71, 13, 10, 26, 10]))
|
||||
return "png";
|
||||
if (compareMagicBytes(file, [255, 216, 255]))
|
||||
return "jpg";
|
||||
return "dat";
|
||||
}
|
||||
function compareMagicBytes(file, magicBytes) {
|
||||
return Buffer.compare(Buffer.from(magicBytes), file.slice(0, magicBytes.length)) === 0;
|
||||
}
|
||||
async function loadScreenshotStyles(stylePath) {
|
||||
if (!stylePath)
|
||||
return;
|
||||
const stylePaths = Array.isArray(stylePath) ? stylePath : [stylePath];
|
||||
const styles = await Promise.all(stylePaths.map(async (stylePath2) => {
|
||||
const text = await import_fs.default.promises.readFile(stylePath2, "utf8");
|
||||
return text.trim();
|
||||
}));
|
||||
return styles.join("\n").trim() || void 0;
|
||||
}
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
0 && (module.exports = {
|
||||
toHaveScreenshot,
|
||||
toHaveScreenshotStepTitle,
|
||||
toMatchSnapshot
|
||||
});
|
||||
105
frontend/e2e/node_modules/playwright/lib/matchers/toMatchText.js
generated
vendored
Normal file
105
frontend/e2e/node_modules/playwright/lib/matchers/toMatchText.js
generated
vendored
Normal file
@@ -0,0 +1,105 @@
|
||||
"use strict";
|
||||
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);
|
||||
var toMatchText_exports = {};
|
||||
__export(toMatchText_exports, {
|
||||
toMatchText: () => toMatchText
|
||||
});
|
||||
module.exports = __toCommonJS(toMatchText_exports);
|
||||
var import_utils = require("playwright-core/lib/utils");
|
||||
var import_util = require("../util");
|
||||
var import_expect = require("./expect");
|
||||
var import_matcherHint = require("./matcherHint");
|
||||
var import_expectBundle = require("../common/expectBundle");
|
||||
async function toMatchText(matcherName, receiver, receiverType, query, expected, options = {}) {
|
||||
(0, import_util.expectTypes)(receiver, [receiverType], matcherName);
|
||||
const matcherOptions = {
|
||||
isNot: this.isNot,
|
||||
promise: this.promise
|
||||
};
|
||||
if (!(typeof expected === "string") && !(expected && typeof expected.test === "function")) {
|
||||
throw new Error([
|
||||
(0, import_matcherHint.matcherHint)(this, receiverType === "Locator" ? receiver : void 0, matcherName, options.receiverLabel ?? receiver, expected, matcherOptions, void 0, void 0, true),
|
||||
`${import_utils.colors.bold("Matcher error")}: ${(0, import_expectBundle.EXPECTED_COLOR)("expected")} value must be a string or regular expression`,
|
||||
this.utils.printWithType("Expected", expected, this.utils.printExpected)
|
||||
].join("\n\n"));
|
||||
}
|
||||
const timeout = options.timeout ?? this.timeout;
|
||||
const { matches: pass, received, log, timedOut } = await query(!!this.isNot, timeout);
|
||||
if (pass === !this.isNot) {
|
||||
return {
|
||||
name: matcherName,
|
||||
message: () => "",
|
||||
pass,
|
||||
expected
|
||||
};
|
||||
}
|
||||
const stringSubstring = options.matchSubstring ? "substring" : "string";
|
||||
const receivedString = received || "";
|
||||
const notFound = received === import_matcherHint.kNoElementsFoundError;
|
||||
let printedReceived;
|
||||
let printedExpected;
|
||||
let printedDiff;
|
||||
if (pass) {
|
||||
if (typeof expected === "string") {
|
||||
if (notFound) {
|
||||
printedExpected = `Expected ${stringSubstring}: not ${this.utils.printExpected(expected)}`;
|
||||
printedReceived = `Received: ${received}`;
|
||||
} else {
|
||||
printedExpected = `Expected ${stringSubstring}: not ${this.utils.printExpected(expected)}`;
|
||||
const formattedReceived = (0, import_expect.printReceivedStringContainExpectedSubstring)(receivedString, receivedString.indexOf(expected), expected.length);
|
||||
printedReceived = `Received string: ${formattedReceived}`;
|
||||
}
|
||||
} else {
|
||||
if (notFound) {
|
||||
printedExpected = `Expected pattern: not ${this.utils.printExpected(expected)}`;
|
||||
printedReceived = `Received: ${received}`;
|
||||
} else {
|
||||
printedExpected = `Expected pattern: not ${this.utils.printExpected(expected)}`;
|
||||
const formattedReceived = (0, import_expect.printReceivedStringContainExpectedResult)(receivedString, typeof expected.exec === "function" ? expected.exec(receivedString) : null);
|
||||
printedReceived = `Received string: ${formattedReceived}`;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
const labelExpected = `Expected ${typeof expected === "string" ? stringSubstring : "pattern"}`;
|
||||
if (notFound) {
|
||||
printedExpected = `${labelExpected}: ${this.utils.printExpected(expected)}`;
|
||||
printedReceived = `Received: ${received}`;
|
||||
} else {
|
||||
printedDiff = this.utils.printDiffOrStringify(expected, receivedString, labelExpected, "Received string", false);
|
||||
}
|
||||
}
|
||||
const message = () => {
|
||||
const resultDetails = printedDiff ? printedDiff : printedExpected + "\n" + printedReceived;
|
||||
const hints = (0, import_matcherHint.matcherHint)(this, receiverType === "Locator" ? receiver : void 0, matcherName, options.receiverLabel ?? "locator", void 0, matcherOptions, timedOut ? timeout : void 0, resultDetails, true);
|
||||
return hints + (0, import_util.callLogText)(log);
|
||||
};
|
||||
return {
|
||||
name: matcherName,
|
||||
expected,
|
||||
message,
|
||||
pass,
|
||||
actual: received,
|
||||
log,
|
||||
timeout: timedOut ? timeout : void 0
|
||||
};
|
||||
}
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
0 && (module.exports = {
|
||||
toMatchText
|
||||
});
|
||||
Reference in New Issue
Block a user