testium-driver-wd/lib/browser/_matchers.js

Testium backend powered by wd

/*
 * Copyright (c) 2015, Groupon, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *
 * Neither the name of GROUPON nor the names of its contributors may be
 * used to endorse or promote products derived from this software without
 * specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

'use strict';

const parseUrl = require('url').parse;

const debug = require('debug')('testium-driver-wd:matchers');

const BASIC_URL_PROPERTIES = ['protocol', 'host', 'pathname', 'hash'];

/**
 * @param {string|RegExp} expected
 * @param {string} actual
 * @returns {boolean}
 */
function string(expected, actual) {
  debug('string: %s === %s', expected, actual);
  if (typeof expected === 'string') {
    return expected === actual;
  } else if (expected instanceof RegExp) {
    return expected.test(actual);
  }
  throw new Error(`Invalid assertion: ${expected}`);
}

/**
 * @param {string|RegExp} expected
 * @param {string} actual
 * @returns {boolean}
 */
function fuzzyString(expected, actual) {
  debug('fuzzyString: %s === %s', expected, actual);
  if (expected === '') {
    return actual === '';
  } else if (typeof expected === 'string') {
    return actual.indexOf(expected) !== -1;
  } else if (expected instanceof RegExp) {
    return expected.test(actual);
  }
  throw new Error(`Invalid assertion: ${expected}`);
}

/**
 * @param {string|RegExp|null|undefined} expected
 * @param {string} actual
 * @returns {boolean}
 */
function stringUnlessNull(expected, actual) {
  if (expected == null) {
    debug('skipping: %s === %s', expected, actual);
    return true;
  }
  return string(expected, actual);
}

/**
 * @param {RegExp|string} expectedUrl
 * @param {Record<string, any>} expectedQuery
 * @param {string} actualUrl
 * @returns {boolean}
 */
function url(expectedUrl, expectedQuery, actualUrl) {
  debug('url: %s === %s', expectedUrl, actualUrl, expectedQuery);
  if (expectedUrl instanceof RegExp) {
    return expectedUrl.test(actualUrl);
  }

  const expected = parseUrl(expectedUrl, true);
  Object.assign(expected.query, expectedQuery || {});

  const actual = parseUrl(actualUrl, true);

  const basicsEqual = BASIC_URL_PROPERTIES.every(prop =>
    stringUnlessNull(expected[prop], actual[prop])
  );
  const queryEqual = Object.entries(expected.query).every(([key, value]) =>
    string(value, actual.query[key])
  );

  return basicsEqual && queryEqual;
}

module.exports = {
  fuzzyString,
  string,
  stringUnlessNull,
  url,
};