rails-assets-enzyme 0.0.1

data/vendor/assets/javascripts/Utils.js

@@ -0,0 +1,266 @@
+/* eslint no-use-before-define:0 */
+import isEqual from 'lodash/isEqual';
+import {
+  isDOMComponent,
+  findDOMNode,
+  childrenToArray,
+} from './react-compat';
+import {
+  REACT013,
+  REACT15,
+} from './version';
+
+function internalInstanceKey(node) {
+  return Object.keys(Object(node)).filter(key => key.match(/^__reactInternalInstance\$/))[0];
+}
+
+export function internalInstance(inst) {
+  return inst._reactInternalInstance ||
+    inst[internalInstanceKey(inst)];
+}
+
+export function isFunctionalComponent(inst) {
+  return inst && inst.constructor && inst.constructor.name === 'StatelessComponent';
+}
+
+export function propsOfNode(node) {
+  if (REACT013 && node && node._store) {
+    return (node._store.props) || {};
+  }
+  if (node && node._reactInternalComponent && node._reactInternalComponent._currentElement) {
+    return (node._reactInternalComponent._currentElement.props) || {};
+  }
+  if (node && node._currentElement) {
+    return (node._currentElement.props) || {};
+  }
+  if (REACT15 && node) {
+    if (internalInstance(node) && internalInstance(node)._currentElement) {
+      return (internalInstance(node)._currentElement.props) || {};
+    }
+  }
+
+  return (node && node.props) || {};
+}
+
+export function typeOfNode(node) {
+  return node ? node.type : null;
+}
+
+export function getNode(node) {
+  return isDOMComponent(node) ? findDOMNode(node) : node;
+}
+
+export function nodeHasType(node, type) {
+  if (!type || !node) return false;
+  if (!node.type) return false;
+  if (typeof node.type === 'string') return node.type === type;
+  return node.type.name === type || node.type.displayName === type;
+}
+
+export function childrenEqual(a, b) {
+  if (a === b) return true;
+  if (!Array.isArray(a) && !Array.isArray(b)) {
+    return nodeEqual(a, b);
+  }
+  if (!a && !b) return true;
+  if (a.length !== b.length) return false;
+  if (a.length === 0 && b.length === 0) return true;
+  for (let i = 0; i < a.length; i++) {
+    if (!nodeEqual(a[i], b[i])) return false;
+  }
+  return true;
+}
+
+export function nodeEqual(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  if (a.type !== b.type) return false;
+  const left = propsOfNode(a);
+  const leftKeys = Object.keys(left);
+  const right = propsOfNode(b);
+  for (let i = 0; i < leftKeys.length; i++) {
+    const prop = leftKeys[i];
+    if (!(prop in right)) return false;
+    if (prop === 'children') {
+      if (!childrenEqual(childrenToArray(left.children), childrenToArray(right.children))) {
+        return false;
+      }
+    } else if (right[prop] === left[prop]) {
+      // continue;
+    } else if (typeof right[prop] === typeof left[prop] && typeof left[prop] === 'object') {
+      if (!isEqual(left[prop], right[prop])) return false;
+    } else {
+      return false;
+    }
+  }
+
+  if (typeof a !== 'string' && typeof a !== 'number') {
+    return leftKeys.length === Object.keys(right).length;
+  }
+
+  return false;
+}
+
+export function containsChildrenSubArray(match, node, subArray) {
+  const children = childrenOfNode(node);
+  const checker = (_, i) => arraysEqual(match, children.slice(i, i + subArray.length), subArray);
+  return children.some(checker);
+}
+
+function arraysEqual(match, left, right) {
+  return left.length === right.length && left.every((el, i) => match(el, right[i]));
+}
+
+function childrenOfNode(node) {
+  const props = propsOfNode(node);
+  const { children } = props;
+  return childrenToArray(children);
+}
+
+
+// 'click' => 'onClick'
+// 'mouseEnter' => 'onMouseEnter'
+export function propFromEvent(event) {
+  const nativeEvent = mapNativeEventNames(event);
+  return `on${nativeEvent[0].toUpperCase()}${nativeEvent.substring(1)}`;
+}
+
+export function withSetStateAllowed(fn) {
+  // NOTE(lmr):
+  // this is currently here to circumvent a React bug where `setState()` is
+  // not allowed without global being defined.
+  let cleanup = false;
+  if (typeof global.document === 'undefined') {
+    cleanup = true;
+    global.document = {};
+  }
+  fn();
+  if (cleanup) {
+    delete global.document;
+  }
+}
+
+export function splitSelector(selector) {
+  return selector.split(/(?=\.|\[.*\])/);
+}
+
+export function isSimpleSelector(selector) {
+  // any of these characters pretty much guarantee it's a complex selector
+  return !/[~\s:>]/.test(selector);
+}
+
+export function selectorError(selector) {
+  return new TypeError(
+    `Enzyme received a complex CSS selector ('${selector}') that it does not currently support`
+  );
+}
+
+export const isCompoundSelector = /([a-z]\.[a-z]|[a-z]\[.*\])/i;
+
+const isPropSelector = /^\[.*\]$/;
+
+export const SELECTOR = {
+  CLASS_TYPE: 0,
+  ID_TYPE: 1,
+  PROP_TYPE: 2,
+};
+
+export function selectorType(selector) {
+  if (selector[0] === '.') {
+    return SELECTOR.CLASS_TYPE;
+  } else if (selector[0] === '#') {
+    return SELECTOR.ID_TYPE;
+  } else if (isPropSelector.test(selector)) {
+    return SELECTOR.PROP_TYPE;
+  }
+  return undefined;
+}
+
+export function AND(fns) {
+  return x => {
+    let i = fns.length;
+    while (i--) {
+      if (!fns[i](x)) return false;
+    }
+    return true;
+  };
+}
+
+export function coercePropValue(propName, propValue) {
+  // can be undefined
+  if (propValue === undefined) {
+    return propValue;
+  }
+
+  const trimmedValue = propValue.trim();
+
+  // if propValue includes quotes, it should be
+  // treated as a string
+  if (/^(['"]).*\1$/.test(trimmedValue)) {
+    return trimmedValue.slice(1, -1);
+  }
+
+  const numericPropValue = +trimmedValue;
+
+  // if parseInt is not NaN, then we've wanted a number
+  if (!isNaN(numericPropValue)) {
+    return numericPropValue;
+  }
+
+  // coerce to boolean
+  if (trimmedValue === 'true') return true;
+  if (trimmedValue === 'false') return false;
+
+  // user provided an unquoted string value
+  throw new TypeError(
+    `Enzyme::Unable to parse selector '[${propName}=${propValue}]'. ` +
+    `Perhaps you forgot to escape a string? Try '[${propName}="${trimmedValue}"]' instead.`
+  );
+}
+
+export function mapNativeEventNames(event) {
+  const nativeToReactEventMap = {
+    compositionend: 'compositionEnd',
+    compositionstart: 'compositionStart',
+    compositionupdate: 'compositionUpdate',
+    keydown: 'keyDown',
+    keyup: 'keyUp',
+    keypress: 'keyPress',
+    contextmenu: 'contextMenu',
+    dblclick: 'doubleClick',
+    doubleclick: 'doubleClick', // kept for legacy. TODO: remove with next major.
+    dragend: 'dragEnd',
+    dragenter: 'dragEnter',
+    dragexist: 'dragExit',
+    dragleave: 'dragLeave',
+    dragover: 'dragOver',
+    dragstart: 'dragStart',
+    mousedown: 'mouseDown',
+    mousemove: 'mouseMove',
+    mouseout: 'mouseOut',
+    mouseover: 'mouseOver',
+    mouseup: 'mouseUp',
+    touchcancel: 'touchCancel',
+    touchend: 'touchEnd',
+    touchmove: 'touchMove',
+    touchstart: 'touchStart',
+    canplay: 'canPlay',
+    canplaythrough: 'canPlayThrough',
+    durationchange: 'durationChange',
+    loadeddata: 'loadedData',
+    loadedmetadata: 'loadedMetadata',
+    loadstart: 'loadStart',
+    ratechange: 'rateChange',
+    timeupdate: 'timeUpdate',
+    volumechange: 'volumeChange',
+  };
+
+  if (!REACT013) {
+    // these could not be simulated in React 0.13:
+    // https://github.com/facebook/react/issues/1297
+    nativeToReactEventMap.mouseenter = 'mouseEnter';
+    nativeToReactEventMap.mouseleave = 'mouseLeave';
+  }
+
+  return nativeToReactEventMap[event] || event;
+}

data/vendor/assets/javascripts/index.js

@@ -0,0 +1,14 @@
+import ReactWrapper from './ReactWrapper';
+import ShallowWrapper from './ShallowWrapper';
+
+import mount from './mount';
+import shallow from './shallow';
+import render from './render';
+
+export {
+  render,
+  shallow,
+  mount,
+  ShallowWrapper,
+  ReactWrapper,
+};

data/vendor/assets/javascripts/mount.js

@@ -0,0 +1,11 @@
+import ReactWrapper from './ReactWrapper';
+
+/**
+ * Mounts and renders a react component into the document and provides a testing wrapper around it.
+ *
+ * @param node
+ * @returns {ReactWrapper}
+ */
+export default function mount(node, options) {
+  return new ReactWrapper(node, null, options);
+}

data/vendor/assets/javascripts/react-compat.js

@@ -0,0 +1,166 @@
+/* eslint react/no-deprecated: 0 */
+import { REACT013 } from './version';
+import objectAssign from 'object.assign';
+
+let TestUtils;
+let createShallowRenderer;
+let renderToStaticMarkup;
+let renderIntoDocument;
+let findDOMNode;
+let childrenToArray;
+let renderWithOptions;
+let unmountComponentAtNode;
+
+const React = require('react');
+
+if (REACT013) {
+  renderToStaticMarkup = React.renderToStaticMarkup;
+  /* eslint-disable react/no-deprecated */
+  findDOMNode = React.findDOMNode;
+  unmountComponentAtNode = React.unmountComponentAtNode;
+  /* eslint-enable react/no-deprecated */
+  TestUtils = require('react/addons').addons.TestUtils;
+  const ReactContext = require('react/lib/ReactContext');
+
+  // Shallow rendering in 0.13 did not properly support context. This function provides a shim
+  // around `TestUtils.createRenderer` that instead returns a ShallowRenderer that actually
+  // works with context. See https://github.com/facebook/react/issues/3721 for more details.
+  createShallowRenderer = function createRendererCompatible() {
+    const renderer = TestUtils.createRenderer();
+    renderer.render = (originalRender => function contextCompatibleRender(node, context = {}) {
+      ReactContext.current = context;
+      originalRender.call(this, React.createElement(node.type, node.props), context);
+      ReactContext.current = {};
+      return renderer.getRenderOutput();
+    })(renderer.render);
+    return renderer;
+  };
+  renderIntoDocument = TestUtils.renderIntoDocument;
+  // this fixes some issues in React 0.13 with setState and jsdom...
+  // see issue: https://github.com/airbnb/enzyme/issues/27
+  require('react/lib/ExecutionEnvironment').canUseDOM = true;
+
+  // in 0.13, a Children.toArray function was not exported. Make our own instead.
+  childrenToArray = (children) => {
+    const results = [];
+    if (children !== undefined && children !== null && children !== false) {
+      React.Children.forEach(children, (el) => {
+        if (el !== undefined && el !== null && el !== false) {
+          results.push(el);
+        }
+      });
+    }
+    return results;
+  };
+
+  renderWithOptions = (node, options) => {
+    if (options.attachTo) {
+      return React.render(node, options.attachTo);
+    }
+    return TestUtils.renderIntoDocument(node);
+  };
+} else {
+  let ReactDOM;
+
+  try {
+    ReactDOM = require('react-dom');
+  } catch (e) {
+    console.error(
+      'react-dom is an implicit dependency in order to support react@0.13-14. ' +
+      'Please add the appropriate version to your devDependencies. ' +
+      'See https://github.com/airbnb/enzyme#installation'
+    );
+    throw e;
+  }
+
+  renderToStaticMarkup = require('react-dom/server').renderToStaticMarkup;
+  findDOMNode = ReactDOM.findDOMNode;
+  unmountComponentAtNode = ReactDOM.unmountComponentAtNode;
+  // We require the testutils, but they don't come with 0.14 out of the box, so we
+  // require them here through this node module. The bummer is that we are not able
+  // to list this as a dependency in package.json and have 0.13 work properly.
+  // As a result, right now this is basically an implicit dependency.
+  try {
+    TestUtils = require('react-addons-test-utils');
+  } catch (e) {
+    console.error(
+      'react-addons-test-utils is an implicit dependency in order to support react@0.13-14. ' +
+      'Please add the appropriate version to your devDependencies. ' +
+      'See https://github.com/airbnb/enzyme#installation'
+    );
+    throw e;
+  }
+
+  // Shallow rendering changed from 0.13 => 0.14 in such a way that
+  // 0.14 now does not allow shallow rendering of native DOM elements.
+  // This is mainly because the result of such a call should not realistically
+  // be any different than the JSX you passed in (result of `React.createElement`.
+  // In order to maintain the same behavior across versions, this function
+  // is essentially a replacement for `TestUtils.createRenderer` that doesn't use
+  // shallow rendering when it's just a DOM element.
+  createShallowRenderer = function createRendererCompatible() {
+    const renderer = TestUtils.createRenderer();
+    const originalRender = renderer.render;
+    const originalRenderOutput = renderer.getRenderOutput;
+    let isDOM = false;
+    let _node;
+    return objectAssign(renderer, {
+      render(node, context) {
+        /* eslint consistent-return: 0 */
+        if (typeof node.type === 'string') {
+          isDOM = true;
+          _node = node;
+        } else {
+          isDOM = false;
+          return originalRender.call(this, node, context);
+        }
+      },
+      getRenderOutput() {
+        if (isDOM) {
+          return _node;
+        }
+        return originalRenderOutput.call(this);
+      },
+    });
+  };
+  renderIntoDocument = TestUtils.renderIntoDocument;
+  childrenToArray = React.Children.toArray;
+
+  renderWithOptions = (node, options) => {
+    if (options.attachTo) {
+      return ReactDOM.render(node, options.attachTo);
+    }
+    return TestUtils.renderIntoDocument(node);
+  };
+}
+
+const {
+  mockComponent,
+  isElement,
+  isElementOfType,
+  isDOMComponent,
+  isCompositeComponent,
+  isCompositeComponentWithType,
+  isCompositeComponentElement,
+  Simulate,
+  findAllInRenderedTree,
+} = TestUtils;
+
+export {
+  createShallowRenderer,
+  renderToStaticMarkup,
+  renderIntoDocument,
+  mockComponent,
+  isElement,
+  isElementOfType,
+  isDOMComponent,
+  isCompositeComponent,
+  isCompositeComponentWithType,
+  isCompositeComponentElement,
+  Simulate,
+  findDOMNode,
+  findAllInRenderedTree,
+  childrenToArray,
+  renderWithOptions,
+  unmountComponentAtNode,
+};