screenshot/test_1

2025-03-27 11:21:02 +00:00
commit 616d466383
470 changed files with 144705 additions and 0 deletions
--- a/node_modules/playwright/lib/matchers/matchers.js
+++ b/node_modules/playwright/lib/matchers/matchers.js
@@ -0,0 +1,475 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toBeAttached = toBeAttached;
+exports.toBeChecked = toBeChecked;
+exports.toBeDisabled = toBeDisabled;
+exports.toBeEditable = toBeEditable;
+exports.toBeEmpty = toBeEmpty;
+exports.toBeEnabled = toBeEnabled;
+exports.toBeFocused = toBeFocused;
+exports.toBeHidden = toBeHidden;
+exports.toBeInViewport = toBeInViewport;
+exports.toBeOK = toBeOK;
+exports.toBeVisible = toBeVisible;
+exports.toContainText = toContainText;
+exports.toHaveAccessibleDescription = toHaveAccessibleDescription;
+exports.toHaveAccessibleErrorMessage = toHaveAccessibleErrorMessage;
+exports.toHaveAccessibleName = toHaveAccessibleName;
+exports.toHaveAttribute = toHaveAttribute;
+exports.toHaveCSS = toHaveCSS;
+exports.toHaveClass = toHaveClass;
+exports.toHaveCount = toHaveCount;
+exports.toHaveId = toHaveId;
+exports.toHaveJSProperty = toHaveJSProperty;
+exports.toHaveRole = toHaveRole;
+exports.toHaveText = toHaveText;
+exports.toHaveTitle = toHaveTitle;
+exports.toHaveURL = toHaveURL;
+exports.toHaveValue = toHaveValue;
+exports.toHaveValues = toHaveValues;
+exports.toPass = toPass;
+var _utils = require("playwright-core/lib/utils");
+var _util = require("../util");
+var _toBeTruthy = require("./toBeTruthy");
+var _toEqual = require("./toEqual");
+var _toHaveURL = require("./toHaveURL");
+var _toMatchText = require("./toMatchText");
+var _config = require("../common/config");
+var _globals = require("../common/globals");
+var _testInfo = require("../worker/testInfo");
+/**
+ * Copyright Microsoft Corporation. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+function toBeAttached(locator, options) {
+  const attached = !options || options.attached === undefined || options.attached;
+  const expected = attached ? 'attached' : 'detached';
+  const arg = attached ? '' : '{ attached: false }';
+  return _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 === null || options === void 0 ? void 0 : options.checked;
+  const indeterminate = options === null || options === void 0 ? void 0 : options.indeterminate;
+  const expectedValue = {
+    checked,
+    indeterminate
+  };
+  let expected;
+  let arg;
+  if (options !== null && options !== void 0 && options.indeterminate) {
+    expected = 'indeterminate';
+    arg = `{ indeterminate: true }`;
+  } else {
+    expected = (options === null || options === void 0 ? void 0 : options.checked) === false ? 'unchecked' : 'checked';
+    arg = (options === null || options === void 0 ? void 0 : options.checked) === false ? `{ checked: false }` : '';
+  }
+  return _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 _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 === undefined || options.editable;
+  const expected = editable ? 'editable' : 'readOnly';
+  const arg = editable ? '' : '{ editable: false }';
+  return _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 _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 === undefined || options.enabled;
+  const expected = enabled ? 'enabled' : 'disabled';
+  const arg = enabled ? '' : '{ enabled: false }';
+  return _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 _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 _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 === undefined || options.visible;
+  const expected = visible ? 'visible' : 'hidden';
+  const arg = visible ? '' : '{ visible: false }';
+  return _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 _toBeTruthy.toBeTruthy.call(this, 'toBeInViewport', locator, 'Locator', 'in viewport', '', async (isNot, timeout) => {
+    return await locator._expect('to.be.in.viewport', {
+      isNot,
+      expectedNumber: options === null || options === void 0 ? void 0 : options.ratio,
+      timeout
+    });
+  }, options);
+}
+function toContainText(locator, expected, options = {}) {
+  if (Array.isArray(expected)) {
+    return _toEqual.toEqual.call(this, 'toContainText', locator, 'Locator', async (isNot, timeout) => {
+      const expectedText = (0, _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 _toMatchText.toMatchText.call(this, 'toContainText', locator, 'Locator', async (isNot, timeout) => {
+      const expectedText = (0, _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 _toMatchText.toMatchText.call(this, 'toHaveAccessibleDescription', locator, 'Locator', async (isNot, timeout) => {
+    const expectedText = (0, _utils.serializeExpectedTextValues)([expected], {
+      ignoreCase: options === null || options === void 0 ? void 0 : options.ignoreCase,
+      normalizeWhiteSpace: true
+    });
+    return await locator._expect('to.have.accessible.description', {
+      expectedText,
+      isNot,
+      timeout
+    });
+  }, expected, options);
+}
+function toHaveAccessibleName(locator, expected, options) {
+  return _toMatchText.toMatchText.call(this, 'toHaveAccessibleName', locator, 'Locator', async (isNot, timeout) => {
+    const expectedText = (0, _utils.serializeExpectedTextValues)([expected], {
+      ignoreCase: options === null || options === void 0 ? void 0 : options.ignoreCase,
+      normalizeWhiteSpace: true
+    });
+    return await locator._expect('to.have.accessible.name', {
+      expectedText,
+      isNot,
+      timeout
+    });
+  }, expected, options);
+}
+function toHaveAccessibleErrorMessage(locator, expected, options) {
+  return _toMatchText.toMatchText.call(this, 'toHaveAccessibleErrorMessage', locator, 'Locator', async (isNot, timeout) => {
+    const expectedText = (0, _utils.serializeExpectedTextValues)([expected], {
+      ignoreCase: options === null || options === void 0 ? void 0 : options.ignoreCase,
+      normalizeWhiteSpace: true
+    });
+    return await locator._expect('to.have.accessible.error.message', {
+      expectedText: expectedText,
+      isNot,
+      timeout
+    });
+  }, expected, options);
+}
+function toHaveAttribute(locator, name, expected, options) {
+  if (!options) {
+    // Update params for the case toHaveAttribute(name, options);
+    if (typeof expected === 'object' && !(0, _utils.isRegExp)(expected)) {
+      options = expected;
+      expected = undefined;
+    }
+  }
+  if (expected === undefined) {
+    return _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 _toMatchText.toMatchText.call(this, 'toHaveAttribute', locator, 'Locator', async (isNot, timeout) => {
+    var _options;
+    const expectedText = (0, _utils.serializeExpectedTextValues)([expected], {
+      ignoreCase: (_options = options) === null || _options === void 0 ? void 0 : _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 _toEqual.toEqual.call(this, 'toHaveClass', locator, 'Locator', async (isNot, timeout) => {
+      const expectedText = (0, _utils.serializeExpectedTextValues)(expected);
+      return await locator._expect('to.have.class.array', {
+        expectedText,
+        isNot,
+        timeout
+      });
+    }, expected, options);
+  } else {
+    return _toMatchText.toMatchText.call(this, 'toHaveClass', locator, 'Locator', async (isNot, timeout) => {
+      const expectedText = (0, _utils.serializeExpectedTextValues)([expected]);
+      return await locator._expect('to.have.class', {
+        expectedText,
+        isNot,
+        timeout
+      });
+    }, expected, options);
+  }
+}
+function toHaveCount(locator, expected, options) {
+  return _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 _toMatchText.toMatchText.call(this, 'toHaveCSS', locator, 'Locator', async (isNot, timeout) => {
+    const expectedText = (0, _utils.serializeExpectedTextValues)([expected]);
+    return await locator._expect('to.have.css', {
+      expressionArg: name,
+      expectedText,
+      isNot,
+      timeout
+    });
+  }, expected, options);
+}
+function toHaveId(locator, expected, options) {
+  return _toMatchText.toMatchText.call(this, 'toHaveId', locator, 'Locator', async (isNot, timeout) => {
+    const expectedText = (0, _utils.serializeExpectedTextValues)([expected]);
+    return await locator._expect('to.have.id', {
+      expectedText,
+      isNot,
+      timeout
+    });
+  }, expected, options);
+}
+function toHaveJSProperty(locator, name, expected, options) {
+  return _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, _utils.isString)(expected)) throw new Error(`"role" argument in toHaveRole must be a string`);
+  return _toMatchText.toMatchText.call(this, 'toHaveRole', locator, 'Locator', async (isNot, timeout) => {
+    const expectedText = (0, _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 _toEqual.toEqual.call(this, 'toHaveText', locator, 'Locator', async (isNot, timeout) => {
+      const expectedText = (0, _utils.serializeExpectedTextValues)(expected, {
+        normalizeWhiteSpace: true,
+        ignoreCase: options.ignoreCase
+      });
+      return await locator._expect('to.have.text.array', {
+        expectedText,
+        isNot,
+        useInnerText: options === null || options === void 0 ? void 0 : options.useInnerText,
+        timeout
+      });
+    }, expected, options);
+  } else {
+    return _toMatchText.toMatchText.call(this, 'toHaveText', locator, 'Locator', async (isNot, timeout) => {
+      const expectedText = (0, _utils.serializeExpectedTextValues)([expected], {
+        normalizeWhiteSpace: true,
+        ignoreCase: options.ignoreCase
+      });
+      return await locator._expect('to.have.text', {
+        expectedText,
+        isNot,
+        useInnerText: options === null || options === void 0 ? void 0 : options.useInnerText,
+        timeout
+      });
+    }, expected, options);
+  }
+}
+function toHaveValue(locator, expected, options) {
+  return _toMatchText.toMatchText.call(this, 'toHaveValue', locator, 'Locator', async (isNot, timeout) => {
+    const expectedText = (0, _utils.serializeExpectedTextValues)([expected]);
+    return await locator._expect('to.have.value', {
+      expectedText,
+      isNot,
+      timeout
+    });
+  }, expected, options);
+}
+function toHaveValues(locator, expected, options) {
+  return _toEqual.toEqual.call(this, 'toHaveValues', locator, 'Locator', async (isNot, timeout) => {
+    const expectedText = (0, _utils.serializeExpectedTextValues)(expected);
+    return await locator._expect('to.have.values', {
+      expectedText,
+      isNot,
+      timeout
+    });
+  }, expected, options);
+}
+function toHaveTitle(page, expected, options = {}) {
+  const locator = page.locator(':root');
+  return _toMatchText.toMatchText.call(this, 'toHaveTitle', locator, 'Locator', async (isNot, timeout) => {
+    const expectedText = (0, _utils.serializeExpectedTextValues)([expected], {
+      normalizeWhiteSpace: true
+    });
+    return await locator._expect('to.have.title', {
+      expectedText,
+      isNot,
+      timeout
+    });
+  }, expected, options);
+}
+function toHaveURL(page, expected, options) {
+  // Ports don't support predicates. Keep separate server and client codepaths
+  if (typeof expected === 'function') return _toHaveURL.toHaveURLWithPredicate.call(this, page, expected, options);
+  const baseURL = page.context()._options.baseURL;
+  expected = typeof expected === 'string' ? (0, _utils.constructURLBasedOnBaseURL)(baseURL, expected) : expected;
+  const locator = page.locator(':root');
+  return _toMatchText.toMatchText.call(this, 'toHaveURL', locator, 'Locator', async (isNot, timeout) => {
+    const expectedText = (0, _utils.serializeExpectedTextValues)([expected], {
+      ignoreCase: options === null || options === void 0 ? void 0 : options.ignoreCase
+    });
+    return await locator._expect('to.have.url', {
+      expectedText,
+      isNot,
+      timeout
+    });
+  }, expected, options);
+}
+async function toBeOK(response) {
+  const matcherName = 'toBeOK';
+  (0, _util.expectTypes)(response, ['APIResponse'], matcherName);
+  const contentType = response.headers()['content-type'];
+  const isTextEncoding = contentType && (0, _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, undefined, '', {
+    isNot: this.isNot
+  }) + (0, _util.callLogText)(log) + (text === null ? '' : `\nResponse text:\n${_utils.colors.dim((text === null || text === void 0 ? void 0 : text.substring(0, 1000)) || '')}`);
+  const pass = response.ok();
+  return {
+    message,
+    pass
+  };
+}
+async function toPass(callback, options = {}) {
+  var _testInfo$_projectInt, _testInfo$_projectInt2;
+  const testInfo = (0, _globals.currentTestInfo)();
+  const timeout = (0, _config.takeFirst)(options.timeout, testInfo === null || testInfo === void 0 || (_testInfo$_projectInt = testInfo._projectInternal.expect) === null || _testInfo$_projectInt === void 0 || (_testInfo$_projectInt = _testInfo$_projectInt.toPass) === null || _testInfo$_projectInt === void 0 ? void 0 : _testInfo$_projectInt.timeout, 0);
+  const intervals = (0, _config.takeFirst)(options.intervals, testInfo === null || testInfo === void 0 || (_testInfo$_projectInt2 = testInfo._projectInternal.expect) === null || _testInfo$_projectInt2 === void 0 || (_testInfo$_projectInt2 = _testInfo$_projectInt2.toPass) === null || _testInfo$_projectInt2 === void 0 ? void 0 : _testInfo$_projectInt2.intervals, [100, 250, 500, 1000]);
+  const {
+    deadline,
+    timeoutMessage
+  } = testInfo ? testInfo._deadlineForMatcher(timeout) : _testInfo.TestInfoImpl._defaultDeadlineForMatcher(timeout);
+  const result = await (0, _utils.pollAgainstDeadline)(async () => {
+    if (testInfo && (0, _globals.currentTestInfo)() !== testInfo) return {
+      continuePolling: false,
+      result: undefined
+    };
+    try {
+      await callback();
+      return {
+        continuePolling: !!this.isNot,
+        result: undefined
+      };
+    } 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: () => ''
+  };
+}