react-morning 0.0.1-security → 1.0.9

package/test/fixtures/textField.json

@@ -0,0 +1,30 @@
+{
+  "input": true,
+  "tableView": true,
+  "inputType": "text",
+  "inputMask": "",
+  "label": "My Textfield",
+  "key": "myTextfield",
+  "placeholder": "",
+  "prefix": "",
+  "suffix": "",
+  "multiple": false,
+  "defaultValue": "",
+  "protected": false,
+  "unique": false,
+  "persistent": true,
+  "validate": {
+    "required": false,
+    "minLength": "",
+    "maxLength": "",
+    "pattern": "",
+    "custom": "",
+    "customPrivate": false
+  },
+  "conditional": {
+    "show": null,
+    "when": null,
+    "eq": ""
+  },
+  "type": "textfield"
+}

package/test/fixtures/visible.json

@@ -0,0 +1,57 @@
+[
+  {
+    "input": true,
+    "inputType": "checkbox",
+    "tableView": true,
+    "hideLabel": true,
+    "label": "Visible",
+    "datagridLabel": true,
+    "key": "visible",
+    "defaultValue": false,
+    "protected": false,
+    "persistent": true,
+    "clearOnHide": true,
+    "validate": {
+      "required": false
+    },
+    "type": "checkbox",
+    "tags": [],
+    "conditional": {
+      "show": "",
+      "when": null,
+      "eq": ""
+    }
+  },
+  {
+    "input": true,
+    "tableView": true,
+    "inputType": "text",
+    "inputMask": "",
+    "label": "Textfield",
+    "key": "textfield",
+    "placeholder": "",
+    "prefix": "",
+    "suffix": "",
+    "multiple": false,
+    "defaultValue": "",
+    "protected": false,
+    "unique": false,
+    "persistent": true,
+    "clearOnHide": true,
+    "validate": {
+      "required": true,
+      "minLength": "",
+      "maxLength": "",
+      "pattern": "",
+      "custom": "",
+      "customPrivate": false
+    },
+    "conditional": {
+      "show": "true",
+      "when": "visible",
+      "eq": "true"
+    },
+    "type": "textfield",
+    "tags": []
+  }
+]

package/test/index.js

@@ -0,0 +1,2 @@
+const testsContext = require.context('.', true, /\.spec\.js$/);
+testsContext.keys().forEach(testsContext);

package/test/utils.js

@@ -0,0 +1,87 @@
+import ReactDOM from 'react-dom';
+import {mount as enzymeMount} from './enzyme';
+
+const WAIT = 1000;
+
+export function autoreject(msg, fn) {
+  if (typeof msg === 'function') {
+    fn = msg;
+    msg = `Timeout of ${WAIT}ms exceeded.`;
+  }
+
+  return new Promise((resolve, reject) => {
+    setTimeout(
+      () => reject(new Error(msg)),
+      WAIT
+    );
+    fn(resolve);
+  });
+}
+
+// Generate an enhanced mount function.
+export function createMount(options1 = {}) {
+  const {mount = enzymeMount, ...other1} = options1;
+
+  const attachTo = window.document.createElement('div');
+  attachTo.className = 'app';
+  attachTo.setAttribute('id', 'app');
+  window.document.body.insertBefore(attachTo, window.document.body.firstChild);
+
+  const mountWithContext = function mountWithContext(node, options2 = {}) {
+    return mount(node, {
+      attachTo,
+      ...other1,
+      ...options2,
+    });
+  };
+
+  mountWithContext.attachTo = attachTo;
+  let n = 1;
+  mountWithContext.cleanUp = () => {
+    if (n === 0) { debugger } else {
+      n -= 1;
+    }
+    ReactDOM.unmountComponentAtNode(attachTo);
+    attachTo.parentNode.removeChild(attachTo);
+  };
+
+  return mountWithContext;
+}
+
+export function createIfExceed() {
+  let sub = null;
+  const ifexceed = (msg, fn) => {
+    return autoreject(msg, resolve => {
+      sub = () => {
+        if (fn.length > 0) {
+          fn(resolve);
+        }
+        else {
+          fn();
+          resolve();
+        }
+      };
+    });
+  };
+  const notify = () => {
+    if (typeof sub === 'function') {
+      sub();
+      sub = null;
+    }
+  };
+
+  return {ifexceed, notify};
+}
+
+export function seq(fns) {
+  const [init, ...tail] = fns;
+
+  return tail.reduce((promise, fn) => promise.then(fn), init());
+}
+
+export default {
+  autoreject,
+  createMount,
+  createIfExceed,
+  seq,
+};

package/test/validation.spec.js

@@ -0,0 +1,130 @@
+import EventEmitter from 'eventemitter2';
+import React from 'react';
+import sinon from 'sinon';
+import {expect} from 'chai';
+import Form from '../src/components/Form';
+import {
+  textField,
+  visible,
+  layout,
+  columns
+} from './fixtures';
+
+import {
+  createIfExceed,
+  createMount,
+  seq
+} from './utils';
+
+describe('Form component', function() {
+  let mount;
+  let options;
+
+  beforeEach(() => {
+    options = {
+      events: new EventEmitter({
+        wildcard: false,
+        maxListeners: 0
+      })
+    };
+    mount = createMount();
+  });
+
+  afterEach(() => {
+    options.events.removeAllListeners();
+    mount.cleanUp();
+  });
+
+  it('should create valid form.', function() {
+    const element = mount(
+      <Form
+        form={{display: 'form', components: [textField]}}
+        options={options}
+      />);
+    return element
+      .instance()
+      .createPromise
+      .then(formio => {
+        expect(formio).to.be.an('object');
+        expect(formio.isValid()).to.be.true;
+      });
+  });
+
+  it('should validate on submit.', function() {
+    const field = Object.assign({}, textField);
+    field.validate = Object.assign({}, textField.validate, {required: true});
+    const element = mount(
+      <Form
+        form={{display: 'form', components: [field]}}
+        options={options}
+      />);
+    return element
+      .instance()
+      .createPromise
+      .then(formio => {
+        expect(formio).to.be.an('object');
+        return formio.submit()
+          .catch(([err]) => {
+            return expect(err.message).to.equal('My Textfield is required');
+          });
+      });
+  });
+
+  it('should validate on change.', function() {
+    let input;
+    let element;
+    let root;
+    let formio;
+    const {ifexceed, notify} = createIfExceed();
+    const onchange = sinon.spy(notify);
+    const field = Object.assign({}, textField);
+    field.validate = Object.assign({}, textField.validate, {required: true});
+    return seq([
+      () => {
+        element = mount(
+          <Form
+            form={{display: 'form', components: [field]}}
+            options={options}
+            onChange={onchange}
+          />);
+        return element
+          .instance()
+          .createPromise
+          .then(_formio => {
+            formio = _formio;
+            expect(formio).to.be.an('object');
+            expect(formio.isValid()).to.be.true;
+          });
+      },
+      () => ifexceed('fail on init change.', () => {
+        expect(onchange.callCount).to.equal(1);
+      }),
+      () => {
+        root = element.getDOMNode();
+        input = root.querySelector('input[type="text"]');
+        input.value = 'x';
+        input.dispatchEvent(new Event('input'));
+        return ifexceed('fail on input change.', () => {
+          expect(onchange.callCount).to.equal(2);
+          expect(formio.isValid()).to.be.true;
+        });
+      },
+      () => {
+        input.value = '';
+        input.dispatchEvent(new Event('input'));
+        return ifexceed('fail on input change.', () => {
+          expect(onchange.callCount).to.equal(3);
+          expect(formio.isValid()).to.be.false;
+        });
+      },
+      () => {
+        input.value = 'y';
+        input.dispatchEvent(new Event('input'));
+        return ifexceed('fail on input change.', () => {
+          expect(onchange.callCount).to.equal(4);
+          expect(formio.isValid()).to.be.true;
+        });
+      }
+    ]);
+  });
+});