codeceptjs 3.0.7 → 3.1.3

package/lib/codecept.js

@@ -130,7 +130,16 @@ class Codecept {
     let patterns = [pattern];
     if (!pattern) {
       patterns = [];
-      if (this.config.tests && !this.opts.features) patterns.push(this.config.tests);
+
+      // If the user wants to test a specific set of test files as an array or string.
+      if (this.config.tests && !this.opts.features) {
+        if (Array.isArray(this.config.tests)) {
+          patterns.push(...this.config.tests);
+        } else {
+          patterns.push(this.config.tests);
+        }
+      }
+
       if (this.config.gherkin.features && !this.opts.tests) {
         if (Array.isArray(this.config.gherkin.features)) {
           this.config.gherkin.features.forEach(feature => {
@@ -147,7 +156,9 @@ class Codecept {
         if (!fsPath.isAbsolute(file)) {
           file = fsPath.join(global.codecept_dir, file);
         }
-        this.testFiles.push(fsPath.resolve(file));
+        if (!this.testFiles.includes(fsPath.resolve(file))) {
+          this.testFiles.push(fsPath.resolve(file));
+        }
       });
     }
   }

package/lib/command/definitions.js

@@ -194,7 +194,14 @@ function getPath(originalPath, targetFolderPath, testsPath) {
   else if (parsedPath.ext === '.ts') parsedPath.base = parsedPath.name;
 
   if (!parsedPath.dir.startsWith('.')) return path.posix.join(parsedPath.dir, parsedPath.base);
-  const relativePath = path.posix.relative(targetFolderPath, path.posix.join(testsPath, parsedPath.dir, parsedPath.base));
+  const relativePath = path.posix.relative(
+    targetFolderPath.split(path.sep).join(path.posix.sep),
+    path.posix.join(
+      testsPath.split(path.sep).join(path.posix.sep),
+      parsedPath.dir.split(path.sep).join(path.posix.sep),
+      parsedPath.base.split(path.sep).join(path.posix.sep),
+    ),
+  );
 
   return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
 }

package/lib/command/run-multiple/collection.js

@@ -80,6 +80,10 @@ class Collection {
         return;
       }
 
+      if (runConfig.gherkin && config.gherkin.features) {
+        patterns.push(runConfig.gherkin.features);
+      }
+
       createChunks(runConfig, patterns).forEach((runChunkConfig, index) => {
         const run = createRun(`${runName}:chunk${index + 1}`, runChunkConfig);
         run.setOriginalName(runName);

package/lib/config.js

@@ -128,7 +128,7 @@ function loadConfigFile(configFile) {
   const extensionName = path.extname(configFile);
 
   // .conf.js config file
-  if (extensionName === '.js' || extensionName === '.ts') {
+  if (extensionName === '.js' || extensionName === '.ts' || extensionName === '.cjs') {
     return Config.create(require(configFile).config);
   }
 

package/lib/container.js

@@ -215,7 +215,7 @@ function createSupportObjects(config) {
         newObj._init();
       }
     } catch (err) {
-      throw new Error(`Initialization failed for ${name}: ${newObj}\n${err.message}`);
+      throw new Error(`Initialization failed for ${name}: ${newObj}\n${err.message}\n${err.stack}`);
     }
     return newObj;
   }
@@ -288,7 +288,7 @@ function createPlugins(config, options = {}) {
       }
       plugins[pluginName] = require(module)(config[pluginName]);
     } catch (err) {
-      throw new Error(`Could not load plugin ${pluginName} from module '${module}':\n${err.message}`);
+      throw new Error(`Could not load plugin ${pluginName} from module '${module}':\n${err.message}\n${err.stack}`);
     }
   }
   return plugins;
@@ -380,7 +380,7 @@ function loadSupportObject(modulePath, supportObjectName) {
 
     return obj;
   } catch (err) {
-    throw new Error(`Could not include object ${supportObjectName} from module '${modulePath}'\n${err.message}`);
+    throw new Error(`Could not include object ${supportObjectName} from module '${modulePath}'\n${err.message}\n${err.stack}`);
   }
 }
 

package/lib/data/dataTableArgument.js

@@ -1,4 +1,9 @@
+/**
+ * DataTableArgument class to store the Cucumber data table from
+ * a step as an object with methods that can be used to access the data.
+ */
 class DataTableArgument {
+  /** @param {*} gherkinDataTable */
   constructor(gherkinDataTable) {
     this.rawData = gherkinDataTable.rows.map((row) => {
       return row.cells.map((cell) => {
@@ -7,16 +12,25 @@ class DataTableArgument {
     });
   }
 
+  /** Returns the table as a 2-D array
+  * @returns {string[][]}
+  */
   raw() {
     return this.rawData.slice(0);
   }
 
+  /** Returns the table as a 2-D array, without the first row
+  * @returns {string[][]}
+  */
   rows() {
     const copy = this.raw();
     copy.shift();
     return copy;
   }
 
+  /** Returns an array of objects where each row is converted to an object (column header is the key)
+  * @returns {any[]}
+  */
   hashes() {
     const copy = this.raw();
     const header = copy.shift();
@@ -26,6 +40,27 @@ class DataTableArgument {
       return r;
     });
   }
+
+  /** Returns an object where each row corresponds to an entry
+   * (first column is the key, second column is the value)
+  * @returns {Record<string, string>}
+  */
+  rowsHash() {
+    const rows = this.raw();
+    const everyRowHasTwoColumns = rows.every((row) => row.length === 2);
+    if (!everyRowHasTwoColumns) {
+      throw new Error('rowsHash can only be called on a data table where all rows have exactly two columns');
+    }
+    /** @type {Record<string, string>} */
+    const result = {};
+    rows.forEach((x) => (result[x[0]] = x[1]));
+    return result;
+  }
+
+  /** Transposed the data */
+  transpose() {
+    this.rawData = this.rawData[0].map((x, i) => this.rawData.map((y) => y[i]));
+  }
 }
 
 module.exports = DataTableArgument;

package/lib/helper/Appium.js

@@ -481,10 +481,11 @@ class Appium extends Webdriver {
    * ```js
    * I.removeApp('appName', 'com.example.android.apis');
    * ```
-   * @param {string} appId
-   * @param {string}  bundleId String  ID of bundle
    *
    * Appium: support only Android
+   *
+   * @param {string} appId
+   * @param {string} [bundleId] ID of bundle
    */
   async removeApp(appId, bundleId) {
     onlyForApps.call(this, 'Android');
@@ -820,9 +821,10 @@ class Appium extends Webdriver {
    * I.hideDeviceKeyboard('pressKey', 'Done');
    * ```
    *
-   * @param {'tapOutside' | 'pressKey'} strategy  desired strategy to close keyboard (‘tapOutside’ or ‘pressKey’)
-   *
    * Appium: support Android and iOS
+   *
+   * @param {'tapOutside' | 'pressKey'} [strategy] Desired strategy to close keyboard (‘tapOutside’ or ‘pressKey’)
+   * @param {string} [key] Optional key
    */
   async hideDeviceKeyboard(strategy, key) {
     onlyForApps.call(this);
@@ -1162,6 +1164,8 @@ class Appium extends Webdriver {
    * ```
    *
    * Appium: support Android and iOS
+   *
+   * @param {Array} actions Array of touch actions
    */
   async touchPerform(actions) {
     onlyForApps.call(this);
@@ -1352,6 +1356,33 @@ class Appium extends Webdriver {
     return super.grabTextFrom(parseLocator.call(this, locator));
   }
 
+  /**
+   * {{> grabNumberOfVisibleElements }}
+   */
+  async grabNumberOfVisibleElements(locator) {
+    if (this.isWeb) return super.grabNumberOfVisibleElements(locator);
+    return super.grabNumberOfVisibleElements(parseLocator.call(this, locator));
+  }
+
+  /**
+   * Can be used for apps only with several values ("contentDescription", "text", "className", "resourceId")
+   *
+   * {{> grabAttributeFrom }}
+   */
+  async grabAttributeFrom(locator, attr) {
+    if (this.isWeb) return super.grabAttributeFrom(locator, attr);
+    return super.grabAttributeFrom(parseLocator.call(this, locator), attr);
+  }
+
+  /**
+   * Can be used for apps only with several values ("contentDescription", "text", "className", "resourceId")
+   * {{> grabAttributeFromAll }}
+   */
+  async grabAttributeFromAll(locator, attr) {
+    if (this.isWeb) return super.grabAttributeFromAll(locator, attr);
+    return super.grabAttributeFromAll(parseLocator.call(this, locator), attr);
+  }
+
   /**
    * {{> grabValueFromAll }}
    *
@@ -1370,6 +1401,20 @@ class Appium extends Webdriver {
     return super.grabValueFrom(parseLocator.call(this, locator));
   }
 
+  /**
+   * Saves a screenshot to ouput folder (set in codecept.json or codecept.conf.js).
+   * Filename is relative to output folder.
+   *
+   * ```js
+   * I.saveScreenshot('debug.png');
+   * ```
+   *
+   * @param {string} fileName file name to save.
+   */
+  async saveScreenshot(fileName) {
+    return super.saveScreenshot(fileName, false);
+  }
+
   /**
    * {{> scrollIntoView }}
    *

package/lib/helper/Playwright.js

@@ -19,6 +19,7 @@ const {
   screenshotOutputFolder,
   getNormalizedKeyAttributeValue,
   isModifierKey,
+  clearString,
 } = require('../utils');
 const {
   isColorProperty,
@@ -28,6 +29,7 @@ const ElementNotFound = require('./errors/ElementNotFound');
 const RemoteBrowserConnectionRefused = require('./errors/RemoteBrowserConnectionRefused');
 const Popup = require('./extras/Popup');
 const Console = require('./extras/Console');
+const findReact = require('./extras/React');
 
 let playwright;
 let perfTiming;
@@ -64,6 +66,8 @@ const { createValueEngine, createDisabledEngine } = require('./extras/Playwright
  * * `restart`: (optional, default: true) - restart browser between tests.
  * * `disableScreenshots`: (optional, default: false)  - don't save screenshot on failure.
  * * `emulate`: (optional, default: {}) launch browser in device emulation mode.
+ * * `video`: (optional, default: false) enables video recording for failed tests; videos are saved into `output/videos` folder
+ * * `trace`: (optional, default: false) record [tracing information](https://playwright.dev/docs/trace-viewer) with screenshots and snapshots.
  * * `fullPageScreenshots` (optional, default: false) - make full page screenshots on failure.
  * * `uniqueScreenshotNames`: (optional, default: false)  - option to prevent screenshot override if you have scenarios with the same name in different suites.
  * * `keepBrowserState`: (optional, default: false) - keep browser state between tests when `restart` is set to false.
@@ -80,6 +84,22 @@ const { createValueEngine, createDisabledEngine } = require('./extras/Playwright
  * * `chromium`: (optional) pass additional chromium options
  * * `electron`: (optional) pass additional electron options
  *
+ * #### Video Recording Customization
+ *
+ * By default, video is saved to `output/video` dir. You can customize this path by passing `dir` option to `recordVideo` option.
+ *
+ * * `video`: enables video recording for failed tests; videos are saved into `output/videos` folder
+ * * `keepVideoForPassedTests`: - save videos for passed tests
+ * * `recordVideo`: [additional options for videos customization](https://playwright.dev/docs/next/api/class-browser#browser-new-context)
+ *
+ * #### Trace Recording Customization
+ *
+ * Trace recording provides a complete information on test execution and includes DOM snapshots, screenshots, and network requests logged during run.
+ * Traces will be saved to `output/trace`
+ *
+ * * `trace`: enables trace recording for failed tests; trace are saved into `output/trace` folder
+ * * `keepTraceForPassedTests`: - save trace for passed tests
+ *
  * #### Example #1: Wait for 0 network connections.
  *
  * ```js
@@ -131,7 +151,7 @@ const { createValueEngine, createDisabledEngine } = require('./extras/Playwright
  *      Playwright: {
  *        url: "http://localhost",
  *        chromium: {
- *          browserWSEndpoint: { wsEndpoint: 'ws://localhost:9222/devtools/browser/c5aa6160-b5bc-4d53-bb49-6ecb36cd2e0a' }
+ *          browserWSEndpoint: 'ws://localhost:9222/devtools/browser/c5aa6160-b5bc-4d53-bb49-6ecb36cd2e0a'
  *        }
  *      }
  *    }
@@ -211,6 +231,7 @@ class Playwright extends Helper {
     this.activeSessionName = '';
     this.isElectron = false;
     this.electronSessions = [];
+    this.storageState = null;
 
     // override defaults with config
     this._setConfig(config);
@@ -220,7 +241,6 @@ class Playwright extends Helper {
     const defaults = {
       // options to emulate context
       emulate: {},
-
       browser: 'chromium',
       waitForAction: 100,
       waitForTimeout: 1000,
@@ -249,10 +269,16 @@ class Playwright extends Helper {
   }
 
   _getOptionsForBrowser(config) {
-    return config[config.browser] ? {
-      ...config[config.browser],
-      wsEndpoint: config[config.browser].browserWSEndpoint,
-    } : {};
+    if (config[config.browser]) {
+      if (config[config.browser].browserWSEndpoint && config[config.browser].browserWSEndpoint.wsEndpoint) {
+        config[config.browser].browserWSEndpoint = config[config.browser].browserWSEndpoint.wsEndpoint;
+      }
+      return {
+        ...config[config.browser],
+        wsEndpoint: config[config.browser].browserWSEndpoint,
+      };
+    }
+    return {};
   }
 
   _setConfig(config) {
@@ -261,6 +287,12 @@ class Playwright extends Helper {
       headless: !this.options.show,
       ...this._getOptionsForBrowser(config),
     };
+    if (this.options.video) {
+      this.options.recordVideo = { size: parseWindowSize(this.options.windowSize) };
+    }
+    if (this.options.recordVideo && !this.options.recordVideo.dir) {
+      this.options.recordVideo.dir = `${global.output_dir}/videos/`;
+    }
     this.isRemoteBrowser = !!this.playwrightOptions.browserWSEndpoint;
     this.isElectron = this.options.browser === 'electron';
     this.userDataDir = this.playwrightOptions.userDataDir;
@@ -319,8 +351,42 @@ class Playwright extends Helper {
         return err.message.includes('context');
       },
     });
-    if (this.options.restart && !this.options.manualStart) return this._startBrowser();
-    if (!this.isRunning && !this.options.manualStart) return this._startBrowser();
+    if (this.options.restart && !this.options.manualStart) await this._startBrowser();
+    if (!this.isRunning && !this.options.manualStart) await this._startBrowser();
+
+    this.isAuthenticated = false;
+    if (this.isElectron) {
+      this.browserContext = this.browser.context();
+    } else if (this.userDataDir) {
+      this.browserContext = this.browser;
+    } else {
+      const contextOptions = {
+        ignoreHTTPSErrors: this.options.ignoreHTTPSErrors,
+        acceptDownloads: true,
+        ...this.options.emulate,
+      };
+      if (this.options.basicAuth) {
+        contextOptions.httpCredentials = this.options.basicAuth;
+        this.isAuthenticated = true;
+      }
+      if (this.options.recordVideo) contextOptions.recordVideo = this.options.recordVideo;
+      if (this.storageState) contextOptions.storageState = this.storageState;
+      this.browserContext = await this.browser.newContext(contextOptions); // Adding the HTTPSError ignore in the context so that we can ignore those errors
+    }
+
+    let mainPage;
+    if (this.isElectron) {
+      mainPage = await this.browser.firstWindow();
+    } else {
+      const existingPages = await this.browserContext.pages();
+      mainPage = existingPages[0] || await this.browserContext.newPage();
+    }
+    targetCreatedHandler.call(this, mainPage);
+
+    await this._setPage(mainPage);
+
+    if (this.options.trace) await this.browserContext.tracing.start({ screenshots: true, snapshots: true });
+
     return this.browser;
   }
 
@@ -333,43 +399,24 @@ class Playwright extends Helper {
       return;
     }
 
+    if (this.options.restart) {
+      this.isRunning = false;
+      return this._stopBrowser();
+    }
+
     // close other sessions
     try {
       const contexts = await this.browser.contexts();
-      contexts.shift();
+      const currentContext = contexts[0];
+      if (currentContext && (this.options.keepCookies || this.options.keepBrowserState)) {
+        this.storageState = await currentContext.storageState();
+      }
 
       await Promise.all(contexts.map(c => c.close()));
     } catch (e) {
       console.log(e);
     }
 
-    if (this.options.restart) {
-      this.isRunning = false;
-      return this._stopBrowser();
-    }
-
-    // ensure current page is in default context
-    if (this.page) {
-      const existingPages = await this.browserContext.pages();
-      await this._setPage(existingPages[0]);
-    }
-
-    if (this.options.keepBrowserState) return;
-
-    if (!this.options.keepCookies) {
-      this.debugSection('Session', 'cleaning cookies and localStorage');
-      await this.clearCookie();
-    }
-    const currentUrl = await this.grabCurrentUrl();
-
-    if (currentUrl.startsWith('http')) {
-      await this.executeScript('localStorage.clear();').catch((err) => {
-        if (!(err.message.indexOf("Storage is disabled inside 'data:' URLs.") > -1)) throw err;
-      });
-      await this.executeScript('sessionStorage.clear();').catch((err) => {
-        if (!(err.message.indexOf("Storage is disabled inside 'data:' URLs.") > -1)) throw err;
-      });
-    }
     // await this.closeOtherTabs();
     return this.browser;
   }
@@ -517,7 +564,7 @@ class Playwright extends Helper {
     page.setDefaultNavigationTimeout(this.options.getPageTimeout);
     this.context = await this.page;
     this.contextLocator = null;
-    if (this.config.browser === 'chrome') {
+    if (this.options.browser === 'chrome') {
       await page.bringToFront();
     }
   }
@@ -533,6 +580,7 @@ class Playwright extends Helper {
     if (!page) {
       return;
     }
+    page.removeAllListeners('dialog');
     page.on('dialog', async (dialog) => {
       popupStore.popup = dialog;
       const action = popupStore.actionType || this.options.defaultPopupAction;
@@ -579,7 +627,7 @@ class Playwright extends Helper {
       this.browser = await playwright._electron.launch(this.playwrightOptions);
     } else if (this.isRemoteBrowser) {
       try {
-        this.browser = await playwright[this.options.browser].connect(this.playwrightOptions.browserWSEndpoint);
+        this.browser = await playwright[this.options.browser].connect(this.playwrightOptions);
       } catch (err) {
         if (err.toString().indexOf('ECONNREFUSED')) {
           throw new RemoteBrowserConnectionRefused(err);
@@ -597,26 +645,6 @@ class Playwright extends Helper {
       this.debugSection('Url', target.url());
     });
 
-    if (this.isElectron) {
-      this.browserContext = this.browser.context();
-    } else if (this.userDataDir) {
-      this.browserContext = this.browser;
-    } else {
-      this.browserContext = await this.browser.newContext({ ignoreHTTPSErrors: this.options.ignoreHTTPSErrors, acceptDownloads: true, ...this.options.emulate });// Adding the HTTPSError ignore in the context so that we can ignore those errors
-    }
-
-    let mainPage;
-    if (this.isElectron) {
-      mainPage = await this.browser.firstWindow();
-    } else {
-      const existingPages = await this.browserContext.pages();
-      mainPage = existingPages[0] || await this.browserContext.newPage();
-    }
-    targetCreatedHandler.call(this, mainPage);
-
-    await this._setPage(mainPage);
-    await this.closeOtherTabs();
-
     this.isRunning = true;
   }
 
@@ -691,9 +719,9 @@ class Playwright extends Helper {
       url = this.options.url + url;
     }
 
-    if (this.config.basicAuth && (this.isAuthenticated !== true)) {
+    if (this.options.basicAuth && (this.isAuthenticated !== true)) {
       if (url.includes(this.options.url)) {
-        await this.browserContext.setHTTPCredentials(this.config.basicAuth);
+        await this.browserContext.setHTTPCredentials(this.options.basicAuth);
         this.isAuthenticated = true;
       }
     }
@@ -752,7 +780,7 @@ class Playwright extends Helper {
     if (!customHeaders) {
       throw new Error('Cannot send empty headers.');
     }
-    return this.page.setExtraHTTPHeaders(customHeaders);
+    return this.browserContext.setExtraHTTPHeaders(customHeaders);
   }
 
   /**
@@ -1050,7 +1078,7 @@ class Playwright extends Helper {
    */
   async seeElement(locator) {
     let els = await this._locate(locator);
-    els = await Promise.all(els.map(el => el.boundingBox()));
+    els = await Promise.all(els.map(el => el.isVisible()));
     return empty('visible elements').negate(els.filter(v => v).fill('ELEMENT'));
   }
 
@@ -1060,7 +1088,7 @@ class Playwright extends Helper {
    */
   async dontSeeElement(locator) {
     let els = await this._locate(locator);
-    els = await Promise.all(els.map(el => el.boundingBox()));
+    els = await Promise.all(els.map(el => el.isVisible()));
     return empty('visible elements').assert(els.filter(v => v).fill('ELEMENT'));
   }
 
@@ -1364,7 +1392,7 @@ class Playwright extends Helper {
    */
   async grabNumberOfVisibleElements(locator) {
     let els = await this._locate(locator);
-    els = await Promise.all(els.map(el => el.boundingBox()));
+    els = await Promise.all(els.map(el => el.isVisible()));
     return els.filter(v => v).length;
   }
 
@@ -1531,6 +1559,7 @@ class Playwright extends Helper {
   async clearCookie() {
     // Playwright currently doesn't support to delete a certain cookie
     // https://github.com/microsoft/playwright/blob/master/docs/api.md#class-browsercontext
+    if (!this.browserContext) return;
     return this.browserContext.clearCookies();
   }
 
@@ -1825,8 +1854,42 @@ class Playwright extends Helper {
     return this.page.screenshot({ path: outputFile, fullPage: fullPageOption, type: 'png' });
   }
 
-  async _failed() {
+  async _failed(test) {
     await this._withinEnd();
+
+    if (!test.artifacts) {
+      test.artifacts = {};
+    }
+
+    if (this.options.recordVideo && this.page.video()) {
+      test.artifacts.video = await this.page.video().path();
+    }
+
+    if (this.options.trace) {
+      const path = `${global.output_dir}/trace/${clearString(test.title).slice(0, 255)}.zip`;
+      await this.browserContext.tracing.stop({ path });
+      test.artifacts.trace = path;
+    }
+  }
+
+  async _passed(test) {
+    if (this.options.recordVideo && this.page.video()) {
+      if (this.options.keepVideoForPassedTests) {
+        test.artifacts.video = await this.page.video().path();
+      } else {
+        this.page.video().delete().catch(e => {});
+      }
+    }
+
+    if (this.options.trace) {
+      if (this.options.keepTraceForPassedTests) {
+        const path = `${global.output_dir}/trace/${clearString(test.title)}.zip`;
+        await this.browserContext.tracing.stop({ path });
+        test.artifacts.trace = path;
+      } else {
+        await this.browserContext.tracing.stop();
+      }
+    }
   }
 
   /**
@@ -2234,6 +2297,39 @@ class Playwright extends Helper {
     if (prop) return rect[prop];
     return rect;
   }
+
+  /**
+  * Mocks network request using [`browserContext.route`](https://playwright.dev/docs/api/class-browsercontext#browser-context-route) of Playwright
+  *
+  * ```js
+  * I.mockRoute(/(\.png$)|(\.jpg$)/, route => route.abort());
+  * ```
+  * This method allows intercepting and mocking requests & responses. [Learn more about it](https://playwright.dev/docs/network#handle-requests)
+  *
+  * @param {string} [url] URL, regex or pattern for to match URL
+  * @param {function} [handler] a function to process request
+  *
+  */
+  async mockRoute(url, handler) {
+    return this.browserContext.route(...arguments);
+  }
+
+  /**
+  * Stops network mocking created by `mockRoute`.
+  *
+  * ```js
+  * I.stopMockingRoute(/(\.png$)|(\.jpg$)/);
+  * I.stopMockingRoute(/(\.png$)|(\.jpg$)/, previouslySetHandler);
+  * ```
+  * If no handler is passed, all mock requests for the rote are disabled.
+  *
+  * @param {string} [url] URL, regex or pattern for to match URL
+  * @param {function} [handler] a function to process request
+  *
+  */
+  async stopMockingRoute(url, handler) {
+    return this.browserContext.unroute(...arguments);
+  }
 }
 
 module.exports = Playwright;
@@ -2249,6 +2345,7 @@ function buildLocatorString(locator) {
 }
 
 async function findElements(matcher, locator) {
+  if (locator.react) return findReact(matcher, locator);
   locator = new Locator(locator, 'css');
   return matcher.$$(buildLocatorString(locator));
 }
@@ -2297,6 +2394,8 @@ async function proceedClick(locator, context = null, options = {}) {
 }
 
 async function findClickable(matcher, locator) {
+  if (locator.react) return findReact(matcher, locator);
+
   locator = new Locator(locator);
   if (!locator.isFuzzy()) return findElements.call(this, matcher, locator);
 
@@ -2403,6 +2502,15 @@ async function findFields(locator) {
 }
 
 async function proceedDragAndDrop(sourceLocator, destinationLocator) {
+  // modern drag and drop in Playwright
+  if (this.page.dragAndDrop) {
+    const source = new Locator(sourceLocator);
+    const dest = new Locator(destinationLocator);
+    if (source.isBasic() && dest.isBasic()) {
+      return this.page.dragAndDrop(source.simplify(), dest.simplify());
+    }
+  }
+
   const src = await this._locate(sourceLocator);
   assertElementExists(src, sourceLocator, 'Source Element');
 
@@ -2562,11 +2670,20 @@ async function targetCreatedHandler(page) {
     await page.setUserAgent(this.options.userAgent);
   }
   if (this.options.windowSize && this.options.windowSize.indexOf('x') > 0 && this._getType() === 'Browser') {
-    const dimensions = this.options.windowSize.split('x');
-    const width = parseInt(dimensions[0], 10);
-    const height = parseInt(dimensions[1], 10);
-    await page.setViewportSize({ width, height });
+    await page.setViewportSize(parseWindowSize(this.options.windowSize));
+  }
+}
+
+function parseWindowSize(windowSize) {
+  if (!windowSize) return { width: 800, height: 600 };
+  const dimensions = windowSize.split('x');
+  if (dimensions.length < 2 || windowSize === 'maximize') {
+    console.log('Invalid window size, setting window to default values');
+    return { width: 800, height: 600 }; // invalid size
   }
+  const width = parseInt(dimensions[0], 10);
+  const height = parseInt(dimensions[1], 10);
+  return { width, height };
 }
 
 // List of key values to key definitions