@applitools/driver 1.2.3 → 1.2.7

package/src/fake/mock-driver.js

@@ -1,355 +0,0 @@
-const {inspect} = require('util')
-const utils = require('@applitools/utils')
-const snippets = require('@applitools/snippets')
-
-const WELL_KNOWN_SCRIPTS = {
-  'dom-snapshot': script => /\/\* @applitools\/dom-snapshot@[\d.]+ \*\//.test(script),
-  'dom-capture': script => /\/\* @applitools\/dom-capture@[\d.]+ \*\//.test(script),
-}
-
-const DEFAULT_DESKTOP_UA =
-  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.89 Safari/537.36'
-const DEFAULT_MOBILE_UA =
-  'Mozilla/5.0 (Linux; Android 8.0.0; Pixel 2 XL Build/OPD1.170816.004) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.135 Mobile Safari/537.36'
-
-const DEFAULT_STYLES = {
-  'border-left-width': '0px',
-  'border-top-width': '0px',
-  overflow: null,
-}
-
-const DEFAULT_PROPS = {
-  clientWidth: 300,
-  clientHeight: 400,
-  overflow: null,
-}
-
-class MockDriver {
-  constructor({viewport = {width: 1000, height: 1000}, device, platform, browser, ua} = {}) {
-    this._device = device
-    this._platform = platform
-    this._browser = browser
-    this._ua = ua
-    this._window = {
-      title: 'Default Page Title',
-      url: 'http://default.url',
-      rect: {x: 0, y: 0, ...viewport},
-    }
-    this._methods = new Map()
-    this._scripts = new Map()
-    this._elements = new Map()
-    this._contexts = new Map()
-    this._contexts.set(null, {
-      document: {id: Symbol('documentId')},
-      state: {
-        get name() {
-          return null
-        },
-      },
-    })
-    this._contextId = null
-    this.mockElement('html', {scrollPosition: {x: 0, y: 0}})
-    this.mockScript(snippets.getContextInfo, async () => {
-      const context = this._contexts.get(this._contextId)
-      const isRoot = !this._contextId
-      const isCORS = !isRoot && context.isCORS
-      const contentDocument = await this.findElement('html')
-      const selector = !isCORS && !isRoot ? context.element.selector : null
-      return [contentDocument, selector, isRoot, isCORS]
-    })
-    this.mockScript(snippets.isEqualElements, async ([element1, element2]) => {
-      return element1.id === element2.id
-    })
-    this.mockScript(snippets.getChildFramesInfo, () => {
-      return Array.from(this._contexts.values())
-        .filter(frame => frame.parentId === this._contextId)
-        .map(frame => [frame.element, frame.isCORS])
-    })
-    this.mockScript(snippets.getElementRect, ([element]) => {
-      return element.rect || {x: 0, y: 0, width: 100, height: 100}
-    })
-    this.mockScript(snippets.getElementComputedStyleProperties, ([element, properties]) => {
-      return properties.map(property => (element.styles || {})[property] || DEFAULT_STYLES[property])
-    })
-    this.mockScript(snippets.getElementProperties, ([element, properties]) => {
-      return properties.map(property => (element.props || {})[property] || DEFAULT_PROPS[property])
-    })
-    this.mockScript(snippets.setElementStyleProperties, ([element, properties]) => {
-      return Object.entries(properties).reduce((original, [name, value]) => {
-        original[name] = {value: element.style[name], important: false}
-        element.style[name] = value
-        return original
-      }, {})
-    })
-    this.mockScript(snippets.setElementAttributes, ([element, attributes]) => {
-      return Object.entries(attributes).reduce((original, [name, value]) => {
-        original[name] = element.attrs[name]
-        element.attrs[name] = value
-        return original
-      }, {})
-    })
-    this.mockScript(snippets.scrollTo, ([element, offset]) => {
-      let scrollingElement = element
-      if (!element) {
-        scrollingElement = this.findElement('html')
-      }
-      scrollingElement.scrollPosition = offset
-      return [scrollingElement.scrollPosition.x, scrollingElement.scrollPosition.y]
-    })
-    this.mockScript(snippets.getElementScrollOffset, ([element]) => {
-      let scrollingElement = element
-      if (!element) {
-        scrollingElement = this.findElement('html')
-      }
-      if (!scrollingElement.scrollPosition) {
-        scrollingElement.scrollPosition = {x: 0, y: 0}
-      }
-      return {x: scrollingElement.scrollPosition.x, y: scrollingElement.scrollPosition.y}
-    })
-    this.mockScript(snippets.getElementInnerOffset, ([element]) => {
-      let scrollingElement = element
-      if (!element) {
-        scrollingElement = this.findElement('html')
-      }
-      if (!scrollingElement.scrollPosition) {
-        scrollingElement.scrollPosition = {x: 0, y: 0}
-      }
-      return {x: scrollingElement.scrollPosition.x, y: scrollingElement.scrollPosition.y}
-    })
-    this.mockScript(snippets.getPixelRatio, () => {
-      return 1
-    })
-    this.mockScript(snippets.getShadowRoot, ([element]) => {
-      return element
-    })
-    this.mockScript(snippets.getUserAgent, () => {
-      if (this._ua !== undefined) return this._ua
-      return this.info.isMobile ? DEFAULT_MOBILE_UA : DEFAULT_DESKTOP_UA
-    })
-    this.mockScript(snippets.getViewportSize, () => {
-      return {width: this._window.rect.width, height: this._window.rect.height}
-    })
-    this.mockScript(snippets.getElementXpath, ([element]) => {
-      if (element.xpath) return element.xpath
-      const elements = Array.from(this._elements.values()).reduce((elements, array) => elements.concat(array), [])
-      const index = elements.findIndex(({id}) => id === element.id)
-      return index >= 0 ? `/HTML[1]/BODY[1]/DIV[${index + 1}]` : `//[data-fake-selector="${element.selector}"]`
-    })
-    this.mockScript(snippets.blurElement, () => {
-      return null
-    })
-    this.mockScript(snippets.addElementIds, ([elements, ids]) => {
-      const selectors = []
-      for (const [index, element] of elements.entries()) {
-        const elementId = ids[index]
-        element.attributes = element.attributes || []
-        element.attributes.push({name: 'data-applitools-selector', value: elementId})
-        const selector = `[data-applitools-selector~="${elementId}"]`
-        selectors.push([selector])
-      }
-      return selectors
-    })
-    this.mockScript(snippets.cleanupElementIds, ([elements]) => {
-      for (const el of elements) {
-        el.attributes.splice(
-          el.attributes.findIndex(({name}) => name === 'data-applitools-marker'),
-          1,
-        )
-      }
-    })
-    this.mockScript(snippets.getElementContentSize, ([element]) => {
-      return element.rect || {x: 0, y: 0, width: 100, height: 100}
-    })
-    this.mockScript(snippets.getDocumentSize, () => {
-      // TODO get window for context: `this.contexts.get(this._contextId)`
-      return {width: this._window.rect.width, height: this._window.rect.height}
-    })
-  }
-  mockScript(scriptMatcher, resultGenerator) {
-    this._scripts.set(String(scriptMatcher), resultGenerator)
-  }
-  mockElement(selector, state) {
-    const element = {
-      id: Symbol('elementId' + Math.floor(Math.random() * 100)),
-      attrs: {},
-      style: {},
-      selector,
-      parentId: null,
-      parentContextId: null,
-      parentRootId: null,
-      ...state,
-    }
-    if (element.shadow) {
-      element.shadowRootId = Symbol('shadowId' + (element.name || Math.floor(Math.random() * 100)))
-    }
-    if (element.frame) {
-      const contextId = Symbol('contextId' + (element.name || Math.floor(Math.random() * 100)))
-      this._contexts.set(contextId, {
-        id: contextId,
-        parentId: state.parentContextId,
-        isCORS: state.isCORS,
-        element,
-        document: {id: Symbol('documentId' + (element.name || Math.floor(Math.random() * 100)))},
-        state: {
-          get name() {
-            return element.name || element.selector
-          },
-        },
-      })
-      element.contextId = contextId
-      this.mockElement('html', {
-        parentContextId: contextId,
-        scrollPosition: {x: 0, y: 0},
-      })
-    }
-    this.mockSelector(selector, element)
-    return element
-  }
-  mockElements(nodes, {parentId = null, parentContextId = null, parentRootId = null} = {}) {
-    for (const node of nodes) {
-      const element = this.mockElement(node.selector, {...node, parentId, parentContextId, parentRootId})
-      if (node.children) {
-        this.mockElements(node.children, {
-          parentId: element.frame ? null : element.id,
-          parentContextId: element.frame ? element.contextId : parentContextId,
-          parentRootId: element.shadow ? element.shadowRootId : parentRootId,
-        })
-      }
-    }
-  }
-  mockSelector(selector, element) {
-    let elements = this._elements.get(selector)
-    if (!elements) {
-      elements = []
-      this._elements.set(selector, elements)
-    }
-    elements.push(element)
-  }
-  wrapMethod(name, wrapper) {
-    if (!this[name] || name.startsWith('_') || !utils.types.isFunction(this[name])) return
-    if (this._methods.has(name)) this.unwrapMethod(name)
-    this._methods.set(name, this[name])
-    this[name] = new Proxy(this[name], {
-      apply: (method, driver, args) => wrapper(method, driver, args),
-    })
-  }
-  unwrapMethod(name) {
-    const method = this._methods.get(name)
-    if (!method) return
-    this[name] = method
-  }
-
-  get info() {
-    return {
-      isMobile: this._device ? Boolean(this._device.isMobile) : false,
-      isNative: this._device ? Boolean(this._device.isNative) : false,
-      deviceName: this._device ? this._device.name : null,
-      platformName: this._platform ? this._platform.name : null,
-      platformVersion: this._platform ? this._platform.version : null,
-      browserName: this._browser ? this._browser.name : null,
-      browserVersion: this._browser ? this._browser.version : null,
-    }
-  }
-  async executeScript(script, args = []) {
-    if (this.info.isNative) throw new Error("Native context doesn't support this method")
-    let result = this._scripts.get(String(script))
-    if (!result) {
-      const name = Object.keys(WELL_KNOWN_SCRIPTS).find(name => WELL_KNOWN_SCRIPTS[name](script))
-      if (!name) return null
-      result = this._scripts.get(name)
-    }
-    const {state} = this._contexts.get(this._contextId)
-    return utils.types.isFunction(result) ? result.call(state, ...args) : result
-  }
-  async findElement(selector, rootElement) {
-    const elements = this._elements.get(selector)
-    return elements
-      ? elements.find(
-          element =>
-            element.parentContextId === this._contextId &&
-            element.parentRootId === ((rootElement || {}).shadowRootId || null),
-        )
-      : null
-  }
-  async findElements(selector, rootElement) {
-    const elements = this._elements.get(selector)
-    return elements
-      ? elements.filter(
-          element =>
-            element.parentContextId === this._contextId &&
-            element.parentRootId === ((rootElement || {}).shadowRootId || null),
-        )
-      : []
-  }
-  async switchToFrame(reference) {
-    if (reference === null) {
-      this._contextId = null
-      return this
-    }
-    if (utils.types.isString(reference)) {
-      reference = await this.findElement(reference)
-    }
-
-    const frame = this._contexts.get(reference.contextId)
-    if (frame && this._contextId === frame.parentId) {
-      this._contextId = frame.id
-      return this
-    } else {
-      throw new Error('Frame not found')
-    }
-  }
-  async switchToParentFrame() {
-    if (!this._contextId) return this
-    for (const frame of this._contexts.values()) {
-      if (frame.id === this._contextId) {
-        this._contextId = frame.parentId
-        return this
-      }
-    }
-    return this
-  }
-  async getWindowRect() {
-    return this._window.rect
-  }
-  async setWindowRect(rect) {
-    Object.assign(this._window.rect, rect)
-  }
-  async getUrl() {
-    if (this.info.isNative) throw new Error("Native context doesn't support this method")
-    return this._window.url
-  }
-  async getTitle() {
-    if (this.info.isNative) throw new Error("Native context doesn't support this method")
-    return this._window.title
-  }
-  async visit(url) {
-    if (this.info.isNative) throw new Error("Native context doesn't support this method")
-    this._window.url = url
-  }
-  async takeScreenshot() {
-    // const image = new png.Image({
-    //   width: this._window.rect.width,
-    //   height: this._window.rect.height,
-    // })
-    // const stream = image.pack()
-    // return new Promise((resolve, reject) => {
-    //   let buffer = Buffer.from([])
-    //   stream.on('data', chunk => {
-    //     buffer = Buffer.concat([buffer, chunk])
-    //   })
-    //   stream.on('end', () => resolve(buffer))
-    //   stream.on('error', reject)
-    // })
-  }
-  toString() {
-    return '<MockDriver>'
-  }
-  toJSON() {
-    return '<MockDriver>'
-  }
-  [inspect.custom]() {
-    return '<MockDriver>'
-  }
-}
-
-module.exports = {MockDriver}

package/src/fake/spec-driver.d.ts

@@ -1,11 +0,0 @@
-import * as types from '@applitools/types'
-import {MockDriver} from './mock-driver'
-
-export type Driver = MockDriver
-export type Context = MockDriver
-export type Element = any
-export type Selector = string | {using: string; value: string}
-
-export type FakeSpecDriver = types.SpecDriver<Driver, Context, Element, Selector>
-
-export const spec: FakeSpecDriver

package/src/fake/spec-driver.js

@@ -1,66 +0,0 @@
-const utils = require('@applitools/utils')
-
-const spec = {
-  isDriver(driver) {
-    return driver && driver.constructor.name === 'MockDriver'
-  },
-  isElement(element) {
-    return utils.types.has(element, 'id')
-  },
-  isSelector(selector) {
-    return utils.types.isString(selector) || utils.types.has(selector, ['using', 'value'])
-  },
-  transformSelector(selector) {
-    return selector.selector || selector
-  },
-  isStaleElementError() {
-    return false
-  },
-  isEqualElements(_driver, element1, element2) {
-    return element1.id === element2.id
-  },
-  executeScript(driver, script, ...args) {
-    return driver.executeScript(script, args)
-  },
-  findElement(driver, selector, parent) {
-    return driver.findElement(selector.selector || selector, parent)
-  },
-  findElements(driver, selector, parent) {
-    return driver.findElements(selector.selector || selector, parent)
-  },
-  mainContext(driver) {
-    return driver.switchToFrame(null)
-  },
-  parentContext(driver) {
-    return driver.switchToParentFrame()
-  },
-  childContext(driver, reference) {
-    return driver.switchToFrame(reference)
-  },
-  takeScreenshot(driver) {
-    return driver.takeScreenshot()
-  },
-  getDriverInfo(driver) {
-    return driver.info
-  },
-  async getWindowSize(driver) {
-    const rect = await driver.getWindowRect()
-    return rect
-  },
-  async setWindowSize(driver, size) {
-    await driver.setWindowRect(size)
-  },
-  async getUrl(driver) {
-    if (this._isNative) return null
-    return driver.getUrl()
-  },
-  async getTitle(driver) {
-    if (this._isNative) return null
-    return driver.getTitle()
-  },
-  async visit(driver, url) {
-    await driver.visit(url)
-  },
-}
-
-module.exports = {spec}

package/src/index.ts

@@ -1,6 +0,0 @@
-export * from './driver'
-export * from './context'
-export * from './element'
-
-export * from './fake/mock-driver'
-export * as fake from './fake/spec-driver'

package/src/user-agent.ts

@@ -1,99 +0,0 @@
-import * as utils from '@applitools/utils'
-
-type PlatformInfo = {platformName: string; platformVersion?: string}
-type BrowserInfo = {browserName: string; browserVersion?: string}
-
-const MAJOR_MINOR = '(\\d+)(?:[_.](\\d+))?'
-
-const PLATFORM_REGEXES = [
-  new RegExp(`(?:(Windows NT) ${MAJOR_MINOR})`),
-  new RegExp('(?:(Windows XP))'),
-  new RegExp('(?:(Windows 2000))'),
-  new RegExp('(?:(Windows NT))'),
-  new RegExp('(?:(Windows))'),
-  new RegExp(`(?:(Mac OS X) ${MAJOR_MINOR})`),
-  new RegExp(`(?:(Android) ${MAJOR_MINOR})`),
-  new RegExp(`(?:(CPU(?: i[a-zA-Z]+)? OS) ${MAJOR_MINOR})`),
-  new RegExp('(?:(Mac OS X))'),
-  new RegExp('(?:(Mac_PowerPC))'),
-  new RegExp('(?:(Linux))'),
-  new RegExp('(?:(CrOS))'),
-  new RegExp('(?:(SymbOS))'),
-]
-
-const BROWSER_REGEXPES = [
-  new RegExp(`(?:(Opera)/${MAJOR_MINOR})`),
-  new RegExp(`(?:(Edg)/${MAJOR_MINOR})`),
-  new RegExp(`(?:(Edge)/${MAJOR_MINOR})`),
-  new RegExp(`(?:(Chrome)/${MAJOR_MINOR})`),
-  new RegExp(`(?:(Safari)/${MAJOR_MINOR})`),
-  new RegExp(`(?:(Firefox)/${MAJOR_MINOR})`),
-  new RegExp(`(?:MS(IE) ${MAJOR_MINOR})`),
-]
-
-const HIDDEN_IE_REGEX = new RegExp(`(?:rv:${MAJOR_MINOR}\\) like Gecko)`)
-
-const BROWSER_VERSION_REGEX = new RegExp(`(?:Version/${MAJOR_MINOR})`)
-
-export function parseUserAgent(userAgent: string): PlatformInfo & BrowserInfo {
-  utils.guard.notNull(userAgent, {name: 'userAgent'})
-
-  userAgent = userAgent.trim()
-  return {
-    ...parsePlatform(userAgent),
-    ...parseBrowser(userAgent),
-  }
-}
-
-export function parsePlatform(userAgent: string): PlatformInfo {
-  const platformRegExp = PLATFORM_REGEXES.find(regexp => regexp.test(userAgent))
-
-  if (!platformRegExp) return {platformName: 'Unknown'}
-
-  const [_, platformName, platformMajorVersion, platformMinorVersion] = platformRegExp.exec(userAgent)
-
-  if (platformName.startsWith('CPU')) {
-    return {platformName: 'iOS', platformVersion: platformMajorVersion}
-  } else if (platformName === 'Windows 2000' || platformName === 'Windows XP') {
-    return {platformName: 'Windows', platformVersion: '5'}
-  } else if (platformName === 'Windows NT') {
-    const result = {platformName: 'Windows', platformVersion: platformMajorVersion}
-    if (!platformMajorVersion) {
-      result.platformVersion = '4'
-    } else if (platformMajorVersion === '6' && platformMinorVersion === '1') {
-      result.platformVersion = '7'
-    } else if (platformMajorVersion === '6' && (platformMinorVersion === '2' || platformMinorVersion === '3')) {
-      result.platformVersion = '8'
-    }
-    return result
-  } else if (platformName === 'Mac_PowerPC') {
-    return {platformName: 'Macintosh', platformVersion: platformMajorVersion}
-  } else if (platformName === 'CrOS') {
-    return {platformName: 'Chrome OS', platformVersion: platformMajorVersion}
-  } else {
-    return {platformName, platformVersion: platformMajorVersion}
-  }
-}
-
-export function parseBrowser(userAgent: string): BrowserInfo {
-  const browserRegExp = BROWSER_REGEXPES.find(regexp => regexp.test(userAgent))
-  if (!browserRegExp) {
-    if (HIDDEN_IE_REGEX.test(userAgent)) {
-      const [_, browserVersion] = HIDDEN_IE_REGEX.exec(userAgent)
-      return {browserName: 'IE', browserVersion}
-    } else {
-      return {browserName: 'Unknown'}
-    }
-  }
-
-  const [_, browserName, browserVersion] = browserRegExp.exec(userAgent)
-  const result = {browserName, browserVersion}
-
-  if (result.browserName === 'Edg') result.browserName = 'Edge'
-  if (BROWSER_VERSION_REGEX.test(userAgent)) {
-    const [_, browserVersion] = BROWSER_VERSION_REGEX.exec(userAgent)
-    result.browserVersion = browserVersion
-  }
-
-  return result
-}

package/src/utils.ts

@@ -1,77 +0,0 @@
-import type * as types from '@applitools/types'
-import * as utils from '@applitools/utils'
-
-const snippets = require('@applitools/snippets')
-
-export type SpecUtils<_TDriver, TContext, TElement, TSelector> = {
-  isSelector(selector: any): selector is types.Selector<TSelector>
-  transformSelector(selector: types.Selector<TSelector>): TSelector
-  splitSelector(selector: types.Selector<TSelector>): types.Selector<TSelector>[]
-  findRootElement(
-    context: TContext,
-    selector: types.Selector<TSelector>,
-  ): Promise<{root: TElement; selector: types.Selector<TSelector>}>
-}
-
-export function makeSpecUtils<TDriver, TContext, TElement, TSelector>(
-  spec: types.SpecDriver<TDriver, TContext, TElement, TSelector>,
-): SpecUtils<TDriver, TContext, TElement, TSelector> {
-  return {isSelector, transformSelector, splitSelector, findRootElement}
-
-  function isSelector(selector: any): selector is types.Selector<TSelector> {
-    return (
-      spec.isSelector(selector) ||
-      utils.types.isString(selector) ||
-      (utils.types.isPlainObject(selector) &&
-        utils.types.has(selector, 'selector') &&
-        (utils.types.isString(selector.selector) || spec.isSelector(selector.selector)))
-    )
-  }
-  function transformSelector(selector: types.Selector<TSelector>): TSelector {
-    return spec.transformSelector?.(selector) ?? (selector as TSelector)
-  }
-  function splitSelector(selector: types.Selector<TSelector>): types.Selector<TSelector>[] {
-    let current = selector
-    let active = {} as any
-    const path = [active]
-    while (
-      utils.types.has(current, 'selector') &&
-      (utils.types.has(current, 'frame') || utils.types.has(current, 'shadow'))
-    ) {
-      active.selector = current.selector
-      if (current.type) active.type = current.type
-      if (current.frame) {
-        active = {}
-        path.push(active)
-        current = current.frame
-      } else if (current.shadow) {
-        active = active.shadow = {}
-        current = current.shadow
-      }
-    }
-
-    if (spec.isSelector(current) || utils.types.isString(current)) {
-      active.selector = current
-    } else {
-      active.selector = current.selector
-      if (current.type) active.type = current.type
-    }
-    return path
-  }
-
-  async function findRootElement(
-    context: TContext,
-    selector: types.Selector<TSelector>,
-  ): Promise<{root: TElement; selector: types.Selector<TSelector>}> {
-    let root = null as TElement
-    let currentSelector = selector
-    while (utils.types.has(currentSelector, ['selector', 'shadow']) && isSelector(currentSelector.shadow)) {
-      const element = await spec.findElement(context, transformSelector(currentSelector), root)
-      if (!element) break
-      root = await spec.executeScript(context, snippets.getShadowRoot, [element])
-      if (!root) break
-      currentSelector = currentSelector.shadow
-    }
-    return {root, selector: currentSelector}
-  }
-}