codeceptjs 3.0.6 → 3.1.2

package/docs/build/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;
@@ -35,9 +37,10 @@ let defaultSelectorEnginesInitialized = false;
 
 const popupStore = new Popup();
 const consoleLogStore = new Console();
-const availableBrowsers = ['chromium', 'webkit', 'firefox'];
+const availableBrowsers = ['chromium', 'webkit', 'firefox', 'electron'];
 
 const { createValueEngine, createDisabledEngine } = require('./extras/PlaywrightPropEngine');
+
 /**
  * Uses [Playwright](https://github.com/microsoft/playwright) library to run tests inside:
  *
@@ -58,11 +61,13 @@ const { createValueEngine, createDisabledEngine } = require('./extras/Playwright
  * This helper should be configured in codecept.json or codecept.conf.js
  *
  * * `url`: base url of website to be tested
- * * `browser`: a browser to test on, either: `chromium`, `firefox`, `webkit`. Default: chromium.
+ * * `browser`: a browser to test on, either: `chromium`, `firefox`, `webkit`, `electron`. Default: chromium.
  * * `show`: (optional, default: false) - show browser window.
  * * `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.
@@ -77,6 +82,23 @@ const { createValueEngine, createDisabledEngine } = require('./extras/Playwright
  * * `userAgent`: (optional) user-agent string.
  * * `manualStart`: (optional, default: false) - do not start browser before a test, start it manually inside a helper with `this.helpers["Playwright"]._startBrowser()`.
  * * `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.
  *
@@ -121,7 +143,7 @@ const { createValueEngine, createDisabledEngine } = require('./extras/Playwright
  * }
  * ```
  *
- * #### Example #4: Connect to remote browser by specifying [websocket endpoint](https://chromedevtools.github.io/devtools-protocol/#how-do-i-access-the-browser-target)
+ * #### Example #4: Connect to remote browser by specifying [websocket endpoint](https://playwright.dev/docs/api/class-browsertype#browsertypeconnectparams)
  *
  * ```js
  * {
@@ -129,7 +151,7 @@ const { createValueEngine, createDisabledEngine } = require('./extras/Playwright
  *      Playwright: {
  *        url: "http://localhost",
  *        chromium: {
- *          browserWSEndpoint: "ws://localhost:9222/devtools/browser/c5aa6160-b5bc-4d53-bb49-6ecb36cd2e0a"
+ *          browserWSEndpoint: 'ws://localhost:9222/devtools/browser/c5aa6160-b5bc-4d53-bb49-6ecb36cd2e0a'
  *        }
  *      }
  *    }
@@ -147,6 +169,7 @@ const { createValueEngine, createDisabledEngine } = require('./extras/Playwright
  *      url: "http://localhost",
  *      show: true // headless mode not supported for extensions
  *      chromium: {
+ *        userDataDir: '/tmp/playwright-tmp', // necessary to launch the browser in normal mode instead of incognito,
  *        args: [
  *           `--disable-extensions-except=${pathToExtension}`,
  *           `--load-extension=${pathToExtension}`
@@ -206,6 +229,9 @@ class Playwright extends Helper {
     this.isAuthenticated = false;
     this.sessionPages = {};
     this.activeSessionName = '';
+    this.isElectron = false;
+    this.electronSessions = [];
+    this.storageState = null;
 
     // override defaults with config
     this._setConfig(config);
@@ -215,7 +241,6 @@ class Playwright extends Helper {
     const defaults = {
       // options to emulate context
       emulate: {},
-
       browser: 'chromium',
       waitForAction: 100,
       waitForTimeout: 1000,
@@ -244,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) {
@@ -256,7 +287,15 @@ 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;
     popupStore.defaultAction = this.options.defaultPopupAction;
   }
 
@@ -268,7 +307,7 @@ class Playwright extends Helper {
       },
       {
         name: 'browser',
-        message: 'Browser in which testing will be performed. Possible options: chromium, firefox or webkit',
+        message: 'Browser in which testing will be performed. Possible options: chromium, firefox, webkit or electron',
         default: 'chromium',
       },
     ];
@@ -312,47 +351,67 @@ 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();
+
+    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.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;
   }
 
   async _after() {
     if (!this.isRunning) return;
 
-    // close other sessions
-    const contexts = await this.browser.contexts();
-    contexts.shift();
-
-    await Promise.all(contexts.map(c => c.close()));
+    if (this.isElectron) {
+      this.browser.close();
+      this.electronSessions.forEach(session => session.close());
+      return;
+    }
 
     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;
+    // close other sessions
+    try {
+      const contexts = await this.browser.contexts();
+      const currentContext = contexts[0];
+      if (currentContext && (this.options.keepCookies || this.options.keepBrowserState)) {
+        this.storageState = await currentContext.storageState();
+      }
 
-    if (!this.options.keepCookies) {
-      this.debugSection('Session', 'cleaning cookies and localStorage');
-      await this.clearCookie();
+      await Promise.all(contexts.map(c => c.close()));
+    } catch (e) {
+      console.log(e);
     }
-    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;
   }
@@ -371,12 +430,22 @@ class Playwright extends Helper {
         this.debugSection('New Context', config ? JSON.stringify(config) : 'opened');
         this.activeSessionName = sessionName;
 
-        const bc = await this.browser.newContext(config);
-        const page = await bc.newPage();
+        let browserContext;
+        let page;
+        if (this.isElectron) {
+          const browser = await playwright._electron.launch(this.playwrightOptions);
+          this.electronSessions.push(browser);
+          browserContext = browser.context();
+          page = await browser.firstWindow();
+        } else {
+          browserContext = await this.browser.newContext(config);
+          page = await browserContext.newPage();
+        }
+
         targetCreatedHandler.call(this, page);
         this._setPage(page);
         // Create a new page inside context.
-        return bc;
+        return browserContext;
       },
       stop: async () => {
         // is closed by _after
@@ -496,6 +565,7 @@ class Playwright extends Helper {
     if (!page) return;
     page.setDefaultNavigationTimeout(this.options.getPageTimeout);
     this.context = await this.page;
+    this.contextLocator = null;
     if (this.config.browser === 'chrome') {
       await page.bringToFront();
     }
@@ -512,6 +582,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;
@@ -554,7 +625,9 @@ class Playwright extends Helper {
   }
 
   async _startBrowser() {
-    if (this.isRemoteBrowser) {
+    if (this.isElectron) {
+      this.browser = await playwright._electron.launch(this.playwrightOptions);
+    } else if (this.isRemoteBrowser) {
       try {
         this.browser = await playwright[this.options.browser].connect(this.playwrightOptions);
       } catch (err) {
@@ -563,6 +636,8 @@ class Playwright extends Helper {
         }
         throw err;
       }
+    } else if (this.userDataDir) {
+      this.browser = await playwright[this.options.browser].launchPersistentContext(this.userDataDir, this.playwrightOptions);
     } else {
       this.browser = await playwright[this.options.browser].launch(this.playwrightOptions);
     }
@@ -571,19 +646,14 @@ class Playwright extends Helper {
     this.browser.on('targetchanged', (target) => {
       this.debugSection('Url', target.url());
     });
-    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
-
-    const existingPages = await this.browserContext.pages();
-
-    const mainPage = existingPages[0] || await this.browserContext.newPage();
-    targetCreatedHandler.call(this, mainPage);
-
-    await this._setPage(mainPage);
-    await this.closeOtherTabs();
 
     this.isRunning = true;
   }
 
+  _getType() {
+    return this.browser._type;
+  }
+
   async _stopBrowser() {
     this.withinLocator = null;
     this._setPage(null);
@@ -618,6 +688,7 @@ class Playwright extends Helper {
     const els = await this._locate(locator);
     assertElementExists(els, locator);
     this.context = els[0];
+    this.contextLocator = locator;
 
     this.withinLocator = new Locator(locator);
   }
@@ -625,6 +696,7 @@ class Playwright extends Helper {
   async _withinEnd() {
     this.withinLocator = null;
     this.context = await this.page;
+    this.contextLocator = null;
   }
 
   _extractDataFromPerformanceTiming(timing, ...dataNames) {
@@ -651,6 +723,9 @@ class Playwright extends Helper {
    * @param {string} url url path or global url.
    */
   async amOnPage(url) {
+    if (this.isElectron) {
+      throw new Error('Cannot open pages inside an Electron container');
+    }
     if (!(/^\w+\:\/\//.test(url))) {
       url = this.options.url + url;
     }
@@ -984,6 +1059,9 @@ class Playwright extends Helper {
    * @param {number} [num=1]
    */
   async switchToNextTab(num = 1) {
+    if (this.isElectron) {
+      throw new Error('Cannot switch tabs inside an Electron container');
+    }
     const pages = await this.browserContext.pages();
 
     const index = pages.indexOf(this.page);
@@ -1007,6 +1085,9 @@ class Playwright extends Helper {
    * @param {number} [num=1]
    */
   async switchToPreviousTab(num = 1) {
+    if (this.isElectron) {
+      throw new Error('Cannot switch tabs inside an Electron container');
+    }
     const pages = await this.browserContext.pages();
     const index = pages.indexOf(this.page);
     this.withinLocator = null;
@@ -1028,6 +1109,9 @@ class Playwright extends Helper {
    * ```
    */
   async closeCurrentTab() {
+    if (this.isElectron) {
+      throw new Error('Cannot close current tab inside an Electron container');
+    }
     const oldPage = this.page;
     await this.switchToPreviousTab();
     await oldPage.close();
@@ -1066,6 +1150,9 @@ class Playwright extends Helper {
    * ```
    */
   async openNewTab(options) {
+    if (this.isElectron) {
+      throw new Error('Cannot open new tabs inside an Electron container');
+    }
     await this._setPage(await this.browserContext.newPage(options));
     return this._waitForAction();
   }
@@ -1098,7 +1185,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'));
   }
 
@@ -1114,7 +1201,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'));
   }
 
@@ -1733,7 +1820,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;
   }
 
@@ -2044,6 +2131,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();
   }
 
@@ -2079,6 +2167,22 @@ class Playwright extends Helper {
     return context.evaluate.apply(context, [fn, arg]);
   }
 
+  /**
+   * Grab Locator if called within Context
+   *
+   * @param {*} locator
+   */
+  _contextLocator(locator) {
+    locator = buildLocatorString(new Locator(locator, 'css'));
+
+    if (this.contextLocator) {
+      const contextLocator = buildLocatorString(new Locator(this.contextLocator, 'css'));
+      locator = `${contextLocator} >> ${locator}`;
+    }
+
+    return locator;
+  }
+
   /**
    * Retrieves a text from an element located by CSS or XPath and returns it to test.
    * Resumes test execution, so **should be used inside async with `await`** operator.
@@ -2094,10 +2198,11 @@ class Playwright extends Helper {
    *
    */
   async grabTextFrom(locator) {
-    const texts = await this.grabTextFromAll(locator);
-    assertElementExists(texts, locator);
-    this.debugSection('Text', texts[0]);
-    return texts[0];
+    locator = this._contextLocator(locator);
+    const text = await this.page.textContent(locator);
+    assertElementExists(text, locator);
+    this.debugSection('Text', text);
+    return text;
   }
 
   /**
@@ -2458,8 +2563,37 @@ class Playwright extends Helper {
     return this.page.screenshot({ path: outputFile, fullPage: fullPageOption, type: 'png' });
   }
 
-  async _failed() {
+  async _failed(test) {
     await this._withinEnd();
+    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();
+      }
+    }
   }
 
   /**
@@ -2850,6 +2984,7 @@ class Playwright extends Helper {
 
       if (locator >= 0 && locator < childFrames.length) {
         this.context = childFrames[locator];
+        this.contextLocator = locator;
       } else {
         throw new Error('Element #invalidIframeSelector was not found by text|CSS|XPath');
       }
@@ -2857,6 +2992,7 @@ class Playwright extends Helper {
     }
     if (!locator) {
       this.context = this.page;
+      this.contextLocator = null;
       return;
     }
 
@@ -2867,8 +3003,10 @@ class Playwright extends Helper {
 
     if (contentFrame) {
       this.context = contentFrame;
+      this.contextLocator = null;
     } else {
       this.context = els[0];
+      this.contextLocator = locator;
     }
   }
 
@@ -3038,6 +3176,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;
@@ -3053,10 +3224,24 @@ function buildLocatorString(locator) {
 }
 
 async function findElements(matcher, locator) {
+  if (locator.react) return findReact(matcher, locator);
   locator = new Locator(locator, 'css');
   return matcher.$$(buildLocatorString(locator));
 }
 
+async function getVisibleElements(elements) {
+  const visibleElements = [];
+  for (const element of elements) {
+    if (await element.isVisible()) {
+      visibleElements.push(element);
+    }
+  }
+  if (visibleElements.length === 0) {
+    return elements;
+  }
+  return visibleElements;
+}
+
 async function proceedClick(locator, context = null, options = {}) {
   let matcher = await this._getContext();
   if (context) {
@@ -3076,7 +3261,8 @@ async function proceedClick(locator, context = null, options = {}) {
   if (options.force) {
     await els[0].dispatchEvent('click');
   } else {
-    await els[0].click(options);
+    const element = els.length > 1 ? (await getVisibleElements(els))[0] : els[0];
+    await element.click(options);
   }
   const promises = [];
   if (options.waitForNavigation) {
@@ -3087,6 +3273,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);
 
@@ -3193,6 +3381,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');
 
@@ -3334,11 +3531,13 @@ async function targetCreatedHandler(page) {
           // we are inside iframe?
           const frameEl = await this.context.frameElement();
           this.context = await frameEl.contentFrame();
+          this.contextLocator = null;
           return;
         }
         // if context element was in iframe - keep it
         // if (await this.context.ownerFrame()) return;
         this.context = page;
+        this.contextLocator = null;
       });
   });
   page.on('console', (msg) => {
@@ -3349,12 +3548,21 @@ async function targetCreatedHandler(page) {
   if (this.options.userAgent) {
     await page.setUserAgent(this.options.userAgent);
   }
-  if (this.options.windowSize && this.options.windowSize.indexOf('x') > 0) {
-    const dimensions = this.options.windowSize.split('x');
-    const width = parseInt(dimensions[0], 10);
-    const height = parseInt(dimensions[1], 10);
-    await page.setViewportSize({ width, height });
+  if (this.options.windowSize && this.options.windowSize.indexOf('x') > 0 && this._getType() === 'Browser') {
+    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

package/docs/build/Protractor.js

@@ -124,6 +124,8 @@ class Protractor extends Helper {
 
     this.isRunning = false;
     this._setConfig(config);
+
+    console.log('Protractor helper is deprecated as well as Protractor itself.\nThis helper will be removed in next major release');
   }
 
   _validateConfig(config) {