@hipay/hipay-material-ui 2.3.1-rc4 → 2.3.1-rc5

package/styles/transitions.test.js

@@ -1,208 +0,0 @@
-import { assert } from 'chai';
-import { stub } from 'sinon';
-import transitions, { easing, duration, formatMs, isString, isNumber } from './transitions';
-describe('transitions', function () {
-  var consoleErrorStub;
-  beforeEach(function () {
-    consoleErrorStub = stub(console, 'error');
-  });
-  afterEach(function () {
-    consoleErrorStub.restore();
-  });
-  describe('formatMs() function', function () {
-    it('should round decimal digits and return formatted value', function () {
-      var formattedValue = formatMs(12.125);
-      assert.strictEqual(formattedValue, '12ms');
-    });
-  });
-  describe('isString() function', function () {
-    it('should return false when passed undefined', function () {
-      var value = isString();
-      assert.strictEqual(value, false);
-    });
-    it('should return false when not passed a string', function () {
-      var value = isString(1);
-      assert.strictEqual(value, false);
-      value = isString({});
-      assert.strictEqual(value, false);
-      value = isString([]);
-      assert.strictEqual(value, false);
-    });
-    it('should return true when passed a string', function () {
-      var value = isString('');
-      assert.strictEqual(value, true);
-      value = isString('test');
-      assert.strictEqual(value, true);
-    });
-  });
-  describe('isNumber() function', function () {
-    it('should return false when passed undefined', function () {
-      var value = isNumber();
-      assert.strictEqual(value, false);
-    });
-    it('should return false when not passed a number', function () {
-      var value = isNumber('');
-      assert.strictEqual(value, false);
-      value = isNumber('test');
-      assert.strictEqual(value, false);
-      value = isNumber({});
-      assert.strictEqual(value, false);
-      value = isNumber([]);
-      assert.strictEqual(value, false);
-    });
-    it('should return true when passed a number', function () {
-      var value = isNumber(1);
-      assert.strictEqual(value, true);
-      value = isNumber(1.5);
-      assert.strictEqual(value, true);
-    });
-  });
-  describe('create() function', function () {
-    it('should create default transition without arguments', function () {
-      var transition = transitions.create();
-      assert.strictEqual(transition, "all ".concat(duration.standard, "ms ").concat(easing.easeInOut, " 0ms"));
-      assert.strictEqual(consoleErrorStub.callCount, 0, 'Wrong number of calls of warning()');
-    });
-    it('should take string props as a first argument', function () {
-      var transition = transitions.create('color');
-      assert.strictEqual(transition, "color ".concat(duration.standard, "ms ").concat(easing.easeInOut, " 0ms"));
-      assert.strictEqual(consoleErrorStub.callCount, 0, 'Wrong number of calls of warning()');
-    });
-    it('should also take array of props as first argument', function () {
-      var options = {
-        delay: 20
-      };
-      var multiple = transitions.create(['color', 'size'], options);
-      var single1 = transitions.create('color', options);
-      var single2 = transitions.create('size', options);
-      var expected = "".concat(single1, ",").concat(single2);
-      assert.strictEqual(multiple, expected);
-      assert.strictEqual(consoleErrorStub.callCount, 0, 'Wrong number of calls of warning()');
-    });
-    it('should warn when first argument is of bad type', function () {
-      // $FlowIgnore
-      transitions.create(5554); // $FlowIgnore
-
-      transitions.create({});
-      assert.strictEqual(consoleErrorStub.callCount, 2, 'Wrong number of calls of warning()');
-    });
-    it('should optionally accept number "duration" option in second argument', function () {
-      var transition = transitions.create('font', {
-        duration: 500
-      });
-      assert.strictEqual(transition, "font 500ms ".concat(easing.easeInOut, " 0ms"));
-      assert.strictEqual(consoleErrorStub.callCount, 0, 'Wrong number of calls of warning()');
-    });
-    it('should optionally accept string "duration" option in second argument', function () {
-      var transition = transitions.create('font', {
-        duration: '500ms'
-      });
-      assert.strictEqual(transition, "font 500ms ".concat(easing.easeInOut, " 0ms"));
-      assert.strictEqual(consoleErrorStub.callCount, 0, 'Wrong number of calls of warning()');
-    });
-    it('should round decimal digits of "duration" prop to whole numbers', function () {
-      var transition = transitions.create('font', {
-        duration: 12.125
-      });
-      assert.strictEqual(transition, "font 12ms ".concat(easing.easeInOut, " 0ms"));
-      assert.strictEqual(consoleErrorStub.callCount, 0, 'Wrong number of calls of warning()');
-    });
-    it('should warn when bad "duration" option type', function () {
-      // $FlowIgnore
-      transitions.create('font', {
-        duration: null
-      }); // $FlowIgnore
-
-      transitions.create('font', {
-        duration: {}
-      });
-      assert.strictEqual(consoleErrorStub.callCount, 2, 'Wrong number of calls of warning()');
-    });
-    it('should optionally accept string "easing" option in second argument', function () {
-      var transition = transitions.create('transform', {
-        easing: easing.sharp
-      });
-      assert.strictEqual(transition, "transform ".concat(duration.standard, "ms ").concat(easing.sharp, " 0ms"));
-      assert.strictEqual(consoleErrorStub.callCount, 0, 'Wrong number of calls of warning()');
-    });
-    it('should warn when bad "easing" option type', function () {
-      // $FlowIgnore
-      transitions.create('transform', {
-        easing: 123
-      }); // $FlowIgnore
-
-      transitions.create('transform', {
-        easing: {}
-      });
-      assert.strictEqual(consoleErrorStub.callCount, 2, 'Wrong number of calls of warning()');
-    });
-    it('should optionally accept number "delay" option in second argument', function () {
-      var transition = transitions.create('size', {
-        delay: 150
-      });
-      assert.strictEqual(transition, "size ".concat(duration.standard, "ms ").concat(easing.easeInOut, " 150ms"));
-      assert.strictEqual(consoleErrorStub.callCount, 0, 'Wrong number of calls of warning()');
-    });
-    it('should optionally accept string "delay" option in second argument', function () {
-      var transition = transitions.create('size', {
-        delay: '150ms'
-      });
-      assert.strictEqual(transition, "size ".concat(duration.standard, "ms ").concat(easing.easeInOut, " 150ms"));
-      assert.strictEqual(consoleErrorStub.callCount, 0, 'Wrong number of calls of warning()');
-    });
-    it('should round decimal digits of "delay" prop to whole numbers', function () {
-      var transition = transitions.create('size', {
-        delay: 1.547
-      });
-      assert.strictEqual(transition, "size ".concat(duration.standard, "ms ").concat(easing.easeInOut, " 2ms"));
-      assert.strictEqual(consoleErrorStub.callCount, 0, 'Wrong number of calls of warning()');
-    });
-    it('should warn when bad "delay" option type', function () {
-      // $FlowIgnore
-      transitions.create('size', {
-        delay: null
-      }); // $FlowIgnore
-
-      transitions.create('size', {
-        delay: {}
-      });
-      assert.strictEqual(consoleErrorStub.callCount, 2, 'Wrong number of calls of warning()');
-    });
-    it('should warn when passed unrecognized option', function () {
-      transitions.create('size', {
-        fffds: 'value'
-      });
-      assert.strictEqual(consoleErrorStub.callCount, 1, 'Wrong number of calls of warning()');
-    });
-    it('should return zero when not passed arguments', function () {
-      var zeroHeightDuration = transitions.getAutoHeightDuration();
-      assert.strictEqual(zeroHeightDuration, 0);
-    });
-    it('should return zero when passed undefined', function () {
-      var zeroHeightDuration = transitions.getAutoHeightDuration(undefined);
-      assert.strictEqual(zeroHeightDuration, 0);
-    });
-    it('should return zero when passed null', function () {
-      var zeroHeightDuration = transitions.getAutoHeightDuration(null);
-      assert.strictEqual(zeroHeightDuration, 0);
-    });
-    it('should return NaN when passed a negative number', function () {
-      var zeroHeightDurationNegativeOne = transitions.getAutoHeightDuration(-1);
-      assert.strictEqual(Number.isNaN(zeroHeightDurationNegativeOne), true);
-      var zeroHeightDurationSmallNegative = transitions.getAutoHeightDuration(-0.000001);
-      assert.strictEqual(Number.isNaN(zeroHeightDurationSmallNegative), true);
-      var zeroHeightDurationBigNegative = transitions.getAutoHeightDuration(-100000);
-      assert.strictEqual(Number.isNaN(zeroHeightDurationBigNegative), true);
-    });
-    it('should return values for pre-calculated positive examples', function () {
-      var zeroHeightDuration = transitions.getAutoHeightDuration(14);
-      assert.strictEqual(zeroHeightDuration, 159);
-      zeroHeightDuration = transitions.getAutoHeightDuration(100);
-      assert.strictEqual(zeroHeightDuration, 239);
-      zeroHeightDuration = transitions.getAutoHeightDuration(0.0001);
-      assert.strictEqual(zeroHeightDuration, 46);
-      zeroHeightDuration = transitions.getAutoHeightDuration(100000);
-      assert.strictEqual(zeroHeightDuration, 6685);
-    });
-  });
-});

package/test-utils/until.test.js

@@ -1,157 +0,0 @@
-import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
-import _inherits from "@babel/runtime/helpers/esm/inherits";
-import assert from 'assert';
-import React from 'react';
-import PropTypes from 'prop-types';
-import { shallow } from 'enzyme';
-import until from './until';
-
-var Div = function Div() {
-  return React.createElement("div", null);
-};
-
-var hoc = function hoc(Component) {
-  return function () {
-    return React.createElement(Component, null);
-  };
-};
-
-describe('until', function () {
-  it('shallow renders the current wrapper one level deep', function () {
-    var EnhancedDiv = hoc(Div);
-    var wrapper = until.call(shallow(React.createElement(EnhancedDiv, null)), 'Div');
-    assert.strictEqual(wrapper.contains(React.createElement("div", null)), true);
-  });
-  it('shallow renders the current wrapper several levels deep', function () {
-    var EnhancedDiv = hoc(hoc(hoc(Div)));
-    var wrapper = until.call(shallow(React.createElement(EnhancedDiv, null)), 'Div');
-    assert.strictEqual(wrapper.contains(React.createElement("div", null)), true);
-  });
-  it('stops shallow rendering when the wrapper is empty', function () {
-    var nullHoc = function nullHoc() {
-      return function () {
-        return null;
-      };
-    };
-
-    var EnhancedDiv = nullHoc();
-    var wrapper = until.call(shallow(React.createElement(EnhancedDiv, null)), 'Div');
-    assert.strictEqual(wrapper.html(), null);
-  });
-  it('shallow renders as much as possible when no selector is provided', function () {
-    var EnhancedDiv = hoc(hoc(Div));
-    var wrapper = until.call(shallow(React.createElement(EnhancedDiv, null)));
-    assert.strictEqual(wrapper.contains(React.createElement("div", null)), true);
-  });
-  it('shallow renders the current wrapper even if the selector never matches', function () {
-    var EnhancedDiv = hoc(Div);
-    var wrapper = until.call(shallow(React.createElement(EnhancedDiv, null)), 'NotDiv');
-    assert.strictEqual(wrapper.contains(React.createElement("div", null)), true);
-  });
-  it('stops shallow rendering when it encounters a DOM element', function () {
-    var wrapper = until.call(shallow(React.createElement("div", null, React.createElement(Div, null))), 'Div');
-    assert.strictEqual(wrapper.contains(React.createElement("div", null, React.createElement(Div, null))), true);
-  });
-  it('throws when assert.strictEqual called on an empty wrapper', function () {
-    assert.throws(function () {
-      until.call(shallow(React.createElement(Div, null)).find('Foo'), 'div');
-    }, Error, 'Method “until” is only meant to be run on a single node. 0 found instead.');
-  });
-  it('shallow renders non-root wrappers', function () {
-    var Container = function Container() {
-      return React.createElement("div", null, React.createElement(Div, null));
-    };
-
-    var wrapper = until.call(shallow(React.createElement(Container, null)).find(Div));
-    assert.strictEqual(wrapper.contains(React.createElement("div", null)), true);
-  }); // eslint-disable-next-line react/prefer-stateless-function
-
-  var Foo =
-  /*#__PURE__*/
-  function (_React$Component) {
-    _inherits(Foo, _React$Component);
-
-    function Foo() {
-      _classCallCheck(this, Foo);
-
-      return _possibleConstructorReturn(this, _getPrototypeOf(Foo).apply(this, arguments));
-    }
-
-    _createClass(Foo, [{
-      key: "render",
-      value: function render() {
-        return React.createElement(Div, null);
-      }
-    }]);
-
-    return Foo;
-  }(React.Component);
-
-  Foo.contextTypes = {
-    quux: PropTypes.bool.isRequired
-  };
-  it('context propagation passes down context from the root component', function () {
-    var EnhancedFoo = hoc(Foo);
-    var options = {
-      context: {
-        quux: true
-      }
-    };
-    var wrapper = until.call(shallow(React.createElement(EnhancedFoo, null), options), 'Foo', options);
-    assert.strictEqual(wrapper.context('quux'), true);
-    assert.strictEqual(wrapper.contains(React.createElement(Div, null)), true);
-  }); // eslint-disable-next-line react/no-multi-comp
-
-  var Bar =
-  /*#__PURE__*/
-  function (_React$Component2) {
-    _inherits(Bar, _React$Component2);
-
-    function Bar() {
-      var _getPrototypeOf2;
-
-      var _this;
-
-      _classCallCheck(this, Bar);
-
-      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-        args[_key] = arguments[_key];
-      }
-
-      _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(Bar)).call.apply(_getPrototypeOf2, [this].concat(args)));
-
-      _defineProperty(_assertThisInitialized(_this), "getChildContext", function () {
-        return {
-          quux: true
-        };
-      });
-
-      return _this;
-    }
-
-    _createClass(Bar, [{
-      key: "render",
-      value: function render() {
-        return React.createElement(Foo, null);
-      }
-    }]);
-
-    return Bar;
-  }(React.Component);
-
-  _defineProperty(Bar, "childContextTypes", {
-    quux: PropTypes.bool
-  });
-
-  it('context propagation passes down context from an intermediary component', function () {
-    var EnhancedBar = hoc(Bar);
-    var wrapper = until.call(shallow(React.createElement(EnhancedBar, null)), 'Foo');
-    assert.strictEqual(wrapper.context('quux'), true);
-    assert.strictEqual(wrapper.contains(React.createElement(Div, null)), true);
-  });
-});

package/withMobileDialog/withMobileDialog.test.js

@@ -1,67 +0,0 @@
-import React from 'react';
-import { assert } from 'chai';
-import { createShallow, getClasses } from '../test-utils';
-import Paper from '@material-ui/core/Paper';
-import Dialog from '@material-ui/core/Dialog';
-import withMobileDialog from './withMobileDialog';
-describe('withMobileDialog', function () {
-  var shallow;
-  var classes;
-  var defaultProps = {
-    open: false
-  };
-  before(function () {
-    shallow = createShallow({
-      untilSelector: 'Dialog'
-    });
-    classes = getClasses(React.createElement(Dialog, defaultProps, "foo"));
-  });
-
-  function isFullScreen(breakpoints, width) {
-    breakpoints.forEach(function (breakpoint) {
-      it("is for width: ".concat(width, " <= ").concat(breakpoint), function () {
-        var ResponsiveDialog = withMobileDialog({
-          breakpoint: breakpoint
-        })(Dialog);
-        var wrapper = shallow(React.createElement(ResponsiveDialog, Object.assign({}, defaultProps, {
-          width: width
-        }), "foo"));
-        assert.strictEqual(wrapper.find(Paper).hasClass(classes.paperFullScreen), true);
-      });
-    });
-  }
-
-  function isNotFullScreen(breakpoints, width) {
-    breakpoints.forEach(function (breakpoint) {
-      it("is not for width: ".concat(width, " > ").concat(breakpoint), function () {
-        var ResponsiveDialog = withMobileDialog({
-          breakpoint: breakpoint
-        })(Dialog);
-        var wrapper = shallow(React.createElement(ResponsiveDialog, Object.assign({}, defaultProps, {
-          width: width
-        }), "foo"));
-        assert.strictEqual(wrapper.find(Paper).hasClass(classes.paperFullScreen), false);
-      });
-    });
-  }
-
-  describe('screen width: xs', function () {
-    isFullScreen(['xs', 'sm', 'md', 'lg', 'xl'], 'xs');
-  });
-  describe('screen width: sm (default)', function () {
-    isFullScreen(['sm', 'md', 'lg', 'xl'], 'sm');
-    isNotFullScreen(['xs'], 'sm');
-  });
-  describe('screen width: md', function () {
-    isFullScreen(['md', 'lg', 'xl'], 'md');
-    isNotFullScreen(['xs', 'sm'], 'md');
-  });
-  describe('screen width: lg', function () {
-    isFullScreen(['lg', 'xl'], 'lg');
-    isNotFullScreen(['xs', 'sm', 'md'], 'lg');
-  });
-  describe('screen width: xl', function () {
-    isFullScreen(['xl'], 'xl');
-    isNotFullScreen(['xs', 'sm', 'md', 'lg'], 'xl');
-  });
-});