@applitools/eyes-testcafe 2.0.0-beta.9 → 3.0.0

package/lib/runner/TestResultContainer.js

@@ -1,38 +0,0 @@
-'use strict'
-
-class TestResultContainer {
-  /**
-   * @param {TestResults} [testResults]
-   * @param {Error} [exception]
-   */
-  constructor(testResults, exception) {
-    this._testResults = testResults
-    this._exception = exception
-  }
-
-  /**
-   * @return {TestResults}
-   */
-  getTestResults() {
-    return this._testResults
-  }
-
-  /**
-   * @return {Error}
-   */
-  getException() {
-    return this._exception
-  }
-
-  /**
-   * @override
-   * @return {string}
-   */
-  toString() {
-    return `${this._testResults ? this._testResults.toString() : ''} - ${
-      this._exception ? this._exception.toString() : ''
-    }`
-  }
-}
-
-exports.TestResultContainer = TestResultContainer

package/lib/runner/TestResultsSummary.js

@@ -1,112 +0,0 @@
-'use strict'
-
-const {ArgumentGuard, TypeUtils, GeneralUtils} = require('@applitools/eyes-common')
-const {TestFailedError, TestResultsStatus} = require('@applitools/eyes-sdk-core')
-
-const {TestResultContainer} = require('./TestResultContainer')
-
-/**
- * @implements {Iterable<TestResultContainer>}
- */
-class TestResultsSummary {
-  /**
-   * @param {(TestResults|Error|TestResultContainer)[]} allResults
-   */
-  constructor(allResults) {
-    ArgumentGuard.isArray(allResults, 'ArgumentGuard')
-
-    this._passed = 0
-    this._unresolved = 0
-    this._failed = 0
-    this._exceptions = 0
-    this._mismatches = 0
-    this._missing = 0
-    this._matches = 0
-
-    this._allResults = []
-
-    for (let result of allResults) {
-      if (!(result instanceof TestResultContainer)) {
-        if (result instanceof TestFailedError) {
-          result = new TestResultContainer(result.getTestResults(), result)
-        } else if (result instanceof Error) {
-          result = new TestResultContainer(undefined, result)
-        } else {
-          result = new TestResultContainer(result)
-        }
-      }
-
-      this._allResults.push(result)
-
-      if (result.getException() !== undefined) {
-        this._exceptions += 1
-      }
-
-      const testResults = result.getTestResults()
-      if (TypeUtils.isNotNull(testResults)) {
-        if (TypeUtils.isNotNull(testResults.getStatus())) {
-          switch (testResults.getStatus()) {
-            case TestResultsStatus.Failed:
-              this._failed += 1
-              break
-            case TestResultsStatus.Passed:
-              this._passed += 1
-              break
-            case TestResultsStatus.Unresolved:
-              this._unresolved += 1
-              break
-            default:
-              break
-          }
-        }
-
-        this._matches += testResults.getMatches()
-        this._missing += testResults.getMissing()
-        this._mismatches += testResults.getMismatches()
-      }
-    }
-  }
-
-  /**
-   * @return {IterableIterator<TestResultContainer>} Iterator to go over the TestResultContainers in the chain.
-   */
-  [Symbol.iterator]() {
-    return this._allResults[Symbol.iterator]()
-  }
-
-  /**
-   * @return {TestResultContainer[]}
-   */
-  getAllResults() {
-    return this._allResults
-  }
-
-  /**
-   * @return {string}
-   */
-  toString() {
-    // eslint-disable-next-line prefer-template
-    return (
-      'result summary {' +
-      '\n\tall results=\n\t\t' +
-      GeneralUtils.toString(this._allResults) +
-      '\n\tpassed=' +
-      this._passed +
-      '\n\tunresolved=' +
-      this._unresolved +
-      '\n\tfailed=' +
-      this._failed +
-      '\n\texceptions=' +
-      this._exceptions +
-      '\n\tmismatches=' +
-      this._mismatches +
-      '\n\tmissing=' +
-      this._missing +
-      '\n\tmatches=' +
-      this._matches +
-      '\n}'
-    )
-  }
-}
-
-exports.TestResultsSummary = TestResultsSummary

package/lib/runner/VisualGridRunner.js

@@ -1,57 +0,0 @@
-'use strict'
-
-const {EyesRunner} = require('./EyesRunner')
-const {TestResultsSummary} = require('./TestResultsSummary')
-
-class VisualGridRunner extends EyesRunner {
-  /**
-   * @param {number} [concurrentSessions]
-   */
-  constructor(concurrentSessions) {
-    super()
-
-    this._concurrentSessions = concurrentSessions
-  }
-
-  /**
-   * @return {number}
-   */
-  getConcurrentSessions() {
-    return this._concurrentSessions
-  }
-
-  /**
-   * @param {boolean} [shouldThrowException=true]
-   * @return {Promise<TestResultsSummary>}
-   */
-  async getAllTestResults(shouldThrowException = true) {
-    if (this._eyesInstances.length > 0) {
-      const resultsPromise = []
-      const allResults = []
-
-      for (const eyesInstance of this._eyesInstances) {
-        resultsPromise.push(eyesInstance.closeAndReturnResults(false))
-      }
-
-      const results = await Promise.all(resultsPromise)
-      for (const result of results) {
-        allResults.push(...result.getAllResults())
-      }
-
-      if (shouldThrowException === true) {
-        for (const result of allResults) {
-          if (result.getException()) {
-            throw result.getException()
-          }
-        }
-      }
-
-      await this._closeAllBatches()
-      return new TestResultsSummary(allResults)
-    }
-
-    return null
-  }
-}
-
-exports.VisualGridRunner = VisualGridRunner

package/lib/safeExecuteFunction.js

@@ -1,28 +0,0 @@
-'use strict'
-
-const {makeClientFunctionWrapper} = require('./makeClientFunctionWrapper')
-const hash = require('./hash')
-
-// TODO
-// This should be used for running functions with saving their compiled Testcafe data
-// Alos this handles the Testcafe return value size limitation
-// Use this function for Dom Capture (or remove it..)
-
-function makeSafeExecuteFunction(driver) {
-  const functionsCache = {}
-  const clientFunctionWrapper = makeClientFunctionWrapper({})
-
-  return async func => {
-    const funcId = hash(func.toString())
-    let wrappedFunc
-    if (!functionsCache[funcId]) {
-      functionsCache[funcId] = await clientFunctionWrapper(func)
-      wrappedFunc = functionsCache[funcId]
-    } else {
-      wrappedFunc = functionsCache[funcId]
-    }
-    return wrappedFunc(driver)
-  }
-}
-
-module.exports = makeSafeExecuteFunction

package/lib/wrappers/EyesTargetLocator.js

@@ -1,335 +0,0 @@
-'use strict'
-
-const {Location, RectangleSize, ArgumentGuard, TypeUtils} = require('@applitools/eyes-common')
-
-const {Frame} = require('../frames/Frame')
-const {FrameChain} = require('../frames/FrameChain')
-const {ScrollPositionProvider} = require('../positioning/ScrollPositionProvider')
-const {TestCafeExecutor} = require('../TestCafeExecutor')
-const {EyesWebElement} = require('./EyesWebElement')
-const {EyesWebElementPromise} = require('./EyesWebElementPromise')
-
-/**
- * Wraps a target locator so we can keep track of which frames have been switched to.
- */
-class EyesTargetLocator {
-  /**
-   * Initialized a new EyesTargetLocator object.
-   *
-   * @param {Logger} logger - A Logger instance.
-   * @param {EyesWebDriver} driver - The WebDriver from which the targetLocator was received.
-   * @param {TargetLocator} targetLocator - The actual TargetLocator object.
-   */
-  constructor(logger, driver) {
-    ArgumentGuard.notNull(logger, 'logger')
-    ArgumentGuard.notNull(driver, 'driver')
-
-    this._logger = logger
-    this._driver = driver
-    this._jsExecutor = new TestCafeExecutor(driver._driver)
-
-    /** @type {ScrollPositionMemento} */
-    this._defaultContentPositionMemento = undefined
-  }
-
-  // noinspection JSCheckFunctionSignatures
-  /**
-   * Schedules a command to switch the focus of all future commands to another frame on the page. The target frame may
-   * be specified as one of the following:
-   *
-   * - A number that specifies a (zero-based) index into [window.frames](
-   *   https://developer.mozilla.org/en-US/docs/Web/API/Window.frames).
-   * - A string, which correspond to a `id` or `name` of element.
-   * - A {@link WebElement} reference, which correspond to a `frame` or `iframe` DOM element.
-   * - The `null` value, to select the topmost frame on the page. Passing `null`
-   *   is the same as calling {@link #defaultContent defaultContent()}.
-   *
-   * @override
-   * @param {number|string|WebElement|null} varArg - The frame locator.
-   * @return {Promise} - A promise that will be resolved when the driver has changed focus to the specified frame.
-   */
-  async frame(varArg) {
-    if (varArg == null) {
-      this._logger.verbose('EyesTargetLocator.frame(null)')
-      await this.defaultContent()
-      return
-    }
-
-    if (TypeUtils.isInteger(varArg)) {
-      /** @type {number} */
-      const frameIndex = varArg
-      this._logger.verbose(`Found integer (${frameIndex})`)
-      // Finding the target element so and reporting it using onWillSwitch.
-      this._logger.verbose('Getting frames list...')
-      const frames = await this._driver.findElementsByCssSelector('frame, iframe')
-      if (frameIndex > frames.length) {
-        throw new TypeError(`Frame index [${frameIndex}] is invalid!`)
-      }
-
-      this._logger.verbose('Done! getting the specific frame...')
-      this._logger.verbose('Done! Making preparations...')
-      await this.willSwitchToFrame(frames[frameIndex])
-
-      this._logger.verbose('Done! Switching to frame...')
-      await this._targetLocator.frame(frameIndex)
-      this._logger.verbose('Done!')
-      return
-    }
-
-    if (TypeUtils.isString(varArg)) {
-      /** @type {string} */
-      const nameOrId = varArg
-      this._logger.verbose(`Found string ('${nameOrId}')`)
-      // Finding the target element so we can report it.
-      // We use find elements(plural) to avoid exception when the element is not found.
-      this._logger.verbose('Getting frames by name...')
-      let frames = await this._driver.findElementsByName(nameOrId)
-      if (frames.length === 0) {
-        this._logger.verbose('No frames Found! Trying by id...')
-        // If there are no frames by this name, we'll try the id
-        frames = await this._driver.findElementsById(nameOrId)
-        if (frames.length === 0) {
-          // No such frame, bummer
-          throw new TypeError(`No frame with name or id '${nameOrId}' exists!`)
-        }
-      }
-
-      this._logger.verbose('Done! Making preparations...')
-      await this.willSwitchToFrame(frames[0])
-
-      this._logger.verbose(`Done! Switching to frame ${nameOrId} ...`)
-      await this._targetLocator.frame(frames[0])
-
-      this._logger.verbose('Done!')
-      return
-    }
-
-    /** @type {WebElement} */
-    const frameElement = varArg
-    this._logger.verbose('Probably, WebElement')
-    this._logger.verbose('Making preparations...')
-    await this.willSwitchToFrame(frameElement)
-
-    this._logger.verbose('Done! Switching to frame...')
-    await this._targetLocator.frame(frameElement)
-
-    this._logger.verbose('Done!')
-  }
-
-  /**
-   * @inheritDoc
-   */
-  async parentFrame() {
-    this._logger.verbose('enter')
-    if (this._driver.getFrameChain().size() !== 0) {
-      this._logger.verbose('Making preparations...')
-      const frame = this._driver.getFrameChain().pop()
-      await frame.returnToOriginalPosition(this._driver)
-      this._logger.verbose('Done! Switching to parent frame...')
-      await EyesTargetLocator.tryParentFrame(this._targetLocator, this._driver.getFrameChain())
-      this._logger.verbose('Done!')
-    }
-  }
-
-  /**
-   * @param {TargetLocator} targetLocator
-   * @param {FrameChain} frameChainToParent
-   * @return {Promise}
-   */
-  static async tryParentFrame(targetLocator, frameChainToParent) {
-    try {
-      await targetLocator.parentFrame()
-    } catch (ignored) {
-      await targetLocator.defaultContent()
-      for (const frame of frameChainToParent) {
-        await targetLocator.frame(frame.getReference())
-      }
-    }
-  }
-
-  /**
-   * Switches into every frame in the frame chain. This is used as way to switch into nested frames (while considering
-   * scroll) in a single call.
-   *
-   * @param {FrameChain} frameChain - The path to the frame to switch to.
-   * @return {Promise} - A promise that will be resolved when the command has completed.
-   */
-  async framesDoScroll(frameChain) {
-    this._logger.verbose('enter')
-    await this.defaultContent()
-    const scrollRootElement = await this._driver.getEyes().getCurrentFrameScrollRootElement()
-    const scrollProvider = new ScrollPositionProvider(
-      this._logger,
-      this._jsExecutor,
-      scrollRootElement,
-    )
-    this._defaultContentPositionMemento = await scrollProvider.getState()
-
-    for (const frame of frameChain.getFrames()) {
-      this._logger.verbose('Scrolling by parent scroll position...')
-      const frameLocation = frame.getLocation()
-      await scrollProvider.setPosition(frameLocation)
-      this._logger.verbose('Done! Switching to frame...')
-      await this.frame(frame.getReference())
-      const newFrame = this._driver.getFrameChain().peek()
-      newFrame.setScrollRootElement(frame.getScrollRootElement())
-      this._logger.verbose('Done!')
-    }
-
-    this._logger.verbose('Done switching into nested frames!')
-  }
-
-  /**
-   * Switches into every frame in the frame chain. This is used as way to switch into nested frames (while considering
-   * scroll) in a single call.
-   *
-   * @param {FrameChain|string[]} varArg - The path to the frame to switch to. Or the path to the frame to check.
-   *   This is a list of frame names/IDs (where each frame is nested in the previous frame).
-   * @return {Promise} - The WebDriver with the switched context.
-   */
-  async frames(varArg) {
-    this._logger.verbose('enter')
-
-    if (varArg instanceof FrameChain) {
-      this._logger.verbose('found frameChain')
-      await this.defaultContent()
-
-      for (const frame of varArg.getFrames()) {
-        await this.frame(frame.getReference())
-        const newFrame = this._driver.getFrameChain().peek()
-        newFrame.setScrollRootElement(frame.getScrollRootElement())
-      }
-
-      this._logger.verbose('Done switching into nested frames!')
-      return
-    }
-
-    if (Array.isArray(varArg)) {
-      this._logger.verbose('found array')
-
-      for (const frameNameOrId of varArg) {
-        this._logger.verbose('Switching to frame...')
-        await this._driver.switchTo().frame(frameNameOrId)
-        this._logger.verbose('Done!')
-      }
-
-      this._logger.verbose('Done switching into nested frames!')
-    }
-  }
-
-  // noinspection JSCheckFunctionSignatures
-  /**
-   * @inheritDoc
-   */
-  async window(nameOrHandle) {
-    this._logger.verbose('enter')
-    this._driver.getFrameChain().clear()
-    this._logger.verbose('Done! Switching to window...')
-    await this._targetLocator.window(nameOrHandle)
-    this._logger.verbose('Done!')
-  }
-
-  /**
-   * @inheritDoc
-   */
-  async defaultContent() {
-    this._logger.verbose('enter')
-    if (this._driver.getFrameChain().size() !== 0) {
-      this._logger.verbose('Making preparations...')
-      this._driver.getFrameChain().clear()
-      this._logger.verbose('Done! Switching to default content...')
-    }
-
-    try {
-      await this._driver._driver.switchToMainWindow()
-    } catch (e) {
-      this._logger.log('testcafe failed to switchToMainWindow (retrying), error', JSON.stringify(e))
-      await this._driver._driver.switchToMainWindow()
-    }
-
-    this._logger.verbose('Done!')
-  }
-
-  // noinspection JSCheckFunctionSignatures
-  /**
-   * Schedules a command retrieve the {@code document.activeElement} element on the current document, or
-   * {@code document.body} if activeElement is not available.
-   *
-   * @override
-   * @return {!EyesWebElementPromise}
-   */
-  activeElement() {
-    this._logger.verbose('Switching to element...')
-    const id = this._driver.execute(/* new Command(Name.GET_ACTIVE_ELEMENT) */)
-
-    this._logger.verbose('Done!')
-    return new EyesWebElementPromise(this._logger, this._driver, id, 'activeElement')
-  }
-
-  /**
-   * Schedules a command to change focus to the active modal dialog, such as those opened by `window.alert()`,
-   * `window.confirm()`, and `window.prompt()`. The returned promise will be rejected with a
-   * {@linkplain error.NoSuchAlertError} if there are no open alerts.
-   *
-   * @return {!AlertPromise} - The open alert.
-   */
-  alert() {
-    this._logger.verbose('Switching to alert...')
-    const result = this._targetLocator.alert()
-    this._logger.verbose('Done!')
-    return result
-  }
-
-  /**
-   * @return {Promise}
-   */
-  async resetScroll() {
-    this._logger.verbose('enter')
-    if (this._defaultContentPositionMemento != null) {
-      const scrollRootElement = await this._driver.getEyes().getCurrentFrameScrollRootElement()
-      const scrollProvider = new ScrollPositionProvider(
-        this._logger,
-        this._jsExecutor,
-        scrollRootElement,
-      )
-      await scrollProvider.restoreState(this._defaultContentPositionMemento)
-    }
-  }
-
-  /**
-   * Will be called before switching into a frame.
-   *
-   * @param {WebElement} targetFrame - The element about to be switched to.
-   * @return {Promise}
-   */
-  async willSwitchToFrame(targetFrame) {
-    ArgumentGuard.notNull(targetFrame, 'targetFrame')
-
-    const eyesFrame =
-      targetFrame instanceof EyesWebElement
-        ? targetFrame
-        : new EyesWebElement(this._logger, this._driver, targetFrame)
-
-    const rect = await eyesFrame.getRect()
-    const sizeAndBorders = await eyesFrame.getSizeAndBorders()
-
-    const contentLocation = new Location(rect.x + sizeAndBorders.left, rect.y + sizeAndBorders.top)
-    const originalLocation = await ScrollPositionProvider.getCurrentPositionStatic(
-      this._jsExecutor,
-      this._driver.findElement('html'),
-    )
-
-    const frame = new Frame(
-      this._logger,
-      targetFrame,
-      contentLocation,
-      new RectangleSize(rect),
-      new RectangleSize(sizeAndBorders),
-      originalLocation,
-      this._driver,
-    )
-    this._driver.getFrameChain().push(frame)
-  }
-}
-
-exports.EyesTargetLocator = EyesTargetLocator