@instructure/ui-test-utils/es/utils/assertions.js

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2015 - present Instructure, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
import React from 'react';
import { findDOMNode } from 'react-dom';
import { elementToString, wrapQueryResult, isElement, matches } from '@instructure/ui-test-queries';
export default function assertions(chai, utils) {
  const flag = utils.flag,
        inspect = utils.inspect;
  const Assertion = chai.Assertion;

  function wrapObj(obj) {
    if (obj && typeof obj.getDOMNode === 'function') {
      return obj;
    }

    let node;

    if (isElement(obj)) {
      node = obj;
    } else if ( /*#__PURE__*/React.isValidElement(obj)) {
      node = findDOMNode(obj);
    }

    if (node) {
      return wrapQueryResult(node);
    }

    return void 0;
  }

  function addAssertion(name, assertion) {
    if (Assertion.prototype[name]) {
      overwriteMethod(name, assertion);
    } else {
      addMethod(name, assertion);
    }
  }

  function overwriteProperty(name, assertion) {
    Assertion.overwriteProperty(name, function (_super) {
      return wrapOverwriteAssertion(assertion, _super);
    });
  }

  function overwriteMethod(name, assertion) {
    Assertion.overwriteMethod(name, function (_super) {
      return wrapOverwriteAssertion(assertion, _super);
    });
  }

  function addMethod(name, assertion) {
    Assertion.addMethod(name, wrapAssertion(assertion));
  }

  function addChainableMethod(name, assertion) {
    Assertion.addChainableMethod(name, wrapAssertion(assertion));
  }

  function overwriteChainableMethod(name, assertion) {
    Assertion.overwriteChainableMethod(name, function (_super) {
      return wrapOverwriteAssertion(assertion, _super);
    }, function (_super) {
      return function () {
        _super.call(this);
      };
    });
  }

  function wrapOverwriteAssertion(assertion, _super) {
    return function (arg1, arg2) {
      const wrapper = wrapObj(flag(this, 'object'));

      if (!wrapper) {
        // eslint-disable-next-line prefer-rest-params
        return _super.apply(this, arguments);
      }

      assertion.call(this, {
        markup: () => wrapper.toString(),
        sig: inspect(wrapper.getDOMNode()),
        wrapper,
        arg1,
        arg2,
        flag,
        inspect
      });
    };
  }

  function wrapAssertion(assertion) {
    return function (arg1, arg2) {
      const wrapper = wrapObj(flag(this, 'object'));
      const config = {
        wrapper,
        arg1,
        flag,
        inspect
      };

      if (wrapper) {
        config.markup = () => wrapper.toString();

        config.sig = inspect(wrapper.getDOMNode());
      }

      if (arguments.length > 1) {
        config.arg2 = arg2;
      }

      assertion.call(this, config);
    };
  }

  overwriteProperty('not', function () {
    flag(this, 'negate', true);
  });
  addChainableMethod('exactly', function exactly(_ref) {
    let flag = _ref.flag,
        arg1 = _ref.arg1;
    flag(this, 'exactlyCount', arg1);
  });
  addAssertion('text', function text(_ref2) {
    let wrapper = _ref2.wrapper,
        markup = _ref2.markup,
        flag = _ref2.flag,
        arg1 = _ref2.arg1,
        arg2 = _ref2.arg2,
        sig = _ref2.sig;
    const actual = wrapper.text(); // TODO check if this is this never null

    if (typeof arg1 !== 'undefined') {
      if (flag(this, 'contains')) {
        this.assert(actual && actual.indexOf(String(arg1)) > -1, () => `expected ${sig} to contain text #{exp}, but it has #{act} ${markup()}`, () => `expected ${sig} not to contain text #{exp}, but it has #{act} ${markup()}`, arg1, actual);
      } else {
        this.assert(actual && matches(actual, arg1, arg2), () => `expected ${sig} to have text #{exp}, but it has #{act} ${markup()}`, () => `expected ${sig} to not have text #{exp}, but it has #{act} ${markup()}`, arg1, actual);
      }
    }

    flag(this, 'object', actual);
  });
  overwriteChainableMethod('contain', function contain(_ref3) {
    let wrapper = _ref3.wrapper,
        markup = _ref3.markup,
        arg1 = _ref3.arg1,
        sig = _ref3.sig;

    if (arg1) {
      this.assert(wrapper && wrapper.contains(arg1), () => `expected ${sig} to contain ${elementToString(arg1)} ${markup()}`, () => `expected ${sig} to not contain ${elementToString(arg1)} ${markup()}`, arg1);
    }
  });
  addAssertion('className', function className(_ref4) {
    let wrapper = _ref4.wrapper,
        markup = _ref4.markup,
        arg1 = _ref4.arg1,
        sig = _ref4.sig;
    const actual = wrapper.classNames(); // TODO check if this is this never null

    this.assert(wrapper && wrapper.hasClass(arg1), () => `expected ${sig} to have a #{exp} class, but it has #{act} ${markup()}`, () => `expected ${sig} to not have a #{exp} class, but it has #{act} ${markup()}`, arg1, actual);
  });
  addAssertion('match', function match(_ref5) {
    let wrapper = _ref5.wrapper,
        markup = _ref5.markup,
        arg1 = _ref5.arg1,
        sig = _ref5.sig;
    this.assert(wrapper && wrapper.matches(arg1), () => `expected ${sig} to match #{exp} ${markup()}`, () => `expected ${sig} to not match #{exp} ${markup()}`, arg1);
  });
  addAssertion('descendants', listAndCountAssertion('descendants', 'descendants'));
  addAssertion('children', listAndCountAssertion('children', 'children'));
  addAssertion('ancestors', listAndCountAssertion('ancestors', 'ancestors'));
  addAssertion('parents', listAndCountAssertion('parents', 'parents'));
  addAssertion('attribute', propAndValueAssertion('attribute', 'attribute'));
  addAssertion('style', propAndValueAssertion('style', 'computed CSS style'));
  addAssertion('bounds', propAndValueAssertion('bounds', 'bounding client rect'));
  addAssertion('tagName', valueAssertion('tagName', 'tag name'));
  addAssertion('id', valueAssertion('id', 'id'));
  addAssertion('visible', booleanAssertion('visible', 'visible'));
  addAssertion('clickable', booleanAssertion('clickable', 'clickable'));
  addAssertion('focus', booleanAssertion('containsFocus', 'focused or contain the focused element'));
  addAssertion('focused', booleanAssertion('focused', 'focused'));
  addAssertion('focusable', booleanAssertion('focusable', 'focusable'));
  addAssertion('tabbable', booleanAssertion('tabbable', 'tabbable'));
  addAssertion('checked', booleanAssertion('checked', 'checked'));
  addAssertion('selected', booleanAssertion('selected', 'selected'));
  addAssertion('disabled', booleanAssertion('disabled', 'disabled'));
  addAssertion('enabled', booleanAssertion('enabled', 'enabled'));
  addAssertion('readonly', booleanAssertion('readonly', 'readonly'));
  addAssertion('accessible', booleanAssertion('accessible', 'accessible'));
  addAssertion('role', valueAssertion('role', 'role'));
  addAssertion('title', valueAssertion('title', 'title'));
  addAssertion('value', valueAssertion('value', 'value'));
  addAssertion('label', valueAssertion('label', 'label'));
}

function getActual(wrapper, assertion) {
  const methodOrProperty = wrapper ? wrapper[assertion] : void 0;

  if (typeof methodOrProperty === 'function') {
    for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
      args[_key - 2] = arguments[_key];
    }

    return methodOrProperty(...args);
  } else {
    return methodOrProperty;
  }
}

function propAndValueAssertion(assertion, desc) {
  return function (args) {
    const wrapper = args.wrapper,
          markup = args.markup,
          flag = args.flag,
          inspect = args.inspect,
          arg1 = args.arg1,
          arg2 = args.arg2,
          arg3 = args.arg3,
          sig = args.sig;
    const actual = getActual(wrapper, assertion, arg1);

    if (arg2) {
      this.assert(actual && matches(actual, arg2, arg3), () => `expected ${sig} to have a ${inspect(arg1)} ${desc} with the value #{exp}, but the value was #{act} ${markup()}`, () => `expected ${sig} to not have a ${inspect(arg1)} ${desc} with the value #{act} ${markup()}`, arg2, actual);
    } else {
      this.assert(typeof actual !== 'undefined' && actual !== null, () => `expected ${sig} to have a #{exp} ${desc} ${markup()}`, () => `expected ${sig} to not have a #{exp} ${desc} ${markup()}`, arg1, actual);
    }

    flag(this, 'object', actual);
  };
}

function booleanAssertion(assertion, desc) {
  return function (_ref6) {
    let wrapper = _ref6.wrapper,
        markup = _ref6.markup,
        sig = _ref6.sig;
    const actual = getActual(wrapper, assertion);
    this.assert(actual, () => `expected ${sig} to be ${desc} ${markup()}`, () => `expected ${sig} to not be ${desc} ${markup()}`, void 0);
  };
}

function valueAssertion(assertion, desc) {
  return function (_ref7) {
    let wrapper = _ref7.wrapper,
        markup = _ref7.markup,
        arg1 = _ref7.arg1,
        arg2 = _ref7.arg2,
        sig = _ref7.sig;
    const actual = getActual(wrapper, assertion);
    this.assert(matches(actual, arg1, arg2), () => `expected ${sig} to have a #{exp} ${desc}, but it has #{act} ${markup()}`, () => `expected ${sig} to not have a #{exp} ${desc}, but it has #{act} ${markup()}`, arg1, actual);
  };
}

function listAndCountAssertion(assertion, desc) {
  return function (_ref8) {
    let wrapper = _ref8.wrapper,
        markup = _ref8.markup,
        arg1 = _ref8.arg1,
        sig = _ref8.sig,
        flag = _ref8.flag;
    const exactlyCount = flag(this, 'exactlyCount');
    const actual = getActual(wrapper, assertion, arg1);
    const count = actual.length;

    if (exactlyCount || exactlyCount === 0) {
      this.assert(count === exactlyCount, () => `expected ${sig} to have ${exactlyCount} ${desc} #{exp} but actually found ${count} ${markup()}`, () => `expected ${sig} to not have ${exactlyCount} ${desc} #{exp} but actually found ${count} ${markup()}`, arg1);
    } else {
      this.assert(count > 0, () => `expected ${sig} to have ${desc} #{exp} ${markup()}`, () => `expected ${sig} to not have ${desc} #{exp} ${markup()}`, arg1);
    }
  };
}