Merge branch 'dev' of https://github.com/artf/grapesjs into dev

package.json

@@ -97,6 +97,9 @@
     "modulePaths": [
       "./src"
     ],
+    "testMatch": [
+      "<rootDir>/test/specs/**/*.js"
+    ],
     "setupFiles": [
       "<rootDir>/test/setup.js"
     ],

test/main.test.js

@@ -1,28 +0,0 @@
-import grapesjs from './../src';
-
-describe('Main', () => {
-  describe('Startup', () => {
-    test('Main object should be loaded', () => {
-      expect(grapesjs).toBeTruthy();
-    });
-  });
-
-  const path = './specs/';
-  require(`${path}keymaps`);
-  require(`${path}asset_manager`);
-  require(`${path}block_manager`);
-  require(`${path}code_manager`);
-  require(`${path}commands`);
-  require(`${path}css_composer`);
-  require(`${path}device_manager`);
-  require(`${path}dom_components`);
-  require(`${path}modal`);
-  require(`${path}panels`);
-  require(`${path}parser`);
-  require(`${path}plugin_manager`);
-  require(`${path}selector_manager`);
-  require(`${path}storage_manager`);
-  require(`${path}style_manager`);
-  require(`${path}trait_manager`);
-  require(`${path}grapesjs`);
-});

test/specs/asset_manager/index.js

@@ -114,13 +114,4 @@ describe('Asset Manager', () => {
       });
     });
   });
-
-  require('./model/Asset').run();
-  require('./model/AssetImage').run();
-  require('./model/Assets').run();
-
-  require('./view/AssetView').run();
-  require('./view/AssetImageView').run();
-  require('./view/AssetsView').run();
-  require('./view/FileUploader').run();
 });

test/specs/asset_manager/model/Asset.js

@@ -1,33 +1,29 @@
 import Asset from 'asset_manager/model/Asset';
 
-module.exports = {
-  run() {
-    describe('Asset', () => {
-      test('Object exists', () => {
-        expect(Asset).toBeTruthy();
-      });
+describe('Asset', () => {
+  test('Object exists', () => {
+    expect(Asset).toBeTruthy();
+  });
 
-      test('Has default values', () => {
-        var obj = new Asset({});
-        expect(obj.get('type')).toBeFalsy();
-        expect(obj.get('src')).toBeFalsy();
-        expect(obj.getExtension()).toBeFalsy();
-        expect(obj.getFilename()).toBeFalsy();
-      });
+  test('Has default values', () => {
+    var obj = new Asset({});
+    expect(obj.get('type')).toBeFalsy();
+    expect(obj.get('src')).toBeFalsy();
+    expect(obj.getExtension()).toBeFalsy();
+    expect(obj.getFilename()).toBeFalsy();
+  });
 
-      test('Test getFilename', () => {
-        var obj = new Asset({ type: 'image', src: 'ch/eck/t.e.s.t' });
-        expect(obj.getFilename()).toEqual('t.e.s.t');
-        var obj = new Asset({ type: 'image', src: 'ch/eck/1234abc' });
-        expect(obj.getFilename()).toEqual('1234abc');
-      });
+  test('Test getFilename', () => {
+    var obj = new Asset({ type: 'image', src: 'ch/eck/t.e.s.t' });
+    expect(obj.getFilename()).toEqual('t.e.s.t');
+    var obj = new Asset({ type: 'image', src: 'ch/eck/1234abc' });
+    expect(obj.getFilename()).toEqual('1234abc');
+  });
 
-      test('Test getExtension', () => {
-        var obj = new Asset({ type: 'image', src: 'ch/eck/t.e.s.t' });
-        expect(obj.getExtension()).toEqual('t');
-        var obj = new Asset({ type: 'image', src: 'ch/eck/1234abc.' });
-        expect(obj.getExtension()).toEqual('');
-      });
-    });
-  }
-};
+  test('Test getExtension', () => {
+    var obj = new Asset({ type: 'image', src: 'ch/eck/t.e.s.t' });
+    expect(obj.getExtension()).toEqual('t');
+    var obj = new Asset({ type: 'image', src: 'ch/eck/1234abc.' });
+    expect(obj.getExtension()).toEqual('');
+  });
+});

test/specs/asset_manager/model/AssetImage.js

@@ -1,22 +1,18 @@
 import AssetImage from 'asset_manager/model/AssetImage';
 
-module.exports = {
-  run() {
-    describe('AssetImage', () => {
-      test('Object exists', () => {
-        expect(AssetImage).toBeTruthy();
-      });
+describe('AssetImage', () => {
+  test('Object exists', () => {
+    expect(AssetImage).toBeTruthy();
+  });
 
-      test('Has default values', () => {
-        var obj = new AssetImage({});
-        expect(obj.get('type')).toEqual('image');
-        expect(obj.get('src')).toBeFalsy();
-        expect(obj.get('unitDim')).toEqual('px');
-        expect(obj.get('height')).toEqual(0);
-        expect(obj.get('width')).toEqual(0);
-        expect(obj.getExtension()).toBeFalsy();
-        expect(obj.getFilename()).toBeFalsy();
-      });
-    });
-  }
-};
+  test('Has default values', () => {
+    var obj = new AssetImage({});
+    expect(obj.get('type')).toEqual('image');
+    expect(obj.get('src')).toBeFalsy();
+    expect(obj.get('unitDim')).toEqual('px');
+    expect(obj.get('height')).toEqual(0);
+    expect(obj.get('width')).toEqual(0);
+    expect(obj.getExtension()).toBeFalsy();
+    expect(obj.getFilename()).toBeFalsy();
+  });
+});

test/specs/asset_manager/model/Assets.js

@@ -1,25 +1,21 @@
 import Assets from 'asset_manager/model/Assets';
 
-module.exports = {
-  run() {
-    describe('Assets', () => {
-      var obj;
+describe('Assets', () => {
+  var obj;
 
-      beforeEach(() => {
-        obj = new Assets();
-      });
+  beforeEach(() => {
+    obj = new Assets();
+  });
 
-      afterEach(() => {
-        obj = null;
-      });
+  afterEach(() => {
+    obj = null;
+  });
 
-      test('Object exists', () => {
-        expect(obj).toBeTruthy();
-      });
+  test('Object exists', () => {
+    expect(obj).toBeTruthy();
+  });
 
-      test('Collection is empty', () => {
-        expect(obj.length).toEqual(0);
-      });
-    });
-  }
-};
+  test('Collection is empty', () => {
+    expect(obj.length).toEqual(0);
+  });
+});

test/specs/asset_manager/view/AssetImageView.js

@@ -1,70 +1,66 @@
 import AssetImageView from 'asset_manager/view/AssetImageView';
 import Assets from 'asset_manager/model/Assets';
 
-module.exports = {
-  run() {
-    let obj;
+let obj;
 
-    describe('AssetImageView', () => {
-      beforeEach(() => {
-        var coll = new Assets();
-        var model = coll.add({ type: 'image', src: '/test' });
-        obj = new AssetImageView({
-          collection: new Assets(),
-          config: {},
-          model
-        });
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        document.body.querySelector('#fixtures').appendChild(obj.render().el);
-      });
+describe('AssetImageView', () => {
+  beforeEach(() => {
+    var coll = new Assets();
+    var model = coll.add({ type: 'image', src: '/test' });
+    obj = new AssetImageView({
+      collection: new Assets(),
+      config: {},
+      model
+    });
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    document.body.querySelector('#fixtures').appendChild(obj.render().el);
+  });
 
-      afterEach(() => {
-        obj = null;
-        document.body.innerHTML = '';
-      });
+  afterEach(() => {
+    obj = null;
+    document.body.innerHTML = '';
+  });
 
-      test('Object exists', () => {
-        expect(AssetImageView).toBeTruthy();
-      });
+  test('Object exists', () => {
+    expect(AssetImageView).toBeTruthy();
+  });
 
-      describe('Asset should be rendered correctly', () => {
-        test('Has preview box', () => {
-          var $asset = obj.$el;
-          expect($asset.find('.preview').length).toEqual(1);
-        });
+  describe('Asset should be rendered correctly', () => {
+    test('Has preview box', () => {
+      var $asset = obj.$el;
+      expect($asset.find('.preview').length).toEqual(1);
+    });
 
-        test('Has meta box', () => {
-          var $asset = obj.$el;
-          expect($asset.find('.meta').length).toEqual(1);
-        });
+    test('Has meta box', () => {
+      var $asset = obj.$el;
+      expect($asset.find('.meta').length).toEqual(1);
+    });
 
-        test('Has close button', () => {
-          var $asset = obj.$el;
-          expect($asset.find('[data-toggle=asset-remove]').length).toEqual(1);
-        });
-      });
+    test('Has close button', () => {
+      var $asset = obj.$el;
+      expect($asset.find('[data-toggle=asset-remove]').length).toEqual(1);
+    });
+  });
 
-      test('Could be selected', () => {
-        var spy = jest.spyOn(obj, 'updateTarget');
-        obj.$el.trigger('click');
-        expect(obj.$el.attr('class')).toContain('highlight');
-        expect(spy).toHaveBeenCalled();
-      });
+  test('Could be selected', () => {
+    var spy = jest.spyOn(obj, 'updateTarget');
+    obj.$el.trigger('click');
+    expect(obj.$el.attr('class')).toContain('highlight');
+    expect(spy).toHaveBeenCalled();
+  });
 
-      test('Could be chosen', () => {
-        sinon.stub(obj, 'updateTarget');
-        var spy = jest.spyOn(obj, 'updateTarget');
-        obj.$el.trigger('dblclick');
-        expect(spy).toHaveBeenCalled();
-        //obj.updateTarget.calledOnce.should.equal(true);
-      });
+  test('Could be chosen', () => {
+    sinon.stub(obj, 'updateTarget');
+    var spy = jest.spyOn(obj, 'updateTarget');
+    obj.$el.trigger('dblclick');
+    expect(spy).toHaveBeenCalled();
+    //obj.updateTarget.calledOnce.should.equal(true);
+  });
 
-      test('Could be removed', () => {
-        var spy = sinon.spy();
-        obj.model.on('remove', spy);
-        obj.onRemove({ stopImmediatePropagation() {} });
-        expect(spy.called).toEqual(true);
-      });
-    });
-  }
-};
+  test('Could be removed', () => {
+    var spy = sinon.spy();
+    obj.model.on('remove', spy);
+    obj.onRemove({ stopImmediatePropagation() {} });
+    expect(spy.called).toEqual(true);
+  });
+});

test/specs/asset_manager/view/AssetView.js

@@ -1,39 +1,35 @@
 import Assets from 'asset_manager/model/Assets';
 import AssetView from 'asset_manager/view/AssetView';
 
-module.exports = {
-  run() {
-    describe('AssetView', () => {
-      let testContext;
+describe('AssetView', () => {
+  let testContext;
 
-      beforeEach(() => {
-        testContext = {};
-      });
+  beforeEach(() => {
+    testContext = {};
+  });
 
-      beforeEach(() => {
-        var coll = new Assets();
-        var model = coll.add({ src: 'test' });
-        testContext.view = new AssetView({
-          config: {},
-          model
-        });
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        document.body
-          .querySelector('#fixtures')
-          .appendChild(testContext.view.render().el);
-      });
+  beforeEach(() => {
+    var coll = new Assets();
+    var model = coll.add({ src: 'test' });
+    testContext.view = new AssetView({
+      config: {},
+      model
+    });
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    document.body
+      .querySelector('#fixtures')
+      .appendChild(testContext.view.render().el);
+  });
 
-      afterEach(() => {
-        testContext.view.remove();
-      });
+  afterEach(() => {
+    testContext.view.remove();
+  });
 
-      test('Object exists', () => {
-        expect(AssetView).toBeTruthy();
-      });
+  test('Object exists', () => {
+    expect(AssetView).toBeTruthy();
+  });
 
-      test('Has correct prefix', () => {
-        expect(testContext.view.pfx).toEqual('');
-      });
-    });
-  }
-};
+  test('Has correct prefix', () => {
+    expect(testContext.view.pfx).toEqual('');
+  });
+});

test/specs/asset_manager/view/AssetsView.js

@@ -2,86 +2,82 @@ import AssetsView from 'asset_manager/view/AssetsView';
 import FileUploader from 'asset_manager/view/FileUploader';
 import Assets from 'asset_manager/model/Assets';
 
-module.exports = {
-  run() {
-    describe('AssetsView', () => {
-      var obj;
-      var coll;
+describe('AssetsView', () => {
+  var obj;
+  var coll;
 
-      beforeEach(() => {
-        coll = new Assets([]);
-        obj = new AssetsView({
-          config: {},
-          collection: coll,
-          globalCollection: new Assets([]),
-          fu: new FileUploader({})
-        });
-        obj = obj;
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        obj.render();
-        document.body.querySelector('#fixtures').appendChild(obj.el);
-      });
+  beforeEach(() => {
+    coll = new Assets([]);
+    obj = new AssetsView({
+      config: {},
+      collection: coll,
+      globalCollection: new Assets([]),
+      fu: new FileUploader({})
+    });
+    obj = obj;
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    obj.render();
+    document.body.querySelector('#fixtures').appendChild(obj.el);
+  });
 
-      afterEach(() => {
-        obj.collection.reset();
-      });
+  afterEach(() => {
+    obj.collection.reset();
+  });
 
-      test('Object exists', () => {
-        expect(AssetsView).toBeTruthy();
-      });
+  test('Object exists', () => {
+    expect(AssetsView).toBeTruthy();
+  });
 
-      test('Collection is empty', () => {
-        expect(obj.getAssetsEl().innerHTML).toBeFalsy();
-      });
+  test('Collection is empty', () => {
+    expect(obj.getAssetsEl().innerHTML).toBeFalsy();
+  });
 
-      test('Add new asset', () => {
-        sinon.stub(obj, 'addAsset');
-        coll.add({ src: 'test' });
-        expect(obj.addAsset.calledOnce).toEqual(true);
-      });
+  test('Add new asset', () => {
+    sinon.stub(obj, 'addAsset');
+    coll.add({ src: 'test' });
+    expect(obj.addAsset.calledOnce).toEqual(true);
+  });
 
-      test('Render new asset', () => {
-        coll.add({ src: 'test' });
-        expect(obj.getAssetsEl().innerHTML).toBeTruthy();
-      });
+  test('Render new asset', () => {
+    coll.add({ src: 'test' });
+    expect(obj.getAssetsEl().innerHTML).toBeTruthy();
+  });
 
-      test('Render correctly new image asset', () => {
-        coll.add({ type: 'image', src: 'test' });
-        var asset = obj.getAssetsEl().firstChild;
-        expect(asset.tagName).toEqual('DIV');
-        expect(asset.innerHTML).toBeTruthy();
-      });
+  test('Render correctly new image asset', () => {
+    coll.add({ type: 'image', src: 'test' });
+    var asset = obj.getAssetsEl().firstChild;
+    expect(asset.tagName).toEqual('DIV');
+    expect(asset.innerHTML).toBeTruthy();
+  });
 
-      test('Clean collection from asset', () => {
-        var model = coll.add({ src: 'test' });
-        coll.remove(model);
-        expect(obj.getAssetsEl().innerHTML).toBeFalsy();
-      });
+  test('Clean collection from asset', () => {
+    var model = coll.add({ src: 'test' });
+    coll.remove(model);
+    expect(obj.getAssetsEl().innerHTML).toBeFalsy();
+  });
 
-      test('Deselect works', () => {
-        coll.add([{}, {}]);
-        var $asset = obj.$el.children().first();
-        $asset.attr('class', obj.pfx + 'highlight');
-        coll.trigger('deselectAll');
-        expect($asset.attr('class')).toBeFalsy();
-      });
+  test('Deselect works', () => {
+    coll.add([{}, {}]);
+    var $asset = obj.$el.children().first();
+    $asset.attr('class', obj.pfx + 'highlight');
+    coll.trigger('deselectAll');
+    expect($asset.attr('class')).toBeFalsy();
+  });
 
-      test('Returns not empty assets element', () => {
-        expect(obj.getAssetsEl()).toBeTruthy();
-      });
+  test('Returns not empty assets element', () => {
+    expect(obj.getAssetsEl()).toBeTruthy();
+  });
 
-      test('Returns not empty url input', () => {
-        expect(obj.getAddInput()).toBeTruthy();
-      });
+  test('Returns not empty url input', () => {
+    expect(obj.getAddInput()).toBeTruthy();
+  });
 
-      test('Add image asset from input string', () => {
-        obj.getAddInput().value = 'test';
-        obj.handleSubmit({
-          preventDefault() {}
-        });
-        var asset = obj.options.globalCollection.at(0);
-        expect(asset.get('src')).toEqual('test');
-      });
+  test('Add image asset from input string', () => {
+    obj.getAddInput().value = 'test';
+    obj.handleSubmit({
+      preventDefault() {}
     });
-  }
-};
+    var asset = obj.options.globalCollection.at(0);
+    expect(asset.get('src')).toEqual('test');
+  });
+});

test/specs/asset_manager/view/FileUploader.js

@@ -1,97 +1,85 @@
 import FileUploader from 'asset_manager/view/FileUploader';
 
-module.exports = {
-  run() {
-    describe('File Uploader', () => {
-      let obj;
+describe('File Uploader', () => {
+  let obj;
 
-      beforeEach(() => {
-        obj = new FileUploader({ config: {} });
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        document.body.querySelector('#fixtures').appendChild(obj.render().el);
-      });
+  beforeEach(() => {
+    obj = new FileUploader({ config: {} });
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    document.body.querySelector('#fixtures').appendChild(obj.render().el);
+  });
 
-      afterEach(() => {
-        obj.remove();
-      });
+  afterEach(() => {
+    obj.remove();
+  });
 
-      test('Object exists', () => {
-        expect(FileUploader).toBeTruthy();
-      });
+  test('Object exists', () => {
+    expect(FileUploader).toBeTruthy();
+  });
 
-      test('Has correct prefix', () => {
-        expect(obj.pfx).toBeFalsy();
-      });
+  test('Has correct prefix', () => {
+    expect(obj.pfx).toBeFalsy();
+  });
 
-      describe('Should be rendered correctly', () => {
-        test('Has title', () => {
-          expect(obj.$el.find('#title').length).toEqual(1);
-        });
+  describe('Should be rendered correctly', () => {
+    test('Has title', () => {
+      expect(obj.$el.find('#title').length).toEqual(1);
+    });
 
-        test('Title is empty', () => {
-          expect(obj.$el.find('#title').html()).toEqual('');
-        });
+    test('Title is empty', () => {
+      expect(obj.$el.find('#title').html()).toEqual('');
+    });
 
-        test('Has file input', () => {
-          expect(obj.$el.find('input[type=file]').length).toEqual(1);
-        });
+    test('Has file input', () => {
+      expect(obj.$el.find('input[type=file]').length).toEqual(1);
+    });
 
-        test('File input is enabled', () => {
-          expect(obj.$el.find('input[type=file]').prop('disabled')).toEqual(
-            true
-          );
-        });
-      });
+    test('File input is enabled', () => {
+      expect(obj.$el.find('input[type=file]').prop('disabled')).toEqual(true);
+    });
+  });
 
-      describe('Interprets configurations correctly', () => {
-        test('Has correct title', () => {
-          var view = new FileUploader({
-            config: {
-              uploadText: 'Test'
-            }
-          });
-          view.render();
-          expect(view.$el.find('#title').html()).toEqual('Test');
-        });
+  describe('Interprets configurations correctly', () => {
+    test('Has correct title', () => {
+      var view = new FileUploader({
+        config: {
+          uploadText: 'Test'
+        }
+      });
+      view.render();
+      expect(view.$el.find('#title').html()).toEqual('Test');
+    });
 
-        test('Could be disabled', () => {
-          var view = new FileUploader({
-            config: {
-              disableUpload: true,
-              upload: 'something'
-            }
-          });
-          view.render();
-          expect(view.$el.find('input[type=file]').prop('disabled')).toEqual(
-            true
-          );
-        });
+    test('Could be disabled', () => {
+      var view = new FileUploader({
+        config: {
+          disableUpload: true,
+          upload: 'something'
+        }
+      });
+      view.render();
+      expect(view.$el.find('input[type=file]').prop('disabled')).toEqual(true);
+    });
 
-        test('Handles multiUpload false', () => {
-          var view = new FileUploader({
-            config: {
-              multiUpload: false
-            }
-          });
-          view.render();
-          expect(
-            view.$el.find('input[type=file]').prop('multiple')
-          ).toBeFalsy();
-        });
+    test('Handles multiUpload false', () => {
+      var view = new FileUploader({
+        config: {
+          multiUpload: false
+        }
+      });
+      view.render();
+      expect(view.$el.find('input[type=file]').prop('multiple')).toBeFalsy();
+    });
 
-        test('Handles embedAsBase64 parameter', () => {
-          var view = new FileUploader({
-            config: {
-              embedAsBase64: true
-            }
-          });
-          view.render();
-          expect(view.$el.find('input[type=file]').prop('disabled')).toEqual(
-            false
-          );
-          expect(view.uploadFile).toEqual(FileUploader.embedAsBase64);
-        });
+    test('Handles embedAsBase64 parameter', () => {
+      var view = new FileUploader({
+        config: {
+          embedAsBase64: true
+        }
       });
+      view.render();
+      expect(view.$el.find('input[type=file]').prop('disabled')).toEqual(false);
+      expect(view.uploadFile).toEqual(FileUploader.embedAsBase64);
     });
-  }
-};
+  });
+});

test/specs/block_manager/index.js

@@ -67,6 +67,4 @@ describe('BlockManager', () => {
       expect(obj.getContainer()).toBeTruthy();
     });
   });
-
-  BlocksView.run();
 });

test/specs/block_manager/view/BlocksView.js

@@ -2,78 +2,72 @@ import Backbone from 'backbone';
 import BlocksView from 'block_manager/view/BlocksView';
 import Blocks from 'block_manager/model/Blocks';
 
-module.exports = {
-  run() {
-    describe('BlocksView', () => {
-      var $fixtures;
-      var $fixture;
-      var model;
-      var view;
-      var editorModel;
-      var ppfx;
+describe('BlocksView', () => {
+  var $fixtures;
+  var $fixture;
+  var model;
+  var view;
+  var editorModel;
+  var ppfx;
 
-      beforeEach(() => {
-        model = new Blocks([]);
-        view = new BlocksView({ collection: model });
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        document.body.querySelector('#fixtures').appendChild(view.render().el);
-      });
+  beforeEach(() => {
+    model = new Blocks([]);
+    view = new BlocksView({ collection: model });
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    document.body.querySelector('#fixtures').appendChild(view.render().el);
+  });
 
-      afterEach(() => {
-        view.collection.reset();
-      });
+  afterEach(() => {
+    view.collection.reset();
+  });
 
-      test('The container is not empty', () => {
-        expect(view.el.outerHTML).toBeTruthy();
-      });
+  test('The container is not empty', () => {
+    expect(view.el.outerHTML).toBeTruthy();
+  });
 
-      test('No children inside', () => {
-        expect(view.getBlocksEl().children.length).toEqual(0);
-      });
+  test('No children inside', () => {
+    expect(view.getBlocksEl().children.length).toEqual(0);
+  });
 
-      test('Render children on add', () => {
-        model.add({});
-        expect(view.getBlocksEl().children.length).toEqual(1);
-        model.add([{}, {}]);
-        expect(view.getBlocksEl().children.length).toEqual(3);
-      });
+  test('Render children on add', () => {
+    model.add({});
+    expect(view.getBlocksEl().children.length).toEqual(1);
+    model.add([{}, {}]);
+    expect(view.getBlocksEl().children.length).toEqual(3);
+  });
 
-      test('Destroy children on remove', () => {
-        model.add([{}, {}]);
-        expect(view.getBlocksEl().children.length).toEqual(2);
-        model.at(0).destroy();
-        expect(view.getBlocksEl().children.length).toEqual(1);
-      });
+  test('Destroy children on remove', () => {
+    model.add([{}, {}]);
+    expect(view.getBlocksEl().children.length).toEqual(2);
+    model.at(0).destroy();
+    expect(view.getBlocksEl().children.length).toEqual(1);
+  });
 
-      describe('With configs', () => {
-        beforeEach(() => {
-          ppfx = 'pfx-t-';
-          editorModel = new Backbone.Model();
-          model = new Blocks([{ name: 'test1' }, { name: 'test2' }]);
-          view = new BlocksView(
-            {
-              collection: model
-            },
-            {
-              pStylePrefix: ppfx
-            }
-          );
-          document.body.innerHTML = '<div id="fixtures"></div>';
-          document.body
-            .querySelector('#fixtures')
-            .appendChild(view.render().el);
-        });
+  describe('With configs', () => {
+    beforeEach(() => {
+      ppfx = 'pfx-t-';
+      editorModel = new Backbone.Model();
+      model = new Blocks([{ name: 'test1' }, { name: 'test2' }]);
+      view = new BlocksView(
+        {
+          collection: model
+        },
+        {
+          pStylePrefix: ppfx
+        }
+      );
+      document.body.innerHTML = '<div id="fixtures"></div>';
+      document.body.querySelector('#fixtures').appendChild(view.render().el);
+    });
 
-        test('Render children', () => {
-          expect(view.getBlocksEl().children.length).toEqual(2);
-        });
+    test('Render children', () => {
+      expect(view.getBlocksEl().children.length).toEqual(2);
+    });
 
-        test('Render container', () => {
-          expect(view.getBlocksEl().getAttribute('class')).toEqual(
-            ppfx + 'blocks-c'
-          );
-        });
-      });
+    test('Render container', () => {
+      expect(view.getBlocksEl().getAttribute('class')).toEqual(
+        ppfx + 'blocks-c'
+      );
     });
-  }
-};
+  });
+});

test/specs/code_manager/index.js

@@ -35,6 +35,4 @@ describe('Code Manager', () => {
       expect(obj.getViewer('test')).toEqual('view');
     });
   });
-
-  Models.run();
 });

test/specs/code_manager/model/CodeModels.js

@@ -5,343 +5,339 @@ import Component from 'dom_components/model/Component';
 import Editor from 'editor/model/Editor';
 import CssComposer from 'css_composer';
 
-module.exports = {
-  run() {
-    let comp;
-    let dcomp;
-    let obj;
-    let em;
-    let cc;
-
-    describe('HtmlGenerator', () => {
-      beforeEach(() => {
-        em = new Editor();
-        obj = new HtmlGenerator();
-        dcomp = new DomComponents();
-        comp = new Component(
-          {},
-          {
-            em,
-            componentTypes: dcomp.componentTypes
-          }
-        );
-      });
-
-      afterEach(() => {
-        obj = null;
-      });
-
-      test('Build correctly one component', () => {
-        expect(obj.build(comp)).toEqual('');
-      });
-
-      test('Build correctly empty component inside', () => {
-        var m1 = comp.get('components').add({});
-        expect(obj.build(comp)).toEqual('<div></div>');
-      });
-
-      test('Build correctly not empty component inside', () => {
-        var m1 = comp.get('components').add({
-          tagName: 'article',
-          attributes: {
-            'data-test1': 'value1',
-            'data-test2': 'value2'
-          }
-        });
-        expect(obj.build(comp)).toEqual(
-          '<article data-test1="value1" data-test2="value2"></article>'
-        );
-      });
-
-      test('Build correctly component with classes', () => {
-        var m1 = comp.get('components').add({
-          tagName: 'article',
-          attributes: {
-            'data-test1': 'value1',
-            'data-test2': 'value2'
-          }
-        });
-        ['class1', 'class2'].forEach(item => {
-          m1.get('classes').add({ name: item });
-        });
-        expect(obj.build(comp)).toEqual(
-          '<article data-test1="value1" data-test2="value2" class="class1 class2"></article>'
-        );
-      });
+let comp;
+let dcomp;
+let obj;
+let em;
+let cc;
+
+describe('HtmlGenerator', () => {
+  beforeEach(() => {
+    em = new Editor();
+    obj = new HtmlGenerator();
+    dcomp = new DomComponents();
+    comp = new Component(
+      {},
+      {
+        em,
+        componentTypes: dcomp.componentTypes
+      }
+    );
+  });
+
+  afterEach(() => {
+    obj = null;
+  });
+
+  test('Build correctly one component', () => {
+    expect(obj.build(comp)).toEqual('');
+  });
+
+  test('Build correctly empty component inside', () => {
+    var m1 = comp.get('components').add({});
+    expect(obj.build(comp)).toEqual('<div></div>');
+  });
+
+  test('Build correctly not empty component inside', () => {
+    var m1 = comp.get('components').add({
+      tagName: 'article',
+      attributes: {
+        'data-test1': 'value1',
+        'data-test2': 'value2'
+      }
     });
-
-    describe('CssGenerator', () => {
-      let newCssComp;
-
-      beforeEach(() => {
-        em = new Editor({});
-        newCssComp = () => new CssComposer().init({ em });
-
-        cc = em.get('CssComposer');
-        obj = new CssGenerator();
-        dcomp = new DomComponents();
-        comp = new Component(
-          {},
-          {
-            em,
-            componentTypes: dcomp.componentTypes
-          }
-        );
-      });
-
-      afterEach(() => {
-        obj = null;
-      });
-
-      test('Build correctly one component', () => {
-        expect(obj.build(comp)).toEqual('');
-      });
-
-      test('Build correctly empty component inside', () => {
-        var m1 = comp.get('components').add({ tagName: 'article' });
-        expect(obj.build(comp)).toEqual('');
-      });
-
-      test('Build correctly component with style inside', () => {
-        var m1 = comp.get('components').add({
-          tagName: 'article',
-          style: {
-            prop1: 'value1',
-            prop2: 'value2'
-          }
-        });
-        expect(obj.build(comp)).toEqual(
-          '#' + m1.getId() + '{prop1:value1;prop2:value2;}'
-        );
-      });
-
-      test('Build correctly component with class styled', () => {
-        var m1 = comp.get('components').add({ tagName: 'article' });
-        var cls1 = m1.get('classes').add({ name: 'class1' });
-
-        var cssc = newCssComp();
-        var rule = cssc.add(cls1);
-        rule.set('style', { prop1: 'value1', prop2: 'value2' });
-
-        expect(obj.build(comp, { cssc })).toEqual(
-          '.class1{prop1:value1;prop2:value2;}'
-        );
-      });
-
-      test('Build correctly component styled with class and state', () => {
-        var m1 = comp.get('components').add({ tagName: 'article' });
-        var cls1 = m1.get('classes').add({ name: 'class1' });
-
-        var cssc = newCssComp();
-        var rule = cssc.add(cls1);
-        rule.set('style', { prop1: 'value1', prop2: 'value2' });
-        rule.set('state', 'hover');
-
-        expect(obj.build(comp, { cssc })).toEqual(
-          '.class1:hover{prop1:value1;prop2:value2;}'
-        );
-      });
-
-      test('Build correctly with more classes', () => {
-        var m1 = comp.get('components').add({ tagName: 'article' });
-        var cls1 = m1.get('classes').add({ name: 'class1' });
-        var cls2 = m1.get('classes').add({ name: 'class2' });
-
-        var cssc = newCssComp();
-        var rule = cssc.add([cls1, cls2]);
-        rule.set('style', { prop1: 'value1', prop2: 'value2' });
-
-        expect(obj.build(comp, { cssc })).toEqual(
-          '.class1.class2{prop1:value1;prop2:value2;}'
-        );
-      });
-
-      test('Build rules with mixed classes', () => {
-        var m1 = comp.get('components').add({ tagName: 'article' });
-        var cls1 = m1.get('classes').add({ name: 'class1' });
-        var cls2 = m1.get('classes').add({ name: 'class2' });
-
-        var cssc = newCssComp();
-        var rule = cssc.add([cls1, cls2]);
-        rule.set('style', { prop1: 'value1', prop2: 'value2' });
-        rule.set('selectorsAdd', '.class1 .class2, div > .class4');
-
-        expect(obj.build(comp, { cssc })).toEqual(
-          '.class1.class2, .class1 .class2, div > .class4{prop1:value1;prop2:value2;}'
-        );
-      });
-
-      test('Build rules with only not class based selectors', () => {
-        var cssc = newCssComp();
-        var rule = cssc.add([]);
-        rule.set('style', { prop1: 'value1', prop2: 'value2' });
-        rule.set('selectorsAdd', '.class1 .class2, div > .class4');
-
-        expect(obj.build(comp, { cssc })).toEqual(
-          '.class1 .class2, div > .class4{prop1:value1;prop2:value2;}'
-        );
-      });
-
-      test('Build correctly with class styled out', () => {
-        var m1 = comp.get('components').add({ tagName: 'article' });
-        var cls1 = m1.get('classes').add({ name: 'class1' });
-        var cls2 = m1.get('classes').add({ name: 'class2' });
-
-        var cssc = newCssComp();
-        var rule = cssc.add([cls1, cls2]);
-        rule.set('style', { prop1: 'value1' });
-        var rule2 = cssc.add(cls2);
-        rule2.set('style', { prop2: 'value2' });
-
-        expect(obj.build(comp, { cssc })).toEqual(
-          '.class1.class2{prop1:value1;}.class2{prop2:value2;}'
-        );
-      });
-
-      test('Rule with media query', () => {
-        var m1 = comp.get('components').add({ tagName: 'article' });
-        var cls1 = m1.get('classes').add({ name: 'class1' });
-        var cls2 = m1.get('classes').add({ name: 'class2' });
-
-        var cssc = newCssComp();
-        var rule = cssc.add([cls1, cls2]);
-        rule.set('style', { prop1: 'value1' });
-        rule.set('mediaText', '(max-width: 999px)');
-
-        expect(obj.build(comp, { cssc })).toEqual(
-          '@media (max-width: 999px){.class1.class2{prop1:value1;}}'
-        );
-      });
-
-      test('Rules mixed with media queries', () => {
-        var m1 = comp.get('components').add({ tagName: 'article' });
-        var cls1 = m1.get('classes').add({ name: 'class1' });
-        var cls2 = m1.get('classes').add({ name: 'class2' });
-
-        var cssc = newCssComp();
-
-        var rule = cssc.add([cls1, cls2]);
-        rule.set('style', { prop1: 'value1' });
-        var rule2 = cssc.add(cls2);
-        rule2.set('style', { prop2: 'value2' });
-
-        var rule3 = cssc.add(cls1, '', '(max-width: 999px)');
-        rule3.set('style', { prop3: 'value3' });
-        var rule4 = cssc.add(cls2, '', '(max-width: 999px)');
-        rule4.set('style', { prop4: 'value4' });
-
-        var rule5 = cssc.add(cls1, '', '(max-width: 100px)');
-        rule5.set('style', { prop5: 'value5' });
-
-        expect(obj.build(comp, { cssc })).toEqual(
-          '.class1.class2{prop1:value1;}.class2{prop2:value2;}' +
-            '@media (max-width: 999px){.class1{prop3:value3;}.class2{prop4:value4;}}' +
-            '@media (max-width: 100px){.class1{prop5:value5;}}'
-        );
-      });
-
-      test('Avoid useless code', () => {
-        var m1 = comp.get('components').add({ tagName: 'article' });
-        var cls1 = m1.get('classes').add({ name: 'class1' });
-
-        var cssc = newCssComp();
-        var rule = cssc.add(cls1);
-        rule.set('style', { prop1: 'value1', prop2: 'value2' });
-
-        comp.get('components').remove(m1);
-        expect(obj.build(comp, { cssc })).toEqual('');
-      });
-
-      test('Render correctly a rule without avoidInlineStyle option', () => {
-        comp.setStyle({ color: 'red' });
-        const id = comp.getId();
-        const result = `#${id}{color:red;}`;
-        expect(obj.build(comp, { cssc: cc })).toEqual(result);
-      });
-
-      test('Render correctly a rule with avoidInlineStyle option', () => {
-        em.getConfig().avoidInlineStyle = 1;
-        comp = new Component(
-          {},
-          {
-            em,
-            componentTypes: dcomp.componentTypes
-          }
-        );
-        comp.setStyle({ color: 'red' });
-        const id = comp.getId();
-        const result = `#${id}{color:red;}`;
-        expect(obj.build(comp, { cssc: cc, em })).toEqual(result);
-      });
-
-      test('Render correctly a rule with avoidInlineStyle and state', () => {
-        em.getConfig().avoidInlineStyle = 1;
-        const state = 'hover';
-        comp.config.avoidInlineStyle = 1;
-        comp.set('state', state);
-        comp.setStyle({ color: 'red' });
-        const id = comp.getId();
-        const result = `#${id}:${state}{color:red;}`;
-        expect(obj.build(comp, { cssc: cc, em })).toEqual(result);
-      });
-
-      test('Render correctly a rule with avoidInlineStyle and w/o state', () => {
-        em.getConfig().avoidInlineStyle = 1;
-        const state = 'hover';
-        comp.config.avoidInlineStyle = 1;
-        comp.setStyle({ color: 'blue' });
-        comp.set('state', state);
-        comp.setStyle({ color: 'red' });
-        const id = comp.getId();
-        const result = `#${id}{color:blue;}#${id}:${state}{color:red;}`;
-        expect(obj.build(comp, { cssc: cc, em })).toEqual(result);
-      });
-
-      test('Media queries are correctly cleaned for the length', () => {
-        [
-          ['@media (max-width: 999px)', 999],
-          ['@media (min-width: 123%)', 123],
-          ['@media (min-width: 1040rem)', 1040]
-        ].forEach(item => {
-          expect(obj.getQueryLength(item[0])).toBe(item[1]);
-        });
-      });
-
-      test('The media objects are correctly sorted', () => {
-        expect(
-          obj.sortMediaObject({
-            '@media (max-width: 480px)': 1,
-            '@font-face': 2,
-            '@media (max-width: 768px)': 3,
-            '@media (max-width: 1020ch)': 4,
-            '@media (max-width: 10%)': 5
-          })
-        ).toEqual([
-          { key: '@font-face', value: 2 },
-          { key: '@media (max-width: 1020ch)', value: 4 },
-          { key: '@media (max-width: 768px)', value: 3 },
-          { key: '@media (max-width: 480px)', value: 1 },
-          { key: '@media (max-width: 10%)', value: 5 }
-        ]);
-      });
-
-      test('The media objects, for the mobile first approach, are correctly sorted', () => {
-        expect(
-          obj.sortMediaObject({
-            '@media (min-width: 480px)': 1,
-            '@font-face': 2,
-            '@media (min-width: 768px)': 3,
-            '@media (min-width: 1020ch)': 4,
-            '@media (min-width: 10%)': 5
-          })
-        ).toEqual([
-          { key: '@font-face', value: 2 },
-          { key: '@media (min-width: 10%)', value: 5 },
-          { key: '@media (min-width: 480px)', value: 1 },
-          { key: '@media (min-width: 768px)', value: 3 },
-          { key: '@media (min-width: 1020ch)', value: 4 }
-        ]);
-      });
+    expect(obj.build(comp)).toEqual(
+      '<article data-test1="value1" data-test2="value2"></article>'
+    );
+  });
+
+  test('Build correctly component with classes', () => {
+    var m1 = comp.get('components').add({
+      tagName: 'article',
+      attributes: {
+        'data-test1': 'value1',
+        'data-test2': 'value2'
+      }
+    });
+    ['class1', 'class2'].forEach(item => {
+      m1.get('classes').add({ name: item });
+    });
+    expect(obj.build(comp)).toEqual(
+      '<article data-test1="value1" data-test2="value2" class="class1 class2"></article>'
+    );
+  });
+});
+
+describe('CssGenerator', () => {
+  let newCssComp;
+
+  beforeEach(() => {
+    em = new Editor({});
+    newCssComp = () => new CssComposer().init({ em });
+
+    cc = em.get('CssComposer');
+    obj = new CssGenerator();
+    dcomp = new DomComponents();
+    comp = new Component(
+      {},
+      {
+        em,
+        componentTypes: dcomp.componentTypes
+      }
+    );
+  });
+
+  afterEach(() => {
+    obj = null;
+  });
+
+  test('Build correctly one component', () => {
+    expect(obj.build(comp)).toEqual('');
+  });
+
+  test('Build correctly empty component inside', () => {
+    var m1 = comp.get('components').add({ tagName: 'article' });
+    expect(obj.build(comp)).toEqual('');
+  });
+
+  test('Build correctly component with style inside', () => {
+    var m1 = comp.get('components').add({
+      tagName: 'article',
+      style: {
+        prop1: 'value1',
+        prop2: 'value2'
+      }
+    });
+    expect(obj.build(comp)).toEqual(
+      '#' + m1.getId() + '{prop1:value1;prop2:value2;}'
+    );
+  });
+
+  test('Build correctly component with class styled', () => {
+    var m1 = comp.get('components').add({ tagName: 'article' });
+    var cls1 = m1.get('classes').add({ name: 'class1' });
+
+    var cssc = newCssComp();
+    var rule = cssc.add(cls1);
+    rule.set('style', { prop1: 'value1', prop2: 'value2' });
+
+    expect(obj.build(comp, { cssc })).toEqual(
+      '.class1{prop1:value1;prop2:value2;}'
+    );
+  });
+
+  test('Build correctly component styled with class and state', () => {
+    var m1 = comp.get('components').add({ tagName: 'article' });
+    var cls1 = m1.get('classes').add({ name: 'class1' });
+
+    var cssc = newCssComp();
+    var rule = cssc.add(cls1);
+    rule.set('style', { prop1: 'value1', prop2: 'value2' });
+    rule.set('state', 'hover');
+
+    expect(obj.build(comp, { cssc })).toEqual(
+      '.class1:hover{prop1:value1;prop2:value2;}'
+    );
+  });
+
+  test('Build correctly with more classes', () => {
+    var m1 = comp.get('components').add({ tagName: 'article' });
+    var cls1 = m1.get('classes').add({ name: 'class1' });
+    var cls2 = m1.get('classes').add({ name: 'class2' });
+
+    var cssc = newCssComp();
+    var rule = cssc.add([cls1, cls2]);
+    rule.set('style', { prop1: 'value1', prop2: 'value2' });
+
+    expect(obj.build(comp, { cssc })).toEqual(
+      '.class1.class2{prop1:value1;prop2:value2;}'
+    );
+  });
+
+  test('Build rules with mixed classes', () => {
+    var m1 = comp.get('components').add({ tagName: 'article' });
+    var cls1 = m1.get('classes').add({ name: 'class1' });
+    var cls2 = m1.get('classes').add({ name: 'class2' });
+
+    var cssc = newCssComp();
+    var rule = cssc.add([cls1, cls2]);
+    rule.set('style', { prop1: 'value1', prop2: 'value2' });
+    rule.set('selectorsAdd', '.class1 .class2, div > .class4');
+
+    expect(obj.build(comp, { cssc })).toEqual(
+      '.class1.class2, .class1 .class2, div > .class4{prop1:value1;prop2:value2;}'
+    );
+  });
+
+  test('Build rules with only not class based selectors', () => {
+    var cssc = newCssComp();
+    var rule = cssc.add([]);
+    rule.set('style', { prop1: 'value1', prop2: 'value2' });
+    rule.set('selectorsAdd', '.class1 .class2, div > .class4');
+
+    expect(obj.build(comp, { cssc })).toEqual(
+      '.class1 .class2, div > .class4{prop1:value1;prop2:value2;}'
+    );
+  });
+
+  test('Build correctly with class styled out', () => {
+    var m1 = comp.get('components').add({ tagName: 'article' });
+    var cls1 = m1.get('classes').add({ name: 'class1' });
+    var cls2 = m1.get('classes').add({ name: 'class2' });
+
+    var cssc = newCssComp();
+    var rule = cssc.add([cls1, cls2]);
+    rule.set('style', { prop1: 'value1' });
+    var rule2 = cssc.add(cls2);
+    rule2.set('style', { prop2: 'value2' });
+
+    expect(obj.build(comp, { cssc })).toEqual(
+      '.class1.class2{prop1:value1;}.class2{prop2:value2;}'
+    );
+  });
+
+  test('Rule with media query', () => {
+    var m1 = comp.get('components').add({ tagName: 'article' });
+    var cls1 = m1.get('classes').add({ name: 'class1' });
+    var cls2 = m1.get('classes').add({ name: 'class2' });
+
+    var cssc = newCssComp();
+    var rule = cssc.add([cls1, cls2]);
+    rule.set('style', { prop1: 'value1' });
+    rule.set('mediaText', '(max-width: 999px)');
+
+    expect(obj.build(comp, { cssc })).toEqual(
+      '@media (max-width: 999px){.class1.class2{prop1:value1;}}'
+    );
+  });
+
+  test('Rules mixed with media queries', () => {
+    var m1 = comp.get('components').add({ tagName: 'article' });
+    var cls1 = m1.get('classes').add({ name: 'class1' });
+    var cls2 = m1.get('classes').add({ name: 'class2' });
+
+    var cssc = newCssComp();
+
+    var rule = cssc.add([cls1, cls2]);
+    rule.set('style', { prop1: 'value1' });
+    var rule2 = cssc.add(cls2);
+    rule2.set('style', { prop2: 'value2' });
+
+    var rule3 = cssc.add(cls1, '', '(max-width: 999px)');
+    rule3.set('style', { prop3: 'value3' });
+    var rule4 = cssc.add(cls2, '', '(max-width: 999px)');
+    rule4.set('style', { prop4: 'value4' });
+
+    var rule5 = cssc.add(cls1, '', '(max-width: 100px)');
+    rule5.set('style', { prop5: 'value5' });
+
+    expect(obj.build(comp, { cssc })).toEqual(
+      '.class1.class2{prop1:value1;}.class2{prop2:value2;}' +
+        '@media (max-width: 999px){.class1{prop3:value3;}.class2{prop4:value4;}}' +
+        '@media (max-width: 100px){.class1{prop5:value5;}}'
+    );
+  });
+
+  test('Avoid useless code', () => {
+    var m1 = comp.get('components').add({ tagName: 'article' });
+    var cls1 = m1.get('classes').add({ name: 'class1' });
+
+    var cssc = newCssComp();
+    var rule = cssc.add(cls1);
+    rule.set('style', { prop1: 'value1', prop2: 'value2' });
+
+    comp.get('components').remove(m1);
+    expect(obj.build(comp, { cssc })).toEqual('');
+  });
+
+  test('Render correctly a rule without avoidInlineStyle option', () => {
+    comp.setStyle({ color: 'red' });
+    const id = comp.getId();
+    const result = `#${id}{color:red;}`;
+    expect(obj.build(comp, { cssc: cc })).toEqual(result);
+  });
+
+  test('Render correctly a rule with avoidInlineStyle option', () => {
+    em.getConfig().avoidInlineStyle = 1;
+    comp = new Component(
+      {},
+      {
+        em,
+        componentTypes: dcomp.componentTypes
+      }
+    );
+    comp.setStyle({ color: 'red' });
+    const id = comp.getId();
+    const result = `#${id}{color:red;}`;
+    expect(obj.build(comp, { cssc: cc, em })).toEqual(result);
+  });
+
+  test('Render correctly a rule with avoidInlineStyle and state', () => {
+    em.getConfig().avoidInlineStyle = 1;
+    const state = 'hover';
+    comp.config.avoidInlineStyle = 1;
+    comp.set('state', state);
+    comp.setStyle({ color: 'red' });
+    const id = comp.getId();
+    const result = `#${id}:${state}{color:red;}`;
+    expect(obj.build(comp, { cssc: cc, em })).toEqual(result);
+  });
+
+  test('Render correctly a rule with avoidInlineStyle and w/o state', () => {
+    em.getConfig().avoidInlineStyle = 1;
+    const state = 'hover';
+    comp.config.avoidInlineStyle = 1;
+    comp.setStyle({ color: 'blue' });
+    comp.set('state', state);
+    comp.setStyle({ color: 'red' });
+    const id = comp.getId();
+    const result = `#${id}{color:blue;}#${id}:${state}{color:red;}`;
+    expect(obj.build(comp, { cssc: cc, em })).toEqual(result);
+  });
+
+  test('Media queries are correctly cleaned for the length', () => {
+    [
+      ['@media (max-width: 999px)', 999],
+      ['@media (min-width: 123%)', 123],
+      ['@media (min-width: 1040rem)', 1040]
+    ].forEach(item => {
+      expect(obj.getQueryLength(item[0])).toBe(item[1]);
     });
-  }
-};
+  });
+
+  test('The media objects are correctly sorted', () => {
+    expect(
+      obj.sortMediaObject({
+        '@media (max-width: 480px)': 1,
+        '@font-face': 2,
+        '@media (max-width: 768px)': 3,
+        '@media (max-width: 1020ch)': 4,
+        '@media (max-width: 10%)': 5
+      })
+    ).toEqual([
+      { key: '@font-face', value: 2 },
+      { key: '@media (max-width: 1020ch)', value: 4 },
+      { key: '@media (max-width: 768px)', value: 3 },
+      { key: '@media (max-width: 480px)', value: 1 },
+      { key: '@media (max-width: 10%)', value: 5 }
+    ]);
+  });
+
+  test('The media objects, for the mobile first approach, are correctly sorted', () => {
+    expect(
+      obj.sortMediaObject({
+        '@media (min-width: 480px)': 1,
+        '@font-face': 2,
+        '@media (min-width: 768px)': 3,
+        '@media (min-width: 1020ch)': 4,
+        '@media (min-width: 10%)': 5
+      })
+    ).toEqual([
+      { key: '@font-face', value: 2 },
+      { key: '@media (min-width: 10%)', value: 5 },
+      { key: '@media (min-width: 480px)', value: 1 },
+      { key: '@media (min-width: 768px)', value: 3 },
+      { key: '@media (min-width: 1020ch)', value: 4 }
+    ]);
+  });
+});

test/specs/commands/index.js

@@ -115,6 +115,3 @@ describe('Commands', () => {
     });
   });
 });
-
-Models.run();
-CommandAbstract.run();

test/specs/commands/model/CommandModels.js

@@ -1,38 +1,34 @@
 import Command from 'commands/model/Command';
 import Commands from 'commands';
 
-module.exports = {
-  run() {
-    describe('Command', () => {
-      let obj;
-
-      beforeEach(() => {
-        obj = new Command();
-      });
-
-      afterEach(() => {
-        obj = null;
-      });
-
-      test('Has id property', () => {
-        expect(obj.has('id')).toEqual(true);
-      });
-    });
-
-    describe('Commands', () => {
-      var obj;
-
-      beforeEach(() => {
-        obj = new Commands();
-      });
-
-      afterEach(() => {
-        obj = null;
-      });
-
-      test('Object is ok', () => {
-        expect(obj).toBeTruthy();
-      });
-    });
-  }
-};
+describe('Command', () => {
+  let obj;
+
+  beforeEach(() => {
+    obj = new Command();
+  });
+
+  afterEach(() => {
+    obj = null;
+  });
+
+  test('Has id property', () => {
+    expect(obj.has('id')).toEqual(true);
+  });
+});
+
+describe('Commands', () => {
+  var obj;
+
+  beforeEach(() => {
+    obj = new Commands();
+  });
+
+  afterEach(() => {
+    obj = null;
+  });
+
+  test('Object is ok', () => {
+    expect(obj).toBeTruthy();
+  });
+});

test/specs/commands/view/CommandAbstract.js

@@ -1,94 +1,84 @@
 import CommandAbstract from 'commands/view/CommandAbstract';
 import Editor from 'editor/model/Editor';
 
-module.exports = {
-  run() {
-    describe('CommandAbstract', () => {
-      let editor, editorTriggerSpy, command;
+describe('CommandAbstract', () => {
+  let editor, editorTriggerSpy, command;
 
-      beforeEach(() => {
-        editor = new Editor();
-        editorTriggerSpy = sinon.spy(editor, 'trigger');
+  beforeEach(() => {
+    editor = new Editor();
+    editorTriggerSpy = sinon.spy(editor, 'trigger');
 
-        command = new CommandAbstract();
-        command.id = 'test';
-      });
+    command = new CommandAbstract();
+    command.id = 'test';
+  });
 
-      afterEach(() => {
-        command = null;
-        editorTriggerSpy = null;
-        editor = null;
-      });
+  afterEach(() => {
+    command = null;
+    editorTriggerSpy = null;
+    editor = null;
+  });
 
-      test('callRun returns result when no "abort" option specified', () => {
-        const runStub = sinon.stub(command, 'run').returns('result');
+  test('callRun returns result when no "abort" option specified', () => {
+    const runStub = sinon.stub(command, 'run').returns('result');
 
-        const result = command.callRun(editor);
-        expect(editorTriggerSpy.callCount).toEqual(3);
-        expect(editorTriggerSpy.getCall(0).args).toEqual([
-          'run:test:before',
-          {}
-        ]);
-        expect(editorTriggerSpy.getCall(1).args).toEqual([
-          'run:test',
-          'result',
-          {}
-        ]);
-        expect(editorTriggerSpy.getCall(2).args).toEqual([
-          'run',
-          'test',
-          'result',
-          {}
-        ]);
+    const result = command.callRun(editor);
+    expect(editorTriggerSpy.callCount).toEqual(3);
+    expect(editorTriggerSpy.getCall(0).args).toEqual(['run:test:before', {}]);
+    expect(editorTriggerSpy.getCall(1).args).toEqual([
+      'run:test',
+      'result',
+      {}
+    ]);
+    expect(editorTriggerSpy.getCall(2).args).toEqual([
+      'run',
+      'test',
+      'result',
+      {}
+    ]);
 
-        expect(result).toEqual('result');
-        expect(runStub.calledOnce).toEqual(true);
-      });
+    expect(result).toEqual('result');
+    expect(runStub.calledOnce).toEqual(true);
+  });
 
-      test('callRun returns undefined when "abort" option is specified', () => {
-        const runStub = sinon.stub(command, 'run').returns('result');
+  test('callRun returns undefined when "abort" option is specified', () => {
+    const runStub = sinon.stub(command, 'run').returns('result');
 
-        const result = command.callRun(editor, { abort: true });
+    const result = command.callRun(editor, { abort: true });
 
-        expect(editorTriggerSpy.calledTwice).toEqual(true);
-        expect(editorTriggerSpy.getCall(0).args).toEqual([
-          'run:test:before',
-          { abort: true }
-        ]);
-        expect(editorTriggerSpy.getCall(1).args).toEqual([
-          'abort:test',
-          { abort: true }
-        ]);
+    expect(editorTriggerSpy.calledTwice).toEqual(true);
+    expect(editorTriggerSpy.getCall(0).args).toEqual([
+      'run:test:before',
+      { abort: true }
+    ]);
+    expect(editorTriggerSpy.getCall(1).args).toEqual([
+      'abort:test',
+      { abort: true }
+    ]);
 
-        expect(result).toEqual(undefined);
-        expect(runStub.notCalled).toEqual(true);
-      });
+    expect(result).toEqual(undefined);
+    expect(runStub.notCalled).toEqual(true);
+  });
 
-      test('callStop returns result', () => {
-        const stopStub = sinon.stub(command, 'stop').returns('stopped');
+  test('callStop returns result', () => {
+    const stopStub = sinon.stub(command, 'stop').returns('stopped');
 
-        const result = command.callStop(editor);
+    const result = command.callStop(editor);
 
-        expect(editorTriggerSpy.callCount).toEqual(3);
-        expect(editorTriggerSpy.getCall(0).args).toEqual([
-          'stop:test:before',
-          {}
-        ]);
-        expect(editorTriggerSpy.getCall(1).args).toEqual([
-          'stop:test',
-          'stopped',
-          {}
-        ]);
-        expect(editorTriggerSpy.getCall(2).args).toEqual([
-          'stop',
-          'test',
-          'stopped',
-          {}
-        ]);
+    expect(editorTriggerSpy.callCount).toEqual(3);
+    expect(editorTriggerSpy.getCall(0).args).toEqual(['stop:test:before', {}]);
+    expect(editorTriggerSpy.getCall(1).args).toEqual([
+      'stop:test',
+      'stopped',
+      {}
+    ]);
+    expect(editorTriggerSpy.getCall(2).args).toEqual([
+      'stop',
+      'test',
+      'stopped',
+      {}
+    ]);
 
-        expect(result).toEqual('stopped');
-        expect(stopStub.calledOnce).toEqual(true);
-      });
-    });
-  }
-};
+    expect(result).toEqual('stopped');
+    expect(stopStub.calledOnce).toEqual(true);
+  });
+});

test/specs/css_composer/e2e/CssComposer.js

@@ -1,202 +1,198 @@
 import Backbone from 'backbone';
 const $ = Backbone.$;
 
-module.exports = {
-  run() {
-    describe('E2E tests', () => {
-      var fixtures;
-      var fixture;
-      var gjs;
-      var cssc;
-      var clsm;
-      var domc;
-      var rulesSet;
-      var rulesSet2;
+describe('E2E tests', () => {
+  var fixtures;
+  var fixture;
+  var gjs;
+  var cssc;
+  var clsm;
+  var domc;
+  var rulesSet;
+  var rulesSet2;
 
-      beforeAll(() => {
-        fixtures = $('#fixtures');
-        fixture = $('<div class="csscomposer-fixture"></div>');
-      });
+  beforeAll(() => {
+    fixtures = $('#fixtures');
+    fixture = $('<div class="csscomposer-fixture"></div>');
+  });
 
-      beforeEach(done => {
-        //this.timeout(5000);
-        gjs = grapesjs.init({
-          stylePrefix: '',
-          storageManager: { autoload: 0, type: 'none' },
-          assetManager: { storageType: 'none' },
-          container: 'csscomposer-fixture'
-        });
-        cssc = gjs.CssComposer;
-        clsm = gjs.SelectorManager;
-        domc = gjs.DomComponents;
-        fixture.empty().appendTo(fixtures);
-        gjs.render();
-        rulesSet = [
-          { selectors: [{ name: 'test1' }, { name: 'test2' }] },
-          { selectors: [{ name: 'test2' }, { name: 'test3' }] },
-          { selectors: [{ name: 'test3' }] }
-        ];
-        rulesSet2 = [
-          {
-            selectors: [{ name: 'test1' }, { name: 'test2' }],
-            state: ':active'
-          },
-          { selectors: [{ name: 'test2' }, { name: 'test3' }] },
-          { selectors: [{ name: 'test3' }], mediaText: '(max-width: 900px)' }
-        ];
-        done();
-      });
+  beforeEach(done => {
+    //this.timeout(5000);
+    gjs = grapesjs.init({
+      stylePrefix: '',
+      storageManager: { autoload: 0, type: 'none' },
+      assetManager: { storageType: 'none' },
+      container: 'csscomposer-fixture'
+    });
+    cssc = gjs.CssComposer;
+    clsm = gjs.SelectorManager;
+    domc = gjs.DomComponents;
+    fixture.empty().appendTo(fixtures);
+    gjs.render();
+    rulesSet = [
+      { selectors: [{ name: 'test1' }, { name: 'test2' }] },
+      { selectors: [{ name: 'test2' }, { name: 'test3' }] },
+      { selectors: [{ name: 'test3' }] }
+    ];
+    rulesSet2 = [
+      {
+        selectors: [{ name: 'test1' }, { name: 'test2' }],
+        state: ':active'
+      },
+      { selectors: [{ name: 'test2' }, { name: 'test3' }] },
+      { selectors: [{ name: 'test3' }], mediaText: '(max-width: 900px)' }
+    ];
+    done();
+  });
 
-      afterEach(() => {
-        gjs = null;
-        cssc = null;
-        clsm = null;
-      });
+  afterEach(() => {
+    gjs = null;
+    cssc = null;
+    clsm = null;
+  });
 
-      afterAll(() => {
-        fixture.remove();
-      });
+  afterAll(() => {
+    fixture.remove();
+  });
 
-      test('Rules are correctly imported from default property', () => {
-        var gj = grapesjs.init({
-          stylePrefix: '',
-          storageManager: { autoload: 0, type: 'none' },
-          cssComposer: { rules: rulesSet },
-          container: 'csscomposer-fixture'
-        });
-        var cssc = gj.editor.get('CssComposer');
-        expect(cssc.getAll().length).toEqual(rulesSet.length);
-        var cls = gj.editor.get('SelectorManager').getAll();
-        expect(cls.length).toEqual(3);
-      });
+  test('Rules are correctly imported from default property', () => {
+    var gj = grapesjs.init({
+      stylePrefix: '',
+      storageManager: { autoload: 0, type: 'none' },
+      cssComposer: { rules: rulesSet },
+      container: 'csscomposer-fixture'
+    });
+    var cssc = gj.editor.get('CssComposer');
+    expect(cssc.getAll().length).toEqual(rulesSet.length);
+    var cls = gj.editor.get('SelectorManager').getAll();
+    expect(cls.length).toEqual(3);
+  });
 
-      test('New rule adds correctly the class inside selector manager', () => {
-        var rules = cssc.getAll();
-        rules.add({ selectors: [{ name: 'test1', private: true }] });
-        var rule = clsm.getAll().at(0);
-        expect(rule.get('name')).toEqual('test1');
-        expect(rule.get('private')).toEqual(true);
-      });
+  test('New rule adds correctly the class inside selector manager', () => {
+    var rules = cssc.getAll();
+    rules.add({ selectors: [{ name: 'test1', private: true }] });
+    var rule = clsm.getAll().at(0);
+    expect(rule.get('name')).toEqual('test1');
+    expect(rule.get('private')).toEqual(true);
+  });
 
-      test('New rules are correctly imported inside selector manager', () => {
-        var rules = cssc.getAll();
-        rulesSet.forEach(item => {
-          rules.add(item);
-        });
-        var cls = clsm.getAll();
-        expect(cls.length).toEqual(3);
-        expect(cls.at(0).get('name')).toEqual('test1');
-        expect(cls.at(1).get('name')).toEqual('test2');
-        expect(cls.at(2).get('name')).toEqual('test3');
-      });
+  test('New rules are correctly imported inside selector manager', () => {
+    var rules = cssc.getAll();
+    rulesSet.forEach(item => {
+      rules.add(item);
+    });
+    var cls = clsm.getAll();
+    expect(cls.length).toEqual(3);
+    expect(cls.at(0).get('name')).toEqual('test1');
+    expect(cls.at(1).get('name')).toEqual('test2');
+    expect(cls.at(2).get('name')).toEqual('test3');
+  });
 
-      test('Add rules from the new component added as a string with style tag', () => {
-        var comps = domc.getComponents();
-        var rules = cssc.getAll();
-        comps.add(
-          '<div>Test</div><style>.test{color: red} .test2{color: blue}</style>'
-        );
-        expect(comps.length).toEqual(1);
-        expect(rules.length).toEqual(2);
-      });
+  test('Add rules from the new component added as a string with style tag', () => {
+    var comps = domc.getComponents();
+    var rules = cssc.getAll();
+    comps.add(
+      '<div>Test</div><style>.test{color: red} .test2{color: blue}</style>'
+    );
+    expect(comps.length).toEqual(1);
+    expect(rules.length).toEqual(2);
+  });
 
-      test('Add raw rule objects with addCollection', () => {
-        cssc.addCollection(rulesSet);
-        expect(cssc.getAll().length).toEqual(3);
-        expect(clsm.getAll().length).toEqual(3);
-      });
+  test('Add raw rule objects with addCollection', () => {
+    cssc.addCollection(rulesSet);
+    expect(cssc.getAll().length).toEqual(3);
+    expect(clsm.getAll().length).toEqual(3);
+  });
 
-      test('Add raw rule objects twice with addCollection do not duplucate rules', () => {
-        var rulesSet2Copy = JSON.parse(JSON.stringify(rulesSet2));
-        var coll1 = cssc.addCollection(rulesSet2);
-        var coll2 = cssc.addCollection(rulesSet2Copy);
-        expect(cssc.getAll().length).toEqual(3);
-        expect(clsm.getAll().length).toEqual(3);
-        expect(coll1).toEqual(coll2);
-      });
+  test('Add raw rule objects twice with addCollection do not duplucate rules', () => {
+    var rulesSet2Copy = JSON.parse(JSON.stringify(rulesSet2));
+    var coll1 = cssc.addCollection(rulesSet2);
+    var coll2 = cssc.addCollection(rulesSet2Copy);
+    expect(cssc.getAll().length).toEqual(3);
+    expect(clsm.getAll().length).toEqual(3);
+    expect(coll1).toEqual(coll2);
+  });
 
-      test('Extend css rule style, if requested', () => {
-        var style1 = { color: 'red', width: '10px' };
-        var style2 = { height: '20px', width: '20px' };
-        var rule1 = {
-          selectors: ['test1'],
-          style: style1
-        };
-        var rule2 = {
-          selectors: ['test1'],
-          style: style2
-        };
-        var ruleOut = cssc.addCollection(rule1)[0];
-        // ruleOut is a Model
-        ruleOut = JSON.parse(JSON.stringify(ruleOut));
-        var ruleResult = {
-          selectors: [
-            {
-              active: true,
-              label: 'test1',
-              name: 'test1',
-              type: clsm.Selector.TYPE_CLASS,
-              private: false,
-              protected: false
-            }
-          ],
-          style: {
-            color: 'red',
-            width: '10px'
-          }
-        };
-        expect(ruleOut).toEqual(ruleResult);
-        var ruleOut = cssc.addCollection(rule2, { extend: 1 })[0];
-        ruleOut = JSON.parse(JSON.stringify(ruleOut));
-        ruleResult.style = {
-          color: 'red',
-          height: '20px',
-          width: '20px'
-        };
-        expect(ruleOut).toEqual(ruleResult);
-      });
+  test('Extend css rule style, if requested', () => {
+    var style1 = { color: 'red', width: '10px' };
+    var style2 = { height: '20px', width: '20px' };
+    var rule1 = {
+      selectors: ['test1'],
+      style: style1
+    };
+    var rule2 = {
+      selectors: ['test1'],
+      style: style2
+    };
+    var ruleOut = cssc.addCollection(rule1)[0];
+    // ruleOut is a Model
+    ruleOut = JSON.parse(JSON.stringify(ruleOut));
+    var ruleResult = {
+      selectors: [
+        {
+          active: true,
+          label: 'test1',
+          name: 'test1',
+          type: clsm.Selector.TYPE_CLASS,
+          private: false,
+          protected: false
+        }
+      ],
+      style: {
+        color: 'red',
+        width: '10px'
+      }
+    };
+    expect(ruleOut).toEqual(ruleResult);
+    var ruleOut = cssc.addCollection(rule2, { extend: 1 })[0];
+    ruleOut = JSON.parse(JSON.stringify(ruleOut));
+    ruleResult.style = {
+      color: 'red',
+      height: '20px',
+      width: '20px'
+    };
+    expect(ruleOut).toEqual(ruleResult);
+  });
 
-      test('Do not extend with different selectorsAdd', () => {
-        var style1 = { color: 'red', width: '10px' };
-        var style2 = { height: '20px', width: '20px' };
-        var rule1 = {
-          selectors: [],
-          selectorsAdd: '*',
-          style: style1
-        };
-        var rule2 = {
-          selectors: [],
-          selectorsAdd: 'p',
-          style: style2
-        };
-        var rule1Out = cssc.addCollection(rule1, { extend: 1 })[0];
-        var rule2Out = cssc.addCollection(rule2, { extend: 1 })[0];
-        rule1Out = JSON.parse(JSON.stringify(rule1Out));
-        rule2Out = JSON.parse(JSON.stringify(rule2Out));
-        var rule1Result = {
-          selectors: [],
-          selectorsAdd: '*',
-          style: {
-            color: 'red',
-            width: '10px'
-          }
-        };
-        var rule2Result = {
-          selectors: [],
-          selectorsAdd: 'p',
-          style: {
-            height: '20px',
-            width: '20px'
-          }
-        };
-        expect(rule1Out).toEqual(rule1Result);
-        expect(rule2Out).toEqual(rule2Result);
-      });
+  test('Do not extend with different selectorsAdd', () => {
+    var style1 = { color: 'red', width: '10px' };
+    var style2 = { height: '20px', width: '20px' };
+    var rule1 = {
+      selectors: [],
+      selectorsAdd: '*',
+      style: style1
+    };
+    var rule2 = {
+      selectors: [],
+      selectorsAdd: 'p',
+      style: style2
+    };
+    var rule1Out = cssc.addCollection(rule1, { extend: 1 })[0];
+    var rule2Out = cssc.addCollection(rule2, { extend: 1 })[0];
+    rule1Out = JSON.parse(JSON.stringify(rule1Out));
+    rule2Out = JSON.parse(JSON.stringify(rule2Out));
+    var rule1Result = {
+      selectors: [],
+      selectorsAdd: '*',
+      style: {
+        color: 'red',
+        width: '10px'
+      }
+    };
+    var rule2Result = {
+      selectors: [],
+      selectorsAdd: 'p',
+      style: {
+        height: '20px',
+        width: '20px'
+      }
+    };
+    expect(rule1Out).toEqual(rule1Result);
+    expect(rule2Out).toEqual(rule2Result);
+  });
 
-      test('Add raw rule objects with width via addCollection', () => {
-        var coll1 = cssc.addCollection(rulesSet2);
-        expect(coll1[2].get('mediaText')).toEqual(rulesSet2[2].mediaText);
-      });
-    });
-  }
-};
+  test('Add raw rule objects with width via addCollection', () => {
+    var coll1 = cssc.addCollection(rulesSet2);
+    expect(coll1[2].get('mediaText')).toEqual(rulesSet2[2].mediaText);
+  });
+});

test/specs/css_composer/index.js

@@ -3,7 +3,7 @@ import CssRuleView from './view/CssRuleView';
 import CssRulesView from './view/CssRulesView';
 import CssComposer from 'css_composer';
 import e2e from './e2e/CssComposer';
-import utils from './../test_utils.js';
+import utils from './../../test_utils.js';
 import Editor from 'editor/model/Editor';
 
 describe('Css Composer', () => {
@@ -322,9 +322,4 @@ describe('Css Composer', () => {
       expect(obj.getAll().length).toEqual(toTest.length);
     });
   });
-
-  Models.run();
-  CssRuleView.run();
-  CssRulesView.run();
-  e2e.run();
 });

test/specs/css_composer/model/CssModels.js

@@ -3,125 +3,119 @@ import CssRules from 'css_composer/model/CssRules';
 import Selectors from 'selector_manager/model/Selectors';
 import Selector from 'selector_manager/model/Selector';
 
-module.exports = {
-  run() {
-    describe('CssRule', () => {
-      let obj;
-
-      beforeEach(() => {
-        obj = new CssRule();
-      });
-
-      afterEach(() => {
-        obj = null;
-      });
-
-      test('Has selectors property', () => {
-        expect(obj.has('selectors')).toEqual(true);
-      });
-
-      test('Has style property', () => {
-        expect(obj.has('style')).toEqual(true);
-      });
-
-      test('Has state property', () => {
-        expect(obj.has('state')).toEqual(true);
-      });
-
-      test('No default selectors', () => {
-        expect(obj.get('selectors').length).toEqual(0);
-      });
-
-      test('Compare returns true with the same selectors', () => {
-        var s1 = obj.get('selectors').add({ name: 'test1' });
-        var s2 = obj.get('selectors').add({ name: 'test2' });
-        expect(obj.compare([s1, s2])).toEqual(true);
-      });
-
-      test('Compare with different state', () => {
-        var s1 = obj.get('selectors').add({ name: 'test1' });
-        var s2 = obj.get('selectors').add({ name: 'test2' });
-        obj.set('state', 'hover');
-        expect(obj.compare([s1, s2])).toEqual(false);
-        expect(obj.compare([s1, s2], 'hover')).toEqual(true);
-      });
-
-      test('Compare with different mediaText', () => {
-        var s1 = obj.get('selectors').add({ name: 'test1' });
-        var s2 = obj.get('selectors').add({ name: 'test2' });
-        obj.set('state', 'hover');
-        obj.set('mediaText', '1000');
-        expect(obj.compare([s1, s2])).toEqual(false);
-        expect(obj.compare([s1, s2], 'hover')).toEqual(false);
-        expect(obj.compare([s2, s1], 'hover', '1000')).toEqual(true);
-      });
-
-      test('toCSS returns empty if there is no style', () => {
-        var s1 = obj.get('selectors').add({ name: 'test1' });
-        expect(obj.toCSS()).toEqual('');
-      });
-
-      test('toCSS returns empty if there is no selectors', () => {
-        obj.setStyle({ color: 'red' });
-        expect(obj.toCSS()).toEqual('');
-      });
-
-      test('toCSS returns simple CSS', () => {
-        obj.get('selectors').add({ name: 'test1' });
-        obj.setStyle({ color: 'red' });
-        expect(obj.toCSS()).toEqual(`.test1{color:red;}`);
-      });
-
-      test('toCSS wraps correctly inside media rule', () => {
-        const media = '(max-width: 768px)';
-        obj.set('atRuleType', 'media');
-        obj.set('mediaText', media);
-        obj.get('selectors').add({ name: 'test1' });
-        obj.setStyle({ color: 'red' });
-        expect(obj.toCSS()).toEqual(`@media ${media}{.test1{color:red;}}`);
-      });
-
-      test('toCSS with a generic at-rule', () => {
-        obj.set('atRuleType', 'supports');
-        obj.get('selectors').add({ name: 'test1' });
-        obj.setStyle({ 'font-family': 'Open Sans' });
-        expect(obj.toCSS()).toEqual(
-          `@supports{.test1{font-family:Open Sans;}}`
-        );
-      });
-
-      test('toCSS with a generic single at-rule', () => {
-        obj.set('atRuleType', 'font-face');
-        obj.set('singleAtRule', 1);
-        obj.setStyle({ 'font-family': 'Sans' });
-        expect(obj.toCSS()).toEqual(`@font-face{font-family:Sans;}`);
-      });
-
-      test('toCSS with a generic at-rule and condition', () => {
-        obj.set('atRuleType', 'font-face');
-        obj.set('mediaText', 'some-condition');
-        obj.get('selectors').add({ name: 'test1' });
-        obj.setStyle({ 'font-family': 'Open Sans' });
-        expect(obj.toCSS()).toEqual(
-          `@font-face some-condition{.test1{font-family:Open Sans;}}`
-        );
-      });
-    });
-
-    describe('CssRules', () => {
-      test('Creates collection item correctly', () => {
-        var c = new CssRules();
-        var m = c.add({});
-        expect(m instanceof CssRule).toEqual(true);
-      });
-    });
-
-    describe('Selectors', () => {
-      test('Creates collection item correctly', () => {
-        var c = new Selectors();
-        var m = c.add({});
-        expect(m instanceof Selector).toEqual(true);
-      });
-    });
-  }
-};
+describe('CssRule', () => {
+  let obj;
+
+  beforeEach(() => {
+    obj = new CssRule();
+  });
+
+  afterEach(() => {
+    obj = null;
+  });
+
+  test('Has selectors property', () => {
+    expect(obj.has('selectors')).toEqual(true);
+  });
+
+  test('Has style property', () => {
+    expect(obj.has('style')).toEqual(true);
+  });
+
+  test('Has state property', () => {
+    expect(obj.has('state')).toEqual(true);
+  });
+
+  test('No default selectors', () => {
+    expect(obj.get('selectors').length).toEqual(0);
+  });
+
+  test('Compare returns true with the same selectors', () => {
+    var s1 = obj.get('selectors').add({ name: 'test1' });
+    var s2 = obj.get('selectors').add({ name: 'test2' });
+    expect(obj.compare([s1, s2])).toEqual(true);
+  });
+
+  test('Compare with different state', () => {
+    var s1 = obj.get('selectors').add({ name: 'test1' });
+    var s2 = obj.get('selectors').add({ name: 'test2' });
+    obj.set('state', 'hover');
+    expect(obj.compare([s1, s2])).toEqual(false);
+    expect(obj.compare([s1, s2], 'hover')).toEqual(true);
+  });
+
+  test('Compare with different mediaText', () => {
+    var s1 = obj.get('selectors').add({ name: 'test1' });
+    var s2 = obj.get('selectors').add({ name: 'test2' });
+    obj.set('state', 'hover');
+    obj.set('mediaText', '1000');
+    expect(obj.compare([s1, s2])).toEqual(false);
+    expect(obj.compare([s1, s2], 'hover')).toEqual(false);
+    expect(obj.compare([s2, s1], 'hover', '1000')).toEqual(true);
+  });
+
+  test('toCSS returns empty if there is no style', () => {
+    var s1 = obj.get('selectors').add({ name: 'test1' });
+    expect(obj.toCSS()).toEqual('');
+  });
+
+  test('toCSS returns empty if there is no selectors', () => {
+    obj.setStyle({ color: 'red' });
+    expect(obj.toCSS()).toEqual('');
+  });
+
+  test('toCSS returns simple CSS', () => {
+    obj.get('selectors').add({ name: 'test1' });
+    obj.setStyle({ color: 'red' });
+    expect(obj.toCSS()).toEqual(`.test1{color:red;}`);
+  });
+
+  test('toCSS wraps correctly inside media rule', () => {
+    const media = '(max-width: 768px)';
+    obj.set('atRuleType', 'media');
+    obj.set('mediaText', media);
+    obj.get('selectors').add({ name: 'test1' });
+    obj.setStyle({ color: 'red' });
+    expect(obj.toCSS()).toEqual(`@media ${media}{.test1{color:red;}}`);
+  });
+
+  test('toCSS with a generic at-rule', () => {
+    obj.set('atRuleType', 'supports');
+    obj.get('selectors').add({ name: 'test1' });
+    obj.setStyle({ 'font-family': 'Open Sans' });
+    expect(obj.toCSS()).toEqual(`@supports{.test1{font-family:Open Sans;}}`);
+  });
+
+  test('toCSS with a generic single at-rule', () => {
+    obj.set('atRuleType', 'font-face');
+    obj.set('singleAtRule', 1);
+    obj.setStyle({ 'font-family': 'Sans' });
+    expect(obj.toCSS()).toEqual(`@font-face{font-family:Sans;}`);
+  });
+
+  test('toCSS with a generic at-rule and condition', () => {
+    obj.set('atRuleType', 'font-face');
+    obj.set('mediaText', 'some-condition');
+    obj.get('selectors').add({ name: 'test1' });
+    obj.setStyle({ 'font-family': 'Open Sans' });
+    expect(obj.toCSS()).toEqual(
+      `@font-face some-condition{.test1{font-family:Open Sans;}}`
+    );
+  });
+});
+
+describe('CssRules', () => {
+  test('Creates collection item correctly', () => {
+    var c = new CssRules();
+    var m = c.add({});
+    expect(m instanceof CssRule).toEqual(true);
+  });
+});
+
+describe('Selectors', () => {
+  test('Creates collection item correctly', () => {
+    var c = new Selectors();
+    var m = c.add({});
+    expect(m instanceof Selector).toEqual(true);
+  });
+});

test/specs/css_composer/view/CssRuleView.js

@@ -1,95 +1,91 @@
 import CssRuleView from 'css_composer/view/CssRuleView';
 import CssRule from 'css_composer/model/CssRule';
 
-module.exports = {
-  run() {
-    describe('CssRuleView', () => {
-      let obj;
-      let fixtures;
+describe('CssRuleView', () => {
+  let obj;
+  let fixtures;
 
-      beforeEach(() => {
-        var m = new CssRule();
-        obj = new CssRuleView({
-          model: m
-        });
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        fixtures = document.body.querySelector('#fixtures');
-        fixtures.appendChild(obj.render().el);
-      });
+  beforeEach(() => {
+    var m = new CssRule();
+    obj = new CssRuleView({
+      model: m
+    });
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    fixtures = document.body.querySelector('#fixtures');
+    fixtures.appendChild(obj.render().el);
+  });
 
-      afterEach(() => {
-        obj.model.destroy();
-      });
+  afterEach(() => {
+    obj.model.destroy();
+  });
 
-      test('Object exists', () => {
-        expect(CssRuleView).toBeTruthy();
-      });
+  test('Object exists', () => {
+    expect(CssRuleView).toBeTruthy();
+  });
 
-      test('Empty style inside', () => {
-        expect(fixtures.innerHTML).toEqual('<style></style>');
-      });
+  test('Empty style inside', () => {
+    expect(fixtures.innerHTML).toEqual('<style></style>');
+  });
 
-      test('On update of style always empty as there is no selectors', () => {
-        obj.model.set('style', { prop: 'value' });
-        expect(fixtures.innerHTML).toEqual('<style></style>');
-      });
+  test('On update of style always empty as there is no selectors', () => {
+    obj.model.set('style', { prop: 'value' });
+    expect(fixtures.innerHTML).toEqual('<style></style>');
+  });
 
-      describe('CssRuleView with selectors', () => {
-        let objReg;
+  describe('CssRuleView with selectors', () => {
+    let objReg;
 
-        beforeEach(() => {
-          var m = new CssRule({
-            selectors: [{ name: 'test1' }, { name: 'test2' }]
-          });
-          objReg = new CssRuleView({
-            model: m
-          });
-          objReg.render();
-          document.body.innerHTML = '<div id="fixtures"></div>';
-          fixtures = document.body.querySelector('#fixtures');
-          fixtures.appendChild(objReg.el);
-        });
+    beforeEach(() => {
+      var m = new CssRule({
+        selectors: [{ name: 'test1' }, { name: 'test2' }]
+      });
+      objReg = new CssRuleView({
+        model: m
+      });
+      objReg.render();
+      document.body.innerHTML = '<div id="fixtures"></div>';
+      fixtures = document.body.querySelector('#fixtures');
+      fixtures.appendChild(objReg.el);
+    });
 
-        afterEach(() => {
-          objReg.model.destroy();
-        });
+    afterEach(() => {
+      objReg.model.destroy();
+    });
 
-        test('Empty with no style', () => {
-          expect(objReg.$el.html()).toEqual('');
-        });
+    test('Empty with no style', () => {
+      expect(objReg.$el.html()).toEqual('');
+    });
 
-        test('Not empty on update of style', () => {
-          objReg.model.set('style', { prop: 'value' });
-          expect(objReg.$el.html()).toEqual('.test1.test2{prop:value;}');
-        });
+    test('Not empty on update of style', () => {
+      objReg.model.set('style', { prop: 'value' });
+      expect(objReg.$el.html()).toEqual('.test1.test2{prop:value;}');
+    });
 
-        test('State correctly rendered', () => {
-          objReg.model.set('style', { prop: 'value' });
-          objReg.model.set('state', 'hover');
-          expect(objReg.$el.html()).toEqual('.test1.test2:hover{prop:value;}');
-        });
+    test('State correctly rendered', () => {
+      objReg.model.set('style', { prop: 'value' });
+      objReg.model.set('state', 'hover');
+      expect(objReg.$el.html()).toEqual('.test1.test2:hover{prop:value;}');
+    });
 
-        test('State render changes on update', () => {
-          objReg.model.set('style', { prop: 'value' });
-          objReg.model.set('state', 'hover');
-          objReg.model.set('state', '');
-          expect(objReg.$el.html()).toEqual('.test1.test2{prop:value;}');
-        });
+    test('State render changes on update', () => {
+      objReg.model.set('style', { prop: 'value' });
+      objReg.model.set('state', 'hover');
+      objReg.model.set('state', '');
+      expect(objReg.$el.html()).toEqual('.test1.test2{prop:value;}');
+    });
 
-        test('Render media queries', () => {
-          objReg.model.set('style', { prop: 'value' });
-          objReg.model.set('mediaText', '(max-width: 999px)');
-          expect(objReg.$el.html()).toEqual(
-            '@media (max-width: 999px){.test1.test2{prop:value;}}'
-          );
-        });
+    test('Render media queries', () => {
+      objReg.model.set('style', { prop: 'value' });
+      objReg.model.set('mediaText', '(max-width: 999px)');
+      expect(objReg.$el.html()).toEqual(
+        '@media (max-width: 999px){.test1.test2{prop:value;}}'
+      );
+    });
 
-        test('Empty on clear', () => {
-          objReg.model.set('style', { prop: 'value' });
-          objReg.model.set('style', {});
-          expect(objReg.$el.html()).toEqual('');
-        });
-      });
+    test('Empty on clear', () => {
+      objReg.model.set('style', { prop: 'value' });
+      objReg.model.set('style', {});
+      expect(objReg.$el.html()).toEqual('');
     });
-  }
-};
+  });
+});

test/specs/css_composer/view/CssRulesView.js

@@ -2,108 +2,104 @@ import CssRulesView from 'css_composer/view/CssRulesView';
 import CssRules from 'css_composer/model/CssRules';
 import Editor from 'editor/model/Editor';
 
-module.exports = {
-  run() {
-    describe('CssRulesView', () => {
-      let obj;
-      const prefix = 'rules';
-      const devices = [
-        {
-          name: 'Mobile portrait',
-          width: '320px',
-          widthMedia: '480px'
-        },
-        {
-          name: 'Tablet',
-          width: '768px',
-          widthMedia: '992px'
-        },
-        {
-          name: 'Desktop',
-          width: '',
-          widthMedia: ''
-        }
-      ];
+describe('CssRulesView', () => {
+  let obj;
+  const prefix = 'rules';
+  const devices = [
+    {
+      name: 'Mobile portrait',
+      width: '320px',
+      widthMedia: '480px'
+    },
+    {
+      name: 'Tablet',
+      width: '768px',
+      widthMedia: '992px'
+    },
+    {
+      name: 'Desktop',
+      width: '',
+      widthMedia: ''
+    }
+  ];
 
-      beforeEach(() => {
-        const col = new CssRules([]);
-        obj = new CssRulesView({
-          collection: col,
-          config: {
-            em: new Editor({
-              deviceManager: {
-                devices
-              }
-            })
+  beforeEach(() => {
+    const col = new CssRules([]);
+    obj = new CssRulesView({
+      collection: col,
+      config: {
+        em: new Editor({
+          deviceManager: {
+            devices
           }
-        });
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        document.body.querySelector('#fixtures').appendChild(obj.render().el);
-      });
+        })
+      }
+    });
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    document.body.querySelector('#fixtures').appendChild(obj.render().el);
+  });
 
-      afterEach(() => {
-        obj.collection.reset();
-      });
+  afterEach(() => {
+    obj.collection.reset();
+  });
 
-      test('Object exists', () => {
-        expect(CssRulesView).toBeTruthy();
-      });
+  test('Object exists', () => {
+    expect(CssRulesView).toBeTruthy();
+  });
 
-      test('Collection is empty. Styles structure bootstraped', () => {
-        expect(obj.$el.html()).toBeTruthy();
-        const foundStylesContainers = obj.$el.find('div');
-        expect(foundStylesContainers.length).toEqual(devices.length);
+  test('Collection is empty. Styles structure bootstraped', () => {
+    expect(obj.$el.html()).toBeTruthy();
+    const foundStylesContainers = obj.$el.find('div');
+    expect(foundStylesContainers.length).toEqual(devices.length);
 
-        const sortedDevicesWidthMedia = devices
-          .map(dvc => dvc.widthMedia)
-          .sort((left, right) => {
-            return (
-              ((right && right.replace('px', '')) || Number.MAX_VALUE) -
-              ((left && left.replace('px', '')) || Number.MAX_VALUE)
-            );
-          })
-          .map(widthMedia => parseFloat(widthMedia));
+    const sortedDevicesWidthMedia = devices
+      .map(dvc => dvc.widthMedia)
+      .sort((left, right) => {
+        return (
+          ((right && right.replace('px', '')) || Number.MAX_VALUE) -
+          ((left && left.replace('px', '')) || Number.MAX_VALUE)
+        );
+      })
+      .map(widthMedia => parseFloat(widthMedia));
 
-        foundStylesContainers.each(($styleC, idx) => {
-          const width = sortedDevicesWidthMedia[idx];
-          expect($styleC.id).toEqual(`${prefix}${width ? `-${width}` : ''}`);
-        });
-      });
+    foundStylesContainers.each(($styleC, idx) => {
+      const width = sortedDevicesWidthMedia[idx];
+      expect($styleC.id).toEqual(`${prefix}${width ? `-${width}` : ''}`);
+    });
+  });
 
-      test('Add new rule', () => {
-        sinon.stub(obj, 'addToCollection');
-        obj.collection.add({});
-        expect(obj.addToCollection.calledOnce).toBeTruthy();
-      });
+  test('Add new rule', () => {
+    sinon.stub(obj, 'addToCollection');
+    obj.collection.add({});
+    expect(obj.addToCollection.calledOnce).toBeTruthy();
+  });
 
-      test('Add correctly rules with different media queries', () => {
-        const foundStylesContainers = obj.$el.find('div');
-        const rules = [
-          {
-            selectorsAdd: '#testid'
-          },
-          {
-            selectorsAdd: '#testid2',
-            mediaText: '(max-width: 1000px)'
-          },
-          {
-            selectorsAdd: '#testid3',
-            mediaText: '(min-width: 900px)'
-          },
-          {
-            selectorsAdd: '#testid4',
-            mediaText: 'screen and (max-width: 900px) and (min-width: 600px)'
-          }
-        ];
-        obj.collection.add(rules);
-        const stylesCont = obj.el.querySelector(`#${obj.className}`);
-        expect(stylesCont.children.length).toEqual(rules.length);
-      });
+  test('Add correctly rules with different media queries', () => {
+    const foundStylesContainers = obj.$el.find('div');
+    const rules = [
+      {
+        selectorsAdd: '#testid'
+      },
+      {
+        selectorsAdd: '#testid2',
+        mediaText: '(max-width: 1000px)'
+      },
+      {
+        selectorsAdd: '#testid3',
+        mediaText: '(min-width: 900px)'
+      },
+      {
+        selectorsAdd: '#testid4',
+        mediaText: 'screen and (max-width: 900px) and (min-width: 600px)'
+      }
+    ];
+    obj.collection.add(rules);
+    const stylesCont = obj.el.querySelector(`#${obj.className}`);
+    expect(stylesCont.children.length).toEqual(rules.length);
+  });
 
-      test('Render new rule', () => {
-        obj.collection.add({});
-        expect(obj.$el.find(`#${prefix}`).html()).toBeTruthy();
-      });
-    });
-  }
-};
+  test('Render new rule', () => {
+    obj.collection.add({});
+    expect(obj.$el.find(`#${prefix}`).html()).toBeTruthy();
+  });
+});

test/specs/device_manager/index.js

@@ -58,6 +58,4 @@ describe('DeviceManager', () => {
       expect(obj.render()).toBeTruthy();
     });
   });
-
-  DevicesView.run();
 });

test/specs/device_manager/view/DevicesView.js

@@ -1,68 +1,62 @@
 import DevicesView from 'device_manager/view/DevicesView';
 import Devices from 'device_manager/model/Devices';
 
-module.exports = {
-  run() {
-    describe('DevicesView', () => {
-      var $fixtures;
-      var $fixture;
-      var model;
-      var view;
-      var editorModel;
-      var em;
-
-      beforeEach(() => {
-        model = new Devices([]);
-        view = new DevicesView({
-          collection: model
-        });
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        document.body.querySelector('#fixtures').appendChild(view.render().el);
-      });
-
-      afterEach(() => {
-        view.collection.reset();
-      });
-
-      test('The content is not empty', () => {
-        expect(view.el.innerHTML).toBeTruthy();
-      });
-
-      test('No options without devices', () => {
-        expect(view.getOptions()).toEqual('');
-      });
-
-      test('Render new button', () => {
-        view.collection.add({});
-        expect(view.$el.html()).toBeTruthy();
+describe('DevicesView', () => {
+  var $fixtures;
+  var $fixture;
+  var model;
+  var view;
+  var editorModel;
+  var em;
+
+  beforeEach(() => {
+    model = new Devices([]);
+    view = new DevicesView({
+      collection: model
+    });
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    document.body.querySelector('#fixtures').appendChild(view.render().el);
+  });
+
+  afterEach(() => {
+    view.collection.reset();
+  });
+
+  test('The content is not empty', () => {
+    expect(view.el.innerHTML).toBeTruthy();
+  });
+
+  test('No options without devices', () => {
+    expect(view.getOptions()).toEqual('');
+  });
+
+  test('Render new button', () => {
+    view.collection.add({});
+    expect(view.$el.html()).toBeTruthy();
+  });
+
+  describe('With configs', () => {
+    beforeEach(() => {
+      editorModel = new Backbone.Model();
+      model = new Devices([{ name: 'test1' }, { name: 'test2' }]);
+      view = new DevicesView({
+        collection: model,
+        config: { em: editorModel }
       });
+      document.body.innerHTML = '<div id="fixtures"></div>';
+      document.body.querySelector('#fixtures').appendChild(view.render().el);
+    });
 
-      describe('With configs', () => {
-        beforeEach(() => {
-          editorModel = new Backbone.Model();
-          model = new Devices([{ name: 'test1' }, { name: 'test2' }]);
-          view = new DevicesView({
-            collection: model,
-            config: { em: editorModel }
-          });
-          document.body.innerHTML = '<div id="fixtures"></div>';
-          document.body
-            .querySelector('#fixtures')
-            .appendChild(view.render().el);
-        });
-
-        test('Update device on select change', () => {
-          view.$el.find('select').val('test2');
-          view.updateDevice();
-          expect(view.config.em.get('device')).toEqual('test2');
-        });
+    test('Update device on select change', () => {
+      view.$el.find('select').val('test2');
+      view.updateDevice();
+      expect(view.config.em.get('device')).toEqual('test2');
+    });
 
-        test('Render options', () => {
-          expect(view.getOptions()).toEqual(
-            '<option value="test1">test1</option><option value="test2">test2</option>'
-          );
-        });
-      });
+    test('Render options', () => {
+      expect(view.getOptions()).toEqual(
+        '<option value="test1">test1</option><option value="test2">test2</option>'
+      );
     });
-  }
-};
+  });
+});

test/specs/dom_components/index.js

@@ -6,7 +6,7 @@ import ComponentsView from './view/ComponentsView';
 import ComponentTextView from './view/ComponentTextView';
 import ComponentImageView from './view/ComponentImageView';
 import Editor from 'editor/model/Editor';
-import utils from './../test_utils.js';
+import utils from './../../test_utils.js';
 
 describe('DOM Components', () => {
   describe('Main', () => {
@@ -267,13 +267,4 @@ describe('DOM Components', () => {
       expect(comp.get('editable')).toBe(1);
     });
   });
-
-  ComponentModels.run();
-
-  describe('Views', () => {
-    ComponentView.run();
-    ComponentsView.run();
-    ComponentTextView.run();
-    ComponentImageView.run();
-  });
 });

test/specs/dom_components/view/ComponentImageView.js

@@ -1,41 +1,37 @@
 import ComponentImageView from 'dom_components/view/ComponentImageView';
 import Component from 'dom_components/model/ComponentImage';
 
-module.exports = {
-  run() {
-    describe('ComponentImageView', () => {
-      var model;
-      var view;
+describe('ComponentImageView', () => {
+  var model;
+  var view;
 
-      beforeEach(() => {
-        model = new Component();
-        view = new ComponentImageView({
-          model
-        });
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        document.body.querySelector('#fixtures').appendChild(view.render().el);
-      });
+  beforeEach(() => {
+    model = new Component();
+    view = new ComponentImageView({
+      model
+    });
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    document.body.querySelector('#fixtures').appendChild(view.render().el);
+  });
 
-      afterEach(() => {
-        view.remove();
-      });
+  afterEach(() => {
+    view.remove();
+  });
 
-      test('Component empty', () => {
-        expect(view.el.getAttribute('class')).toEqual(view.classEmpty);
-      });
+  test('Component empty', () => {
+    expect(view.el.getAttribute('class')).toEqual(view.classEmpty);
+  });
 
-      test('TagName is <img>', () => {
-        expect(view.el.tagName).toEqual('IMG');
-      });
+  test('TagName is <img>', () => {
+    expect(view.el.tagName).toEqual('IMG');
+  });
 
-      test('Update src attribute', () => {
-        model.set('src', './');
-        expect(view.el.getAttribute('src')).toEqual('./');
-      });
+  test('Update src attribute', () => {
+    model.set('src', './');
+    expect(view.el.getAttribute('src')).toEqual('./');
+  });
 
-      test('Renders correctly', () => {
-        expect(view.render()).toBeTruthy();
-      });
-    });
-  }
-};
+  test('Renders correctly', () => {
+    expect(view.render()).toBeTruthy();
+  });
+});

test/specs/dom_components/view/ComponentTextView.js

@@ -1,46 +1,42 @@
 import ComponentTextView from 'dom_components/view/ComponentTextView';
 import Component from 'dom_components/model/Component';
 
-module.exports = {
-  run() {
-    describe('ComponentTextView', () => {
-      var fixtures;
-      var model;
-      var view;
+describe('ComponentTextView', () => {
+  var fixtures;
+  var model;
+  var view;
 
-      beforeEach(() => {
-        model = new Component();
-        view = new ComponentTextView({
-          model
-        });
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        fixtures = document.body.querySelector('#fixtures');
-        fixtures.appendChild(view.render().el);
-      });
+  beforeEach(() => {
+    model = new Component();
+    view = new ComponentTextView({
+      model
+    });
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    fixtures = document.body.querySelector('#fixtures');
+    fixtures.appendChild(view.render().el);
+  });
 
-      afterEach(() => {
-        view.remove();
-      });
+  afterEach(() => {
+    view.remove();
+  });
 
-      test('Component empty', () => {
-        expect(fixtures.innerHTML).toEqual(
-          '<div data-gjs-type="default" data-highlightable="1"></div>'
-        );
-      });
+  test('Component empty', () => {
+    expect(fixtures.innerHTML).toEqual(
+      '<div data-gjs-type="default" data-highlightable="1"></div>'
+    );
+  });
 
-      test('Input content is stored in model', () => {
-        //view.enableEditing();
-        view.el.innerHTML = 'test';
-        //view.disableEditing();
-        //model.get('content').should.equal('test');
-      });
+  test('Input content is stored in model', () => {
+    //view.enableEditing();
+    view.el.innerHTML = 'test';
+    //view.disableEditing();
+    //model.get('content').should.equal('test');
+  });
 
-      test('Init with content', () => {
-        model = new Component({ content: 'test' });
-        view = new ComponentTextView({ model });
-        fixtures.appendChild(view.render().el);
-        expect(view.el.innerHTML).toEqual('test');
-      });
-    });
-  }
-};
+  test('Init with content', () => {
+    model = new Component({ content: 'test' });
+    view = new ComponentTextView({ model });
+    fixtures.appendChild(view.render().el);
+    expect(view.el.innerHTML).toEqual('test');
+  });
+});

test/specs/dom_components/view/ComponentV.js

@@ -3,144 +3,140 @@ import Component from 'dom_components/model/Component';
 import DomComponents from 'dom_components';
 import Editor from 'editor/model/Editor';
 
-module.exports = {
-  run() {
-    describe('ComponentView', () => {
-      var fixtures;
-      var model;
-      var view;
-      var hClass = 'hc-state';
-      var dcomp;
-      var compOpts;
-      let em;
-
-      beforeEach(() => {
-        em = new Editor({});
-        dcomp = new DomComponents();
-        compOpts = {
-          em,
-          componentTypes: dcomp.componentTypes
-        };
-        model = new Component({}, compOpts);
-        view = new ComponentView({
-          model
-        });
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        fixtures = document.body.querySelector('#fixtures');
-        fixtures.appendChild(view.render().el);
-      });
-
-      afterEach(() => {
-        view.remove();
-      });
-
-      test('Component empty', () => {
-        expect(fixtures.innerHTML).toEqual(
-          '<div data-gjs-type="default" data-highlightable="1"></div>'
-        );
-      });
-
-      test('Add helper class on update of state', () => {
-        model.set('state', 'test');
-        expect(fixtures.innerHTML).toEqual(
-          '<div data-gjs-type="default" data-highlightable="1" class="' +
-            hClass +
-            '"></div>'
-        );
-      });
-
-      test('Clean form helper state', () => {
-        model.set('state', 'test');
-        model.set('state', '');
-        expect(fixtures.innerHTML).toEqual(
-          '<div data-gjs-type="default" data-highlightable="1" class=""></div>'
-        );
-      });
-
-      test('Add helper class on status update', () => {
-        model.set('status', 'selected');
-        expect(fixtures.innerHTML).toEqual(
-          '<div data-gjs-type="default" data-highlightable="1" class="selected"></div>'
-        );
-      });
-
-      test('Get string of classes', () => {
-        model.set('attributes', { class: ['test', 'test2'] });
-        expect(view.getClasses()).toEqual('test test2');
-      });
-
-      test('Update attributes', () => {
-        model.set('attributes', {
-          title: 'value',
-          'data-test': 'value2'
-        });
-        expect(view.el.getAttribute('title')).toEqual('value');
-        expect(view.el.getAttribute('data-test')).toEqual('value2');
-      });
-
-      test('Update style', () => {
-        model.set('style', {
-          color: 'red',
-          float: 'left'
-        });
-        expect(view.el.getAttribute('style')).toEqual('color:red;float:left;');
-      });
-
-      test('Clean style', () => {
-        model.set('style', { color: 'red' });
-        model.set('style', {});
-        expect(view.el.getAttribute('style')).toEqual(null);
-      });
-
-      test('Add class', () => {
-        model.get('classes').add({ name: 'test' });
-        expect(view.el.getAttribute('class')).toEqual('test');
-      });
-
-      test('Add classes', () => {
-        model.get('classes').add([{ name: 'test' }, { name: 'test2' }]);
-        expect(view.el.getAttribute('class')).toEqual('test test2');
-      });
-
-      test('Update on remove of some class', () => {
-        var cls1 = model.get('classes').add({ name: 'test' });
-        var cls12 = model.get('classes').add({ name: 'test2' });
-        model.get('classes').remove(cls1);
-        expect(view.el.getAttribute('class')).toEqual('test2');
-      });
-
-      test('Init with different tag', () => {
-        model = new Component({ tagName: 'span' });
-        view = new ComponentView({ model });
-        fixtures.innerHTML = '';
-        fixtures.appendChild(view.render().el);
-        expect(view.render().el.tagName).toEqual('SPAN');
-      });
-
-      test('Init with nested components', () => {
-        model = new Component(
-          {
-            components: [{ tagName: 'span' }, { attributes: { title: 'test' } }]
-          },
-          compOpts
-        );
-        view = new ComponentView({
-          model,
-          componentTypes: dcomp.componentTypes
-        });
-        fixtures.innerHTML = '';
-        fixtures.appendChild(view.render().el);
-        expect(view.$el.html()).toEqual(
-          '<span data-gjs-type="default" data-highlightable="1"></span><div data-gjs-type="default" data-highlightable="1" title="test"></div>'
-        );
-      });
-
-      test('removeClass removes classes from attributes', () => {
-        model.addClass('class1');
-        model.removeClass('class1');
-        const result = model.getAttributes();
-        expect(result.class).toEqual(undefined);
-      });
+describe('ComponentView', () => {
+  var fixtures;
+  var model;
+  var view;
+  var hClass = 'hc-state';
+  var dcomp;
+  var compOpts;
+  let em;
+
+  beforeEach(() => {
+    em = new Editor({});
+    dcomp = new DomComponents();
+    compOpts = {
+      em,
+      componentTypes: dcomp.componentTypes
+    };
+    model = new Component({}, compOpts);
+    view = new ComponentView({
+      model
     });
-  }
-};
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    fixtures = document.body.querySelector('#fixtures');
+    fixtures.appendChild(view.render().el);
+  });
+
+  afterEach(() => {
+    view.remove();
+  });
+
+  test('Component empty', () => {
+    expect(fixtures.innerHTML).toEqual(
+      '<div data-gjs-type="default" data-highlightable="1"></div>'
+    );
+  });
+
+  test('Add helper class on update of state', () => {
+    model.set('state', 'test');
+    expect(fixtures.innerHTML).toEqual(
+      '<div data-gjs-type="default" data-highlightable="1" class="' +
+        hClass +
+        '"></div>'
+    );
+  });
+
+  test('Clean form helper state', () => {
+    model.set('state', 'test');
+    model.set('state', '');
+    expect(fixtures.innerHTML).toEqual(
+      '<div data-gjs-type="default" data-highlightable="1" class=""></div>'
+    );
+  });
+
+  test('Add helper class on status update', () => {
+    model.set('status', 'selected');
+    expect(fixtures.innerHTML).toEqual(
+      '<div data-gjs-type="default" data-highlightable="1" class="selected"></div>'
+    );
+  });
+
+  test('Get string of classes', () => {
+    model.set('attributes', { class: ['test', 'test2'] });
+    expect(view.getClasses()).toEqual('test test2');
+  });
+
+  test('Update attributes', () => {
+    model.set('attributes', {
+      title: 'value',
+      'data-test': 'value2'
+    });
+    expect(view.el.getAttribute('title')).toEqual('value');
+    expect(view.el.getAttribute('data-test')).toEqual('value2');
+  });
+
+  test('Update style', () => {
+    model.set('style', {
+      color: 'red',
+      float: 'left'
+    });
+    expect(view.el.getAttribute('style')).toEqual('color:red;float:left;');
+  });
+
+  test('Clean style', () => {
+    model.set('style', { color: 'red' });
+    model.set('style', {});
+    expect(view.el.getAttribute('style')).toEqual(null);
+  });
+
+  test('Add class', () => {
+    model.get('classes').add({ name: 'test' });
+    expect(view.el.getAttribute('class')).toEqual('test');
+  });
+
+  test('Add classes', () => {
+    model.get('classes').add([{ name: 'test' }, { name: 'test2' }]);
+    expect(view.el.getAttribute('class')).toEqual('test test2');
+  });
+
+  test('Update on remove of some class', () => {
+    var cls1 = model.get('classes').add({ name: 'test' });
+    var cls12 = model.get('classes').add({ name: 'test2' });
+    model.get('classes').remove(cls1);
+    expect(view.el.getAttribute('class')).toEqual('test2');
+  });
+
+  test('Init with different tag', () => {
+    model = new Component({ tagName: 'span' });
+    view = new ComponentView({ model });
+    fixtures.innerHTML = '';
+    fixtures.appendChild(view.render().el);
+    expect(view.render().el.tagName).toEqual('SPAN');
+  });
+
+  test('Init with nested components', () => {
+    model = new Component(
+      {
+        components: [{ tagName: 'span' }, { attributes: { title: 'test' } }]
+      },
+      compOpts
+    );
+    view = new ComponentView({
+      model,
+      componentTypes: dcomp.componentTypes
+    });
+    fixtures.innerHTML = '';
+    fixtures.appendChild(view.render().el);
+    expect(view.$el.html()).toEqual(
+      '<span data-gjs-type="default" data-highlightable="1"></span><div data-gjs-type="default" data-highlightable="1" title="test"></div>'
+    );
+  });
+
+  test('removeClass removes classes from attributes', () => {
+    model.addClass('class1');
+    model.removeClass('class1');
+    const result = model.getAttributes();
+    expect(result.class).toEqual(undefined);
+  });
+});

test/specs/dom_components/view/ComponentsView.js

@@ -2,48 +2,44 @@ import DomComponents from 'dom_components';
 import ComponentsView from 'dom_components/view/ComponentsView';
 import Components from 'dom_components/model/Components';
 
-module.exports = {
-  run() {
-    describe('ComponentsView', () => {
-      var $fixtures;
-      var $fixture;
-      var model;
-      var view;
-      var dcomp;
-      var compOpts;
+describe('ComponentsView', () => {
+  var $fixtures;
+  var $fixture;
+  var model;
+  var view;
+  var dcomp;
+  var compOpts;
 
-      beforeEach(() => {
-        dcomp = new DomComponents();
-        compOpts = {
-          componentTypes: dcomp.componentTypes
-        };
-        model = new Components([], compOpts);
-        view = new ComponentsView({
-          collection: model,
-          componentTypes: dcomp.componentTypes
-        });
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        document.body.querySelector('#fixtures').appendChild(view.render().el);
-      });
+  beforeEach(() => {
+    dcomp = new DomComponents();
+    compOpts = {
+      componentTypes: dcomp.componentTypes
+    };
+    model = new Components([], compOpts);
+    view = new ComponentsView({
+      collection: model,
+      componentTypes: dcomp.componentTypes
+    });
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    document.body.querySelector('#fixtures').appendChild(view.render().el);
+  });
 
-      afterEach(() => {
-        view.collection.reset();
-      });
+  afterEach(() => {
+    view.collection.reset();
+  });
 
-      test('Collection is empty', () => {
-        expect(view.$el.html()).toBeFalsy();
-      });
+  test('Collection is empty', () => {
+    expect(view.$el.html()).toBeFalsy();
+  });
 
-      test('Add new component', () => {
-        sinon.stub(view, 'addToCollection');
-        view.collection.add({});
-        expect(view.addToCollection.calledOnce).toEqual(true);
-      });
+  test('Add new component', () => {
+    sinon.stub(view, 'addToCollection');
+    view.collection.add({});
+    expect(view.addToCollection.calledOnce).toEqual(true);
+  });
 
-      test('Render new component', () => {
-        view.collection.add({});
-        expect(view.$el.html()).toBeTruthy();
-      });
-    });
-  }
-};
+  test('Render new component', () => {
+    view.collection.add({});
+    expect(view.$el.html()).toBeTruthy();
+  });
+});

test/specs/modal/index.js

@@ -55,6 +55,4 @@ describe('Modal dialog', () => {
       expect(obj.isOpen()).toEqual(false);
     });
   });
-
-  ModalView.run();
 });

test/specs/modal/view/ModalView.js

@@ -1,58 +1,54 @@
 import ModalView from 'modal_dialog/view/ModalView';
 import Modal from 'modal_dialog/model/Modal';
 
-module.exports = {
-  run() {
-    describe('ModalView', () => {
-      var model;
-      var view;
-      var editorModel;
-
-      beforeEach(() => {
-        model = new Modal();
-        view = new ModalView({
-          model
-        });
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        document.body.querySelector('#fixtures').appendChild(view.render().el);
-      });
-
-      afterEach(() => {
-        view = null;
-        model = null;
-      });
-
-      test('The content is not empty', () => {
-        expect(view.el.innerHTML).toBeTruthy();
-      });
-
-      test('Get content', () => {
-        expect(view.getContent()).toBeTruthy();
-      });
-
-      test('Update content', () => {
-        model.set('content', 'test');
-        expect(view.getContent().get(0).innerHTML).toEqual('test');
-      });
-
-      test('Get title', () => {
-        expect(view.getTitle()).toBeTruthy();
-      });
-
-      test('Update title', () => {
-        model.set('title', 'test');
-        expect(view.getTitle().innerHTML).toEqual('test');
-      });
-
-      test('Close by default', () => {
-        view.updateOpen();
-        expect(view.el.style.display).toEqual('none');
-      });
-
-      test('Open dialog', () => {
-        model.set('open', 1);
-        expect(view.el.style.display).toEqual('');
-      });
+describe('ModalView', () => {
+  var model;
+  var view;
+  var editorModel;
+
+  beforeEach(() => {
+    model = new Modal();
+    view = new ModalView({
+      model
     });
-  }
-};
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    document.body.querySelector('#fixtures').appendChild(view.render().el);
+  });
+
+  afterEach(() => {
+    view = null;
+    model = null;
+  });
+
+  test('The content is not empty', () => {
+    expect(view.el.innerHTML).toBeTruthy();
+  });
+
+  test('Get content', () => {
+    expect(view.getContent()).toBeTruthy();
+  });
+
+  test('Update content', () => {
+    model.set('content', 'test');
+    expect(view.getContent().get(0).innerHTML).toEqual('test');
+  });
+
+  test('Get title', () => {
+    expect(view.getTitle()).toBeTruthy();
+  });
+
+  test('Update title', () => {
+    model.set('title', 'test');
+    expect(view.getTitle().innerHTML).toEqual('test');
+  });
+
+  test('Close by default', () => {
+    view.updateOpen();
+    expect(view.el.style.display).toEqual('none');
+  });
+
+  test('Open dialog', () => {
+    model.set('open', 1);
+    expect(view.el.style.display).toEqual('');
+  });
+});

test/specs/panels/e2e/PanelsE2e.js

@@ -1,70 +1,66 @@
-module.exports = {
-  run() {
-    describe('E2E tests', () => {
-      var fixtures;
-      var fixture;
-      var obj;
-      var config;
-      var editorName = 'panel-fixture';
+describe('E2E tests', () => {
+  var fixtures;
+  var fixture;
+  var obj;
+  var config;
+  var editorName = 'panel-fixture';
 
-      beforeAll(() => {
-        fixtures = $('<div id="#fixtures"></div>').appendTo('body');
-      });
+  beforeAll(() => {
+    fixtures = $('<div id="#fixtures"></div>').appendTo('body');
+  });
 
-      beforeEach(() => {
-        obj = grapesjs;
-        config = {
-          container: '#' + editorName,
-          storageManager: { autoload: 0, type: 'none' }
-        };
-        fixture = $('<div id="' + editorName + '"></div>');
-        fixture.empty().appendTo(fixtures);
-      });
+  beforeEach(() => {
+    obj = grapesjs;
+    config = {
+      container: '#' + editorName,
+      storageManager: { autoload: 0, type: 'none' }
+    };
+    fixture = $('<div id="' + editorName + '"></div>');
+    fixture.empty().appendTo(fixtures);
+  });
 
-      afterEach(() => {
-        obj = null;
-        config = null;
-        fixture.remove();
-      });
+  afterEach(() => {
+    obj = null;
+    config = null;
+    fixture.remove();
+  });
 
-      afterAll(() => {
-        //fixture.remove();
-      });
+  afterAll(() => {
+    //fixture.remove();
+  });
 
-      test('Command is correctly executed on button click', () => {
-        var commandId = 'command-test';
-        config.commands = {
-          defaults: [
+  test('Command is correctly executed on button click', () => {
+    var commandId = 'command-test';
+    config.commands = {
+      defaults: [
+        {
+          id: commandId,
+          run(ed, caller) {
+            ed.testValue = 'testValue';
+            caller.set('active', false);
+          }
+        }
+      ]
+    };
+    config.panels = {
+      defaults: [
+        {
+          id: 'toolbar-test',
+          buttons: [
             {
-              id: commandId,
-              run(ed, caller) {
-                ed.testValue = 'testValue';
-                caller.set('active', false);
-              }
+              id: 'button-test',
+              className: 'fa fa-smile-o',
+              command: commandId
             }
           ]
-        };
-        config.panels = {
-          defaults: [
-            {
-              id: 'toolbar-test',
-              buttons: [
-                {
-                  id: 'button-test',
-                  className: 'fa fa-smile-o',
-                  command: commandId
-                }
-              ]
-            }
-          ]
-        };
-        var editor = obj.init(config);
-        editor.testValue = '';
-        var button = editor.Panels.getButton('toolbar-test', 'button-test');
-        button.set('active', 1);
-        expect(editor.testValue).toEqual('testValue');
-        expect(button.get('active')).toEqual(false);
-      });
-    });
-  }
-};
+        }
+      ]
+    };
+    var editor = obj.init(config);
+    editor.testValue = '';
+    var button = editor.Panels.getButton('toolbar-test', 'button-test');
+    button.set('active', 1);
+    expect(editor.testValue).toEqual('testValue');
+    expect(button.get('active')).toEqual(false);
+  });
+});

test/specs/panels/index.js

@@ -166,14 +166,4 @@ describe('Panels', () => {
       });
     });
   });
-
-  Models.run();
-
-  describe('Views', () => {
-    PanelView.run();
-    PanelsView.run();
-    ButtonView.run();
-    ButtonsView.run();
-    e2e.run();
-  });
 });

test/specs/panels/model/PanelModels.js

@@ -2,133 +2,129 @@ import Button from 'panels/model/Button';
 import Buttons from 'panels/model/Buttons';
 import Panel from 'panels/model/Panel';
 
-module.exports = {
-  run() {
-    describe('Button', () => {
-      var obj;
-
-      beforeEach(() => {
-        obj = new Button();
-      });
-
-      afterEach(() => {
-        obj = null;
-      });
-
-      test('Has buttons instance', () => {
-        expect(obj.has('buttons')).toEqual(true);
-      });
-
-      test('Has no buttons', () => {
-        expect(obj.get('buttons').length).toEqual(0);
-      });
-
-      test('Init with other buttons inside correctly', () => {
-        obj = new Button({
-          buttons: [{}]
-        });
-        expect(obj.get('buttons') instanceof Buttons).toEqual(true);
-        expect(obj.get('buttons').length).toEqual(1);
-      });
-
-      test('Has a disable attribute with default value as false', () => {
-        expect(obj.get('disable')).toEqual(false);
-      });
-    });
+describe('Button', () => {
+  var obj;
 
-    describe('Buttons', () => {
-      var obj;
-
-      beforeEach(() => {
-        obj = new Buttons();
-      });
-
-      afterEach(() => {
-        obj = null;
-      });
-
-      test('Deactivates buttons', () => {
-        obj.add({ active: true });
-        obj.deactivateAll();
-        expect(obj.at(0).get('active')).toEqual(false);
-      });
-
-      test('Deactivates buttons with context', () => {
-        obj.add({ active: true });
-        obj.deactivateAll('someContext');
-        expect(obj.at(0).get('active')).toEqual(true);
-      });
-
-      test('Deactivates except one', () => {
-        var btn = obj.add({ active: true });
-        obj.deactivateAllExceptOne();
-        expect(obj.at(0).get('active')).toEqual(false);
-      });
-
-      test('Deactivates except one with model', () => {
-        var btn = obj.add({ active: true });
-        obj.deactivateAllExceptOne(btn);
-        expect(obj.at(0).get('active')).toEqual(true);
-      });
-
-      test('Disable all buttons', () => {
-        obj.add({ disable: false });
-        obj.disableAllButtons();
-        expect(obj.at(0).get('disable')).toEqual(true);
-      });
-
-      test('Disables buttons with context', () => {
-        obj.add({ disable: false, context: 'someContext' });
-        obj.disableAllButtons('someContext');
-        expect(obj.at(0).get('disable')).toEqual(true);
-      });
-
-      test('Disables except one', () => {
-        var btn = obj.add({ disable: false });
-        obj.disableAllButtonsExceptOne(btn);
-        expect(obj.at(0).get('disable')).toEqual(false);
-      });
-    });
+  beforeEach(() => {
+    obj = new Button();
+  });
 
-    describe('Panel', () => {
-      var obj;
-
-      beforeEach(() => {
-        obj = new Panel();
-      });
-
-      afterEach(() => {
-        obj = null;
-      });
-
-      test('Has buttons instance', () => {
-        expect(obj.has('buttons')).toEqual(true);
-        expect(obj.get('buttons') instanceof Buttons).toEqual(true);
-      });
-
-      test('Has no buttons', () => {
-        expect(obj.get('buttons').length).toEqual(0);
-      });
-
-      test('Init with buttons inside correctly', () => {
-        obj = new Panel({
-          buttons: [{}]
-        });
-        expect(obj.get('buttons') instanceof Buttons).toEqual(true);
-        expect(obj.get('buttons').length).toEqual(1);
-      });
-    });
+  afterEach(() => {
+    obj = null;
+  });
 
-    describe('Panels', () => {
-      var obj;
+  test('Has buttons instance', () => {
+    expect(obj.has('buttons')).toEqual(true);
+  });
 
-      beforeEach(() => {
-        obj = new Panel();
-      });
+  test('Has no buttons', () => {
+    expect(obj.get('buttons').length).toEqual(0);
+  });
 
-      afterEach(() => {
-        obj = null;
-      });
+  test('Init with other buttons inside correctly', () => {
+    obj = new Button({
+      buttons: [{}]
+    });
+    expect(obj.get('buttons') instanceof Buttons).toEqual(true);
+    expect(obj.get('buttons').length).toEqual(1);
+  });
+
+  test('Has a disable attribute with default value as false', () => {
+    expect(obj.get('disable')).toEqual(false);
+  });
+});
+
+describe('Buttons', () => {
+  var obj;
+
+  beforeEach(() => {
+    obj = new Buttons();
+  });
+
+  afterEach(() => {
+    obj = null;
+  });
+
+  test('Deactivates buttons', () => {
+    obj.add({ active: true });
+    obj.deactivateAll();
+    expect(obj.at(0).get('active')).toEqual(false);
+  });
+
+  test('Deactivates buttons with context', () => {
+    obj.add({ active: true });
+    obj.deactivateAll('someContext');
+    expect(obj.at(0).get('active')).toEqual(true);
+  });
+
+  test('Deactivates except one', () => {
+    var btn = obj.add({ active: true });
+    obj.deactivateAllExceptOne();
+    expect(obj.at(0).get('active')).toEqual(false);
+  });
+
+  test('Deactivates except one with model', () => {
+    var btn = obj.add({ active: true });
+    obj.deactivateAllExceptOne(btn);
+    expect(obj.at(0).get('active')).toEqual(true);
+  });
+
+  test('Disable all buttons', () => {
+    obj.add({ disable: false });
+    obj.disableAllButtons();
+    expect(obj.at(0).get('disable')).toEqual(true);
+  });
+
+  test('Disables buttons with context', () => {
+    obj.add({ disable: false, context: 'someContext' });
+    obj.disableAllButtons('someContext');
+    expect(obj.at(0).get('disable')).toEqual(true);
+  });
+
+  test('Disables except one', () => {
+    var btn = obj.add({ disable: false });
+    obj.disableAllButtonsExceptOne(btn);
+    expect(obj.at(0).get('disable')).toEqual(false);
+  });
+});
+
+describe('Panel', () => {
+  var obj;
+
+  beforeEach(() => {
+    obj = new Panel();
+  });
+
+  afterEach(() => {
+    obj = null;
+  });
+
+  test('Has buttons instance', () => {
+    expect(obj.has('buttons')).toEqual(true);
+    expect(obj.get('buttons') instanceof Buttons).toEqual(true);
+  });
+
+  test('Has no buttons', () => {
+    expect(obj.get('buttons').length).toEqual(0);
+  });
+
+  test('Init with buttons inside correctly', () => {
+    obj = new Panel({
+      buttons: [{}]
     });
-  }
-};
+    expect(obj.get('buttons') instanceof Buttons).toEqual(true);
+    expect(obj.get('buttons').length).toEqual(1);
+  });
+});
+
+describe('Panels', () => {
+  var obj;
+
+  beforeEach(() => {
+    obj = new Panel();
+  });
+
+  afterEach(() => {
+    obj = null;
+  });
+});

test/specs/panels/view/ButtonView.js

@@ -1,91 +1,87 @@
 import ButtonView from 'panels/view/ButtonView';
 import Button from 'panels/model/Button';
 
-module.exports = {
-  run() {
-    describe('ButtonView', () => {
-      var fixtures;
-      var model;
-      var view;
-      var btnClass = 'btn';
+describe('ButtonView', () => {
+  var fixtures;
+  var model;
+  var view;
+  var btnClass = 'btn';
 
-      beforeEach(() => {
-        model = new Button();
-        view = new ButtonView({
-          model: model
-        });
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        fixtures = document.body.querySelector('#fixtures');
-        fixtures.appendChild(view.render().el);
-      });
+  beforeEach(() => {
+    model = new Button();
+    view = new ButtonView({
+      model: model
+    });
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    fixtures = document.body.querySelector('#fixtures');
+    fixtures.appendChild(view.render().el);
+  });
 
-      afterEach(() => {
-        view.remove();
-      });
+  afterEach(() => {
+    view.remove();
+  });
 
-      test('Button empty', () => {
-        expect(fixtures.innerHTML).toEqual(
-          '<span class="' + btnClass + '"></span>'
-        );
-      });
+  test('Button empty', () => {
+    expect(fixtures.innerHTML).toEqual(
+      '<span class="' + btnClass + '"></span>'
+    );
+  });
 
-      test('Update class', () => {
-        model.set('className', 'test');
-        expect(view.el.getAttribute('class')).toEqual(btnClass + ' test');
-      });
+  test('Update class', () => {
+    model.set('className', 'test');
+    expect(view.el.getAttribute('class')).toEqual(btnClass + ' test');
+  });
 
-      test('Update attributes', () => {
-        model.set('attributes', {
-          'data-test': 'test-value'
-        });
-        expect(view.el.getAttribute('data-test')).toEqual('test-value');
-      });
+  test('Update attributes', () => {
+    model.set('attributes', {
+      'data-test': 'test-value'
+    });
+    expect(view.el.getAttribute('data-test')).toEqual('test-value');
+  });
 
-      test('Check enable active', () => {
-        model.set('active', true, { silent: true });
-        view.checkActive();
-        expect(view.el.getAttribute('class')).toContain(btnClass + ' active');
-      });
+  test('Check enable active', () => {
+    model.set('active', true, { silent: true });
+    view.checkActive();
+    expect(view.el.getAttribute('class')).toContain(btnClass + ' active');
+  });
 
-      test('Check disable active', () => {
-        model.set('active', true, { silent: true });
-        view.checkActive();
-        model.set('active', false, { silent: true });
-        view.checkActive();
-        expect(view.el.getAttribute('class')).toEqual(btnClass);
-      });
+  test('Check disable active', () => {
+    model.set('active', true, { silent: true });
+    view.checkActive();
+    model.set('active', false, { silent: true });
+    view.checkActive();
+    expect(view.el.getAttribute('class')).toEqual(btnClass);
+  });
 
-      test('Disable the button', () => {
-        model.set('disable', true, { silent: true });
-        view.updateDisable();
-        expect(view.el.getAttribute('class')).toEqual(btnClass + ' disabled');
-      });
+  test('Disable the button', () => {
+    model.set('disable', true, { silent: true });
+    view.updateDisable();
+    expect(view.el.getAttribute('class')).toEqual(btnClass + ' disabled');
+  });
 
-      test('Enable the disabled button', () => {
-        model.set('disable', true, { silent: true });
-        view.updateDisable();
-        model.set('disable', false, { silent: true });
-        view.updateDisable();
-        expect(view.el.getAttribute('class')).toEqual(btnClass);
-      });
+  test('Enable the disabled button', () => {
+    model.set('disable', true, { silent: true });
+    view.updateDisable();
+    model.set('disable', false, { silent: true });
+    view.updateDisable();
+    expect(view.el.getAttribute('class')).toEqual(btnClass);
+  });
 
-      test('Cancels the click action when button is disabled', () => {
-        const stub = sinon.stub(view, 'toogleActive');
-        model.set('disable', true, { silent: true });
-        view.clicked();
-        expect(stub.called).toEqual(false);
-      });
+  test('Cancels the click action when button is disabled', () => {
+    const stub = sinon.stub(view, 'toogleActive');
+    model.set('disable', true, { silent: true });
+    view.clicked();
+    expect(stub.called).toEqual(false);
+  });
 
-      test('Enable the click action when button is enable', () => {
-        const stub = sinon.stub(view, 'toogleActive');
-        model.set('disable', false, { silent: true });
-        view.clicked();
-        expect(stub.called).toEqual(true);
-      });
+  test('Enable the click action when button is enable', () => {
+    const stub = sinon.stub(view, 'toogleActive');
+    model.set('disable', false, { silent: true });
+    view.clicked();
+    expect(stub.called).toEqual(true);
+  });
 
-      test('Renders correctly', () => {
-        expect(view.render()).toBeTruthy();
-      });
-    });
-  }
-};
+  test('Renders correctly', () => {
+    expect(view.render()).toBeTruthy();
+  });
+});

test/specs/panels/view/ButtonsView.js

@@ -1,41 +1,37 @@
 import ButtonsView from 'panels/view/ButtonsView';
 import Buttons from 'panels/model/Buttons';
 
-module.exports = {
-  run() {
-    describe('ButtonsView', () => {
-      var fixtures;
-      var model;
-      var view;
+describe('ButtonsView', () => {
+  var fixtures;
+  var model;
+  var view;
 
-      beforeEach(() => {
-        model = new Buttons([]);
-        view = new ButtonsView({
-          collection: model
-        });
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        fixtures = document.body.querySelector('#fixtures');
-        fixtures.appendChild(view.render().el);
-      });
+  beforeEach(() => {
+    model = new Buttons([]);
+    view = new ButtonsView({
+      collection: model
+    });
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    fixtures = document.body.querySelector('#fixtures');
+    fixtures.appendChild(view.render().el);
+  });
 
-      afterEach(() => {
-        view.collection.reset();
-      });
+  afterEach(() => {
+    view.collection.reset();
+  });
 
-      test('Collection is empty', () => {
-        expect(view.$el.html()).toEqual('');
-      });
+  test('Collection is empty', () => {
+    expect(view.$el.html()).toEqual('');
+  });
 
-      test('Add new button', () => {
-        sinon.stub(view, 'addToCollection');
-        view.collection.add({});
-        expect(view.addToCollection.calledOnce).toEqual(true);
-      });
+  test('Add new button', () => {
+    sinon.stub(view, 'addToCollection');
+    view.collection.add({});
+    expect(view.addToCollection.calledOnce).toEqual(true);
+  });
 
-      test('Render new button', () => {
-        view.collection.add({});
-        expect(view.$el.html()).toBeTruthy();
-      });
-    });
-  }
-};
+  test('Render new button', () => {
+    view.collection.add({});
+    expect(view.$el.html()).toBeTruthy();
+  });
+});

test/specs/panels/view/PanelView.js

@@ -1,74 +1,70 @@
 import PanelView from 'panels/view/PanelView';
 import Panel from 'panels/model/Panel';
 
-module.exports = {
-  run() {
-    describe('PanelView', () => {
-      var fixtures;
-      var model;
-      var view;
+describe('PanelView', () => {
+  var fixtures;
+  var model;
+  var view;
 
-      beforeEach(() => {
-        model = new Panel();
-        view = new PanelView({
-          model
-        });
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        fixtures = document.body.querySelector('#fixtures');
-        fixtures.appendChild(view.render().el);
-      });
-
-      afterEach(() => {
-        view.remove();
-      });
+  beforeEach(() => {
+    model = new Panel();
+    view = new PanelView({
+      model
+    });
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    fixtures = document.body.querySelector('#fixtures');
+    fixtures.appendChild(view.render().el);
+  });
 
-      test('Panel empty', () => {
-        fixtures.firstChild.className = '';
-        expect(fixtures.innerHTML).toEqual('<div class=""></div>');
-      });
+  afterEach(() => {
+    view.remove();
+  });
 
-      test('Append content', () => {
-        model.set('appendContent', 'test');
-        model.set('appendContent', 'test2');
-        expect(view.$el.html()).toEqual('testtest2');
-      });
+  test('Panel empty', () => {
+    fixtures.firstChild.className = '';
+    expect(fixtures.innerHTML).toEqual('<div class=""></div>');
+  });
 
-      test('Update content', () => {
-        model.set('content', 'test');
-        model.set('content', 'test2');
-        expect(view.$el.html()).toEqual('test2');
-      });
+  test('Append content', () => {
+    model.set('appendContent', 'test');
+    model.set('appendContent', 'test2');
+    expect(view.$el.html()).toEqual('testtest2');
+  });
 
-      test('Hide panel', () => {
-        expect(view.$el.hasClass('hidden')).toBeFalsy();
-        model.set('visible', false);
-        expect(view.$el.hasClass('hidden')).toBeTruthy();
-      });
+  test('Update content', () => {
+    model.set('content', 'test');
+    model.set('content', 'test2');
+    expect(view.$el.html()).toEqual('test2');
+  });
 
-      test('Show panel', () => {
-        model.set('visible', false);
-        expect(view.$el.hasClass('hidden')).toBeTruthy();
-        model.set('visible', true);
-        expect(view.$el.hasClass('hidden')).toBeFalsy();
-      });
+  test('Hide panel', () => {
+    expect(view.$el.hasClass('hidden')).toBeFalsy();
+    model.set('visible', false);
+    expect(view.$el.hasClass('hidden')).toBeTruthy();
+  });
 
-      describe('Init with options', () => {
-        beforeEach(() => {
-          model = new Panel({
-            buttons: [{}]
-          });
-          view = new PanelView({
-            model
-          });
-          document.body.innerHTML = '<div id="fixtures"></div>';
-          fixtures = document.body.querySelector('#fixtures');
-          fixtures.appendChild(view.render().el);
-        });
+  test('Show panel', () => {
+    model.set('visible', false);
+    expect(view.$el.hasClass('hidden')).toBeTruthy();
+    model.set('visible', true);
+    expect(view.$el.hasClass('hidden')).toBeFalsy();
+  });
 
-        afterEach(() => {
-          view.remove();
-        });
+  describe('Init with options', () => {
+    beforeEach(() => {
+      model = new Panel({
+        buttons: [{}]
       });
+      view = new PanelView({
+        model
+      });
+      document.body.innerHTML = '<div id="fixtures"></div>';
+      fixtures = document.body.querySelector('#fixtures');
+      fixtures.appendChild(view.render().el);
+    });
+
+    afterEach(() => {
+      view.remove();
     });
-  }
-};
+  });
+});

test/specs/panels/view/PanelsView.js

@@ -1,42 +1,38 @@
 import PanelsView from 'panels/view/PanelsView';
 import Panels from 'panels/model/Panels';
 
-module.exports = {
-  run() {
-    describe('PanelsView', () => {
-      var fixtures;
-      var $fixture;
-      var model;
-      var view;
+describe('PanelsView', () => {
+  var fixtures;
+  var $fixture;
+  var model;
+  var view;
 
-      beforeEach(() => {
-        model = new Panels([]);
-        view = new PanelsView({
-          collection: model
-        });
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        fixtures = document.body.querySelector('#fixtures');
-        fixtures.appendChild(view.render().el);
-      });
+  beforeEach(() => {
+    model = new Panels([]);
+    view = new PanelsView({
+      collection: model
+    });
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    fixtures = document.body.querySelector('#fixtures');
+    fixtures.appendChild(view.render().el);
+  });
 
-      afterEach(() => {
-        view.collection.reset();
-      });
+  afterEach(() => {
+    view.collection.reset();
+  });
 
-      test('Collection is empty', () => {
-        expect(view.$el.html()).toEqual('');
-      });
+  test('Collection is empty', () => {
+    expect(view.$el.html()).toEqual('');
+  });
 
-      test('Add new panel', () => {
-        sinon.stub(view, 'addToCollection');
-        view.collection.add({});
-        expect(view.addToCollection.calledOnce).toEqual(true);
-      });
+  test('Add new panel', () => {
+    sinon.stub(view, 'addToCollection');
+    view.collection.add({});
+    expect(view.addToCollection.calledOnce).toEqual(true);
+  });
 
-      test('Render new panel', () => {
-        view.collection.add({});
-        expect(view.$el.html()).toBeTruthy();
-      });
-    });
-  }
-};
+  test('Render new panel', () => {
+    view.collection.add({});
+    expect(view.$el.html()).toBeTruthy();
+  });
+});

test/specs/parser/index.js

@@ -1,7 +0,0 @@
-import ParserHtml from './model/ParserHtml';
-import ParserCss from './model/ParserCss';
-
-describe('Parser', () => {
-  ParserHtml.run();
-  ParserCss.run();
-});

test/specs/parser/model/ParserCss.js

@@ -1,498 +1,493 @@
 import { parseSelector } from 'parser/model/BrowserParserCss';
 import ParserCss from 'parser/model/ParserCss';
 
-module.exports = {
-  run() {
-    describe('ParserCss', () => {
-      let obj;
-      let config;
-      let customParser;
-
-      beforeEach(() => {
-        config = {
-          em: {
-            getCustomParserCss: () => customParser
-          }
-        };
-        obj = new ParserCss(config);
-      });
-
-      afterEach(() => {
-        obj = null;
-      });
-
-      test('Parse selector', () => {
-        var str = '.test';
-        var result = [['test']];
-        expect(parseSelector(str).result).toEqual(result);
-      });
-
-      test('Parse selectors', () => {
-        var str = '.test1, .test1.test2, .test2.test3';
-        var result = [['test1'], ['test1', 'test2'], ['test2', 'test3']];
-        expect(parseSelector(str).result).toEqual(result);
-      });
-
-      test('Ignore not valid selectors', () => {
-        var str =
-          '.test1.test2, .test2 .test3, div > .test4, #test.test5, .test6';
-        var result = [['test1', 'test2'], ['test6']];
-        expect(parseSelector(str).result).toEqual(result);
-      });
-
-      test('Parse selectors with state', () => {
-        var str = '.test1. test2, .test2>test3, .test4.test5:hover';
-        var result = [['test4', 'test5:hover']];
-        expect(parseSelector(str).result).toEqual(result);
-      });
-
-      test('Parse simple rule', () => {
-        var str = ' .test1 {color:red; width: 50px  }';
-        var result = {
-          selectors: ['test1'],
-          style: {
-            color: 'red',
-            width: '50px'
-          }
-        };
-        expect(obj.parse(str)).toEqual([result]);
-      });
-
-      test('Parse rule with more selectors', () => {
-        var str = ' .test1.test2 {color:red; test: value}';
-        var result = {
-          selectors: ['test1', 'test2'],
-          style: { color: 'red', test: 'value' }
-        };
-        expect(obj.parse(str)).toEqual([result]);
-      });
-
-      test('Parse same rule with more selectors', () => {
-        var str = ' .test1.test2, .test3{ color:red }';
-        var result = [
-          {
-            selectors: ['test1', 'test2'],
-            style: { color: 'red' }
-          },
-          {
-            selectors: ['test3'],
-            style: { color: 'red' }
-          }
-        ];
-        expect(obj.parse(str)).toEqual(result);
-      });
-
-      test('Parse more rules', () => {
-        var str =
-          ' .test1.test2, .test3{ color:red } .test4, .test5.test6{ width:10px }';
-        var result = [
-          {
-            selectors: ['test1', 'test2'],
-            style: { color: 'red' }
-          },
-          {
-            selectors: ['test3'],
-            style: { color: 'red' }
-          },
-          {
-            selectors: ['test4'],
-            style: { width: '10px' }
-          },
-          {
-            selectors: ['test5', 'test6'],
-            style: { width: '10px' }
-          }
-        ];
-        expect(obj.parse(str)).toEqual(result);
-      });
-
-      test('Parse rule with state', () => {
-        var str = ' .test1.test2:hover{ color:red }';
-        var result = {
-          selectors: ['test1', 'test2'],
-          style: { color: 'red' },
-          state: 'hover'
-        };
-        expect(obj.parse(str)).toEqual([result]);
-      });
-
-      test('Parse rule with state like after', () => {
-        var str = ' .test1.test2::after{ color:red }';
-        var result = {
-          selectors: ['test1', 'test2'],
-          style: { color: 'red' },
-          state: ':after'
-        };
-        expect(obj.parse(str)).toEqual([result]);
-      });
-
-      test('Parse rule with nth-x state', () => {
-        var str = ' .test1.test2:nth-of-type(2n){ color:red }';
-        var result = {
-          selectors: ['test1', 'test2'],
-          style: { color: 'red' },
-          state: 'nth-of-type(2n)'
-        };
-        expect(obj.parse(str)).toEqual([result]);
-      });
-
-      // Phantom don't find 'node.conditionText' so will skip it
-      test('Parse rule inside media query', () => {
-        var str =
-          '@media only screen and (max-width: 992px){ .test1.test2:hover{ color:red }}';
-        var result = {
-          atRuleType: 'media',
-          selectors: ['test1', 'test2'],
-          style: { color: 'red' },
-          state: 'hover',
-          mediaText: 'only screen and (max-width: 992px)'
-        };
-        expect(obj.parse(str)).toEqual([result]);
-      });
-
-      // Phantom don't find 'node.conditionText' so will skip it
-      test('Parse rule inside media query', () => {
-        var str = '@media (max-width: 992px){ .test1.test2:hover{ color:red }}';
-        var result = {
-          atRuleType: 'media',
-          selectors: ['test1', 'test2'],
-          style: { color: 'red' },
-          state: 'hover',
-          mediaText: '(max-width: 992px)'
-        };
-        expect(obj.parse(str)).toEqual([result]);
-      });
-
-      // Phantom doesn't find 'node.conditionText' so will skip it
-      test('Parse rules inside media queries', () => {
-        var str =
-          '.test1:hover{ color:white }@media (max-width: 992px){ .test1.test2:hover{ color:red } .test2{ color: blue }}';
-        var result = [
-          {
-            selectors: ['test1'],
-            style: { color: 'white' },
-            state: 'hover'
-          },
-          {
-            selectors: ['test1', 'test2'],
-            style: { color: 'red' },
-            state: 'hover',
-            atRuleType: 'media',
-            mediaText: '(max-width: 992px)'
-          },
-          {
-            selectors: ['test2'],
-            style: { color: 'blue' },
-            atRuleType: 'media',
-            mediaText: '(max-width: 992px)'
-          }
-        ];
-        expect(obj.parse(str)).toEqual(result);
-      });
-
-      test('Parse rules with not class-based selectors', () => {
-        var str = ' .class1 .class2, div > .class3 { color:red }';
-        var result = {
-          selectors: [],
-          selectorsAdd: '.class1 .class2, div > .class3',
-          style: { color: 'red' }
-        };
-        expect(obj.parse(str)).toEqual([result]);
-      });
-
-      test('Parse rule with mixed selectors', () => {
-        var str =
-          ' .class1 .class2, .class3, div > .class4, .class5.class6 { color:red }';
-        var result = [
-          {
-            selectors: ['class3'],
-            style: { color: 'red' }
-          },
-          {
-            selectors: ['class5', 'class6'],
-            selectorsAdd: '.class1 .class2, div > .class4',
-            style: { color: 'red' }
-          }
-        ];
-        expect(obj.parse(str)).toEqual(result);
-      });
-
-      test('Parse rule with important styles', () => {
-        var str =
-          ' .test1 {color:red !important; width: 100px; height: 10px !important}';
-        var result = {
-          selectors: ['test1'],
-          style: {
-            color: 'red !important',
-            height: '10px !important',
-            width: '100px'
-          }
-        };
-        expect(obj.parse(str)).toEqual([result]);
-      });
-
-      test('Parse rule with CSS variables', () => {
-        var str = `:root {
-            --some-color: red;
-            --some-width: 55px;
-        }`;
-        var result = {
-          selectors: [],
-          selectorsAdd: ':root',
-          style: {
-            '--some-color': 'red',
-            '--some-width': '55px'
-          }
-        };
-        expect(obj.parse(str)).toEqual([result]);
-      });
-
-      // Can't test keyframes https://github.com/NV/CSSOM/issues/95
-      test.skip('Parse rule with a keyframes at-rule', () => {
-        var str = `@keyframes {
-          from {opacity: 0;}
-          to {opacity: 1;}
-        }`;
-        var result = [
-          {
-            selectors: [],
-            atRuleType: 'keyframes',
-            selectorsAdd: 'from',
-            style: { opacity: '0' }
-          },
-          {
-            selectors: [],
-            atRuleType: 'keyframes',
-            selectorsAdd: 'to',
-            style: { opacity: '1' }
-          }
-        ];
-        expect(obj.parse(str)).toEqual(result);
-      });
-
-      test('Parse rule with font-face at-rule', () => {
-        var str = `@font-face {
-         font-family: "Open Sans";
-        }`;
-        var result = {
-          selectors: [],
-          selectorsAdd: '',
-          atRuleType: 'font-face',
-          singleAtRule: 1,
-          style: { 'font-family': '"Open Sans"' }
-        };
-        expect(obj.parse(str)).toEqual([result]);
-      });
-
-      test('Parses multiple font-face at-rules', () => {
-        const str = `
-          @font-face {
-            font-family: "Open Sans";
-          }
-          @font-face {
-            font-family: 'Glyphicons Halflings';
-            src:url(https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.7/fonts/glyphicons-halflings-regular.eot)
-          }`;
-        const result = [
-          {
-            selectors: [],
-            selectorsAdd: '',
-            style: { 'font-family': '"Open Sans"' },
-            singleAtRule: 1,
-            atRuleType: 'font-face'
-          },
-          {
-            selectors: [],
-            selectorsAdd: '',
-            style: {
-              'font-family': "'Glyphicons Halflings'",
-              src:
-                'url(https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.7/fonts/glyphicons-halflings-regular.eot)'
-            },
-            singleAtRule: 1,
-            atRuleType: 'font-face'
-          }
-        ];
-        const parsed = obj.parse(str);
-        expect(parsed).toEqual(result);
-      });
-
-      test('Parse ID rule', () => {
-        var str = `#test { color: red }`;
-        var result = {
-          selectors: ['#test'],
-          style: { color: 'red' }
-        };
-        expect(obj.parse(str)).toEqual([result]);
-      });
-
-      test('Parse ID rule with state', () => {
-        var str = `#test:hover { color: red }`;
-        var result = {
-          selectors: ['#test'],
-          state: 'hover',
-          style: { color: 'red' }
-        };
-        expect(obj.parse(str)).toEqual([result]);
-      });
-
-      test('Avoid composed selectors with ID', () => {
-        var str = `#test.class, #test.class:hover, .class  { color: red }`;
-        var result = {
-          selectors: ['class'],
-          selectorsAdd: '#test.class, #test.class:hover',
-          style: { color: 'red' }
-        };
-        expect(obj.parse(str)).toEqual([result]);
-      });
-
-      test('Parse CSS with custom parser', () => {
-        var str = '.test1 { color:red }';
-        var result = {
-          selectors: ['test1'],
-          style: { color: 'blue' }
-        };
-        obj = new ParserCss({
-          parserCss: () => [result]
-        });
-        expect(obj.parse(str)).toEqual([result]);
-      });
-
-      test.skip('Parse CSS with custom async parser', async () => {
-        var str = '.test1 { color:red }';
-        var result = {
-          selectors: ['test1'],
-          style: { color: 'blue' }
-        };
-        obj = new ParserCss({
-          parserCss: async () => [result]
-        });
-        const cssResult = await obj.parse(str);
-        expect(cssResult).toEqual([result]);
-      });
-
-      test('Check node with font-face rule', () => {
-        const style = {
-          'font-family': '"Glyphicons Halflings"',
+describe('ParserCss', () => {
+  let obj;
+  let config;
+  let customParser;
+
+  beforeEach(() => {
+    config = {
+      em: {
+        getCustomParserCss: () => customParser
+      }
+    };
+    obj = new ParserCss(config);
+  });
+
+  afterEach(() => {
+    obj = null;
+  });
+
+  test('Parse selector', () => {
+    var str = '.test';
+    var result = [['test']];
+    expect(parseSelector(str).result).toEqual(result);
+  });
+
+  test('Parse selectors', () => {
+    var str = '.test1, .test1.test2, .test2.test3';
+    var result = [['test1'], ['test1', 'test2'], ['test2', 'test3']];
+    expect(parseSelector(str).result).toEqual(result);
+  });
+
+  test('Ignore not valid selectors', () => {
+    var str = '.test1.test2, .test2 .test3, div > .test4, #test.test5, .test6';
+    var result = [['test1', 'test2'], ['test6']];
+    expect(parseSelector(str).result).toEqual(result);
+  });
+
+  test('Parse selectors with state', () => {
+    var str = '.test1. test2, .test2>test3, .test4.test5:hover';
+    var result = [['test4', 'test5:hover']];
+    expect(parseSelector(str).result).toEqual(result);
+  });
+
+  test('Parse simple rule', () => {
+    var str = ' .test1 {color:red; width: 50px  }';
+    var result = {
+      selectors: ['test1'],
+      style: {
+        color: 'red',
+        width: '50px'
+      }
+    };
+    expect(obj.parse(str)).toEqual([result]);
+  });
+
+  test('Parse rule with more selectors', () => {
+    var str = ' .test1.test2 {color:red; test: value}';
+    var result = {
+      selectors: ['test1', 'test2'],
+      style: { color: 'red', test: 'value' }
+    };
+    expect(obj.parse(str)).toEqual([result]);
+  });
+
+  test('Parse same rule with more selectors', () => {
+    var str = ' .test1.test2, .test3{ color:red }';
+    var result = [
+      {
+        selectors: ['test1', 'test2'],
+        style: { color: 'red' }
+      },
+      {
+        selectors: ['test3'],
+        style: { color: 'red' }
+      }
+    ];
+    expect(obj.parse(str)).toEqual(result);
+  });
+
+  test('Parse more rules', () => {
+    var str =
+      ' .test1.test2, .test3{ color:red } .test4, .test5.test6{ width:10px }';
+    var result = [
+      {
+        selectors: ['test1', 'test2'],
+        style: { color: 'red' }
+      },
+      {
+        selectors: ['test3'],
+        style: { color: 'red' }
+      },
+      {
+        selectors: ['test4'],
+        style: { width: '10px' }
+      },
+      {
+        selectors: ['test5', 'test6'],
+        style: { width: '10px' }
+      }
+    ];
+    expect(obj.parse(str)).toEqual(result);
+  });
+
+  test('Parse rule with state', () => {
+    var str = ' .test1.test2:hover{ color:red }';
+    var result = {
+      selectors: ['test1', 'test2'],
+      style: { color: 'red' },
+      state: 'hover'
+    };
+    expect(obj.parse(str)).toEqual([result]);
+  });
+
+  test('Parse rule with state like after', () => {
+    var str = ' .test1.test2::after{ color:red }';
+    var result = {
+      selectors: ['test1', 'test2'],
+      style: { color: 'red' },
+      state: ':after'
+    };
+    expect(obj.parse(str)).toEqual([result]);
+  });
+
+  test('Parse rule with nth-x state', () => {
+    var str = ' .test1.test2:nth-of-type(2n){ color:red }';
+    var result = {
+      selectors: ['test1', 'test2'],
+      style: { color: 'red' },
+      state: 'nth-of-type(2n)'
+    };
+    expect(obj.parse(str)).toEqual([result]);
+  });
+
+  // Phantom don't find 'node.conditionText' so will skip it
+  test('Parse rule inside media query', () => {
+    var str =
+      '@media only screen and (max-width: 992px){ .test1.test2:hover{ color:red }}';
+    var result = {
+      atRuleType: 'media',
+      selectors: ['test1', 'test2'],
+      style: { color: 'red' },
+      state: 'hover',
+      mediaText: 'only screen and (max-width: 992px)'
+    };
+    expect(obj.parse(str)).toEqual([result]);
+  });
+
+  // Phantom don't find 'node.conditionText' so will skip it
+  test('Parse rule inside media query', () => {
+    var str = '@media (max-width: 992px){ .test1.test2:hover{ color:red }}';
+    var result = {
+      atRuleType: 'media',
+      selectors: ['test1', 'test2'],
+      style: { color: 'red' },
+      state: 'hover',
+      mediaText: '(max-width: 992px)'
+    };
+    expect(obj.parse(str)).toEqual([result]);
+  });
+
+  // Phantom doesn't find 'node.conditionText' so will skip it
+  test('Parse rules inside media queries', () => {
+    var str =
+      '.test1:hover{ color:white }@media (max-width: 992px){ .test1.test2:hover{ color:red } .test2{ color: blue }}';
+    var result = [
+      {
+        selectors: ['test1'],
+        style: { color: 'white' },
+        state: 'hover'
+      },
+      {
+        selectors: ['test1', 'test2'],
+        style: { color: 'red' },
+        state: 'hover',
+        atRuleType: 'media',
+        mediaText: '(max-width: 992px)'
+      },
+      {
+        selectors: ['test2'],
+        style: { color: 'blue' },
+        atRuleType: 'media',
+        mediaText: '(max-width: 992px)'
+      }
+    ];
+    expect(obj.parse(str)).toEqual(result);
+  });
+
+  test('Parse rules with not class-based selectors', () => {
+    var str = ' .class1 .class2, div > .class3 { color:red }';
+    var result = {
+      selectors: [],
+      selectorsAdd: '.class1 .class2, div > .class3',
+      style: { color: 'red' }
+    };
+    expect(obj.parse(str)).toEqual([result]);
+  });
+
+  test('Parse rule with mixed selectors', () => {
+    var str =
+      ' .class1 .class2, .class3, div > .class4, .class5.class6 { color:red }';
+    var result = [
+      {
+        selectors: ['class3'],
+        style: { color: 'red' }
+      },
+      {
+        selectors: ['class5', 'class6'],
+        selectorsAdd: '.class1 .class2, div > .class4',
+        style: { color: 'red' }
+      }
+    ];
+    expect(obj.parse(str)).toEqual(result);
+  });
+
+  test('Parse rule with important styles', () => {
+    var str =
+      ' .test1 {color:red !important; width: 100px; height: 10px !important}';
+    var result = {
+      selectors: ['test1'],
+      style: {
+        color: 'red !important',
+        height: '10px !important',
+        width: '100px'
+      }
+    };
+    expect(obj.parse(str)).toEqual([result]);
+  });
+
+  test('Parse rule with CSS variables', () => {
+    var str = `:root {
+        --some-color: red;
+        --some-width: 55px;
+    }`;
+    var result = {
+      selectors: [],
+      selectorsAdd: ':root',
+      style: {
+        '--some-color': 'red',
+        '--some-width': '55px'
+      }
+    };
+    expect(obj.parse(str)).toEqual([result]);
+  });
+
+  // Can't test keyframes https://github.com/NV/CSSOM/issues/95
+  test.skip('Parse rule with a keyframes at-rule', () => {
+    var str = `@keyframes {
+      from {opacity: 0;}
+      to {opacity: 1;}
+    }`;
+    var result = [
+      {
+        selectors: [],
+        atRuleType: 'keyframes',
+        selectorsAdd: 'from',
+        style: { opacity: '0' }
+      },
+      {
+        selectors: [],
+        atRuleType: 'keyframes',
+        selectorsAdd: 'to',
+        style: { opacity: '1' }
+      }
+    ];
+    expect(obj.parse(str)).toEqual(result);
+  });
+
+  test('Parse rule with font-face at-rule', () => {
+    var str = `@font-face {
+     font-family: "Open Sans";
+    }`;
+    var result = {
+      selectors: [],
+      selectorsAdd: '',
+      atRuleType: 'font-face',
+      singleAtRule: 1,
+      style: { 'font-family': '"Open Sans"' }
+    };
+    expect(obj.parse(str)).toEqual([result]);
+  });
+
+  test('Parses multiple font-face at-rules', () => {
+    const str = `
+      @font-face {
+        font-family: "Open Sans";
+      }
+      @font-face {
+        font-family: 'Glyphicons Halflings';
+        src:url(https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.7/fonts/glyphicons-halflings-regular.eot)
+      }`;
+    const result = [
+      {
+        selectors: [],
+        selectorsAdd: '',
+        style: { 'font-family': '"Open Sans"' },
+        singleAtRule: 1,
+        atRuleType: 'font-face'
+      },
+      {
+        selectors: [],
+        selectorsAdd: '',
+        style: {
+          'font-family': "'Glyphicons Halflings'",
           src:
-            'url("https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.7/fonts/glyphicons-halflings-regular.eot")'
-        };
-        expect(
-          obj.checkNode({
-            atRule: 'font-face',
-            selectors: '',
-            style: style
-          })
-        ).toEqual([
-          {
-            style: style,
-            atRuleType: 'font-face',
-            singleAtRule: 1,
-            selectors: []
-          }
-        ]);
-      });
-
-      test('Check node with keyframes rule', () => {
-        const style = { opacity: 0 };
-        expect(
-          obj.checkNode({
-            atRule: 'keyframes',
-            params: 'name',
-            selectors: 'from',
-            style: style
-          })
-        ).toEqual([
-          {
-            selectors: [],
-            atRuleType: 'keyframes',
-            selectorsAdd: 'from',
-            style: style,
-            mediaText: 'name'
-          }
-        ]);
-      });
-
-      test('Check node with media rule', () => {
-        const style = { color: 'blue' };
-        expect(
-          obj.checkNode({
-            atRule: 'media',
-            params: 'screen and (min-width: 480px)',
-            selectors: '.class-test.class2:hover, div > span ',
-            style
-          })
-        ).toEqual([
-          {
-            atRuleType: 'media',
-            selectors: ['class-test', 'class2'],
-            selectorsAdd: 'div > span',
-            style: style,
-            state: 'hover',
-            mediaText: 'screen and (min-width: 480px)'
-          }
-        ]);
-      });
-
-      test('Check node with a rule containing id', () => {
-        const style = { border: '1px solid black !important' };
-        expect(
-          obj.checkNode({
-            selectors: '#main:hover',
-            style
-          })
-        ).toEqual([
-          {
-            selectors: ['#main'],
-            state: 'hover',
-            style: style
-          }
-        ]);
-      });
-
-      test('Check node with multiple class selectors', () => {
-        const style = {
-          border: '1px solid black !important',
-          'background-repeat': 'repeat-y, no-repeat'
-        };
-        expect(
-          obj.checkNode({
-            selectors:
-              '.class1, .class1.class2:hover, div > .test:hover, span.test2',
-            style
-          })
-        ).toEqual([
-          {
-            selectors: ['class1'],
-            style: style
-          },
-          {
-            selectors: ['class1', 'class2'],
-            state: 'hover',
-            selectorsAdd: 'div > .test:hover, span.test2',
-            style: style
-          }
-        ]);
-      });
-
-      test('Check node with a rule containing CSS variables', () => {
-        const style = {
-          '--some-color': 'red',
-          '--some-width': '55px'
-        };
-        expect(
-          obj.checkNode({
-            selectors: ':root',
-            style
-          })
-        ).toEqual([
-          {
-            selectors: [],
-            selectorsAdd: ':root',
-            style: style
-          }
-        ]);
-      });
+            'url(https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.7/fonts/glyphicons-halflings-regular.eot)'
+        },
+        singleAtRule: 1,
+        atRuleType: 'font-face'
+      }
+    ];
+    const parsed = obj.parse(str);
+    expect(parsed).toEqual(result);
+  });
+
+  test('Parse ID rule', () => {
+    var str = `#test { color: red }`;
+    var result = {
+      selectors: ['#test'],
+      style: { color: 'red' }
+    };
+    expect(obj.parse(str)).toEqual([result]);
+  });
+
+  test('Parse ID rule with state', () => {
+    var str = `#test:hover { color: red }`;
+    var result = {
+      selectors: ['#test'],
+      state: 'hover',
+      style: { color: 'red' }
+    };
+    expect(obj.parse(str)).toEqual([result]);
+  });
+
+  test('Avoid composed selectors with ID', () => {
+    var str = `#test.class, #test.class:hover, .class  { color: red }`;
+    var result = {
+      selectors: ['class'],
+      selectorsAdd: '#test.class, #test.class:hover',
+      style: { color: 'red' }
+    };
+    expect(obj.parse(str)).toEqual([result]);
+  });
+
+  test('Parse CSS with custom parser', () => {
+    var str = '.test1 { color:red }';
+    var result = {
+      selectors: ['test1'],
+      style: { color: 'blue' }
+    };
+    obj = new ParserCss({
+      parserCss: () => [result]
     });
-  }
-};
+    expect(obj.parse(str)).toEqual([result]);
+  });
+
+  test.skip('Parse CSS with custom async parser', async () => {
+    var str = '.test1 { color:red }';
+    var result = {
+      selectors: ['test1'],
+      style: { color: 'blue' }
+    };
+    obj = new ParserCss({
+      parserCss: async () => [result]
+    });
+    const cssResult = await obj.parse(str);
+    expect(cssResult).toEqual([result]);
+  });
+
+  test('Check node with font-face rule', () => {
+    const style = {
+      'font-family': '"Glyphicons Halflings"',
+      src:
+        'url("https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.7/fonts/glyphicons-halflings-regular.eot")'
+    };
+    expect(
+      obj.checkNode({
+        atRule: 'font-face',
+        selectors: '',
+        style: style
+      })
+    ).toEqual([
+      {
+        style: style,
+        atRuleType: 'font-face',
+        singleAtRule: 1,
+        selectors: []
+      }
+    ]);
+  });
+
+  test('Check node with keyframes rule', () => {
+    const style = { opacity: 0 };
+    expect(
+      obj.checkNode({
+        atRule: 'keyframes',
+        params: 'name',
+        selectors: 'from',
+        style: style
+      })
+    ).toEqual([
+      {
+        selectors: [],
+        atRuleType: 'keyframes',
+        selectorsAdd: 'from',
+        style: style,
+        mediaText: 'name'
+      }
+    ]);
+  });
+
+  test('Check node with media rule', () => {
+    const style = { color: 'blue' };
+    expect(
+      obj.checkNode({
+        atRule: 'media',
+        params: 'screen and (min-width: 480px)',
+        selectors: '.class-test.class2:hover, div > span ',
+        style
+      })
+    ).toEqual([
+      {
+        atRuleType: 'media',
+        selectors: ['class-test', 'class2'],
+        selectorsAdd: 'div > span',
+        style: style,
+        state: 'hover',
+        mediaText: 'screen and (min-width: 480px)'
+      }
+    ]);
+  });
+
+  test('Check node with a rule containing id', () => {
+    const style = { border: '1px solid black !important' };
+    expect(
+      obj.checkNode({
+        selectors: '#main:hover',
+        style
+      })
+    ).toEqual([
+      {
+        selectors: ['#main'],
+        state: 'hover',
+        style: style
+      }
+    ]);
+  });
+
+  test('Check node with multiple class selectors', () => {
+    const style = {
+      border: '1px solid black !important',
+      'background-repeat': 'repeat-y, no-repeat'
+    };
+    expect(
+      obj.checkNode({
+        selectors:
+          '.class1, .class1.class2:hover, div > .test:hover, span.test2',
+        style
+      })
+    ).toEqual([
+      {
+        selectors: ['class1'],
+        style: style
+      },
+      {
+        selectors: ['class1', 'class2'],
+        state: 'hover',
+        selectorsAdd: 'div > .test:hover, span.test2',
+        style: style
+      }
+    ]);
+  });
+
+  test('Check node with a rule containing CSS variables', () => {
+    const style = {
+      '--some-color': 'red',
+      '--some-width': '55px'
+    };
+    expect(
+      obj.checkNode({
+        selectors: ':root',
+        style
+      })
+    ).toEqual([
+      {
+        selectors: [],
+        selectorsAdd: ':root',
+        style: style
+      }
+    ]);
+  });
+});

test/specs/parser/model/ParserHtml.js

@@ -2,507 +2,502 @@ import ParserHtml from 'parser/model/ParserHtml';
 import ParserCss from 'parser/model/ParserCss';
 import DomComponents from 'dom_components';
 
-module.exports = {
-  run() {
-    describe('ParserHtml', () => {
-      var obj;
+describe('ParserHtml', () => {
+  var obj;
 
-      beforeEach(() => {
-        var dom = new DomComponents();
-        obj = new ParserHtml({
-          textTags: ['br', 'b', 'i', 'u'],
-          pStylePrefix: 'gjs-'
-        });
-        obj.compTypes = dom.componentTypes;
-      });
+  beforeEach(() => {
+    var dom = new DomComponents();
+    obj = new ParserHtml({
+      textTags: ['br', 'b', 'i', 'u'],
+      pStylePrefix: 'gjs-'
+    });
+    obj.compTypes = dom.componentTypes;
+  });
 
-      afterEach(() => {
-        obj = null;
-      });
+  afterEach(() => {
+    obj = null;
+  });
 
-      test('Simple div node', () => {
-        var str = '<div></div>';
-        var result = { tagName: 'div' };
-        expect(obj.parse(str).html).toEqual(result);
-      });
+  test('Simple div node', () => {
+    var str = '<div></div>';
+    var result = { tagName: 'div' };
+    expect(obj.parse(str).html).toEqual(result);
+  });
 
-      test('Simple article node', () => {
-        var str = '<article></article>';
-        var result = { tagName: 'article' };
-        expect(obj.parse(str).html).toEqual(result);
-      });
+  test('Simple article node', () => {
+    var str = '<article></article>';
+    var result = { tagName: 'article' };
+    expect(obj.parse(str).html).toEqual(result);
+  });
 
-      test('Node with attributes', () => {
-        var str =
-          '<div id="test1" class="test2 test3" data-one="test4" strange="test5"></div>';
-        var result = {
-          tagName: 'div',
-          classes: ['test2', 'test3'],
-          attributes: {
-            'data-one': 'test4',
-            id: 'test1',
-            strange: 'test5'
-          }
-        };
-        expect(obj.parse(str).html).toEqual(result);
-      });
+  test('Node with attributes', () => {
+    var str =
+      '<div id="test1" class="test2 test3" data-one="test4" strange="test5"></div>';
+    var result = {
+      tagName: 'div',
+      classes: ['test2', 'test3'],
+      attributes: {
+        'data-one': 'test4',
+        id: 'test1',
+        strange: 'test5'
+      }
+    };
+    expect(obj.parse(str).html).toEqual(result);
+  });
 
-      test('Parse style string to object', () => {
-        var str = 'color:black; width:100px; test:value;';
-        var result = {
-          color: 'black',
-          width: '100px',
-          test: 'value'
-        };
-        expect(obj.parseStyle(str)).toEqual(result);
-      });
+  test('Parse style string to object', () => {
+    var str = 'color:black; width:100px; test:value;';
+    var result = {
+      color: 'black',
+      width: '100px',
+      test: 'value'
+    };
+    expect(obj.parseStyle(str)).toEqual(result);
+  });
 
-      test('Parse style string with values containing colon to object', () => {
-        var str =
-          'background-image:url("https://some-website.ex"); test:value;';
-        var result = {
-          'background-image': 'url("https://some-website.ex")',
-          test: 'value'
-        };
-        expect(obj.parseStyle(str)).toEqual(result);
-      });
+  test('Parse style string with values containing colon to object', () => {
+    var str = 'background-image:url("https://some-website.ex"); test:value;';
+    var result = {
+      'background-image': 'url("https://some-website.ex")',
+      test: 'value'
+    };
+    expect(obj.parseStyle(str)).toEqual(result);
+  });
 
-      test('Parse class string to array', () => {
-        var str = 'test1 test2    test3 test-4';
-        var result = ['test1', 'test2', 'test3', 'test-4'];
-        expect(obj.parseClass(str)).toEqual(result);
-      });
+  test('Parse class string to array', () => {
+    var str = 'test1 test2    test3 test-4';
+    var result = ['test1', 'test2', 'test3', 'test-4'];
+    expect(obj.parseClass(str)).toEqual(result);
+  });
 
-      test('Parse class string to array with special classes', () => {
-        var str = 'test1 test2    test3 test-4 gjs-test';
-        var result = ['test1', 'test2', 'test3', 'test-4', 'gjs-test'];
-        expect(obj.parseClass(str)).toEqual(result);
-      });
+  test('Parse class string to array with special classes', () => {
+    var str = 'test1 test2    test3 test-4 gjs-test';
+    var result = ['test1', 'test2', 'test3', 'test-4', 'gjs-test'];
+    expect(obj.parseClass(str)).toEqual(result);
+  });
 
-      test('Style attribute is isolated', () => {
-        var str =
-          '<div id="test1" style="color:black; width:100px; test:value;"></div>';
-        var result = {
-          tagName: 'div',
-          attributes: { id: 'test1' },
-          style: {
-            color: 'black',
-            width: '100px',
-            test: 'value'
-          }
-        };
-        expect(obj.parse(str).html).toEqual(result);
-      });
+  test('Style attribute is isolated', () => {
+    var str =
+      '<div id="test1" style="color:black; width:100px; test:value;"></div>';
+    var result = {
+      tagName: 'div',
+      attributes: { id: 'test1' },
+      style: {
+        color: 'black',
+        width: '100px',
+        test: 'value'
+      }
+    };
+    expect(obj.parse(str).html).toEqual(result);
+  });
 
-      test('Class attribute is isolated', () => {
-        var str = '<div id="test1" class="test2 test3 test4"></div>';
-        var result = {
-          tagName: 'div',
-          attributes: { id: 'test1' },
-          classes: ['test2', 'test3', 'test4']
-        };
-        expect(obj.parse(str).html).toEqual(result);
-      });
+  test('Class attribute is isolated', () => {
+    var str = '<div id="test1" class="test2 test3 test4"></div>';
+    var result = {
+      tagName: 'div',
+      attributes: { id: 'test1' },
+      classes: ['test2', 'test3', 'test4']
+    };
+    expect(obj.parse(str).html).toEqual(result);
+  });
 
-      test('Parse images nodes', () => {
-        var str = '<img id="test1" src="./index.html"/>';
-        var result = {
-          tagName: 'img',
-          type: 'image',
-          attributes: {
-            id: 'test1',
-            src: './index.html'
-          }
-        };
-        expect(obj.parse(str).html).toEqual(result);
-      });
+  test('Parse images nodes', () => {
+    var str = '<img id="test1" src="./index.html"/>';
+    var result = {
+      tagName: 'img',
+      type: 'image',
+      attributes: {
+        id: 'test1',
+        src: './index.html'
+      }
+    };
+    expect(obj.parse(str).html).toEqual(result);
+  });
 
-      test('Parse text nodes', () => {
-        var str = '<div id="test1">test2 </div>';
-        var result = {
-          tagName: 'div',
-          attributes: { id: 'test1' },
-          type: 'text',
-          content: 'test2 '
-        };
-        expect(obj.parse(str).html).toEqual(result);
-      });
+  test('Parse text nodes', () => {
+    var str = '<div id="test1">test2 </div>';
+    var result = {
+      tagName: 'div',
+      attributes: { id: 'test1' },
+      type: 'text',
+      content: 'test2 '
+    };
+    expect(obj.parse(str).html).toEqual(result);
+  });
 
-      test('Parse text with few text tags', () => {
-        var str =
-          '<div id="test1"><br/> test2 <br/> a b <b>b</b> <i>i</i> <u>u</u> test </div>';
-        var result = {
-          tagName: 'div',
-          attributes: { id: 'test1' },
+  test('Parse text with few text tags', () => {
+    var str =
+      '<div id="test1"><br/> test2 <br/> a b <b>b</b> <i>i</i> <u>u</u> test </div>';
+    var result = {
+      tagName: 'div',
+      attributes: { id: 'test1' },
+      type: 'text',
+      components: [
+        { tagName: 'br' },
+        {
+          content: ' test2 ',
+          type: 'textnode',
+          tagName: ''
+        },
+        { tagName: 'br' },
+        {
+          content: ' a b ',
+          type: 'textnode',
+          tagName: ''
+        },
+        {
+          content: 'b',
           type: 'text',
-          components: [
-            { tagName: 'br' },
-            {
-              content: ' test2 ',
-              type: 'textnode',
-              tagName: ''
-            },
-            { tagName: 'br' },
-            {
-              content: ' a b ',
-              type: 'textnode',
-              tagName: ''
-            },
-            {
-              content: 'b',
-              type: 'text',
-              tagName: 'b'
-            },
-            {
-              content: ' ',
-              type: 'textnode',
-              tagName: ''
-            },
-            {
-              content: 'i',
-              tagName: 'i',
-              type: 'text'
-            },
-            {
-              content: ' ',
-              type: 'textnode',
-              tagName: ''
-            },
-            {
-              content: 'u',
-              tagName: 'u',
-              type: 'text'
-            },
-            {
-              content: ' test ',
-              type: 'textnode',
-              tagName: ''
-            }
-          ]
-        };
-        expect(obj.parse(str).html).toEqual(result);
-      });
+          tagName: 'b'
+        },
+        {
+          content: ' ',
+          type: 'textnode',
+          tagName: ''
+        },
+        {
+          content: 'i',
+          tagName: 'i',
+          type: 'text'
+        },
+        {
+          content: ' ',
+          type: 'textnode',
+          tagName: ''
+        },
+        {
+          content: 'u',
+          tagName: 'u',
+          type: 'text'
+        },
+        {
+          content: ' test ',
+          type: 'textnode',
+          tagName: ''
+        }
+      ]
+    };
+    expect(obj.parse(str).html).toEqual(result);
+  });
 
-      test('Parse text with few text tags and nested node', () => {
-        var str =
-          '<div id="test1">a b <b>b</b> <i>i</i>c <div>ABC</div> <i>i</i> <u>u</u> test </div>';
-        var result = {
+  test('Parse text with few text tags and nested node', () => {
+    var str =
+      '<div id="test1">a b <b>b</b> <i>i</i>c <div>ABC</div> <i>i</i> <u>u</u> test </div>';
+    var result = {
+      tagName: 'div',
+      attributes: { id: 'test1' },
+      type: 'text',
+      components: [
+        {
+          content: 'a b ',
+          type: 'textnode',
+          tagName: ''
+        },
+        {
+          content: 'b',
+          tagName: 'b',
+          type: 'text'
+        },
+        {
+          content: ' ',
+          type: 'textnode',
+          tagName: ''
+        },
+        {
+          content: 'i',
+          tagName: 'i',
+          type: 'text'
+        },
+        {
+          content: 'c ',
+          type: 'textnode',
+          tagName: ''
+        },
+        {
           tagName: 'div',
-          attributes: { id: 'test1' },
           type: 'text',
-          components: [
-            {
-              content: 'a b ',
-              type: 'textnode',
-              tagName: ''
-            },
-            {
-              content: 'b',
-              tagName: 'b',
-              type: 'text'
-            },
-            {
-              content: ' ',
-              type: 'textnode',
-              tagName: ''
-            },
-            {
-              content: 'i',
-              tagName: 'i',
-              type: 'text'
-            },
-            {
-              content: 'c ',
-              type: 'textnode',
-              tagName: ''
-            },
-            {
-              tagName: 'div',
-              type: 'text',
-              content: 'ABC'
-            },
-            {
-              content: ' ',
-              type: 'textnode',
-              tagName: ''
-            },
-            {
-              content: 'i',
-              tagName: 'i',
-              type: 'text'
-            },
-            {
-              content: ' ',
-              type: 'textnode',
-              tagName: ''
-            },
-            {
-              content: 'u',
-              tagName: 'u',
-              type: 'text'
-            },
-            {
-              content: ' test ',
-              type: 'textnode',
-              tagName: ''
-            }
-          ]
-        };
-        expect(obj.parse(str).html).toEqual(result);
-      });
+          content: 'ABC'
+        },
+        {
+          content: ' ',
+          type: 'textnode',
+          tagName: ''
+        },
+        {
+          content: 'i',
+          tagName: 'i',
+          type: 'text'
+        },
+        {
+          content: ' ',
+          type: 'textnode',
+          tagName: ''
+        },
+        {
+          content: 'u',
+          tagName: 'u',
+          type: 'text'
+        },
+        {
+          content: ' test ',
+          type: 'textnode',
+          tagName: ''
+        }
+      ]
+    };
+    expect(obj.parse(str).html).toEqual(result);
+  });
 
-      test('Parse nested nodes', () => {
-        var str =
-          '<article id="test1">   <div></div> <footer id="test2"></footer>  Text mid <div id="last"></div></article>';
-        var result = {
-          tagName: 'article',
-          attributes: { id: 'test1' },
-          components: [
-            {
-              tagName: 'div'
-            },
-            {
-              content: ' ',
-              type: 'textnode',
-              tagName: ''
-            },
-            {
-              tagName: 'footer',
-              attributes: { id: 'test2' }
-            },
-            {
-              tagName: '',
-              type: 'textnode',
-              content: '  Text mid '
-            },
-            {
-              tagName: 'div',
-              attributes: { id: 'last' }
-            }
-          ]
-        };
-        expect(obj.parse(str).html).toEqual(result);
-      });
+  test('Parse nested nodes', () => {
+    var str =
+      '<article id="test1">   <div></div> <footer id="test2"></footer>  Text mid <div id="last"></div></article>';
+    var result = {
+      tagName: 'article',
+      attributes: { id: 'test1' },
+      components: [
+        {
+          tagName: 'div'
+        },
+        {
+          content: ' ',
+          type: 'textnode',
+          tagName: ''
+        },
+        {
+          tagName: 'footer',
+          attributes: { id: 'test2' }
+        },
+        {
+          tagName: '',
+          type: 'textnode',
+          content: '  Text mid '
+        },
+        {
+          tagName: 'div',
+          attributes: { id: 'last' }
+        }
+      ]
+    };
+    expect(obj.parse(str).html).toEqual(result);
+  });
 
-      test('Parse nested text nodes', () => {
-        var str = '<div>content1 <div>nested</div> content2</div>';
-        var result = {
+  test('Parse nested text nodes', () => {
+    var str = '<div>content1 <div>nested</div> content2</div>';
+    var result = {
+      tagName: 'div',
+      type: 'text',
+      components: [
+        {
+          tagName: '',
+          type: 'textnode',
+          content: 'content1 '
+        },
+        {
           tagName: 'div',
           type: 'text',
-          components: [
-            {
-              tagName: '',
-              type: 'textnode',
-              content: 'content1 '
-            },
-            {
-              tagName: 'div',
-              type: 'text',
-              content: 'nested'
-            },
-            {
-              tagName: '',
-              type: 'textnode',
-              content: ' content2'
-            }
-          ]
-        };
-        expect(obj.parse(str).html).toEqual(result);
-      });
+          content: 'nested'
+        },
+        {
+          tagName: '',
+          type: 'textnode',
+          content: ' content2'
+        }
+      ]
+    };
+    expect(obj.parse(str).html).toEqual(result);
+  });
 
-      test('Parse nested span text nodes', () => {
-        var str = '<div>content1 <div><span>nested</span></div> content2</div>';
-        var result = {
+  test('Parse nested span text nodes', () => {
+    var str = '<div>content1 <div><span>nested</span></div> content2</div>';
+    var result = {
+      tagName: 'div',
+      components: [
+        {
+          tagName: '',
+          type: 'textnode',
+          content: 'content1 '
+        },
+        {
           tagName: 'div',
           components: [
             {
-              tagName: '',
-              type: 'textnode',
-              content: 'content1 '
-            },
-            {
-              tagName: 'div',
-              components: [
-                {
-                  tagName: 'span',
-                  type: 'text',
-                  content: 'nested'
-                }
-              ]
-            },
-            {
-              tagName: '',
-              type: 'textnode',
-              content: ' content2'
+              tagName: 'span',
+              type: 'text',
+              content: 'nested'
             }
           ]
-        };
-        expect(obj.parse(str).html).toEqual(result);
-      });
+        },
+        {
+          tagName: '',
+          type: 'textnode',
+          content: ' content2'
+        }
+      ]
+    };
+    expect(obj.parse(str).html).toEqual(result);
+  });
 
-      test('Parse multiple nodes', () => {
-        var str = '<div></div><div></div>';
-        var result = [{ tagName: 'div' }, { tagName: 'div' }];
-        expect(obj.parse(str).html).toEqual(result);
-      });
+  test('Parse multiple nodes', () => {
+    var str = '<div></div><div></div>';
+    var result = [{ tagName: 'div' }, { tagName: 'div' }];
+    expect(obj.parse(str).html).toEqual(result);
+  });
 
-      test('Remove script tags', () => {
-        var str =
-          '<div><script>var test;</script></div><div></div><script>var test2;</script>';
-        var result = [{ tagName: 'div' }, { tagName: 'div' }];
-        expect(obj.parse(str).html).toEqual(result);
-      });
+  test('Remove script tags', () => {
+    var str =
+      '<div><script>var test;</script></div><div></div><script>var test2;</script>';
+    var result = [{ tagName: 'div' }, { tagName: 'div' }];
+    expect(obj.parse(str).html).toEqual(result);
+  });
 
-      test('Isolate styles', () => {
-        var str =
-          '<div><style>.a{color: red}</style></div><div></div><style>.b{color: blue}</style>';
-        var resHtml = [{ tagName: 'div' }, { tagName: 'div' }];
-        var resCss = [
-          {
-            selectors: ['a'],
-            style: { color: 'red' }
-          },
-          {
-            selectors: ['b'],
-            style: { color: 'blue' }
-          }
-        ];
-        var res = obj.parse(str, new ParserCss());
-        expect(res.html).toEqual(resHtml);
-        expect(res.css).toEqual(resCss);
-      });
+  test('Isolate styles', () => {
+    var str =
+      '<div><style>.a{color: red}</style></div><div></div><style>.b{color: blue}</style>';
+    var resHtml = [{ tagName: 'div' }, { tagName: 'div' }];
+    var resCss = [
+      {
+        selectors: ['a'],
+        style: { color: 'red' }
+      },
+      {
+        selectors: ['b'],
+        style: { color: 'blue' }
+      }
+    ];
+    var res = obj.parse(str, new ParserCss());
+    expect(res.html).toEqual(resHtml);
+    expect(res.css).toEqual(resCss);
+  });
 
-      test('Respect multiple font-faces contained in styles in html', () => {
-        const str = `
-          <style>
-          @font-face {
-            font-family: "Open Sans";
-            src:url(https://fonts.gstatic.com/s/droidsans/v8/SlGVmQWMvZQIdix7AFxXkHNSbRYXags.woff2)
-          }
-          @font-face {
-            font-family: 'Glyphicons Halflings';
-            src:url(https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.7/fonts/glyphicons-halflings-regular.eot)
-          }
-          </style>
-          <div>a div</div>
-        `;
+  test('Respect multiple font-faces contained in styles in html', () => {
+    const str = `
+      <style>
+      @font-face {
+        font-family: "Open Sans";
+        src:url(https://fonts.gstatic.com/s/droidsans/v8/SlGVmQWMvZQIdix7AFxXkHNSbRYXags.woff2)
+      }
+      @font-face {
+        font-family: 'Glyphicons Halflings';
+        src:url(https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.7/fonts/glyphicons-halflings-regular.eot)
+      }
+      </style>
+      <div>a div</div>
+    `;
 
-        const expected = [
-          {
-            selectors: [],
-            selectorsAdd: '',
-            style: {
-              'font-family': '"Open Sans"',
-              src:
-                'url(https://fonts.gstatic.com/s/droidsans/v8/SlGVmQWMvZQIdix7AFxXkHNSbRYXags.woff2)'
-            },
-            singleAtRule: 1,
-            atRuleType: 'font-face'
-          },
-          {
-            selectors: [],
-            selectorsAdd: '',
-            style: {
-              'font-family': "'Glyphicons Halflings'",
-              src:
-                'url(https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.7/fonts/glyphicons-halflings-regular.eot)'
-            },
-            singleAtRule: 1,
-            atRuleType: 'font-face'
-          }
-        ];
+    const expected = [
+      {
+        selectors: [],
+        selectorsAdd: '',
+        style: {
+          'font-family': '"Open Sans"',
+          src:
+            'url(https://fonts.gstatic.com/s/droidsans/v8/SlGVmQWMvZQIdix7AFxXkHNSbRYXags.woff2)'
+        },
+        singleAtRule: 1,
+        atRuleType: 'font-face'
+      },
+      {
+        selectors: [],
+        selectorsAdd: '',
+        style: {
+          'font-family': "'Glyphicons Halflings'",
+          src:
+            'url(https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.7/fonts/glyphicons-halflings-regular.eot)'
+        },
+        singleAtRule: 1,
+        atRuleType: 'font-face'
+      }
+    ];
 
-        const res = obj.parse(str, new ParserCss());
-        expect(res.css).toEqual(expected);
-      });
+    const res = obj.parse(str, new ParserCss());
+    expect(res.css).toEqual(expected);
+  });
 
-      test('Parse nested div with text and spaces', () => {
-        var str = '<div> <p>TestText</p> </div>';
-        var result = {
-          tagName: 'div',
-          type: 'text',
-          components: [
-            {
-              tagName: '',
-              type: 'textnode',
-              content: ' '
-            },
-            {
-              tagName: 'p',
-              content: 'TestText',
-              type: 'text'
-            },
-            {
-              tagName: '',
-              type: 'textnode',
-              content: ' '
-            }
-          ]
-        };
-        expect(obj.parse(str).html).toEqual(result);
-      });
+  test('Parse nested div with text and spaces', () => {
+    var str = '<div> <p>TestText</p> </div>';
+    var result = {
+      tagName: 'div',
+      type: 'text',
+      components: [
+        {
+          tagName: '',
+          type: 'textnode',
+          content: ' '
+        },
+        {
+          tagName: 'p',
+          content: 'TestText',
+          type: 'text'
+        },
+        {
+          tagName: '',
+          type: 'textnode',
+          content: ' '
+        }
+      ]
+    };
+    expect(obj.parse(str).html).toEqual(result);
+  });
 
-      test('Parse node with model attributes to fetch', () => {
-        var str =
-          '<div id="test1" data-test="test-value" data-gjs-draggable=".myselector" data-gjs-stuff="test">test2 </div>';
-        var result = {
-          tagName: 'div',
-          draggable: '.myselector',
-          stuff: 'test',
-          attributes: {
-            id: 'test1',
-            'data-test': 'test-value'
-          },
-          type: 'text',
-          content: 'test2 '
-        };
-        expect(obj.parse(str).html).toEqual(result);
-      });
+  test('Parse node with model attributes to fetch', () => {
+    var str =
+      '<div id="test1" data-test="test-value" data-gjs-draggable=".myselector" data-gjs-stuff="test">test2 </div>';
+    var result = {
+      tagName: 'div',
+      draggable: '.myselector',
+      stuff: 'test',
+      attributes: {
+        id: 'test1',
+        'data-test': 'test-value'
+      },
+      type: 'text',
+      content: 'test2 '
+    };
+    expect(obj.parse(str).html).toEqual(result);
+  });
 
-      test('Parse model attributes with true and false', () => {
-        var str =
-          '<div id="test1" data-test="test-value" data-gjs-draggable="true" data-gjs-stuff="false">test2 </div>';
-        var result = {
-          tagName: 'div',
-          draggable: true,
-          stuff: false,
-          attributes: {
-            id: 'test1',
-            'data-test': 'test-value'
-          },
-          type: 'text',
-          content: 'test2 '
-        };
-        expect(obj.parse(str).html).toEqual(result);
-      });
+  test('Parse model attributes with true and false', () => {
+    var str =
+      '<div id="test1" data-test="test-value" data-gjs-draggable="true" data-gjs-stuff="false">test2 </div>';
+    var result = {
+      tagName: 'div',
+      draggable: true,
+      stuff: false,
+      attributes: {
+        id: 'test1',
+        'data-test': 'test-value'
+      },
+      type: 'text',
+      content: 'test2 '
+    };
+    expect(obj.parse(str).html).toEqual(result);
+  });
 
-      test('Parse attributes with object inside', () => {
-        var str = `<div data-gjs-test='{ "prop1": "value1", "prop2": 10, "prop3": true}'>test2 </div>`;
-        var result = {
-          tagName: 'div',
-          attributes: {},
-          type: 'text',
-          test: {
-            prop1: 'value1',
-            prop2: 10,
-            prop3: true
-          },
-          content: 'test2 '
-        };
-        expect(obj.parse(str).html).toEqual(result);
-      });
+  test('Parse attributes with object inside', () => {
+    var str = `<div data-gjs-test='{ "prop1": "value1", "prop2": 10, "prop3": true}'>test2 </div>`;
+    var result = {
+      tagName: 'div',
+      attributes: {},
+      type: 'text',
+      test: {
+        prop1: 'value1',
+        prop2: 10,
+        prop3: true
+      },
+      content: 'test2 '
+    };
+    expect(obj.parse(str).html).toEqual(result);
+  });
 
-      test('Parse attributes with arrays inside', () => {
-        var str = `<div data-gjs-test='["value1", "value2"]'>test2 </div>`;
-        var result = {
-          tagName: 'div',
-          attributes: {},
-          type: 'text',
-          test: ['value1', 'value2'],
-          content: 'test2 '
-        };
-        expect(obj.parse(str).html).toEqual(result);
-      });
-    });
-  }
-};
+  test('Parse attributes with arrays inside', () => {
+    var str = `<div data-gjs-test='["value1", "value2"]'>test2 </div>`;
+    var result = {
+      tagName: 'div',
+      attributes: {},
+      type: 'text',
+      test: ['value1', 'value2'],
+      content: 'test2 '
+    };
+    expect(obj.parse(str).html).toEqual(result);
+  });
+});

test/specs/selector_manager/e2e/ClassManager.js

@@ -1,134 +1,130 @@
 import Selectors from 'selector_manager/model/Selectors';
 import ClassTagsView from 'selector_manager/view/ClassTagsView';
 
-module.exports = {
-  run() {
-    describe('E2E tests', () => {
-      var fixtures;
-      var components;
-      var tagEl;
-      var gjs;
+describe('E2E tests', () => {
+  var fixtures;
+  var components;
+  var tagEl;
+  var gjs;
 
-      var instClassTagViewer = (gjs, fixtures) => {
-        var tagEl;
-        var clm = gjs.editor.get('SelectorManager');
+  var instClassTagViewer = (gjs, fixtures) => {
+    var tagEl;
+    var clm = gjs.editor.get('SelectorManager');
 
-        if (clm) {
-          tagEl = new ClassTagsView({
-            collection: new Selectors([]),
-            config: { em: gjs.editor }
-          }).render();
-          fixtures.appendChild(tagEl.el);
-        }
+    if (clm) {
+      tagEl = new ClassTagsView({
+        collection: new Selectors([]),
+        config: { em: gjs.editor }
+      }).render();
+      fixtures.appendChild(tagEl.el);
+    }
 
-        return tagEl;
-      };
-      /*
-        before(function () {
-          this.$fixtures  = $("#fixtures");
-          this.$fixture   = $('<div id="SelectorManager-fixture"></div>');
-        });
+    return tagEl;
+  };
+  /*
+    before(function () {
+      this.$fixtures  = $("#fixtures");
+      this.$fixture   = $('<div id="SelectorManager-fixture"></div>');
+    });
 */
-      beforeEach(() => {
-        document.body.innerHTML =
-          '<div id="fixtures"><div id="SelectorManager-fixture"></div></div>';
-        fixtures = document.body.firstChild;
-        gjs = grapesjs.init({
-          stylePrefix: '',
-          storageManager: { autoload: 0, type: 0 },
-          assetManager: {
-            storageType: 'none'
-          },
-          container: '#SelectorManager-fixture'
-        });
-      });
+  beforeEach(() => {
+    document.body.innerHTML =
+      '<div id="fixtures"><div id="SelectorManager-fixture"></div></div>';
+    fixtures = document.body.firstChild;
+    gjs = grapesjs.init({
+      stylePrefix: '',
+      storageManager: { autoload: 0, type: 0 },
+      assetManager: {
+        storageType: 'none'
+      },
+      container: '#SelectorManager-fixture'
+    });
+  });
 
-      describe('Interaction with Components', () => {
-        beforeEach(() => {
-          components = gjs.getComponents();
-          tagEl = instClassTagViewer(gjs, fixtures);
-        });
+  describe('Interaction with Components', () => {
+    beforeEach(() => {
+      components = gjs.getComponents();
+      tagEl = instClassTagViewer(gjs, fixtures);
+    });
 
-        test('Assign correctly new class to component', done => {
-          var model = components.add({});
-          expect(model.get('classes').length).toEqual(0);
-          gjs.select(model);
-          setTimeout(() => {
-            tagEl.addNewTag('test');
-            expect(model.get('classes').length).toEqual(1);
-            expect(
-              model
-                .get('classes')
-                .at(0)
-                .get('name')
-            ).toEqual('test');
-            done();
-          });
-        });
+    test('Assign correctly new class to component', done => {
+      var model = components.add({});
+      expect(model.get('classes').length).toEqual(0);
+      gjs.select(model);
+      setTimeout(() => {
+        tagEl.addNewTag('test');
+        expect(model.get('classes').length).toEqual(1);
+        expect(
+          model
+            .get('classes')
+            .at(0)
+            .get('name')
+        ).toEqual('test');
+        done();
+      });
+    });
 
-        test('Classes from components are correctly imported inside main container', () => {
-          var model = components.add([
-            { classes: ['test11', 'test12', 'test13'] },
-            { classes: ['test11', 'test22', 'test22'] }
-          ]);
-          expect(gjs.editor.get('SelectorManager').getAll().length).toEqual(4);
-        });
+    test('Classes from components are correctly imported inside main container', () => {
+      var model = components.add([
+        { classes: ['test11', 'test12', 'test13'] },
+        { classes: ['test11', 'test22', 'test22'] }
+      ]);
+      expect(gjs.editor.get('SelectorManager').getAll().length).toEqual(4);
+    });
 
-        test('Class imported into component is the same model from main container', () => {
-          var model = components.add({ classes: ['test1'] });
-          var clModel = model.get('classes').at(0);
-          var clModel2 = gjs.editor
-            .get('SelectorManager')
-            .getAll()
-            .at(0);
-          expect(clModel).toEqual(clModel2);
-        });
+    test('Class imported into component is the same model from main container', () => {
+      var model = components.add({ classes: ['test1'] });
+      var clModel = model.get('classes').at(0);
+      var clModel2 = gjs.editor
+        .get('SelectorManager')
+        .getAll()
+        .at(0);
+      expect(clModel).toEqual(clModel2);
+    });
 
-        test('Can assign only one time the same class on selected component and the class viewer', done => {
-          var model = components.add({});
-          gjs.select(model);
-          setTimeout(() => {
-            tagEl.addNewTag('test');
-            tagEl.addNewTag('test');
-            expect(model.getSelectors().length).toEqual(1);
-            expect(
-              model
-                .getSelectors()
-                .at(0)
-                .get('name')
-            ).toEqual('test');
-            expect(tagEl.collection.length).toEqual(1);
-            expect(tagEl.collection.at(0).get('name')).toEqual('test');
-            done();
-          });
-        });
+    test('Can assign only one time the same class on selected component and the class viewer', done => {
+      var model = components.add({});
+      gjs.select(model);
+      setTimeout(() => {
+        tagEl.addNewTag('test');
+        tagEl.addNewTag('test');
+        expect(model.getSelectors().length).toEqual(1);
+        expect(
+          model
+            .getSelectors()
+            .at(0)
+            .get('name')
+        ).toEqual('test');
+        expect(tagEl.collection.length).toEqual(1);
+        expect(tagEl.collection.at(0).get('name')).toEqual('test');
+        done();
+      });
+    });
 
-        test('Removing from container removes also from selected component', () => {
-          var model = components.add({});
-          gjs.editor.setSelected(model);
-          tagEl.addNewTag('test');
-          tagEl
-            .getClasses()
-            .find('.tag #close')
-            .trigger('click');
-          setTimeout(() => expect(model.get('classes').length).toEqual(0));
-        });
+    test('Removing from container removes also from selected component', () => {
+      var model = components.add({});
+      gjs.editor.setSelected(model);
+      tagEl.addNewTag('test');
+      tagEl
+        .getClasses()
+        .find('.tag #close')
+        .trigger('click');
+      setTimeout(() => expect(model.get('classes').length).toEqual(0));
+    });
 
-        test('Trigger correctly event on target with new class add', done => {
-          var spy = sinon.spy();
-          var model = components.add({});
-          gjs.select(model);
-          setTimeout(() => {
-            tagEl.addNewTag('test');
-            gjs.editor.on('component:update:classes', spy);
-            tagEl.addNewTag('test');
-            expect(spy.called).toEqual(false);
-            tagEl.addNewTag('test2');
-            expect(spy.called).toEqual(true);
-            done();
-          });
-        });
+    test('Trigger correctly event on target with new class add', done => {
+      var spy = sinon.spy();
+      var model = components.add({});
+      gjs.select(model);
+      setTimeout(() => {
+        tagEl.addNewTag('test');
+        gjs.editor.on('component:update:classes', spy);
+        tagEl.addNewTag('test');
+        expect(spy.called).toEqual(false);
+        tagEl.addNewTag('test2');
+        expect(spy.called).toEqual(true);
+        done();
       });
     });
-  }
-};
+  });
+});

test/specs/selector_manager/index.js

@@ -1,9 +1,5 @@
 import SelectorManager from 'selector_manager';
 import Selector from 'selector_manager/model/Selector';
-import Models from './model/SelectorModels';
-import ClassTagView from './view/ClassTagView';
-import ClassTagsView from './view/ClassTagsView';
-import e2e from './e2e/ClassManager';
 import Editor from 'editor/model/Editor';
 
 describe('SelectorManager', () => {
@@ -172,12 +168,4 @@ describe('SelectorManager', () => {
       expect(result.length).toEqual(1);
     });
   });
-
-  Models.run();
-
-  describe('Views', () => {
-    ClassTagView.run();
-    ClassTagsView.run();
-    e2e.run();
-  });
 });

test/specs/selector_manager/model/SelectorModels.js

@@ -1,68 +1,64 @@
 import Selector from 'selector_manager/model/Selector';
 import Selectors from 'selector_manager/model/Selectors';
 
-module.exports = {
-  run() {
-    describe('Selector', () => {
-      var obj;
+describe('Selector', () => {
+  var obj;
 
-      beforeEach(() => {
-        obj = new Selector();
-      });
+  beforeEach(() => {
+    obj = new Selector();
+  });
 
-      afterEach(() => {
-        obj = null;
-      });
+  afterEach(() => {
+    obj = null;
+  });
 
-      test('Has name property', () => {
-        expect(obj.has('name')).toEqual(true);
-      });
+  test('Has name property', () => {
+    expect(obj.has('name')).toEqual(true);
+  });
 
-      test('Has label property', () => {
-        expect(obj.has('label')).toEqual(true);
-      });
+  test('Has label property', () => {
+    expect(obj.has('label')).toEqual(true);
+  });
 
-      test('Has active property', () => {
-        expect(obj.has('active')).toEqual(true);
-      });
+  test('Has active property', () => {
+    expect(obj.has('active')).toEqual(true);
+  });
 
-      test('escapeName test', () => {
-        expect(Selector.escapeName('@Te sT*')).toEqual('-Te-sT-');
-      });
+  test('escapeName test', () => {
+    expect(Selector.escapeName('@Te sT*')).toEqual('-Te-sT-');
+  });
 
-      test('Name is corrected at instantiation', () => {
-        obj = new Selector({ name: '@Te sT*' });
-        expect(obj.get('name')).toEqual('-Te-sT-');
-      });
-    });
+  test('Name is corrected at instantiation', () => {
+    obj = new Selector({ name: '@Te sT*' });
+    expect(obj.get('name')).toEqual('-Te-sT-');
+  });
+});
 
-    describe('Selectors', () => {
-      var obj;
+describe('Selectors', () => {
+  var obj;
 
-      beforeEach(() => {
-        obj = new Selectors();
-      });
+  beforeEach(() => {
+    obj = new Selectors();
+  });
 
-      test('Creates collection item correctly', () => {
-        var c = new Selectors();
-        var m = c.add({});
-        expect(m instanceof Selector).toEqual(true);
-      });
+  test('Creates collection item correctly', () => {
+    var c = new Selectors();
+    var m = c.add({});
+    expect(m instanceof Selector).toEqual(true);
+  });
 
-      test('getFullString with single class', () => {
-        obj.add({ name: 'test' });
-        expect(obj.getFullString()).toEqual('.test');
-      });
+  test('getFullString with single class', () => {
+    obj.add({ name: 'test' });
+    expect(obj.getFullString()).toEqual('.test');
+  });
 
-      test('getFullString with multiple classes', () => {
-        obj.add([{ name: 'test' }, { name: 'test2' }]);
-        expect(obj.getFullString()).toEqual('.test.test2');
-      });
+  test('getFullString with multiple classes', () => {
+    obj.add([{ name: 'test' }, { name: 'test2' }]);
+    expect(obj.getFullString()).toEqual('.test.test2');
+  });
 
-      test('getFullString with mixed selectors', () => {
-        obj.add([{ name: 'test' }, { name: 'test2', type: Selector.TYPE_ID }]);
-        expect(obj.getFullString()).toEqual('.test#test2');
-      });
-    });
-  }
-};
+  test('getFullString with mixed selectors', () => {
+    obj.add([{ name: 'test' }, { name: 'test2', type: Selector.TYPE_ID }]);
+    expect(obj.getFullString()).toEqual('.test#test2');
+  });
+});

test/specs/selector_manager/view/ClassTagView.js

@@ -2,96 +2,92 @@ import EditorModel from 'editor/model/Editor';
 import ClassTagView from 'selector_manager/view/ClassTagView';
 import Selectors from 'selector_manager/model/Selectors';
 
-module.exports = {
-  run() {
-    describe('ClassTagView', () => {
-      var obj;
-      var fixtures;
-      var testLabel;
-      var coll;
-      var em;
+describe('ClassTagView', () => {
+  var obj;
+  var fixtures;
+  var testLabel;
+  var coll;
+  var em;
 
-      beforeEach(() => {
-        coll = new Selectors();
-        testLabel = 'TestLabel';
-        em = new EditorModel();
-        var model = coll.add({
-          name: 'test',
-          label: testLabel
-        });
-        obj = new ClassTagView({
-          config: { em },
-          model,
-          coll
-        });
-        //obj.target = { get() {} };
-        //_.extend(obj.target, Backbone.Events);
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        fixtures = document.body.querySelector('#fixtures');
-        fixtures.appendChild(obj.render().el);
-      });
+  beforeEach(() => {
+    coll = new Selectors();
+    testLabel = 'TestLabel';
+    em = new EditorModel();
+    var model = coll.add({
+      name: 'test',
+      label: testLabel
+    });
+    obj = new ClassTagView({
+      config: { em },
+      model,
+      coll
+    });
+    //obj.target = { get() {} };
+    //_.extend(obj.target, Backbone.Events);
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    fixtures = document.body.querySelector('#fixtures');
+    fixtures.appendChild(obj.render().el);
+  });
 
-      afterEach(() => {
-        obj.model = null;
-      });
+  afterEach(() => {
+    obj.model = null;
+  });
 
-      test('Object exists', () => {
-        expect(ClassTagView).toBeTruthy();
-      });
+  test('Object exists', () => {
+    expect(ClassTagView).toBeTruthy();
+  });
 
-      test('Not empty', () => {
-        var $el = obj.$el;
-        expect($el.html()).toBeTruthy();
-      });
+  test('Not empty', () => {
+    var $el = obj.$el;
+    expect($el.html()).toBeTruthy();
+  });
 
-      test('Not empty', () => {
-        var $el = obj.$el;
-        expect($el.html()).toContain(testLabel);
-      });
+  test('Not empty', () => {
+    var $el = obj.$el;
+    expect($el.html()).toContain(testLabel);
+  });
 
-      describe('Should be rendered correctly', () => {
-        test('Has close button', () => {
-          var $el = obj.$el;
-          expect($el.find('#close')[0]).toBeTruthy();
-        });
-        test('Has checkbox', () => {
-          var $el = obj.$el;
-          expect($el.find('#checkbox')[0]).toBeTruthy();
-        });
-        test('Has label', () => {
-          var $el = obj.$el;
-          expect($el.find('#tag-label')[0]).toBeTruthy();
-        });
-      });
-      // To refactor.. the remove method relies on selected component...
-      test.skip('Could be removed', () => {
-        obj.$el.find('#close').trigger('click');
-        expect(fixtures.innerHTML).toBeFalsy();
-      });
+  describe('Should be rendered correctly', () => {
+    test('Has close button', () => {
+      var $el = obj.$el;
+      expect($el.find('#close')[0]).toBeTruthy();
+    });
+    test('Has checkbox', () => {
+      var $el = obj.$el;
+      expect($el.find('#checkbox')[0]).toBeTruthy();
+    });
+    test('Has label', () => {
+      var $el = obj.$el;
+      expect($el.find('#tag-label')[0]).toBeTruthy();
+    });
+  });
+  // To refactor.. the remove method relies on selected component...
+  test.skip('Could be removed', () => {
+    obj.$el.find('#close').trigger('click');
+    expect(fixtures.innerHTML).toBeFalsy();
+  });
 
-      test('Checkbox toggles status', () => {
-        var spy = sinon.spy();
-        obj.model.on('change:active', spy);
-        obj.model.set('active', true);
-        obj.$el.find('#checkbox').trigger('click');
-        expect(obj.model.get('active')).toEqual(false);
-        expect(spy.called).toEqual(true);
-      });
+  test('Checkbox toggles status', () => {
+    var spy = sinon.spy();
+    obj.model.on('change:active', spy);
+    obj.model.set('active', true);
+    obj.$el.find('#checkbox').trigger('click');
+    expect(obj.model.get('active')).toEqual(false);
+    expect(spy.called).toEqual(true);
+  });
 
-      test('Label input is disabled', () => {
-        expect(obj.getInputEl().contentEditable).toBeFalsy();
-      });
+  test('Label input is disabled', () => {
+    expect(obj.getInputEl().contentEditable).toBeFalsy();
+  });
 
-      test('On double click label input is enable', () => {
-        obj.$el.find('#tag-label').trigger('dblclick');
-        expect(obj.getInputEl().contentEditable).toEqual(true);
-      });
+  test('On double click label input is enable', () => {
+    obj.$el.find('#tag-label').trigger('dblclick');
+    expect(obj.getInputEl().contentEditable).toEqual(true);
+  });
 
-      test('On blur label input turns back disabled', () => {
-        obj.$el.find('#tag-label').trigger('dblclick');
-        obj.endEditTag();
-        expect(obj.getInputEl().contentEditable).toEqual(false);
-      });
-    });
-  }
-};
+  test('On blur label input turns back disabled', () => {
+    obj.$el.find('#tag-label').trigger('dblclick');
+    obj.endEditTag();
+    expect(obj.getInputEl().contentEditable).toEqual(false);
+  });
+});

test/specs/selector_manager/view/ClassTagsView.js

@@ -3,206 +3,202 @@ import Selectors from 'selector_manager/model/Selectors';
 import Component from 'dom_components/model/Component';
 import Editor from 'editor/model/Editor';
 
-module.exports = {
-  run() {
-    describe('ClassTagsView', () => {
-      let testContext;
-
-      beforeEach(() => {
-        testContext = {};
-      });
-
-      var view;
-      var fixture;
-      var fixtures;
-      var testLabel;
-      var coll;
-      var target;
-      var em;
-
-      beforeAll(() => {
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        fixtures = document.body.querySelector('#fixtures');
-        fixture = $('<div class="classtag-fixture"></div>');
-      });
-
-      afterAll(() => {
-        fixture.remove();
-      });
-
-      beforeEach(() => {
-        target = new Editor();
-        coll = new Selectors();
-        view = new ClassTagsView({
-          config: { em: target },
-          collection: coll
-        });
-
-        testContext.targetStub = {
-          add(v) {
-            return { name: v };
-          }
-        };
-
-        testContext.compTargetStub = new Component();
-
-        fixtures.innerHTML = '';
-        fixture.empty().appendTo(fixtures);
-        fixture.append(view.render().el);
-        testContext.btnAdd = view.$addBtn;
-        testContext.input = view.$el.find('input#' + view.newInputId);
-        testContext.$tags = fixture.find('#tags-c');
-        testContext.$states = fixture.find('#states');
-        testContext.$statesC = fixture.find('#input-c');
-      });
-
-      afterEach(() => {
-        delete view.collection;
-      });
-
-      test('Object exists', () => {
-        expect(ClassTagsView).toBeTruthy();
-      });
-
-      test('Not tags inside', () => {
-        expect(testContext.$tags.html()).toEqual('');
-      });
-
-      test('Add new tag triggers correct method', () => {
-        sinon.stub(view, 'addToClasses');
-        coll.add({ name: 'test' });
-        expect(view.addToClasses.calledOnce).toEqual(true);
-      });
-
-      test('Start new tag creation', () => {
-        testContext.btnAdd.trigger('click');
-        expect(testContext.btnAdd.css('display')).toEqual('none');
-        expect(testContext.input.css('display')).not.toEqual('none');
-      });
-
-      test('Stop tag creation', () => {
-        testContext.btnAdd.trigger('click');
-        testContext.input.val('test');
-        testContext.input.trigger('blur');
-        expect(testContext.btnAdd.css('display')).not.toEqual('none');
-        expect(testContext.input.css('display')).toEqual('none');
-        expect(testContext.input.val()).toEqual(null);
-      });
-
-      test.skip('Check keyup of ESC on input', function() {
-        this.btnAdd.click();
-        sinon.stub(view, 'addNewTag');
-        this.input.trigger({
-          type: 'keyup',
-          keyCode: 13
-        });
-        expect(view.addNewTag.calledOnce).toEqual(true);
-      });
-
-      test.skip('Check keyup on ENTER on input', function() {
-        this.btnAdd.click();
-        sinon.stub(view, 'endNewTag');
-        this.input.trigger({
-          type: 'keyup',
-          keyCode: 27
-        });
-        expect(view.endNewTag.calledOnce).toEqual(true);
-      });
-
-      test('Collection changes on update of target', done => {
-        coll.add({ name: 'test' });
-        target.trigger('component:toggled');
-        setTimeout(() => {
-          expect(coll.length).toEqual(0);
-          done();
-        });
-      });
-
-      test('Collection reacts on reset', () => {
-        coll.add([{ name: 'test1' }, { name: 'test2' }]);
-        sinon.stub(view, 'addToClasses');
-        coll.trigger('reset');
-        expect(view.addToClasses.calledTwice).toEqual(true);
-      });
-
-      test("Don't accept empty tags", () => {
-        view.addNewTag('');
-        expect(testContext.$tags.html()).toEqual('');
-      });
-
-      test('Accept new tags', () => {
-        view.compTarget = testContext.compTargetStub;
-        view.addNewTag('test');
-        view.compTarget = testContext.compTargetStub;
-        view.addNewTag('test2');
-        expect(testContext.$tags.children().length).toEqual(2);
-      });
-
-      test('New tag correctly added', () => {
-        coll.add({ label: 'test' });
-        expect(
-          testContext.$tags
-            .children()
-            .first()
-            .find('[data-tag-name]')
-            .text()
-        ).toEqual('test');
-      });
-
-      test('States are hidden in case no tags', () => {
-        view.updateStateVis();
-        expect(testContext.$statesC.css('display')).toEqual('none');
-      });
-
-      test('States are visible in case of more tags inside', () => {
-        coll.add({ label: 'test' });
-        view.updateStateVis();
-        expect(testContext.$statesC.css('display')).toEqual('block');
-      });
-
-      test('Update state visibility on new tag', () => {
-        sinon.stub(view, 'updateStateVis');
-        sinon.stub(target, 'get').returns(testContext.targetStub);
-        view.compTarget = testContext.compTargetStub;
-        view.addNewTag('test');
-        expect(view.updateStateVis.called).toEqual(true);
-      });
-
-      test('Update state visibility on removing of the tag', () => {
-        view.compTarget = testContext.compTargetStub;
-        view.addNewTag('test');
-        sinon.stub(view, 'updateStateVis');
-        coll.remove(coll.at(0));
-        expect(view.updateStateVis.calledOnce).toEqual(true);
-      });
-
-      test('Output correctly state options', () => {
-        var view = new ClassTagsView({
-          config: {
-            em: target,
-            states: [{ name: 'testName', label: 'testLabel' }]
-          },
-          collection: coll
-        });
-        expect(view.getStateOptions()).toEqual(
-          '<option value="testName">testLabel</option>'
-        );
-      });
-
-      describe('Should be rendered correctly', () => {
-        test('Has label', () => {
-          expect(view.$el.find('#label')[0]).toBeTruthy();
-        });
-        test('Has tags container', () => {
-          expect(view.$el.find('#tags-c')[0]).toBeTruthy();
-        });
-        test('Has add button', () => {
-          expect(view.$el.find('#add-tag')[0]).toBeTruthy();
-        });
-        test('Has states input', () => {
-          expect(view.$el.find('#states')[0]).toBeTruthy();
-        });
-      });
+describe('ClassTagsView', () => {
+  let testContext;
+
+  beforeEach(() => {
+    testContext = {};
+  });
+
+  var view;
+  var fixture;
+  var fixtures;
+  var testLabel;
+  var coll;
+  var target;
+  var em;
+
+  beforeAll(() => {
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    fixtures = document.body.querySelector('#fixtures');
+    fixture = $('<div class="classtag-fixture"></div>');
+  });
+
+  afterAll(() => {
+    fixture.remove();
+  });
+
+  beforeEach(() => {
+    target = new Editor();
+    coll = new Selectors();
+    view = new ClassTagsView({
+      config: { em: target },
+      collection: coll
     });
-  }
-};
+
+    testContext.targetStub = {
+      add(v) {
+        return { name: v };
+      }
+    };
+
+    testContext.compTargetStub = new Component();
+
+    fixtures.innerHTML = '';
+    fixture.empty().appendTo(fixtures);
+    fixture.append(view.render().el);
+    testContext.btnAdd = view.$addBtn;
+    testContext.input = view.$el.find('input#' + view.newInputId);
+    testContext.$tags = fixture.find('#tags-c');
+    testContext.$states = fixture.find('#states');
+    testContext.$statesC = fixture.find('#input-c');
+  });
+
+  afterEach(() => {
+    delete view.collection;
+  });
+
+  test('Object exists', () => {
+    expect(ClassTagsView).toBeTruthy();
+  });
+
+  test('Not tags inside', () => {
+    expect(testContext.$tags.html()).toEqual('');
+  });
+
+  test('Add new tag triggers correct method', () => {
+    sinon.stub(view, 'addToClasses');
+    coll.add({ name: 'test' });
+    expect(view.addToClasses.calledOnce).toEqual(true);
+  });
+
+  test('Start new tag creation', () => {
+    testContext.btnAdd.trigger('click');
+    expect(testContext.btnAdd.css('display')).toEqual('none');
+    expect(testContext.input.css('display')).not.toEqual('none');
+  });
+
+  test('Stop tag creation', () => {
+    testContext.btnAdd.trigger('click');
+    testContext.input.val('test');
+    testContext.input.trigger('blur');
+    expect(testContext.btnAdd.css('display')).not.toEqual('none');
+    expect(testContext.input.css('display')).toEqual('none');
+    expect(testContext.input.val()).toEqual(null);
+  });
+
+  test.skip('Check keyup of ESC on input', function() {
+    this.btnAdd.click();
+    sinon.stub(view, 'addNewTag');
+    this.input.trigger({
+      type: 'keyup',
+      keyCode: 13
+    });
+    expect(view.addNewTag.calledOnce).toEqual(true);
+  });
+
+  test.skip('Check keyup on ENTER on input', function() {
+    this.btnAdd.click();
+    sinon.stub(view, 'endNewTag');
+    this.input.trigger({
+      type: 'keyup',
+      keyCode: 27
+    });
+    expect(view.endNewTag.calledOnce).toEqual(true);
+  });
+
+  test('Collection changes on update of target', done => {
+    coll.add({ name: 'test' });
+    target.trigger('component:toggled');
+    setTimeout(() => {
+      expect(coll.length).toEqual(0);
+      done();
+    });
+  });
+
+  test('Collection reacts on reset', () => {
+    coll.add([{ name: 'test1' }, { name: 'test2' }]);
+    sinon.stub(view, 'addToClasses');
+    coll.trigger('reset');
+    expect(view.addToClasses.calledTwice).toEqual(true);
+  });
+
+  test("Don't accept empty tags", () => {
+    view.addNewTag('');
+    expect(testContext.$tags.html()).toEqual('');
+  });
+
+  test('Accept new tags', () => {
+    view.compTarget = testContext.compTargetStub;
+    view.addNewTag('test');
+    view.compTarget = testContext.compTargetStub;
+    view.addNewTag('test2');
+    expect(testContext.$tags.children().length).toEqual(2);
+  });
+
+  test('New tag correctly added', () => {
+    coll.add({ label: 'test' });
+    expect(
+      testContext.$tags
+        .children()
+        .first()
+        .find('[data-tag-name]')
+        .text()
+    ).toEqual('test');
+  });
+
+  test('States are hidden in case no tags', () => {
+    view.updateStateVis();
+    expect(testContext.$statesC.css('display')).toEqual('none');
+  });
+
+  test('States are visible in case of more tags inside', () => {
+    coll.add({ label: 'test' });
+    view.updateStateVis();
+    expect(testContext.$statesC.css('display')).toEqual('block');
+  });
+
+  test('Update state visibility on new tag', () => {
+    sinon.stub(view, 'updateStateVis');
+    sinon.stub(target, 'get').returns(testContext.targetStub);
+    view.compTarget = testContext.compTargetStub;
+    view.addNewTag('test');
+    expect(view.updateStateVis.called).toEqual(true);
+  });
+
+  test('Update state visibility on removing of the tag', () => {
+    view.compTarget = testContext.compTargetStub;
+    view.addNewTag('test');
+    sinon.stub(view, 'updateStateVis');
+    coll.remove(coll.at(0));
+    expect(view.updateStateVis.calledOnce).toEqual(true);
+  });
+
+  test('Output correctly state options', () => {
+    var view = new ClassTagsView({
+      config: {
+        em: target,
+        states: [{ name: 'testName', label: 'testLabel' }]
+      },
+      collection: coll
+    });
+    expect(view.getStateOptions()).toEqual(
+      '<option value="testName">testLabel</option>'
+    );
+  });
+
+  describe('Should be rendered correctly', () => {
+    test('Has label', () => {
+      expect(view.$el.find('#label')[0]).toBeTruthy();
+    });
+    test('Has tags container', () => {
+      expect(view.$el.find('#tags-c')[0]).toBeTruthy();
+    });
+    test('Has add button', () => {
+      expect(view.$el.find('#add-tag')[0]).toBeTruthy();
+    });
+    test('Has states input', () => {
+      expect(view.$el.find('#states')[0]).toBeTruthy();
+    });
+  });
+});

test/specs/storage_manager/index.js

@@ -102,6 +102,4 @@ describe('Storage Manager', () => {
       });
     });
   });
-
-  Models.run();
 });

test/specs/storage_manager/model/Models.js

@@ -2,161 +2,157 @@ import 'whatwg-fetch';
 import LocalStorage from 'storage_manager/model/LocalStorage';
 import RemoteStorage from 'storage_manager/model/RemoteStorage';
 
-module.exports = {
-  run() {
-    describe('LocalStorage', () => {
-      var obj;
-      var itemName = 'testItem';
-      var data = {
-        item1: 'value1',
-        item2: 'value2'
-      };
-
-      beforeEach(() => {
-        obj = new LocalStorage();
-      });
-
-      afterEach(() => {
-        obj = null;
-      });
-
-      test('Store and load items', () => {
-        obj.store(data);
-        var result = obj.load(['item1', 'item2']);
-        expect(result).toEqual(data);
-      });
-
-      test('Store, update and load items', () => {
-        obj.store(data);
-        obj.store({ item3: 'value3' });
-        obj.store({ item2: 'value22' });
-        var result = obj.load(['item1', 'item2', 'item3']);
-        expect(result).toEqual({
-          item1: 'value1',
-          item2: 'value22',
-          item3: 'value3'
-        });
-      });
-
-      test('Remove items', () => {
-        var items = ['item1', 'item2', 'item3'];
-        obj.store(data);
-        obj.remove(items);
-        expect(obj.load(items)).toEqual({});
-      });
+describe('LocalStorage', () => {
+  var obj;
+  var itemName = 'testItem';
+  var data = {
+    item1: 'value1',
+    item2: 'value2'
+  };
+
+  beforeEach(() => {
+    obj = new LocalStorage();
+  });
+
+  afterEach(() => {
+    obj = null;
+  });
+
+  test('Store and load items', () => {
+    obj.store(data);
+    var result = obj.load(['item1', 'item2']);
+    expect(result).toEqual(data);
+  });
+
+  test('Store, update and load items', () => {
+    obj.store(data);
+    obj.store({ item3: 'value3' });
+    obj.store({ item2: 'value22' });
+    var result = obj.load(['item1', 'item2', 'item3']);
+    expect(result).toEqual({
+      item1: 'value1',
+      item2: 'value22',
+      item3: 'value3'
     });
-
-    describe('RemoteStorage', () => {
-      var obj;
-      var itemName = 'testItem';
-      var endpointStore = 'testStoreEndpoint';
-      var endpointLoad = 'testLoadEndpoint';
-      var params = { test: 'testValue' };
-      var storageOptions;
-      var data;
-      var mockResponse = (body = {}) => {
-        return new window.Response(JSON.stringify(body), {
-          status: 200,
-          headers: { 'Content-type': 'application/json' }
-        });
-      };
-
-      beforeEach(() => {
-        data = {
-          item1: 'value1',
-          item2: 'value2'
-        };
-        storageOptions = {
-          urlStore: endpointStore,
-          urlLoad: endpointLoad,
-          params
-        };
-        obj = new RemoteStorage(storageOptions);
-        sinon
-          .stub(obj, 'fetch')
-          .returns(Promise.resolve(mockResponse({ data: 1 })));
-      });
-
-      afterEach(() => {
-        obj.fetch.restore();
-        obj = null;
-      });
-
-      test('Store data', () => {
-        obj.store(data);
-        const callResult = obj.fetch;
-        expect(callResult.called).toEqual(true);
-        expect(callResult.firstCall.args[0]).toEqual(endpointStore);
-      });
-
-      test('Load data', () => {
-        obj.load(['item1', 'item2']);
-        const callResult = obj.fetch;
-        expect(callResult.called).toEqual(true);
-        expect(callResult.firstCall.args[0]).toEqual(endpointLoad);
-      });
-
-      test("Load data with credentials option as 'include' by default", () => {
-        obj.load(['item1', 'item2']);
-        const callResult = obj.fetch;
-        expect(callResult.called).toEqual(true);
-        expect(callResult.firstCall.args[1]).toMatchObject({
-          credentials: 'include'
-        });
-      });
-
-      test("Store data with credentials option as 'include' by default", () => {
-        obj.store(data);
-        const callResult = obj.fetch;
-        expect(callResult.called).toEqual(true);
-        expect(callResult.firstCall.args[1]).toMatchObject({
-          credentials: 'include'
-        });
-      });
-
-      test('Store data with credentials option as false ', () => {
-        obj = new RemoteStorage({ ...storageOptions, credentials: false });
-        sinon
-          .stub(obj, 'fetch')
-          .returns(Promise.resolve(mockResponse({ data: 1 })));
-
-        obj.store(data);
-        const callResult = obj.fetch;
-        expect(callResult.called).toEqual(true);
-        expect(callResult.firstCall.args[1]).toMatchObject({
-          credentials: false
-        });
-      });
-
-      test('Load data with credentials option as false', () => {
-        obj = new RemoteStorage({ ...storageOptions, credentials: false });
-        sinon
-          .stub(obj, 'fetch')
-          .returns(Promise.resolve(mockResponse({ data: 1 })));
-        obj.load(['item1', 'item2']);
-        const callResult = obj.fetch;
-        expect(callResult.called).toEqual(true);
-        expect(callResult.firstCall.args[1]).toMatchObject({
-          credentials: false
-        });
-      });
-
-      test('Load data with custom fetch options as function', () => {
-        const customOpts = { customOpt: 'customValue' };
-        obj = new RemoteStorage({
-          ...storageOptions,
-          fetchOptions: () => {
-            return customOpts;
-          }
-        });
-        sinon
-          .stub(obj, 'fetch')
-          .returns(Promise.resolve(mockResponse({ data: 1 })));
-        obj.load(['item1', 'item2']);
-        const callResult = obj.fetch;
-        expect(callResult.called).toEqual(true);
-        expect(callResult.firstCall.args[1]).toMatchObject(customOpts);
-      });
+  });
+
+  test('Remove items', () => {
+    var items = ['item1', 'item2', 'item3'];
+    obj.store(data);
+    obj.remove(items);
+    expect(obj.load(items)).toEqual({});
+  });
+});
+
+describe('RemoteStorage', () => {
+  var obj;
+  var itemName = 'testItem';
+  var endpointStore = 'testStoreEndpoint';
+  var endpointLoad = 'testLoadEndpoint';
+  var params = { test: 'testValue' };
+  var storageOptions;
+  var data;
+  var mockResponse = (body = {}) => {
+    return new window.Response(JSON.stringify(body), {
+      status: 200,
+      headers: { 'Content-type': 'application/json' }
+    });
+  };
+
+  beforeEach(() => {
+    data = {
+      item1: 'value1',
+      item2: 'value2'
+    };
+    storageOptions = {
+      urlStore: endpointStore,
+      urlLoad: endpointLoad,
+      params
+    };
+    obj = new RemoteStorage(storageOptions);
+    sinon
+      .stub(obj, 'fetch')
+      .returns(Promise.resolve(mockResponse({ data: 1 })));
+  });
+
+  afterEach(() => {
+    obj.fetch.restore();
+    obj = null;
+  });
+
+  test('Store data', () => {
+    obj.store(data);
+    const callResult = obj.fetch;
+    expect(callResult.called).toEqual(true);
+    expect(callResult.firstCall.args[0]).toEqual(endpointStore);
+  });
+
+  test('Load data', () => {
+    obj.load(['item1', 'item2']);
+    const callResult = obj.fetch;
+    expect(callResult.called).toEqual(true);
+    expect(callResult.firstCall.args[0]).toEqual(endpointLoad);
+  });
+
+  test("Load data with credentials option as 'include' by default", () => {
+    obj.load(['item1', 'item2']);
+    const callResult = obj.fetch;
+    expect(callResult.called).toEqual(true);
+    expect(callResult.firstCall.args[1]).toMatchObject({
+      credentials: 'include'
+    });
+  });
+
+  test("Store data with credentials option as 'include' by default", () => {
+    obj.store(data);
+    const callResult = obj.fetch;
+    expect(callResult.called).toEqual(true);
+    expect(callResult.firstCall.args[1]).toMatchObject({
+      credentials: 'include'
+    });
+  });
+
+  test('Store data with credentials option as false ', () => {
+    obj = new RemoteStorage({ ...storageOptions, credentials: false });
+    sinon
+      .stub(obj, 'fetch')
+      .returns(Promise.resolve(mockResponse({ data: 1 })));
+
+    obj.store(data);
+    const callResult = obj.fetch;
+    expect(callResult.called).toEqual(true);
+    expect(callResult.firstCall.args[1]).toMatchObject({
+      credentials: false
+    });
+  });
+
+  test('Load data with credentials option as false', () => {
+    obj = new RemoteStorage({ ...storageOptions, credentials: false });
+    sinon
+      .stub(obj, 'fetch')
+      .returns(Promise.resolve(mockResponse({ data: 1 })));
+    obj.load(['item1', 'item2']);
+    const callResult = obj.fetch;
+    expect(callResult.called).toEqual(true);
+    expect(callResult.firstCall.args[1]).toMatchObject({
+      credentials: false
+    });
+  });
+
+  test('Load data with custom fetch options as function', () => {
+    const customOpts = { customOpt: 'customValue' };
+    obj = new RemoteStorage({
+      ...storageOptions,
+      fetchOptions: () => {
+        return customOpts;
+      }
     });
-  }
-};
+    sinon
+      .stub(obj, 'fetch')
+      .returns(Promise.resolve(mockResponse({ data: 1 })));
+    obj.load(['item1', 'item2']);
+    const callResult = obj.fetch;
+    expect(callResult.called).toEqual(true);
+    expect(callResult.firstCall.args[1]).toMatchObject(customOpts);
+  });
+});

test/specs/style_manager/index.js

@@ -180,20 +180,5 @@ describe('StyleManager', () => {
         expect(prop1.get('name')).toEqual('Width');
       });
     });
-
-    Models.run();
-
-    describe('Views', () => {
-      SectorView.run();
-      SectorsView.run();
-      PropertyView.run();
-      PropertySelectView.run();
-      PropertyRadioView.run();
-      PropertyIntegerView.run();
-      PropertyColorView.run();
-      PropertyCompositeView.run();
-      PropertyStackView.run();
-      LayerView.run();
-    });
   });
 });

test/specs/style_manager/view/LayerView.js

@@ -1,59 +1,55 @@
 import LayerView from 'style_manager/view/LayerView';
 import Layers from 'style_manager/model/Layers';
 
-module.exports = {
-  run() {
-    describe('LayerView', () => {
-      var component;
-      var fixtures;
-      var target;
-      var model;
-      var view;
-
-      beforeEach(() => {
-        var coll = new Layers();
-        model = coll.add({});
-        view = new LayerView({
-          model
-        });
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        fixtures = document.body.firstChild;
-        fixtures.appendChild(view.render().el);
-      });
-
-      afterAll(() => {
-        component = null;
-        view = null;
-        model = null;
-      });
-
-      test('Rendered correctly', () => {
-        var layer = view.el;
-        expect(fixtures.querySelector('.layer')).toBeTruthy();
-        expect(layer.querySelector('#label')).toBeTruthy();
-        expect(layer.querySelector('#close-layer')).toBeTruthy();
-        expect(view.getPropertiesWrapper()).toBeTruthy();
-        expect(view.getPreviewEl()).toBeTruthy();
-      });
-
-      test('Is not active by default', () => {
-        expect(view.$el.hasClass('active')).toEqual(false);
-      });
-
-      test('Is possible to activate it', () => {
-        view.model.set('active', 1);
-        expect(view.$el.hasClass('active')).toEqual(true);
-      });
-
-      test('Is possible to activate it with active()', () => {
-        view.active();
-        expect(view.$el.hasClass('active')).toEqual(true);
-      });
-
-      test('No preview', () => {
-        var style = view.el.querySelector('#preview').style;
-        expect(style.cssText).toBeFalsy();
-      });
+describe('LayerView', () => {
+  var component;
+  var fixtures;
+  var target;
+  var model;
+  var view;
+
+  beforeEach(() => {
+    var coll = new Layers();
+    model = coll.add({});
+    view = new LayerView({
+      model
     });
-  }
-};
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    fixtures = document.body.firstChild;
+    fixtures.appendChild(view.render().el);
+  });
+
+  afterAll(() => {
+    component = null;
+    view = null;
+    model = null;
+  });
+
+  test('Rendered correctly', () => {
+    var layer = view.el;
+    expect(fixtures.querySelector('.layer')).toBeTruthy();
+    expect(layer.querySelector('#label')).toBeTruthy();
+    expect(layer.querySelector('#close-layer')).toBeTruthy();
+    expect(view.getPropertiesWrapper()).toBeTruthy();
+    expect(view.getPreviewEl()).toBeTruthy();
+  });
+
+  test('Is not active by default', () => {
+    expect(view.$el.hasClass('active')).toEqual(false);
+  });
+
+  test('Is possible to activate it', () => {
+    view.model.set('active', 1);
+    expect(view.$el.hasClass('active')).toEqual(true);
+  });
+
+  test('Is possible to activate it with active()', () => {
+    view.active();
+    expect(view.$el.hasClass('active')).toEqual(true);
+  });
+
+  test('No preview', () => {
+    var style = view.el.querySelector('#preview').style;
+    expect(style.cssText).toBeFalsy();
+  });
+});

test/specs/style_manager/view/PropertyColorView.js

@@ -4,165 +4,161 @@ import Component from 'dom_components/model/Component';
 import Editor from 'editor/model/Editor';
 import DomComponents from 'dom_components';
 
-module.exports = {
-  run() {
-    describe('PropertyColorView', () => {
-      let em;
-      let dcomp;
-      let compOpts;
-      var component;
-      var fixtures;
-      var target;
-      var model;
-      var view;
-      var propTarget;
-      var propName = 'testprop';
-      var propValue = '#fff';
-      var defValue = 'test2value';
-
-      beforeAll(() => {
-        $.fn.spectrum = function() {
-          return this;
-        };
-      });
-
-      beforeEach(() => {
-        em = new Editor({});
-        dcomp = new DomComponents();
-        compOpts = { em, componentTypes: dcomp.componentTypes };
-        propTarget = { ...Backbone.Events };
-        target = new Component({}, compOpts);
-        component = new Component({}, compOpts);
-        model = new Property({
-          type: 'color',
-          property: propName
-        });
-        propTarget.model = component;
-        view = new PropertyColorView({
-          model,
-          propTarget
-        });
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        fixtures = document.body.firstChild;
-        view.render();
-        fixtures.appendChild(view.el);
-      });
-
-      afterEach(() => {
-        //view.remove(); // strange errors ???
-      });
-
-      afterAll(() => {
-        component = null;
-        view = null;
-        model = null;
-      });
-
-      test('Rendered correctly', () => {
-        var prop = view.el;
-        expect(fixtures.querySelector('.property')).toBeTruthy();
-        expect(prop.querySelector('.label')).toBeTruthy();
-        expect(prop.querySelector('.field')).toBeTruthy();
-      });
-
-      test('Inputs rendered', () => {
-        var prop = view.el;
-        expect(prop.querySelector('input[type=text]')).toBeTruthy();
-      });
-
-      test('Inputs should exist', () => {
-        expect(view.$input).toBeTruthy();
-        expect(view.$color).toBeTruthy();
-      });
-
-      test('Input value is empty', () => {
-        expect(view.model.get('value')).toBeFalsy();
-        expect(view.getInputValue()).toBeFalsy();
-      });
-
-      test('Update model on setValue', () => {
-        view.setValue(propValue);
-        expect(view.getInputValue()).toEqual(propValue);
+describe('PropertyColorView', () => {
+  let em;
+  let dcomp;
+  let compOpts;
+  var component;
+  var fixtures;
+  var target;
+  var model;
+  var view;
+  var propTarget;
+  var propName = 'testprop';
+  var propValue = '#fff';
+  var defValue = 'test2value';
+
+  beforeAll(() => {
+    $.fn.spectrum = function() {
+      return this;
+    };
+  });
+
+  beforeEach(() => {
+    em = new Editor({});
+    dcomp = new DomComponents();
+    compOpts = { em, componentTypes: dcomp.componentTypes };
+    propTarget = { ...Backbone.Events };
+    target = new Component({}, compOpts);
+    component = new Component({}, compOpts);
+    model = new Property({
+      type: 'color',
+      property: propName
+    });
+    propTarget.model = component;
+    view = new PropertyColorView({
+      model,
+      propTarget
+    });
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    fixtures = document.body.firstChild;
+    view.render();
+    fixtures.appendChild(view.el);
+  });
+
+  afterEach(() => {
+    //view.remove(); // strange errors ???
+  });
+
+  afterAll(() => {
+    component = null;
+    view = null;
+    model = null;
+  });
+
+  test('Rendered correctly', () => {
+    var prop = view.el;
+    expect(fixtures.querySelector('.property')).toBeTruthy();
+    expect(prop.querySelector('.label')).toBeTruthy();
+    expect(prop.querySelector('.field')).toBeTruthy();
+  });
+
+  test('Inputs rendered', () => {
+    var prop = view.el;
+    expect(prop.querySelector('input[type=text]')).toBeTruthy();
+  });
+
+  test('Inputs should exist', () => {
+    expect(view.$input).toBeTruthy();
+    expect(view.$color).toBeTruthy();
+  });
+
+  test('Input value is empty', () => {
+    expect(view.model.get('value')).toBeFalsy();
+    expect(view.getInputValue()).toBeFalsy();
+  });
+
+  test('Update model on setValue', () => {
+    view.setValue(propValue);
+    expect(view.getInputValue()).toEqual(propValue);
+  });
+
+  test('Update model on input change', () => {
+    view.getInputEl().value = propValue;
+    view.inputValueChanged();
+    expect(view.model.get('value')).toEqual(propValue);
+  });
+
+  test('Update input on value change', () => {
+    view.model.set('value', propValue);
+    expect(view.getInputValue()).toEqual(propValue);
+  });
+
+  test('Update target on value change', () => {
+    view.selectedComponent = component;
+    view.model.set('value', propValue);
+    var compStyle = view.selectedComponent.get('style');
+    var assertStyle = {};
+    assertStyle[propName] = propValue;
+    expect(compStyle).toEqual(assertStyle);
+  });
+
+  describe('With target setted', () => {
+    beforeEach(() => {
+      target.model = component;
+      view = new PropertyColorView({
+        model,
+        propTarget: target
       });
+      fixtures.innerHTML = '';
+      view.render();
+      fixtures.appendChild(view.el);
+    });
 
-      test('Update model on input change', () => {
-        view.getInputEl().value = propValue;
-        view.inputValueChanged();
-        expect(view.model.get('value')).toEqual(propValue);
-      });
+    test('Update value and input on target swap', () => {
+      var style = {};
+      style[propName] = propValue;
+      component.set('style', style);
+      view.propTarget.trigger('update');
+      expect(view.model.get('value')).toEqual(propValue);
+      expect(view.getInputValue()).toEqual(propValue);
+    });
 
-      test('Update input on value change', () => {
-        view.model.set('value', propValue);
-        expect(view.getInputValue()).toEqual(propValue);
+    test('Update value after multiple swaps', () => {
+      var style = {};
+      style[propName] = propValue;
+      component.set('style', style);
+      view.propTarget.trigger('update');
+      style[propName] = '#123123';
+      component.set('style', style);
+      view.propTarget.trigger('update');
+      expect(view.model.get('value')).toEqual('#123123');
+      expect(view.getInputValue()).toEqual('#123123');
+    });
+  });
+
+  describe('Init property', () => {
+    beforeEach(() => {
+      component = new Component();
+      model = new Property({
+        type: 'color',
+        property: propName,
+        defaults: propValue
       });
-
-      test('Update target on value change', () => {
-        view.selectedComponent = component;
-        view.model.set('value', propValue);
-        var compStyle = view.selectedComponent.get('style');
-        var assertStyle = {};
-        assertStyle[propName] = propValue;
-        expect(compStyle).toEqual(assertStyle);
+      view = new PropertyColorView({
+        model
       });
+      fixtures.innerHTML = '';
+      view.render();
+      fixtures.appendChild(view.el);
+    });
 
-      describe('With target setted', () => {
-        beforeEach(() => {
-          target.model = component;
-          view = new PropertyColorView({
-            model,
-            propTarget: target
-          });
-          fixtures.innerHTML = '';
-          view.render();
-          fixtures.appendChild(view.el);
-        });
-
-        test('Update value and input on target swap', () => {
-          var style = {};
-          style[propName] = propValue;
-          component.set('style', style);
-          view.propTarget.trigger('update');
-          expect(view.model.get('value')).toEqual(propValue);
-          expect(view.getInputValue()).toEqual(propValue);
-        });
-
-        test('Update value after multiple swaps', () => {
-          var style = {};
-          style[propName] = propValue;
-          component.set('style', style);
-          view.propTarget.trigger('update');
-          style[propName] = '#123123';
-          component.set('style', style);
-          view.propTarget.trigger('update');
-          expect(view.model.get('value')).toEqual('#123123');
-          expect(view.getInputValue()).toEqual('#123123');
-        });
-      });
+    test('Value as default', () => {
+      expect(view.model.get('value')).toEqual(propValue);
+    });
 
-      describe('Init property', () => {
-        beforeEach(() => {
-          component = new Component();
-          model = new Property({
-            type: 'color',
-            property: propName,
-            defaults: propValue
-          });
-          view = new PropertyColorView({
-            model
-          });
-          fixtures.innerHTML = '';
-          view.render();
-          fixtures.appendChild(view.el);
-        });
-
-        test('Value as default', () => {
-          expect(view.model.get('value')).toEqual(propValue);
-        });
-
-        test('Input value is the default', () => {
-          expect(view.getInputValue()).toEqual(propValue);
-        });
-      });
+    test('Input value is the default', () => {
+      expect(view.getInputValue()).toEqual(propValue);
     });
-  }
-};
+  });
+});

test/specs/style_manager/view/PropertyCompositeView.js

@@ -4,243 +4,239 @@ import Component from 'dom_components/model/Component';
 import Editor from 'editor/model/Editor';
 import DomComponents from 'dom_components';
 
-module.exports = {
-  run() {
-    describe('PropertyCompositeView', () => {
-      let em;
-      let dcomp;
-      let compOpts;
-      var component;
-      var fixtures;
-      var target;
-      var model;
-      var view;
-      var propName = 'testprop';
-      var propValue = 'test1value';
-      var defValue = 'test2value';
-      var properties = [
-        {
-          property: 'subprop1'
-        },
-        {
-          type: 'integer',
-          property: 'subprop2',
-          defaults: 0,
-          units: ['%', 'px']
-        },
-        {
-          type: 'select',
-          property: 'subprop3',
-          defaults: 'val2',
-          list: [{ value: 'val1' }, { value: 'val2' }, { value: 'val3' }]
-        }
-      ];
-
-      beforeEach(() => {
-        em = new Editor({});
-        dcomp = new DomComponents();
-        compOpts = { em, componentTypes: dcomp.componentTypes };
-        target = new Component({}, compOpts);
-        component = new Component({}, compOpts);
-        target.model = component;
-        model = new PropertyComposite({
-          type: 'composite',
-          property: propName,
-          properties
-        });
-        view = new PropertyCompositeView({
-          model
-        });
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        fixtures = document.body.firstChild;
-        view.render();
-        fixtures.appendChild(view.el);
+describe('PropertyCompositeView', () => {
+  let em;
+  let dcomp;
+  let compOpts;
+  var component;
+  var fixtures;
+  var target;
+  var model;
+  var view;
+  var propName = 'testprop';
+  var propValue = 'test1value';
+  var defValue = 'test2value';
+  var properties = [
+    {
+      property: 'subprop1'
+    },
+    {
+      type: 'integer',
+      property: 'subprop2',
+      defaults: 0,
+      units: ['%', 'px']
+    },
+    {
+      type: 'select',
+      property: 'subprop3',
+      defaults: 'val2',
+      list: [{ value: 'val1' }, { value: 'val2' }, { value: 'val3' }]
+    }
+  ];
+
+  beforeEach(() => {
+    em = new Editor({});
+    dcomp = new DomComponents();
+    compOpts = { em, componentTypes: dcomp.componentTypes };
+    target = new Component({}, compOpts);
+    component = new Component({}, compOpts);
+    target.model = component;
+    model = new PropertyComposite({
+      type: 'composite',
+      property: propName,
+      properties
+    });
+    view = new PropertyCompositeView({
+      model
+    });
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    fixtures = document.body.firstChild;
+    view.render();
+    fixtures.appendChild(view.el);
+  });
+
+  afterAll(() => {
+    component = null;
+    view = null;
+    model = null;
+  });
+
+  test('Rendered correctly', () => {
+    var prop = view.el;
+    expect(fixtures.querySelector('.property')).toBeTruthy();
+    expect(prop.querySelector('.label')).toBeTruthy();
+    expect(prop.querySelector('.field')).toBeTruthy();
+  });
+
+  test('Properties rendered', () => {
+    var prop = view.el;
+    expect(prop.querySelector('.properties')).toBeTruthy();
+  });
+
+  test('Properties rendered correctly', () => {
+    var children = view.el.querySelector('.properties').children;
+    expect(children.length).toEqual(properties.length);
+    expect(children[0].id).toEqual(properties[0].property);
+    expect(children[1].id).toEqual(properties[1].property);
+    expect(children[2].id).toEqual(properties[2].property);
+  });
+
+  test('Props should exist', () => {
+    expect(view.$props).toBeTruthy();
+  });
+
+  test('Input value is empty', () => {
+    expect(model.getFullValue()).toEqual('0 val2');
+  });
+
+  test('Update input on value change', () => {
+    view.model.set('value', propValue);
+    // Fetch always values from properties
+    expect(view.getInputValue()).toEqual('0 val2');
+  });
+
+  describe('With target setted', () => {
+    var prop2Val;
+    var prop3Val;
+    var prop2Unit;
+    var finalResult;
+    var $prop1;
+    var $prop2;
+    var $prop3;
+
+    beforeEach(() => {
+      model = new PropertyComposite({
+        type: 'composite',
+        property: propName,
+        properties
       });
-
-      afterAll(() => {
-        component = null;
-        view = null;
-        model = null;
+      view = new PropertyCompositeView({
+        model,
+        propTarget: target
       });
+      fixtures.innerHTML = '';
+      view.render();
+      fixtures.appendChild(view.el);
+      prop2Val = properties[1].defaults;
+      prop2Unit = properties[1].units[0];
+      prop3Val = properties[2].list[2].value;
+      finalResult = propValue + ' ' + prop2Val + ' ' + prop3Val;
+      $prop1 = view.$props.find('#' + properties[0].property + ' input');
+      $prop2 = view.$props.find('#' + properties[1].property + ' input');
+      $prop3 = view.$props.find('#' + properties[2].property + ' select');
+    });
 
-      test('Rendered correctly', () => {
-        var prop = view.el;
-        expect(fixtures.querySelector('.property')).toBeTruthy();
-        expect(prop.querySelector('.label')).toBeTruthy();
-        expect(prop.querySelector('.field')).toBeTruthy();
-      });
+    test('Update model on input change', () => {
+      $prop1.val(propValue).trigger('change');
+      $prop3.val(prop3Val).trigger('change');
+      expect(model.getFullValue()).toEqual(finalResult);
+    });
 
-      test('Properties rendered', () => {
-        var prop = view.el;
-        expect(prop.querySelector('.properties')).toBeTruthy();
-      });
+    test('Update value on models change', () => {
+      view.model
+        .get('properties')
+        .at(0)
+        .set('value', propValue);
+      view.model
+        .get('properties')
+        .at(2)
+        .set('value', prop3Val);
+      expect(view.model.get('value')).toEqual(finalResult);
+    });
 
-      test('Properties rendered correctly', () => {
-        var children = view.el.querySelector('.properties').children;
-        expect(children.length).toEqual(properties.length);
-        expect(children[0].id).toEqual(properties[0].property);
-        expect(children[1].id).toEqual(properties[1].property);
-        expect(children[2].id).toEqual(properties[2].property);
-      });
+    test('Update target on value change', () => {
+      $prop1.val(propValue).trigger('change');
+      var compStyle = view.getTarget().get('style');
+      var assertStyle = {};
+      assertStyle[propName] = propValue + ' 0 val2';
+      expect(compStyle).toEqual(assertStyle);
+    });
 
-      test('Props should exist', () => {
-        expect(view.$props).toBeTruthy();
+    test('Update target on detached value change', () => {
+      model = new PropertyComposite({
+        type: 'composite',
+        property: propName,
+        properties,
+        detached: true
       });
-
-      test('Input value is empty', () => {
-        expect(model.getFullValue()).toEqual('0 val2');
+      view = new PropertyCompositeView({
+        model,
+        propTarget: target
       });
+      fixtures.innerHTML = '';
+      view.render();
+      fixtures.appendChild(view.el);
+      $prop1 = view.$props.find('#' + properties[0].property + ' input');
+      $prop1.val(propValue).trigger('change');
+      var compStyle = view.getTarget().get('style');
+      var assertStyle = {};
+      assertStyle[properties[0].property] = $prop1.val();
+      expect(compStyle).toEqual(assertStyle);
+    });
 
-      test('Update input on value change', () => {
-        view.model.set('value', propValue);
-        // Fetch always values from properties
-        expect(view.getInputValue()).toEqual('0 val2');
-      });
+    test('Update value and input on target swap', () => {
+      var style = {};
+      style[propName] = finalResult;
+      component.set('style', style);
+      view.propTarget.trigger('update');
+      expect($prop1.val()).toEqual(propValue);
+      expect($prop3.val()).toEqual(prop3Val);
+    });
 
-      describe('With target setted', () => {
-        var prop2Val;
-        var prop3Val;
-        var prop2Unit;
-        var finalResult;
-        var $prop1;
-        var $prop2;
-        var $prop3;
-
-        beforeEach(() => {
-          model = new PropertyComposite({
-            type: 'composite',
-            property: propName,
-            properties
-          });
-          view = new PropertyCompositeView({
-            model,
-            propTarget: target
-          });
-          fixtures.innerHTML = '';
-          view.render();
-          fixtures.appendChild(view.el);
-          prop2Val = properties[1].defaults;
-          prop2Unit = properties[1].units[0];
-          prop3Val = properties[2].list[2].value;
-          finalResult = propValue + ' ' + prop2Val + ' ' + prop3Val;
-          $prop1 = view.$props.find('#' + properties[0].property + ' input');
-          $prop2 = view.$props.find('#' + properties[1].property + ' input');
-          $prop3 = view.$props.find('#' + properties[2].property + ' select');
-        });
-
-        test('Update model on input change', () => {
-          $prop1.val(propValue).trigger('change');
-          $prop3.val(prop3Val).trigger('change');
-          expect(model.getFullValue()).toEqual(finalResult);
-        });
-
-        test('Update value on models change', () => {
-          view.model
-            .get('properties')
-            .at(0)
-            .set('value', propValue);
-          view.model
-            .get('properties')
-            .at(2)
-            .set('value', prop3Val);
-          expect(view.model.get('value')).toEqual(finalResult);
-        });
-
-        test('Update target on value change', () => {
-          $prop1.val(propValue).trigger('change');
-          var compStyle = view.getTarget().get('style');
-          var assertStyle = {};
-          assertStyle[propName] = propValue + ' 0 val2';
-          expect(compStyle).toEqual(assertStyle);
-        });
-
-        test('Update target on detached value change', () => {
-          model = new PropertyComposite({
-            type: 'composite',
-            property: propName,
-            properties,
-            detached: true
-          });
-          view = new PropertyCompositeView({
-            model,
-            propTarget: target
-          });
-          fixtures.innerHTML = '';
-          view.render();
-          fixtures.appendChild(view.el);
-          $prop1 = view.$props.find('#' + properties[0].property + ' input');
-          $prop1.val(propValue).trigger('change');
-          var compStyle = view.getTarget().get('style');
-          var assertStyle = {};
-          assertStyle[properties[0].property] = $prop1.val();
-          expect(compStyle).toEqual(assertStyle);
-        });
-
-        test('Update value and input on target swap', () => {
-          var style = {};
-          style[propName] = finalResult;
-          component.set('style', style);
-          view.propTarget.trigger('update');
-          expect($prop1.val()).toEqual(propValue);
-          expect($prop3.val()).toEqual(prop3Val);
-        });
-
-        test('Update value after multiple swaps', () => {
-          var style = {};
-          style[propName] = finalResult;
-          component.set('style', style);
-          view.propTarget.trigger('update');
-          style[propName] =
-            propValue + '2 ' + prop2Val + '2' + prop2Unit + ' ' + 'val1';
-          component.set('style', style);
-          view.propTarget.trigger('update');
-          expect($prop1.val()).toEqual(propValue + '2');
-          expect($prop2.val()).toEqual('2');
-          expect($prop3.val()).toEqual('val1');
-        });
-
-        test('The value is correctly extracted from the composite string', () => {
-          var style = {};
-          style[propName] = 'value1 value2 value3 value4';
-          component.set('style', style);
-          expect(view.valueOnIndex(2)).toEqual('value3');
-          expect(view.valueOnIndex(0)).toEqual('value1');
-          expect(view.valueOnIndex(4)).toEqual(undefined);
-        });
-
-        test('Build value from properties', () => {
-          view.model
-            .get('properties')
-            .at(0)
-            .set('value', propValue);
-          view.model
-            .get('properties')
-            .at(2)
-            .set('value', prop3Val);
-          expect(model.getFullValue()).toEqual(finalResult);
-        });
-      });
+    test('Update value after multiple swaps', () => {
+      var style = {};
+      style[propName] = finalResult;
+      component.set('style', style);
+      view.propTarget.trigger('update');
+      style[propName] =
+        propValue + '2 ' + prop2Val + '2' + prop2Unit + ' ' + 'val1';
+      component.set('style', style);
+      view.propTarget.trigger('update');
+      expect($prop1.val()).toEqual(propValue + '2');
+      expect($prop2.val()).toEqual('2');
+      expect($prop3.val()).toEqual('val1');
+    });
 
-      describe('Init property', () => {
-        beforeEach(() => {
-          model = new PropertyComposite({
-            type: 'composite',
-            property: propName,
-            properties,
-            defaults: defValue
-          });
-          view = new PropertyCompositeView({
-            model
-          });
-          fixtures.innerHTML = '';
-          view.render();
-          fixtures.appendChild(view.el);
-        });
-
-        test('Value as default', () => {
-          expect(view.model.get('value')).toEqual(defValue);
-        });
+    test('The value is correctly extracted from the composite string', () => {
+      var style = {};
+      style[propName] = 'value1 value2 value3 value4';
+      component.set('style', style);
+      expect(view.valueOnIndex(2)).toEqual('value3');
+      expect(view.valueOnIndex(0)).toEqual('value1');
+      expect(view.valueOnIndex(4)).toEqual(undefined);
+    });
+
+    test('Build value from properties', () => {
+      view.model
+        .get('properties')
+        .at(0)
+        .set('value', propValue);
+      view.model
+        .get('properties')
+        .at(2)
+        .set('value', prop3Val);
+      expect(model.getFullValue()).toEqual(finalResult);
+    });
+  });
+
+  describe('Init property', () => {
+    beforeEach(() => {
+      model = new PropertyComposite({
+        type: 'composite',
+        property: propName,
+        properties,
+        defaults: defValue
+      });
+      view = new PropertyCompositeView({
+        model
       });
+      fixtures.innerHTML = '';
+      view.render();
+      fixtures.appendChild(view.el);
+    });
+
+    test('Value as default', () => {
+      expect(view.model.get('value')).toEqual(defValue);
     });
-  }
-};
+  });
+});

test/specs/style_manager/view/PropertyIntegerView.js

@@ -4,200 +4,196 @@ import Component from 'dom_components/model/Component';
 import Editor from 'editor/model/Editor';
 import DomComponents from 'dom_components';
 
-module.exports = {
-  run() {
-    describe('PropertyIntegerView', () => {
-      let em;
-      let dcomp;
-      let compOpts;
-      var component;
-      var fixtures;
-      var target;
-      var model;
-      var view;
-      var propTarget;
-      var propName = 'testprop';
-      var intValue = '55';
-      var unitValue = 'px';
-      var propValue = intValue + unitValue;
-      var defValue = 'test2value';
-      var units = ['px', '%', 'em'];
-      var minValue = -15;
-      var maxValue = 75;
-      var unitsElSel = '.field-units select';
-
-      beforeEach(() => {
-        em = new Editor({});
-        dcomp = new DomComponents();
-        compOpts = { em, componentTypes: dcomp.componentTypes };
-        propTarget = { ...Backbone.Events };
-        target = new Component({}, compOpts);
-        component = new Component({}, compOpts);
-        model = new PropertyInteger({
-          units,
-          property: propName
-        });
-        propTarget.model = component;
-        view = new PropertyIntegerView({
-          model,
-          propTarget
-        });
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        fixtures = document.body.firstChild;
-        view.render();
-        fixtures.appendChild(view.el);
-      });
-
-      afterEach(() => {
-        //view.remove(); // strange errors ???
-      });
-
-      afterAll(() => {
-        component = null;
-        view = null;
-        model = null;
-      });
-
-      test('Rendered correctly', () => {
-        var prop = view.el;
-        expect(fixtures.querySelector('.property')).toBeTruthy();
-        expect(prop.querySelector('.label')).toBeTruthy();
-        expect(prop.querySelector('.field')).toBeTruthy();
-      });
-
-      test('Inputs rendered', () => {
-        var prop = view.el;
-        expect(prop.querySelector('input[type=text]')).toBeTruthy();
-        expect(prop.querySelector(unitsElSel)).toBeTruthy();
-      });
-
-      test('Units rendered', () => {
-        var select = view.el.querySelector(unitsElSel);
-        expect(select.children.length).toEqual(units.length);
-      });
-
-      test('Units rendered correctly', () => {
-        var children = view.el.querySelector(unitsElSel).children;
-        expect(children[0].textContent).toEqual(units[0]);
-        expect(children[1].textContent).toEqual(units[1]);
-        expect(children[2].textContent).toEqual(units[2]);
-      });
-
-      test('Inputs should exist', () => {
-        expect(view.input).toBeTruthy();
-        expect(view.unit).toBeTruthy();
-      });
-
-      test('Input value is empty', () => {
-        expect(view.model.get('value')).toBeFalsy();
-      });
-
-      test('Update model on setValue', () => {
-        view.setValue(intValue + unitValue);
-        expect(view.model.get('value')).toEqual(parseFloat(intValue));
-        expect(view.model.get('unit')).toEqual(unitValue);
-        expect(view.getInputValue()).toEqual(intValue);
-        expect(view.unit.value).toEqual(unitValue);
-      });
+describe('PropertyIntegerView', () => {
+  let em;
+  let dcomp;
+  let compOpts;
+  var component;
+  var fixtures;
+  var target;
+  var model;
+  var view;
+  var propTarget;
+  var propName = 'testprop';
+  var intValue = '55';
+  var unitValue = 'px';
+  var propValue = intValue + unitValue;
+  var defValue = 'test2value';
+  var units = ['px', '%', 'em'];
+  var minValue = -15;
+  var maxValue = 75;
+  var unitsElSel = '.field-units select';
+
+  beforeEach(() => {
+    em = new Editor({});
+    dcomp = new DomComponents();
+    compOpts = { em, componentTypes: dcomp.componentTypes };
+    propTarget = { ...Backbone.Events };
+    target = new Component({}, compOpts);
+    component = new Component({}, compOpts);
+    model = new PropertyInteger({
+      units,
+      property: propName
+    });
+    propTarget.model = component;
+    view = new PropertyIntegerView({
+      model,
+      propTarget
+    });
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    fixtures = document.body.firstChild;
+    view.render();
+    fixtures.appendChild(view.el);
+  });
+
+  afterEach(() => {
+    //view.remove(); // strange errors ???
+  });
+
+  afterAll(() => {
+    component = null;
+    view = null;
+    model = null;
+  });
+
+  test('Rendered correctly', () => {
+    var prop = view.el;
+    expect(fixtures.querySelector('.property')).toBeTruthy();
+    expect(prop.querySelector('.label')).toBeTruthy();
+    expect(prop.querySelector('.field')).toBeTruthy();
+  });
+
+  test('Inputs rendered', () => {
+    var prop = view.el;
+    expect(prop.querySelector('input[type=text]')).toBeTruthy();
+    expect(prop.querySelector(unitsElSel)).toBeTruthy();
+  });
+
+  test('Units rendered', () => {
+    var select = view.el.querySelector(unitsElSel);
+    expect(select.children.length).toEqual(units.length);
+  });
+
+  test('Units rendered correctly', () => {
+    var children = view.el.querySelector(unitsElSel).children;
+    expect(children[0].textContent).toEqual(units[0]);
+    expect(children[1].textContent).toEqual(units[1]);
+    expect(children[2].textContent).toEqual(units[2]);
+  });
+
+  test('Inputs should exist', () => {
+    expect(view.input).toBeTruthy();
+    expect(view.unit).toBeTruthy();
+  });
+
+  test('Input value is empty', () => {
+    expect(view.model.get('value')).toBeFalsy();
+  });
+
+  test('Update model on setValue', () => {
+    view.setValue(intValue + unitValue);
+    expect(view.model.get('value')).toEqual(parseFloat(intValue));
+    expect(view.model.get('unit')).toEqual(unitValue);
+    expect(view.getInputValue()).toEqual(intValue);
+    expect(view.unit.value).toEqual(unitValue);
+  });
+
+  test('Update model on input change', () => {
+    view.$input.val(123).trigger('change');
+    expect(view.model.get('value')).toEqual(123);
+  });
+
+  test('Update model on unit change', () => {
+    view.$unit.val(units[1]).trigger('change');
+    expect(view.model.get('unit')).toEqual(units[1]);
+  });
+
+  test('Update input on value change', () => {
+    view.model.set('value', intValue);
+    expect(view.getInputValue()).toEqual(intValue);
+  });
+
+  test('Update target on value change', () => {
+    const val = `${intValue}%`;
+    view.model.setValue(val);
+    expect(view.getTargetValue()).toEqual(val);
+  });
+
+  describe('With target setted', () => {
+    beforeEach(() => {
+      target.model = component;
+      view = new PropertyIntegerView({
+        model,
+        propTarget: target
+      });
+      fixtures.innerHTML = '';
+      view.render();
+      fixtures.appendChild(view.el);
+    });
 
-      test('Update model on input change', () => {
-        view.$input.val(123).trigger('change');
-        expect(view.model.get('value')).toEqual(123);
-      });
+    test('Update value and input on target swap', () => {
+      var style = {};
+      style[propName] = propValue;
+      component.set('style', style);
+      view.propTarget.trigger('update');
+      expect(view.model.get('value')).toEqual(parseFloat(intValue));
+      expect(view.getInputValue()).toEqual(intValue);
+    });
 
-      test('Update model on unit change', () => {
-        view.$unit.val(units[1]).trigger('change');
-        expect(view.model.get('unit')).toEqual(units[1]);
-      });
+    test('Update value after multiple swaps', () => {
+      var style = {};
+      style[propName] = propValue;
+      component.set('style', style);
+      view.propTarget.trigger('update');
+      style[propName] = '20em';
+      component.set('style', style);
+      view.propTarget.trigger('update');
+      expect(view.model.get('value')).toEqual(20);
+      expect(view.model.get('unit')).toEqual('em');
+      expect(view.getInputValue()).toEqual('20');
+      expect(view.$unit.val()).toEqual('em');
+    });
+  });
+
+  describe('Init property', () => {
+    beforeEach(() => {
+      component = new Component();
+      model = new PropertyInteger({
+        units,
+        property: propName,
+        defaults: intValue,
+        min: minValue,
+        max: maxValue,
+        unit: units[1]
+      });
+      view = new PropertyIntegerView({
+        model
+      });
+      fixtures.innerHTML = '';
+      view.render();
+      fixtures.appendChild(view.el);
+    });
 
-      test('Update input on value change', () => {
-        view.model.set('value', intValue);
-        expect(view.getInputValue()).toEqual(intValue);
-      });
+    test('Value as default', () => {
+      expect(view.model.get('value')).toEqual(parseInt(intValue));
+      expect(view.model.get('unit')).toEqual(units[1]);
+    });
 
-      test('Update target on value change', () => {
-        const val = `${intValue}%`;
-        view.model.setValue(val);
-        expect(view.getTargetValue()).toEqual(val);
-      });
+    test('Input value is as default', () => {
+      expect(view.getInputValue()).toEqual(intValue);
+      expect(view.$unit.val()).toEqual(units[1]);
+    });
 
-      describe('With target setted', () => {
-        beforeEach(() => {
-          target.model = component;
-          view = new PropertyIntegerView({
-            model,
-            propTarget: target
-          });
-          fixtures.innerHTML = '';
-          view.render();
-          fixtures.appendChild(view.el);
-        });
-
-        test('Update value and input on target swap', () => {
-          var style = {};
-          style[propName] = propValue;
-          component.set('style', style);
-          view.propTarget.trigger('update');
-          expect(view.model.get('value')).toEqual(parseFloat(intValue));
-          expect(view.getInputValue()).toEqual(intValue);
-        });
-
-        test('Update value after multiple swaps', () => {
-          var style = {};
-          style[propName] = propValue;
-          component.set('style', style);
-          view.propTarget.trigger('update');
-          style[propName] = '20em';
-          component.set('style', style);
-          view.propTarget.trigger('update');
-          expect(view.model.get('value')).toEqual(20);
-          expect(view.model.get('unit')).toEqual('em');
-          expect(view.getInputValue()).toEqual('20');
-          expect(view.$unit.val()).toEqual('em');
-        });
-      });
+    test('Input follows min', () => {
+      view.$input.val(minValue - 50).trigger('change');
+      expect(view.model.get('value')).toEqual(minValue);
+      expect(view.getInputValue()).toEqual(minValue + '');
+    });
 
-      describe('Init property', () => {
-        beforeEach(() => {
-          component = new Component();
-          model = new PropertyInteger({
-            units,
-            property: propName,
-            defaults: intValue,
-            min: minValue,
-            max: maxValue,
-            unit: units[1]
-          });
-          view = new PropertyIntegerView({
-            model
-          });
-          fixtures.innerHTML = '';
-          view.render();
-          fixtures.appendChild(view.el);
-        });
-
-        test('Value as default', () => {
-          expect(view.model.get('value')).toEqual(parseInt(intValue));
-          expect(view.model.get('unit')).toEqual(units[1]);
-        });
-
-        test('Input value is as default', () => {
-          expect(view.getInputValue()).toEqual(intValue);
-          expect(view.$unit.val()).toEqual(units[1]);
-        });
-
-        test('Input follows min', () => {
-          view.$input.val(minValue - 50).trigger('change');
-          expect(view.model.get('value')).toEqual(minValue);
-          expect(view.getInputValue()).toEqual(minValue + '');
-        });
-
-        test('Input follows max', () => {
-          view.$input.val(maxValue + 50).trigger('change');
-          expect(view.model.get('value')).toEqual(maxValue);
-          expect(view.getInputValue()).toEqual(maxValue + '');
-        });
-      });
+    test('Input follows max', () => {
+      view.$input.val(maxValue + 50).trigger('change');
+      expect(view.model.get('value')).toEqual(maxValue);
+      expect(view.getInputValue()).toEqual(maxValue + '');
     });
-  }
-};
+  });
+});

test/specs/style_manager/view/PropertyRadioView.js

@@ -4,186 +4,178 @@ import Component from 'dom_components/model/Component';
 import Editor from 'editor/model/Editor';
 import DomComponents from 'dom_components';
 
-module.exports = {
-  run() {
-    describe('PropertyRadioView', () => {
-      let em;
-      let dcomp;
-      let compOpts;
-      var component;
-      var fixtures;
-      var target;
-      var model;
-      var view;
-      var propTarget;
-      var propName = 'testprop';
-      var propValue = 'test1value';
-      var defValue = 'test2value';
-      var options = [
-        { value: 'test1value', title: 'testtitle' },
-        { name: 'test2', value: 'test2value' }
-      ];
-
-      // Have some issue with getCheckedEl() and jsdom
-      // this view.getInputEl().querySelector('input:checked') return null
-      // but view.getInputEl().querySelectorAll('input:checked')[0] works
-      var getCheckedEl = view =>
-        view.getInputEl().querySelectorAll('input:checked')[0];
-
-      beforeEach(() => {
-        em = new Editor({});
-        dcomp = new DomComponents();
-        compOpts = { em, componentTypes: dcomp.componentTypes };
-        propTarget = { ...Backbone.Events };
-        target = new Component({}, compOpts);
-        component = new Component({}, compOpts);
-        model = new Property({
-          type: 'radio',
-          list: options,
-          property: propName
-        });
-        propTarget.model = component;
-        view = new PropertyRadioView({
-          model,
-          propTarget
-        });
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        fixtures = document.body.firstChild;
-        view.render();
-        fixtures.appendChild(view.el);
-      });
-
-      afterEach(() => {
-        //view.remove(); // strange errors ???
-      });
-
-      afterAll(() => {
-        component = null;
-      });
-
-      test('Rendered correctly', () => {
-        var prop = view.el;
-        expect(fixtures.querySelector('.property')).toBeTruthy();
-        expect(prop.querySelector('.label')).toBeTruthy();
-        expect(prop.querySelector('.field')).toBeTruthy();
-      });
-
-      test('Radio rendered', () => {
-        var prop = view.el;
-        expect(prop.querySelector('input[type=radio]')).toBeTruthy();
-      });
-
-      test('Options rendered', () => {
-        var input = view.el.querySelector('.field').firstChild;
-        expect(input.children.length).toEqual(options.length);
-      });
-
-      test('Options rendered correctly', () => {
-        var children = view.el.querySelector('.field').firstChild.children;
-        expect(children[0].querySelector('label').textContent).toEqual(
-          'test1value'
-        );
-        expect(children[1].querySelector('label').textContent).toEqual('test2');
-        expect(children[0].querySelector('input').value).toEqual(
-          options[0].value
-        );
-        expect(children[1].querySelector('input').value).toEqual(
-          options[1].value
-        );
-        expect(
-          children[0].querySelector('label').getAttribute('title')
-        ).toEqual(options[0].title);
-        expect(
-          children[1].querySelector('label').getAttribute('title')
-        ).toEqual(null);
-      });
-
-      test('Input should exist', () => {
-        expect(view.input).toBeTruthy();
-      });
-
-      test('Input value is empty', () => {
-        expect(view.model.get('value')).toBeFalsy();
+describe('PropertyRadioView', () => {
+  let em;
+  let dcomp;
+  let compOpts;
+  var component;
+  var fixtures;
+  var target;
+  var model;
+  var view;
+  var propTarget;
+  var propName = 'testprop';
+  var propValue = 'test1value';
+  var defValue = 'test2value';
+  var options = [
+    { value: 'test1value', title: 'testtitle' },
+    { name: 'test2', value: 'test2value' }
+  ];
+
+  // Have some issue with getCheckedEl() and jsdom
+  // this view.getInputEl().querySelector('input:checked') return null
+  // but view.getInputEl().querySelectorAll('input:checked')[0] works
+  var getCheckedEl = view =>
+    view.getInputEl().querySelectorAll('input:checked')[0];
+
+  beforeEach(() => {
+    em = new Editor({});
+    dcomp = new DomComponents();
+    compOpts = { em, componentTypes: dcomp.componentTypes };
+    propTarget = { ...Backbone.Events };
+    target = new Component({}, compOpts);
+    component = new Component({}, compOpts);
+    model = new Property({
+      type: 'radio',
+      list: options,
+      property: propName
+    });
+    propTarget.model = component;
+    view = new PropertyRadioView({
+      model,
+      propTarget
+    });
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    fixtures = document.body.firstChild;
+    view.render();
+    fixtures.appendChild(view.el);
+  });
+
+  afterEach(() => {
+    //view.remove(); // strange errors ???
+  });
+
+  afterAll(() => {
+    component = null;
+  });
+
+  test('Rendered correctly', () => {
+    var prop = view.el;
+    expect(fixtures.querySelector('.property')).toBeTruthy();
+    expect(prop.querySelector('.label')).toBeTruthy();
+    expect(prop.querySelector('.field')).toBeTruthy();
+  });
+
+  test('Radio rendered', () => {
+    var prop = view.el;
+    expect(prop.querySelector('input[type=radio]')).toBeTruthy();
+  });
+
+  test('Options rendered', () => {
+    var input = view.el.querySelector('.field').firstChild;
+    expect(input.children.length).toEqual(options.length);
+  });
+
+  test('Options rendered correctly', () => {
+    var children = view.el.querySelector('.field').firstChild.children;
+    expect(children[0].querySelector('label').textContent).toEqual(
+      'test1value'
+    );
+    expect(children[1].querySelector('label').textContent).toEqual('test2');
+    expect(children[0].querySelector('input').value).toEqual(options[0].value);
+    expect(children[1].querySelector('input').value).toEqual(options[1].value);
+    expect(children[0].querySelector('label').getAttribute('title')).toEqual(
+      options[0].title
+    );
+    expect(children[1].querySelector('label').getAttribute('title')).toEqual(
+      null
+    );
+  });
+
+  test('Input should exist', () => {
+    expect(view.input).toBeTruthy();
+  });
+
+  test('Input value is empty', () => {
+    expect(view.model.get('value')).toBeFalsy();
+  });
+
+  test('Update model on input change', () => {
+    view.setValue(propValue);
+    expect(getCheckedEl(view).value).toEqual(propValue);
+  });
+
+  test('Update input on value change', () => {
+    view.model.set('value', propValue);
+    expect(getCheckedEl(view).value).toEqual(propValue);
+  });
+
+  test('Update target on value change', () => {
+    view.selectedComponent = component;
+    view.model.set('value', propValue);
+    var compStyle = view.selectedComponent.get('style');
+    var assertStyle = {};
+    assertStyle[propName] = propValue;
+    expect(compStyle).toEqual(assertStyle);
+  });
+
+  describe('With target setted', () => {
+    beforeEach(() => {
+      target.model = component;
+      view = new PropertyRadioView({
+        model,
+        propTarget: target
       });
+      fixtures.innerHTML = '';
+      view.render();
+      fixtures.appendChild(view.el);
+    });
 
-      test('Update model on input change', () => {
-        view.setValue(propValue);
-        expect(getCheckedEl(view).value).toEqual(propValue);
-      });
+    test('Update value and input on target swap', () => {
+      var style = {};
+      style[propName] = propValue;
+      component.set('style', style);
+      view.propTarget.trigger('update');
+      expect(view.model.get('value')).toEqual(propValue);
+      expect(getCheckedEl(view).value).toEqual(propValue);
+    });
 
-      test('Update input on value change', () => {
-        view.model.set('value', propValue);
-        expect(getCheckedEl(view).value).toEqual(propValue);
+    test('Update value after multiple swaps', () => {
+      var style = {};
+      style[propName] = propValue;
+      component.set('style', style);
+      view.propTarget.trigger('update');
+      style[propName] = 'test2value';
+      component.set('style', style);
+      view.propTarget.trigger('update');
+      expect(view.model.get('value')).toEqual('test2value');
+      expect(getCheckedEl(view).value).toEqual('test2value');
+    });
+  });
+
+  describe('Init property', () => {
+    beforeEach(() => {
+      component = new Component();
+      model = new Property({
+        type: 'select',
+        list: options,
+        defaults: defValue,
+        property: propName
       });
-
-      test('Update target on value change', () => {
-        view.selectedComponent = component;
-        view.model.set('value', propValue);
-        var compStyle = view.selectedComponent.get('style');
-        var assertStyle = {};
-        assertStyle[propName] = propValue;
-        expect(compStyle).toEqual(assertStyle);
+      view = new PropertyRadioView({
+        model
       });
+      fixtures.innerHTML = '';
+      view.render();
+      fixtures.appendChild(view.el);
+    });
 
-      describe('With target setted', () => {
-        beforeEach(() => {
-          target.model = component;
-          view = new PropertyRadioView({
-            model,
-            propTarget: target
-          });
-          fixtures.innerHTML = '';
-          view.render();
-          fixtures.appendChild(view.el);
-        });
-
-        test('Update value and input on target swap', () => {
-          var style = {};
-          style[propName] = propValue;
-          component.set('style', style);
-          view.propTarget.trigger('update');
-          expect(view.model.get('value')).toEqual(propValue);
-          expect(getCheckedEl(view).value).toEqual(propValue);
-        });
-
-        test('Update value after multiple swaps', () => {
-          var style = {};
-          style[propName] = propValue;
-          component.set('style', style);
-          view.propTarget.trigger('update');
-          style[propName] = 'test2value';
-          component.set('style', style);
-          view.propTarget.trigger('update');
-          expect(view.model.get('value')).toEqual('test2value');
-          expect(getCheckedEl(view).value).toEqual('test2value');
-        });
-      });
+    test('Value as default', () => {
+      expect(view.model.get('value')).toEqual(defValue);
+    });
 
-      describe('Init property', () => {
-        beforeEach(() => {
-          component = new Component();
-          model = new Property({
-            type: 'select',
-            list: options,
-            defaults: defValue,
-            property: propName
-          });
-          view = new PropertyRadioView({
-            model
-          });
-          fixtures.innerHTML = '';
-          view.render();
-          fixtures.appendChild(view.el);
-        });
-
-        test('Value as default', () => {
-          expect(view.model.get('value')).toEqual(defValue);
-        });
-
-        test('Input value is as default', () => {
-          expect(view.model.getDefaultValue()).toEqual(defValue);
-        });
-      });
+    test('Input value is as default', () => {
+      expect(view.model.getDefaultValue()).toEqual(defValue);
     });
-  }
-};
+  });
+});

test/specs/style_manager/view/PropertySelectView.js

@@ -4,196 +4,192 @@ import Editor from 'editor/model/Editor';
 import DomComponents from 'dom_components';
 import Component from 'dom_components/model/Component';
 
-module.exports = {
-  run() {
-    describe('PropertySelectView', () => {
-      let em;
-      let dcomp;
-      let compOpts;
-      var component;
-      var fixtures;
-      var target;
-      var model;
-      var view;
-      var propTarget;
-      var options;
-      var propName = 'testprop';
-      var propValue = 'test1value';
-      var defValue = 'test2value';
-      var options = [
-        { value: 'test1value', style: 'test:style' },
-        { name: 'test2', value: 'test2value' }
-      ];
-
-      beforeEach(() => {
-        em = new Editor({});
-        dcomp = new DomComponents();
-        compOpts = { em, componentTypes: dcomp.componentTypes };
-        propTarget = { ...Backbone.Events };
-        target = new Component({}, compOpts);
-        component = new Component({}, compOpts);
-        model = new Property({
-          type: 'select',
-          list: options,
-          property: propName
-        });
-        propTarget.model = component;
-        view = new PropertySelectView({
-          model,
-          propTarget
-        });
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        fixtures = document.body.firstChild;
-        view.render();
-        fixtures.appendChild(view.el);
-      });
-
-      afterEach(() => {
-        //view.remove(); // strange errors ???
-      });
-
-      afterAll(() => {
-        component = null;
-      });
-
-      test('Rendered correctly', () => {
-        var prop = view.el;
-        expect(fixtures.querySelector('.property')).toBeTruthy();
-        expect(prop.querySelector('.label')).toBeTruthy();
-        expect(prop.querySelector('.field')).toBeTruthy();
-      });
-
-      test('Select rendered', () => {
-        var prop = view.el;
-        expect(prop.querySelector('select')).toBeTruthy();
-      });
-
-      test('Options rendered', () => {
-        var select = view.el.querySelector('select');
-        expect(select.children.length).toEqual(options.length);
-      });
-
-      test('Options rendered correctly', () => {
-        var select = view.el.querySelector('select');
-        var children = select.children;
-        expect(children[0].value).toEqual(options[0].value);
-        expect(children[1].value).toEqual(options[1].value);
-        expect(children[0].textContent).toEqual(options[0].value);
-        expect(children[1].textContent).toEqual(options[1].name);
-        expect(children[0].getAttribute('style')).toEqual(options[0].style);
-        expect(children[1].getAttribute('style')).toEqual(null);
+describe('PropertySelectView', () => {
+  let em;
+  let dcomp;
+  let compOpts;
+  var component;
+  var fixtures;
+  var target;
+  var model;
+  var view;
+  var propTarget;
+  var options;
+  var propName = 'testprop';
+  var propValue = 'test1value';
+  var defValue = 'test2value';
+  var options = [
+    { value: 'test1value', style: 'test:style' },
+    { name: 'test2', value: 'test2value' }
+  ];
+
+  beforeEach(() => {
+    em = new Editor({});
+    dcomp = new DomComponents();
+    compOpts = { em, componentTypes: dcomp.componentTypes };
+    propTarget = { ...Backbone.Events };
+    target = new Component({}, compOpts);
+    component = new Component({}, compOpts);
+    model = new Property({
+      type: 'select',
+      list: options,
+      property: propName
+    });
+    propTarget.model = component;
+    view = new PropertySelectView({
+      model,
+      propTarget
+    });
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    fixtures = document.body.firstChild;
+    view.render();
+    fixtures.appendChild(view.el);
+  });
+
+  afterEach(() => {
+    //view.remove(); // strange errors ???
+  });
+
+  afterAll(() => {
+    component = null;
+  });
+
+  test('Rendered correctly', () => {
+    var prop = view.el;
+    expect(fixtures.querySelector('.property')).toBeTruthy();
+    expect(prop.querySelector('.label')).toBeTruthy();
+    expect(prop.querySelector('.field')).toBeTruthy();
+  });
+
+  test('Select rendered', () => {
+    var prop = view.el;
+    expect(prop.querySelector('select')).toBeTruthy();
+  });
+
+  test('Options rendered', () => {
+    var select = view.el.querySelector('select');
+    expect(select.children.length).toEqual(options.length);
+  });
+
+  test('Options rendered correctly', () => {
+    var select = view.el.querySelector('select');
+    var children = select.children;
+    expect(children[0].value).toEqual(options[0].value);
+    expect(children[1].value).toEqual(options[1].value);
+    expect(children[0].textContent).toEqual(options[0].value);
+    expect(children[1].textContent).toEqual(options[1].name);
+    expect(children[0].getAttribute('style')).toEqual(options[0].style);
+    expect(children[1].getAttribute('style')).toEqual(null);
+  });
+
+  test('Input should exist', () => {
+    expect(view.input).toBeTruthy();
+  });
+
+  test('Input value is empty', () => {
+    expect(view.model.get('value')).toBeFalsy();
+  });
+
+  test('Update model on input change', () => {
+    view.getInputEl().value = propValue;
+    view.inputValueChanged();
+    expect(view.model.get('value')).toEqual(propValue);
+  });
+
+  test('Update input on value change', () => {
+    view.model.set('value', propValue);
+    expect(view.getInputValue()).toEqual(propValue);
+  });
+
+  test('Update target on value change', () => {
+    view.selectedComponent = component;
+    view.model.set('value', propValue);
+    var compStyle = view.selectedComponent.get('style');
+    var assertStyle = {};
+    assertStyle[propName] = propValue;
+    expect(compStyle).toEqual(assertStyle);
+  });
+
+  describe('With target setted', () => {
+    beforeEach(() => {
+      target.model = component;
+      view = new PropertySelectView({
+        model,
+        propTarget: target
       });
+      fixtures.innerHTML = '';
+      view.render();
+      fixtures.appendChild(view.el);
+    });
 
-      test('Input should exist', () => {
-        expect(view.input).toBeTruthy();
-      });
+    test('Update value and input on target swap', () => {
+      var style = {};
+      style[propName] = propValue;
+      component.set('style', style);
+      view.propTarget.trigger('update');
+      expect(view.model.get('value')).toEqual(propValue);
+      expect(view.getInputValue()).toEqual(propValue);
+    });
 
-      test('Input value is empty', () => {
-        expect(view.model.get('value')).toBeFalsy();
+    test('Update value after multiple swaps', () => {
+      var style = {};
+      style[propName] = propValue;
+      component.set('style', style);
+      view.propTarget.trigger('update');
+      style[propName] = 'test2value';
+      component.set('style', style);
+      view.propTarget.trigger('update');
+      expect(view.model.get('value')).toEqual('test2value');
+      expect(view.getInputValue()).toEqual('test2value');
+    });
+  });
+
+  describe('Init property', () => {
+    beforeEach(() => {
+      component = new Component();
+      model = new Property({
+        type: 'select',
+        list: options,
+        defaults: defValue,
+        property: propName
       });
-
-      test('Update model on input change', () => {
-        view.getInputEl().value = propValue;
-        view.inputValueChanged();
-        expect(view.model.get('value')).toEqual(propValue);
+      view = new PropertySelectView({
+        model
       });
+      fixtures.innerHTML = '';
+      view.render();
+      fixtures.appendChild(view.el);
+    });
 
-      test('Update input on value change', () => {
-        view.model.set('value', propValue);
-        expect(view.getInputValue()).toEqual(propValue);
-      });
+    test('Value as default', () => {
+      expect(view.model.get('value')).toEqual(defValue);
+    });
 
-      test('Update target on value change', () => {
-        view.selectedComponent = component;
-        view.model.set('value', propValue);
-        var compStyle = view.selectedComponent.get('style');
-        var assertStyle = {};
-        assertStyle[propName] = propValue;
-        expect(compStyle).toEqual(assertStyle);
+    test('Empty value as default', () => {
+      options = [
+        { value: '', name: 'test' },
+        { value: 'test1value', name: 'test1' },
+        { value: 'test2value', name: 'test2' },
+        { value: '', name: 'TestDef' }
+      ];
+      component = new Component();
+      model = new Property({
+        type: 'select',
+        list: options,
+        defaults: '',
+        property: 'emptyDefault'
       });
-
-      describe('With target setted', () => {
-        beforeEach(() => {
-          target.model = component;
-          view = new PropertySelectView({
-            model,
-            propTarget: target
-          });
-          fixtures.innerHTML = '';
-          view.render();
-          fixtures.appendChild(view.el);
-        });
-
-        test('Update value and input on target swap', () => {
-          var style = {};
-          style[propName] = propValue;
-          component.set('style', style);
-          view.propTarget.trigger('update');
-          expect(view.model.get('value')).toEqual(propValue);
-          expect(view.getInputValue()).toEqual(propValue);
-        });
-
-        test('Update value after multiple swaps', () => {
-          var style = {};
-          style[propName] = propValue;
-          component.set('style', style);
-          view.propTarget.trigger('update');
-          style[propName] = 'test2value';
-          component.set('style', style);
-          view.propTarget.trigger('update');
-          expect(view.model.get('value')).toEqual('test2value');
-          expect(view.getInputValue()).toEqual('test2value');
-        });
+      view = new PropertySelectView({
+        model
       });
+      view.render();
+      fixtures.innerHTML = '';
+      fixtures.appendChild(view.el);
+      expect(view.getInputValue()).toEqual('');
+    });
 
-      describe('Init property', () => {
-        beforeEach(() => {
-          component = new Component();
-          model = new Property({
-            type: 'select',
-            list: options,
-            defaults: defValue,
-            property: propName
-          });
-          view = new PropertySelectView({
-            model
-          });
-          fixtures.innerHTML = '';
-          view.render();
-          fixtures.appendChild(view.el);
-        });
-
-        test('Value as default', () => {
-          expect(view.model.get('value')).toEqual(defValue);
-        });
-
-        test('Empty value as default', () => {
-          options = [
-            { value: '', name: 'test' },
-            { value: 'test1value', name: 'test1' },
-            { value: 'test2value', name: 'test2' },
-            { value: '', name: 'TestDef' }
-          ];
-          component = new Component();
-          model = new Property({
-            type: 'select',
-            list: options,
-            defaults: '',
-            property: 'emptyDefault'
-          });
-          view = new PropertySelectView({
-            model
-          });
-          view.render();
-          fixtures.innerHTML = '';
-          fixtures.appendChild(view.el);
-          expect(view.getInputValue()).toEqual('');
-        });
-
-        test('Input value is as default', () => {
-          expect(view.model.getDefaultValue()).toEqual(defValue);
-        });
-      });
+    test('Input value is as default', () => {
+      expect(view.model.getDefaultValue()).toEqual(defValue);
     });
-  }
-};
+  });
+});

test/specs/style_manager/view/PropertyStackView.js

@@ -4,124 +4,120 @@ import Component from 'dom_components/model/Component';
 import Editor from 'editor/model/Editor';
 import DomComponents from 'dom_components';
 
-module.exports = {
-  run() {
-    describe('PropertyStackView', () => {
-      let em;
-      let dcomp;
-      let compOpts;
-      var component;
-      var fixtures;
-      var target;
-      var model;
-      var view;
-      var propName = 'testprop';
-      var propValue = 'test1value';
-      var defValue = 'test2value';
-      var layers = [
-        { value: 'lval1' },
-        { value: 'lval2 lval22' },
-        { value: 'lval3 lval32 lval33' }
-      ];
-      var properties = [
-        { property: 'subprop1' },
-        {
-          type: 'integer',
-          property: 'subprop2',
-          defaults: 0,
-          units: ['%', 'px']
-        },
-        {
-          type: 'select',
-          property: 'subprop3',
-          defaults: 'val2',
-          list: [{ value: 'val1' }, { value: 'val2' }, { value: 'val3' }]
-        }
-      ];
+describe('PropertyStackView', () => {
+  let em;
+  let dcomp;
+  let compOpts;
+  var component;
+  var fixtures;
+  var target;
+  var model;
+  var view;
+  var propName = 'testprop';
+  var propValue = 'test1value';
+  var defValue = 'test2value';
+  var layers = [
+    { value: 'lval1' },
+    { value: 'lval2 lval22' },
+    { value: 'lval3 lval32 lval33' }
+  ];
+  var properties = [
+    { property: 'subprop1' },
+    {
+      type: 'integer',
+      property: 'subprop2',
+      defaults: 0,
+      units: ['%', 'px']
+    },
+    {
+      type: 'select',
+      property: 'subprop3',
+      defaults: 'val2',
+      list: [{ value: 'val1' }, { value: 'val2' }, { value: 'val3' }]
+    }
+  ];
 
-      beforeEach(() => {
-        em = new Editor({});
-        dcomp = new DomComponents();
-        compOpts = { em, componentTypes: dcomp.componentTypes };
-        target = new Component({}, compOpts);
-        component = new Component({}, compOpts);
-        target.model = component;
-        model = new Property({
-          type: 'stack',
-          property: propName,
-          properties
-        });
-        view = new PropertyStackView({
-          model
-        });
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        fixtures = document.body.firstChild;
-        view.render();
-        fixtures.appendChild(view.el);
-      });
+  beforeEach(() => {
+    em = new Editor({});
+    dcomp = new DomComponents();
+    compOpts = { em, componentTypes: dcomp.componentTypes };
+    target = new Component({}, compOpts);
+    component = new Component({}, compOpts);
+    target.model = component;
+    model = new Property({
+      type: 'stack',
+      property: propName,
+      properties
+    });
+    view = new PropertyStackView({
+      model
+    });
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    fixtures = document.body.firstChild;
+    view.render();
+    fixtures.appendChild(view.el);
+  });
 
-      afterAll(() => {
-        component = null;
-        view = null;
-        model = null;
-      });
+  afterAll(() => {
+    component = null;
+    view = null;
+    model = null;
+  });
 
-      test('Rendered correctly', () => {
-        var prop = view.el;
-        expect(fixtures.querySelector('.property')).toBeTruthy();
-        expect(prop.querySelector('.label')).toBeTruthy();
-        expect(prop.querySelector('.field')).toBeTruthy();
-        expect(prop.querySelector('#add')).toBeTruthy();
-      });
+  test('Rendered correctly', () => {
+    var prop = view.el;
+    expect(fixtures.querySelector('.property')).toBeTruthy();
+    expect(prop.querySelector('.label')).toBeTruthy();
+    expect(prop.querySelector('.field')).toBeTruthy();
+    expect(prop.querySelector('#add')).toBeTruthy();
+  });
 
-      test('Layers rendered', () => {
-        expect(view.el.querySelector('.layers')).toBeTruthy();
-      });
+  test('Layers rendered', () => {
+    expect(view.el.querySelector('.layers')).toBeTruthy();
+  });
 
-      test('Layers wrapper should exist', () => {
-        expect(view.el.querySelector('[data-layers-wrapper]')).toBeTruthy();
-      });
+  test('Layers wrapper should exist', () => {
+    expect(view.el.querySelector('[data-layers-wrapper]')).toBeTruthy();
+  });
 
-      test('Layers rendered correctly', () => {
-        var children = view.el.querySelector('[data-layers-wrapper]').children;
-        expect(children.length).toEqual(1);
-      });
+  test('Layers rendered correctly', () => {
+    var children = view.el.querySelector('[data-layers-wrapper]').children;
+    expect(children.length).toEqual(1);
+  });
 
-      test('Input value is on default', () => {
-        expect(view.model.get('value')).toEqual('0 val2');
-      });
+  test('Input value is on default', () => {
+    expect(view.model.get('value')).toEqual('0 val2');
+  });
 
-      test('Layers container is empty', () => {
-        var layers = view.el.querySelector('.layers');
-        expect(layers.innerHTML).toBeFalsy();
-      });
+  test('Layers container is empty', () => {
+    var layers = view.el.querySelector('.layers');
+    expect(layers.innerHTML).toBeFalsy();
+  });
 
-      describe('With layers', () => {
-        beforeEach(() => {
-          model = new Property({
-            type: 'stack',
-            property: propName,
-            properties
-          });
-          view = new PropertyStackView({
-            model,
-            propTarget: target
-          });
-          fixtures.innerHTML = '';
-          view.render();
-          fixtures.appendChild(view.el);
-          model.get('layers').add(layers);
-        });
+  describe('With layers', () => {
+    beforeEach(() => {
+      model = new Property({
+        type: 'stack',
+        property: propName,
+        properties
+      });
+      view = new PropertyStackView({
+        model,
+        propTarget: target
+      });
+      fixtures.innerHTML = '';
+      view.render();
+      fixtures.appendChild(view.el);
+      model.get('layers').add(layers);
+    });
 
-        test('Layers inserted', () => {
-          expect(view.getLayers().length).toEqual(layers.length);
-        });
+    test('Layers inserted', () => {
+      expect(view.getLayers().length).toEqual(layers.length);
+    });
 
-        test('Add layer', () => {
-          view.addLayer();
-          expect(view.getLayers().length).toEqual(layers.length + 1);
-        });
-      });
+    test('Add layer', () => {
+      view.addLayer();
+      expect(view.getLayers().length).toEqual(layers.length + 1);
     });
-  }
-};
+  });
+});

test/specs/style_manager/view/PropertyView.js

@@ -4,223 +4,219 @@ import Editor from 'editor/model/Editor';
 import DomComponents from 'dom_components';
 import Component from 'dom_components/model/Component';
 
-module.exports = {
-  run() {
-    describe('PropertyView', () => {
-      let em;
-      let dcomp;
-      let compOpts;
-      var component;
-      var fixtures;
-      var target;
-      var model;
-      var view;
-      var propTarget;
-      var options;
-      var propName = 'testprop';
-      var propValue = 'testvalue';
-      var defValue = 'testDefault';
-
-      beforeEach(() => {
-        em = new Editor({});
-        dcomp = new DomComponents();
-        compOpts = { em, componentTypes: dcomp.componentTypes };
-        propTarget = { ...Backbone.Events };
-        target = new Component({}, compOpts);
-        component = new Component({}, compOpts);
-        model = new Property({ property: propName });
-        propTarget.model = component;
-        options = {
-          model,
-          propTarget
-        };
-        view = new PropertyView(options);
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        fixtures = document.body.firstChild;
-        view.render();
-        fixtures.appendChild(view.el);
-      });
-
-      afterEach(() => {
-        //view.remove(); // strange errors ???
-      });
-
-      afterAll(() => {
-        component = null;
-      });
-
-      test('Rendered correctly', () => {
-        var prop = view.el;
-        expect(fixtures.querySelector('.property')).toBeTruthy();
-        expect(prop.querySelector('.label')).toBeTruthy();
-        expect(prop.querySelector('.field')).toBeTruthy();
-      });
-
-      test('Input should exist', () => {
-        expect(view.getInputEl()).toBeTruthy();
-      });
-
-      test('Input value is empty', () => {
-        expect(view.model.get('value')).toBeFalsy();
-        expect(view.getInputValue()).toBeFalsy();
-      });
-
-      test('Model not change without update trigger', () => {
-        view.getInputEl().value = propValue;
-        expect(view.model.get('value')).toBeFalsy();
-      });
-
-      // Tests inputValueChanged()
-      test('Update model on input change', () => {
-        view.getInputEl().value = propValue;
-        view.inputValueChanged();
-        expect(view.model.get('value')).toEqual(propValue);
-      });
-
-      // Tests modelValueChanged() -> ...
-      test('Update input on value change', () => {
-        view.model.set('value', propValue);
-        expect(view.getInputValue()).toEqual(propValue);
-      });
-
-      test('Update target on value change', () => {
-        view.model.set('value', propValue);
-        var compStyle = view.getTargetModel().get('style');
-        var assertStyle = {};
-        assertStyle[propName] = propValue;
-        expect(compStyle).toEqual(assertStyle);
-      });
+describe('PropertyView', () => {
+  let em;
+  let dcomp;
+  let compOpts;
+  var component;
+  var fixtures;
+  var target;
+  var model;
+  var view;
+  var propTarget;
+  var options;
+  var propName = 'testprop';
+  var propValue = 'testvalue';
+  var defValue = 'testDefault';
+
+  beforeEach(() => {
+    em = new Editor({});
+    dcomp = new DomComponents();
+    compOpts = { em, componentTypes: dcomp.componentTypes };
+    propTarget = { ...Backbone.Events };
+    target = new Component({}, compOpts);
+    component = new Component({}, compOpts);
+    model = new Property({ property: propName });
+    propTarget.model = component;
+    options = {
+      model,
+      propTarget
+    };
+    view = new PropertyView(options);
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    fixtures = document.body.firstChild;
+    view.render();
+    fixtures.appendChild(view.el);
+  });
+
+  afterEach(() => {
+    //view.remove(); // strange errors ???
+  });
+
+  afterAll(() => {
+    component = null;
+  });
+
+  test('Rendered correctly', () => {
+    var prop = view.el;
+    expect(fixtures.querySelector('.property')).toBeTruthy();
+    expect(prop.querySelector('.label')).toBeTruthy();
+    expect(prop.querySelector('.field')).toBeTruthy();
+  });
+
+  test('Input should exist', () => {
+    expect(view.getInputEl()).toBeTruthy();
+  });
+
+  test('Input value is empty', () => {
+    expect(view.model.get('value')).toBeFalsy();
+    expect(view.getInputValue()).toBeFalsy();
+  });
+
+  test('Model not change without update trigger', () => {
+    view.getInputEl().value = propValue;
+    expect(view.model.get('value')).toBeFalsy();
+  });
+
+  // Tests inputValueChanged()
+  test('Update model on input change', () => {
+    view.getInputEl().value = propValue;
+    view.inputValueChanged();
+    expect(view.model.get('value')).toEqual(propValue);
+  });
+
+  // Tests modelValueChanged() -> ...
+  test('Update input on value change', () => {
+    view.model.set('value', propValue);
+    expect(view.getInputValue()).toEqual(propValue);
+  });
+
+  test('Update target on value change', () => {
+    view.model.set('value', propValue);
+    var compStyle = view.getTargetModel().get('style');
+    var assertStyle = {};
+    assertStyle[propName] = propValue;
+    expect(compStyle).toEqual(assertStyle);
+  });
+
+  test('Update target on value change with functionName', () => {
+    view.model.set('functionName', 'testfunc');
+    view.model.set('value', propValue);
+    var compStyle = view.getTargetModel().get('style');
+    var assertStyle = {};
+    assertStyle[propName] = 'testfunc(' + propValue + ')';
+    expect(compStyle).toEqual(assertStyle);
+  });
+
+  test('Clean target from the property if its value is empty', () => {
+    view.model.set('value', propValue);
+    view.model.set('value', '');
+    var compStyle = view.getTargetModel().get('style');
+    expect(compStyle).toEqual({});
+  });
+
+  test('Check stylable element', () => {
+    expect(view.isTargetStylable()).toEqual(true);
+    component.set('stylable', false);
+    expect(view.isTargetStylable()).toEqual(false);
+    component.set('stylable', [propName]);
+    expect(view.isTargetStylable()).toEqual(true);
+    component.set('stylable', ['test1', propName]);
+    expect(view.isTargetStylable()).toEqual(true);
+    component.set('stylable', ['test1', 'test2']);
+    expect(view.isTargetStylable()).toEqual(false);
+  });
+
+  test('Target style is empty without values', () => {
+    expect(view.getTargetValue()).toBeFalsy();
+  });
+
+  test('Target style is correct', () => {
+    var style = {};
+    style[propName] = propValue;
+    component.set('style', style);
+    expect(view.getTargetValue()).toEqual(propValue);
+  });
+
+  test('Target style is empty with an other style', () => {
+    var style = {};
+    style[propName + '2'] = propValue;
+    component.set('style', style);
+    expect(view.getTargetValue()).toBeFalsy();
+  });
+
+  test('Fetch value from function', () => {
+    view.selectedComponent = component;
+    const val = `testfun(${propValue})`;
+    component.set('style', { [propName]: val });
+    view.model.set('functionName', 'testfun');
+    expect(view.getTargetValue()).toEqual(val);
+  });
+
+  describe('With target setted', () => {
+    beforeEach(() => {
+      target.model = component;
+      view = new PropertyView({
+        model,
+        propTarget: target
+      });
+      fixtures.innerHTML = '';
+      view.render();
+      fixtures.appendChild(view.el);
+    });
 
-      test('Update target on value change with functionName', () => {
-        view.model.set('functionName', 'testfunc');
-        view.model.set('value', propValue);
-        var compStyle = view.getTargetModel().get('style');
-        var assertStyle = {};
-        assertStyle[propName] = 'testfunc(' + propValue + ')';
-        expect(compStyle).toEqual(assertStyle);
-      });
+    test('updateTargetStyle', () => {
+      view.updateTargetStyle(propValue);
+      var style = {};
+      style[propName] = propValue;
+      expect(component.get('style')).toEqual(style);
+    });
 
-      test('Clean target from the property if its value is empty', () => {
-        view.model.set('value', propValue);
-        view.model.set('value', '');
-        var compStyle = view.getTargetModel().get('style');
-        expect(compStyle).toEqual({});
-      });
+    test('updateTargetStyle with custom property', () => {
+      view.updateTargetStyle(propValue, propName + '2');
+      var style = {};
+      style[propName + '2'] = propValue;
+      expect(component.get('style')).toEqual(style);
+    });
 
-      test('Check stylable element', () => {
-        expect(view.isTargetStylable()).toEqual(true);
-        component.set('stylable', false);
-        expect(view.isTargetStylable()).toEqual(false);
-        component.set('stylable', [propName]);
-        expect(view.isTargetStylable()).toEqual(true);
-        component.set('stylable', ['test1', propName]);
-        expect(view.isTargetStylable()).toEqual(true);
-        component.set('stylable', ['test1', 'test2']);
-        expect(view.isTargetStylable()).toEqual(false);
-      });
+    test('Update value and input on target swap', () => {
+      var style = {};
+      style[propName] = propValue;
+      component.set('style', style);
+      view.propTarget.trigger('update');
+      expect(view.model.get('value')).toEqual(propValue);
+      expect(view.getInputValue()).toEqual(propValue);
+    });
 
-      test('Target style is empty without values', () => {
-        expect(view.getTargetValue()).toBeFalsy();
-      });
+    test('Update value after multiple swaps', () => {
+      var style = {};
+      style[propName] = propValue;
+      component.set('style', style);
+      view.propTarget.trigger('update');
+      style[propName] = propValue + '2';
+      component.set('style', style);
+      view.propTarget.trigger('update');
+      expect(view.model.get('value')).toEqual(propValue + '2');
+      expect(view.getInputValue()).toEqual(propValue + '2');
+    });
+  });
 
-      test('Target style is correct', () => {
-        var style = {};
-        style[propName] = propValue;
-        component.set('style', style);
-        expect(view.getTargetValue()).toEqual(propValue);
+  describe('Init property', () => {
+    beforeEach(() => {
+      component = new Component();
+      model = new Property({
+        property: propName,
+        defaults: defValue
       });
-
-      test('Target style is empty with an other style', () => {
-        var style = {};
-        style[propName + '2'] = propValue;
-        component.set('style', style);
-        expect(view.getTargetValue()).toBeFalsy();
+      view = new PropertyView({
+        model
       });
+      fixtures.innerHTML = '';
+      view.render();
+      fixtures.appendChild(view.el);
+    });
 
-      test('Fetch value from function', () => {
-        view.selectedComponent = component;
-        const val = `testfun(${propValue})`;
-        component.set('style', { [propName]: val });
-        view.model.set('functionName', 'testfun');
-        expect(view.getTargetValue()).toEqual(val);
-      });
+    test('Value as default', () => {
+      expect(view.model.get('value')).toEqual(defValue);
+    });
 
-      describe('With target setted', () => {
-        beforeEach(() => {
-          target.model = component;
-          view = new PropertyView({
-            model,
-            propTarget: target
-          });
-          fixtures.innerHTML = '';
-          view.render();
-          fixtures.appendChild(view.el);
-        });
-
-        test('updateTargetStyle', () => {
-          view.updateTargetStyle(propValue);
-          var style = {};
-          style[propName] = propValue;
-          expect(component.get('style')).toEqual(style);
-        });
-
-        test('updateTargetStyle with custom property', () => {
-          view.updateTargetStyle(propValue, propName + '2');
-          var style = {};
-          style[propName + '2'] = propValue;
-          expect(component.get('style')).toEqual(style);
-        });
-
-        test('Update value and input on target swap', () => {
-          var style = {};
-          style[propName] = propValue;
-          component.set('style', style);
-          view.propTarget.trigger('update');
-          expect(view.model.get('value')).toEqual(propValue);
-          expect(view.getInputValue()).toEqual(propValue);
-        });
-
-        test('Update value after multiple swaps', () => {
-          var style = {};
-          style[propName] = propValue;
-          component.set('style', style);
-          view.propTarget.trigger('update');
-          style[propName] = propValue + '2';
-          component.set('style', style);
-          view.propTarget.trigger('update');
-          expect(view.model.get('value')).toEqual(propValue + '2');
-          expect(view.getInputValue()).toEqual(propValue + '2');
-        });
-      });
+    test('Placeholder as default', () => {
+      var input = view.getInputEl();
+      expect(input.getAttribute('placeholder')).toEqual(defValue);
+    });
 
-      describe('Init property', () => {
-        beforeEach(() => {
-          component = new Component();
-          model = new Property({
-            property: propName,
-            defaults: defValue
-          });
-          view = new PropertyView({
-            model
-          });
-          fixtures.innerHTML = '';
-          view.render();
-          fixtures.appendChild(view.el);
-        });
-
-        test('Value as default', () => {
-          expect(view.model.get('value')).toEqual(defValue);
-        });
-
-        test('Placeholder as default', () => {
-          var input = view.getInputEl();
-          expect(input.getAttribute('placeholder')).toEqual(defValue);
-        });
-
-        test('Input value is set up to default', () => {
-          expect(view.getInputValue()).toEqual(defValue);
-        });
-      });
+    test('Input value is set up to default', () => {
+      expect(view.getInputValue()).toEqual(defValue);
     });
-  }
-};
+  });
+});

test/specs/style_manager/view/SectorView.js

@@ -1,91 +1,85 @@
 import SectorView from 'style_manager/view/SectorView';
 import Sector from 'style_manager/model/Sector';
 
-module.exports = {
-  run() {
-    describe('SectorView', () => {
-      var fixtures;
-      var model;
-      var view;
+describe('SectorView', () => {
+  var fixtures;
+  var model;
+  var view;
 
-      beforeEach(() => {
-        model = new Sector();
-        view = new SectorView({
-          model
-        });
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        fixtures = document.body.querySelector('#fixtures');
-        fixtures.appendChild(view.render().el);
-      });
+  beforeEach(() => {
+    model = new Sector();
+    view = new SectorView({
+      model
+    });
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    fixtures = document.body.querySelector('#fixtures');
+    fixtures.appendChild(view.render().el);
+  });
 
-      afterEach(() => {
-        view.remove();
-      });
+  afterEach(() => {
+    view.remove();
+  });
 
-      test('Rendered correctly', () => {
-        var sector = view.el;
-        expect(sector.querySelector('.title')).toBeTruthy();
-        var props = sector.querySelector('.properties');
-        expect(props).toBeTruthy();
-        expect(sector.classList.contains('open')).toEqual(true);
-      });
+  test('Rendered correctly', () => {
+    var sector = view.el;
+    expect(sector.querySelector('.title')).toBeTruthy();
+    var props = sector.querySelector('.properties');
+    expect(props).toBeTruthy();
+    expect(sector.classList.contains('open')).toEqual(true);
+  });
 
-      test('No properties', () => {
-        var props = view.el.querySelector('.properties');
-        expect(props.innerHTML).toEqual('');
-      });
+  test('No properties', () => {
+    var props = view.el.querySelector('.properties');
+    expect(props.innerHTML).toEqual('');
+  });
 
-      test('Update on open', () => {
-        var sector = view.el;
-        var props = sector.querySelector('.properties');
-        model.set('open', false);
-        expect(sector.classList.contains('open')).toEqual(false);
-        expect(props.style.display).toEqual('none');
-      });
+  test('Update on open', () => {
+    var sector = view.el;
+    var props = sector.querySelector('.properties');
+    model.set('open', false);
+    expect(sector.classList.contains('open')).toEqual(false);
+    expect(props.style.display).toEqual('none');
+  });
 
-      test('Toggle on click', () => {
-        var sector = view.el;
-        view.$el.find('.title').click();
-        expect(sector.classList.contains('open')).toEqual(false);
-      });
+  test('Toggle on click', () => {
+    var sector = view.el;
+    view.$el.find('.title').click();
+    expect(sector.classList.contains('open')).toEqual(false);
+  });
 
-      describe('Init with options', () => {
-        beforeEach(() => {
-          model = new Sector({
-            open: false,
-            name: 'TestName',
-            properties: [
-              { type: 'integer' },
-              { type: 'integer' },
-              { type: 'integer' }
-            ]
-          });
-          view = new SectorView({
-            model
-          });
-          //$fixture.empty().appendTo($fixtures);
-          //$fixture.html(view.render().el);
-          document.body.innerHTML = '<div id="fixtures"></div>';
-          fixtures = document.body.querySelector('#fixtures');
-          fixtures.appendChild(view.render().el);
-        });
+  describe('Init with options', () => {
+    beforeEach(() => {
+      model = new Sector({
+        open: false,
+        name: 'TestName',
+        properties: [
+          { type: 'integer' },
+          { type: 'integer' },
+          { type: 'integer' }
+        ]
+      });
+      view = new SectorView({
+        model
+      });
+      //$fixture.empty().appendTo($fixtures);
+      //$fixture.html(view.render().el);
+      document.body.innerHTML = '<div id="fixtures"></div>';
+      fixtures = document.body.querySelector('#fixtures');
+      fixtures.appendChild(view.render().el);
+    });
 
-        test('Rendered correctly', () => {
-          var sector = view.el;
-          var props = sector.querySelector('.properties');
-          expect(sector.querySelector('.title').innerHTML).toContain(
-            'TestName'
-          );
-          expect(props).toBeTruthy();
-          expect(sector.classList.contains('open')).toEqual(false);
-          expect(props.style.display).toEqual('none');
-        });
+    test('Rendered correctly', () => {
+      var sector = view.el;
+      var props = sector.querySelector('.properties');
+      expect(sector.querySelector('.title').innerHTML).toContain('TestName');
+      expect(props).toBeTruthy();
+      expect(sector.classList.contains('open')).toEqual(false);
+      expect(props.style.display).toEqual('none');
+    });
 
-        test('Has properties', () => {
-          var props = view.el.querySelector('.properties');
-          expect(props.children.length).toEqual(3);
-        });
-      });
+    test('Has properties', () => {
+      var props = view.el.querySelector('.properties');
+      expect(props.children.length).toEqual(3);
     });
-  }
-};
+  });
+});

test/specs/style_manager/view/SectorsView.js

@@ -1,35 +1,31 @@
 import SectorsView from 'style_manager/view/SectorsView';
 import Sectors from 'style_manager/model/Sectors';
 
-module.exports = {
-  run() {
-    describe('SectorsView', () => {
-      var fixtures;
-      var model;
-      var view;
+describe('SectorsView', () => {
+  var fixtures;
+  var model;
+  var view;
 
-      beforeEach(() => {
-        model = new Sectors([]);
-        view = new SectorsView({
-          collection: model
-        });
-        document.body.innerHTML = '<div id="fixtures"></div>';
-        fixtures = document.body.firstChild;
-        fixtures.appendChild(view.render().el);
-      });
+  beforeEach(() => {
+    model = new Sectors([]);
+    view = new SectorsView({
+      collection: model
+    });
+    document.body.innerHTML = '<div id="fixtures"></div>';
+    fixtures = document.body.firstChild;
+    fixtures.appendChild(view.render().el);
+  });
 
-      afterEach(() => {
-        view.collection.reset();
-      });
+  afterEach(() => {
+    view.collection.reset();
+  });
 
-      test('Collection is empty', () => {
-        expect(view.el.innerHTML).toEqual('');
-      });
+  test('Collection is empty', () => {
+    expect(view.el.innerHTML).toEqual('');
+  });
 
-      test('Add new sectors', () => {
-        view.collection.add([{}, {}]);
-        expect(view.el.children.length).toEqual(2);
-      });
-    });
-  }
-};
+  test('Add new sectors', () => {
+    view.collection.add([{}, {}]);
+    expect(view.el.children.length).toEqual(2);
+  });
+});

test/specs/trait_manager/index.js

@@ -1,20 +0,0 @@
-import TraitManager from 'trait_manager';
-import TraitsModel from './model/TraitsModel';
-import TraitsView from './view/TraitsView';
-
-describe('TraitManager', () => {
-  describe('Main', () => {
-    var obj;
-
-    beforeEach(() => {
-      obj = new TraitManager().init();
-    });
-
-    afterEach(() => {
-      obj = null;
-    });
-  });
-
-  TraitsModel.run();
-  TraitsView.run();
-});

test/specs/trait_manager/model/TraitsModel.js

@@ -1,28 +1,24 @@
 import Trait from 'trait_manager/model/Trait';
 import Component from 'dom_components/model/Component';
 
-module.exports = {
-  run() {
-    describe('TraitModels', () => {
-      var obj;
-      var target;
-      var modelName = 'title';
+describe('TraitModels', () => {
+  var obj;
+  var target;
+  var modelName = 'title';
 
-      beforeEach(() => {
-        target = new Component();
-        obj = new Trait({
-          name: modelName,
-          target
-        });
-      });
+  beforeEach(() => {
+    target = new Component();
+    obj = new Trait({
+      name: modelName,
+      target
+    });
+  });
 
-      afterEach(() => {
-        obj = null;
-      });
+  afterEach(() => {
+    obj = null;
+  });
 
-      test('Object exists', () => {
-        expect(Trait).toBeTruthy();
-      });
-    });
-  }
-};
+  test('Object exists', () => {
+    expect(Trait).toBeTruthy();
+  });
+});

test/specs/trait_manager/view/TraitsView.js

@@ -2,69 +2,65 @@ import Trait from 'trait_manager/model/Trait';
 import TraitView from 'trait_manager/view/TraitView';
 import Component from 'dom_components/model/Component';
 
-module.exports = {
-  run() {
-    describe('TraitView', () => {
-      var obj;
-      var model;
-      var modelName = 'title';
-      var target;
+describe('TraitView', () => {
+  var obj;
+  var model;
+  var modelName = 'title';
+  var target;
 
-      beforeEach(() => {
-        target = new Component();
-        model = new Trait({
-          name: modelName,
-          target
-        });
-        obj = new TraitView({
-          model
-        });
-      });
-
-      afterEach(() => {
-        obj = null;
-        model = null;
-        target = null;
-      });
+  beforeEach(() => {
+    target = new Component();
+    model = new Trait({
+      name: modelName,
+      target
+    });
+    obj = new TraitView({
+      model
+    });
+  });
 
-      test('Object exists', () => {
-        expect(Trait).toBeTruthy();
-      });
+  afterEach(() => {
+    obj = null;
+    model = null;
+    target = null;
+  });
 
-      test('Target has no attributes on init', () => {
-        expect(target.get('attributes')).toEqual({});
-      });
+  test('Object exists', () => {
+    expect(Trait).toBeTruthy();
+  });
 
-      test('On update of the value updates the target attributes', () => {
-        model.set('value', 'test');
-        var eq = {};
-        eq[modelName] = 'test';
-        expect(target.get('attributes')).toEqual(eq);
-      });
+  test('Target has no attributes on init', () => {
+    expect(target.get('attributes')).toEqual({});
+  });
 
-      test('Updates on different models do not alter other targets', () => {
-        var target1 = new Component();
-        var target2 = new Component();
-        var model1 = new Trait({
-          name: modelName,
-          target: target1
-        });
-        var model2 = new Trait({
-          name: modelName,
-          target: target2
-        });
-        var obj1 = new TraitView({ model: model1 });
-        var obj2 = new TraitView({ model: model2 });
+  test('On update of the value updates the target attributes', () => {
+    model.set('value', 'test');
+    var eq = {};
+    eq[modelName] = 'test';
+    expect(target.get('attributes')).toEqual(eq);
+  });
 
-        model1.set('value', 'test1');
-        model2.set('value', 'test2');
-        var eq1 = {};
-        eq1[modelName] = 'test1';
-        var eq2 = {};
-        eq2[modelName] = 'test2';
-        expect(target1.get('attributes')).toEqual(eq1);
-        expect(target2.get('attributes')).toEqual(eq2);
-      });
+  test('Updates on different models do not alter other targets', () => {
+    var target1 = new Component();
+    var target2 = new Component();
+    var model1 = new Trait({
+      name: modelName,
+      target: target1
     });
-  }
-};
+    var model2 = new Trait({
+      name: modelName,
+      target: target2
+    });
+    var obj1 = new TraitView({ model: model1 });
+    var obj2 = new TraitView({ model: model2 });
+
+    model1.set('value', 'test1');
+    model2.set('value', 'test2');
+    var eq1 = {};
+    eq1[modelName] = 'test1';
+    var eq2 = {};
+    eq2[modelName] = 'test2';
+    expect(target1.get('attributes')).toEqual(eq1);
+    expect(target2.get('attributes')).toEqual(eq2);
+  });
+});

test/specs/utils/Sorter.js

@@ -1,438 +1,432 @@
-define(function(require, exports, module) {
-  'use strict';
-  var Sorter = require('undefined');
-
-  module.exports = {
-    run: function() {
-      describe('Sorter', () => {
-        var fixtures;
-        var fixture;
-        var obj;
-        var parent;
-        var plh;
-        var html;
-
-        beforeAll(function() {
-          fixture = $('<div class="sorter-fixture"></div>').get(0);
-        });
-
-        beforeEach(() => {
-          parent = document.createElement('div');
-          parent.setAttribute('class', 'parent1');
-          plh = document.createElement('div');
-          document.body.appendChild(parent);
-          obj = new Sorter({ container: '.parent1' });
-          document.body.appendChild(fixture);
-          fixture.appendChild(parent);
-          html =
-            '<div id="el1" style="overflow: hidden;">' +
-            '<div id="el2">ba' +
-            '<p id="baa">baa</p>' +
-            '<span id="elspan">bab</span>' +
-            '<span id="bac" style="display:block;">bac</span>' +
-            '<div id="eldiv">eldiv</div>' +
-            '</div>' +
-            '</div>' +
-            '<div id="a">' +
-            '<div id="aa">aa' +
-            '<p id="aaa">aaa</p>' +
-            '<span id="aab">aab</span>' +
-            '<span id="aac" style="display:block;">aac</span>' +
-            '</div>' +
-            '<div id="ab" style="float: left;">ab</div>' +
-            '<div id="ac" style="position: absolute;">ac' +
-            '<div id="aca" style="float: left;">aca</div>' +
-            '<div id="acb">acb</div>' +
-            '</div>' +
-            '<div id="ad" style="overflow: hidden;">ad' +
-            '<p id="ada">ada</p>' +
-            '<span id="adb">adb</span>' +
-            '<span id="adc" style="display:block;">adc</span>' +
-            '</div>' +
-            '</div>';
-        });
-
-        afterEach(() => {
-          document.body.removeChild(fixture);
-          obj = null;
-          parent = null;
-          html = null;
-        });
-
-        test('matches class', () => {
-          var el = document.createElement('div');
-          el.setAttribute('class', 'test test2');
-          parent.appendChild(el);
-          obj.matches(el, '.test').should.equal(true);
-          obj.matches(el, '.test2').should.equal(true);
-          obj.matches(el, '.test3').should.equal(false);
-        });
-
-        test('matches id', () => {
-          var el = document.createElement('div');
-          el.setAttribute('id', 'test2');
-          parent.appendChild(el);
-          obj.matches(el, '#test2').should.equal(true);
-          obj.matches(el, '.test2').should.equal(false);
-          obj.matches(el, '#test').should.equal(false);
-        });
-
-        test('matches tag', () => {
-          var el = document.createElement('span');
-          parent.appendChild(el);
-          obj.matches(el, 'span').should.equal(true);
-          obj.matches(el, 'div').should.equal(false);
-          obj.matches(el, '*').should.equal(true);
-        });
-
-        test('Creates placeholder', () => {
-          obj.createPlaceholder().className.should.equal('placeholder');
-        });
-
-        test('isInFlow to overflow hidden', () => {
-          parent.innerHTML = html;
-          var el = parent.querySelector('#el1');
-          obj.isInFlow(el).should.equal(false);
-        });
-
-        test('isInFlow inner to overflow', () => {
-          parent.innerHTML = html;
-          var el = parent.querySelector('#el2');
-          if (!el) {
-            console.log('phantom issue');
-            return;
-          }
-          obj.isInFlow(el).should.equal(true);
-        });
-
-        test('isInFlow for span', () => {
-          parent.innerHTML = html;
-          var el = parent.querySelector('#elspan');
-          obj.isInFlow(el).should.equal(false);
-        });
-
-        test('isInFlow for div #a', () => {
-          parent.innerHTML = html;
-          var el = parent.querySelector('#a');
-          if (!el) {
-            console.log('phantom issue');
-            return;
-          }
-          obj.isInFlow(el).should.equal(true);
-        });
-
-        test('isInFlow for div #aa', () => {
-          parent.innerHTML = html;
-          var el = parent.querySelector('#aa');
-          if (!el) {
-            console.log('phantom issue');
-            return;
-          }
-          obj.isInFlow(el).should.equal(true);
-        });
-
-        test('isInFlow for p #aaa', () => {
-          parent.innerHTML = html;
-          var el = parent.querySelector('#aaa');
-          if (!el) {
-            console.log('phantom issue');
-            return;
-          }
-          obj.isInFlow(el).should.equal(true);
-        });
-
-        test('isInFlow for span #aab', () => {
-          parent.innerHTML = html;
-          var el = parent.querySelector('#aab');
-          obj.isInFlow(el).should.equal(false);
-        });
-
-        test('isInFlow for span #aac with display block', () => {
-          parent.innerHTML = html;
-          var el = parent.querySelector('#aac');
-          if (!el)
-            // in phantom doesnt work
-            return;
-          obj.isInFlow(el).should.equal(true);
-        });
-
-        test('isInFlow for div #ab with float left', () => {
-          parent.innerHTML = html;
-          var el = parent.querySelector('#ab');
-          obj.isInFlow(el).should.equal(false);
-        });
-
-        test('isInFlow for div #ac in absolute', () => {
-          parent.innerHTML = html;
-          var el = parent.querySelector('#ac');
-          obj.isInFlow(el).should.equal(false);
-        });
-
-        test('isInFlow for div #acb inside absolute', () => {
-          parent.innerHTML = html;
-          var el = parent.querySelector('#acb');
-          if (!el) {
-            console.log('phantom issue');
-            return;
-          }
-          obj.isInFlow(el).should.equal(true);
-        });
-
-        test('isInFlow for div #ad overflow hidden', () => {
-          parent.innerHTML = html;
-          var el = parent.querySelector('#ad');
-          obj.isInFlow(el).should.equal(false);
-        });
-
-        describe('Closest method', () => {
-          var parent2;
-          var parent3;
-
-          beforeEach(() => {
-            parent2 = document.createElement('span');
-            parent2.setAttribute('class', 'parent2');
-            parent3 = document.createElement('div');
-            parent3.setAttribute('class', 'parent3');
-            parent.appendChild(parent2);
-            parent2.appendChild(parent3);
-          });
-
-          test('Closest by class', () => {
-            var el = document.createElement('div');
-            parent3.appendChild(el);
-            obj.closest(el, '.parent2').should.deep.equal(parent2);
-            obj.closest(el, '.parent3').should.deep.equal(parent3);
-            obj.closest(el, '.parent1').should.deep.equal(parent);
-          });
-
-          test('Closest by tag', () => {
-            var el = document.createElement('div');
-            el.setAttribute('class', 'el');
-            parent3.appendChild(el);
-            obj.closest(el, 'span').should.deep.equal(parent2);
-            obj.closest(el, 'div').should.deep.equal(parent3);
-            obj.closest(el, '*').should.deep.equal(parent3);
-          });
-        });
-
-        describe('With elements', () => {
-          var vertDims;
-          var parent2;
-          var parent3;
-          var sib1;
-          var sib2;
-          var sib3;
-          var sib4;
-          var el;
-
-          beforeEach(() => {
-            parent2 = document.createElement('span');
-            parent2.setAttribute('class', 'parent2');
-            parent3 = document.createElement('div');
-            parent3.setAttribute('class', 'parent3');
-            parent.appendChild(parent2);
-            parent2.appendChild(parent3);
-            el = document.createElement('div');
-            el.setAttribute('class', 'el');
-            parent3.appendChild(el);
-
-            sib1 = document.createElement('div');
-            sib2 = document.createElement('div');
-            sib3 = document.createElement('div');
-            sib4 = document.createElement('div');
-            sib1.style.width = '100px';
-            sib1.style.height = '50px';
-            sib2.style.width = '100px';
-            sib2.style.height = '50px';
-            sib3.style.width = '100px';
-            sib3.style.height = '50px';
-            sib3.style.float = 'left';
-            sib4.style.width = '70px';
-            sib4.style.height = '50px';
-            sib4.style.float = 'left';
-            el.appendChild(sib1);
-            el.appendChild(sib2);
-            el.appendChild(sib3);
-            el.appendChild(sib4);
-
-            vertDims = [
-              [0, 0, 50, 100, true],
-              [50, 0, 50, 100, true],
-              [100, 0, 50, 100, true],
-              [150, 0, 50, 70, true]
-            ];
-          });
-
-          test('startSort inits correctly inits', () => {
-            obj.startSort(el);
-            obj.moved.should.equal(0);
-            obj.plh.style.display.should.equal('none');
-          });
-
-          test('onMove', () => {
-            var target = document.createElement('div');
-            obj.startSort(el);
-            obj.onMove({
-              pageX: 0,
-              pageY: 0,
-              target: target
-            });
-            obj.moved.should.equal(1);
-          });
-
-          test('getDim from element', () => {
-            var subPos = obj.offset(sib1);
-            var top = subPos.top;
-            var left = subPos.left;
-            var result = [top, left, 50, 100];
-            obj.getDim(sib1).should.deep.equal(result);
-          });
-
-          test('getChildrenDim from element', () => {
-            el.style.position = 'absolute';
-            el.style.top = '0';
-            var ch = obj.getChildrenDim(el);
-            ch = ch.map(function(v) {
-              return v.slice(0, 5);
-            });
-            var subPos = obj.offset(sib1);
-            var top = subPos.top;
-            var left = subPos.left;
-            var result = [
-              [top, left, 50, 100, true],
-              [top + 50, left + 0, 50, 100, true],
-              [top + 100, left + 0, 50, 100, true],
-              [top + 100, left + 100, 50, 70, true]
-            ];
-            ch.should.deep.equal(result);
-          });
-
-          test('nearBorders', () => {
-            obj.borderOffset = 10;
-            var dim = [0, 0, 100, 200];
-            obj.nearBorders(dim, 20, 15).should.equal(false);
-            obj.nearBorders(dim, 3, 4).should.equal(true);
-            obj.nearBorders(dim, 500, 500).should.equal(true);
-          });
-
-          test('dimsFromTarget', () => {
-            var child1 = document.createElement('div');
-            var child2 = document.createElement('div');
-            child1.style.width = '30px';
-            child1.style.height = '30px';
-            child2.style.width = '30px';
-            child2.style.height = '20px';
-            sib3.appendChild(child1);
-            sib3.appendChild(child2);
-
-            var subPos = obj.offset(sib1);
-            var top = subPos.top;
-            var left = subPos.left;
-            var topSib3 = top + 100;
-            var leftSib3 = left + 0;
-            var resultParent = [
-              [top, left, 50, 100, true],
-              [top + 50, left + 0, 50, 100, true],
-              [topSib3, leftSib3, 50, 100, true],
-              [top + 100, left + 100, 50, 70, true]
-            ];
-            var resultChildren = [
-              [topSib3, leftSib3, 30, 30, true],
-              [topSib3 + 30, left + 0, 20, 30, true]
-            ];
-
-            var dims = obj.dimsFromTarget(sib3);
-            dims = dims.map(function(v) {
-              return v.slice(0, 5);
-            });
-            dims.should.deep.equal(resultParent);
-
-            // Inside target
-            var dims = obj.dimsFromTarget(sib3, leftSib3 + 15, topSib3 + 15);
-            dims = dims.map(function(v) {
-              return v.slice(0, 5);
-            });
-            dims.should.deep.equal(resultChildren);
-
-            // Exactly on border
-            var bOffset = obj.borderOffset;
-            var dims = obj.dimsFromTarget(
-              sib3,
-              leftSib3 + bOffset,
-              topSib3 + bOffset
-            );
-            dims = dims.map(function(v) {
-              return v.slice(0, 5);
-            });
-            dims.should.deep.equal(resultChildren);
-
-            // Slightly near border
-            var dims = obj.dimsFromTarget(
-              sib3,
-              leftSib3 + bOffset - 3,
-              topSib3 + bOffset
-            );
-            dims = dims.map(function(v) {
-              return v.slice(0, 5);
-            });
-            dims.should.deep.equal(resultParent);
-          });
-
-          describe('findPosition', () => {
-            beforeEach(() => {});
-
-            test('Vertical dimensions', () => {
-              var result = { index: 0, method: 'before' };
-              obj.findPosition(vertDims, -10, -10).should.deep.equal(result);
-              obj.findPosition(vertDims, 0, 0).should.deep.equal(result);
-              obj.findPosition(vertDims, 10, 10).should.deep.equal(result);
-
-              var result = { index: 1, method: 'before' };
-              obj.findPosition(vertDims, 10, 30).should.deep.equal(result);
-              obj.findPosition(vertDims, 10, 70).should.deep.equal(result);
-
-              var result = { index: 2, method: 'before' };
-              obj.findPosition(vertDims, 10, 76).should.deep.equal(result);
-
-              var result = { index: 3, method: 'before' };
-              obj.findPosition(vertDims, 100, 140).should.deep.equal(result);
-              obj.findPosition(vertDims, 100, 160).should.deep.equal(result);
-
-              var result = { index: 3, method: 'after' };
-              obj.findPosition(vertDims, 1000, 1000).should.deep.equal(result);
-            });
-          });
-
-          describe('movePlaceholder', () => {
-            beforeEach(() => {
-              vertDims = [
-                [0, 10, 50, 100, true],
-                [50, 20, 50, 70, true],
-                [100, 30, 50, 100, true],
-                [150, 40, 50, 70, true]
-              ];
-            });
-
-            test('Vertical dimensions with before position', () => {
-              var pos = { index: 2, method: 'before' };
-              obj.movePlaceholder(plh, vertDims, pos);
-              var style = plh.style;
-              style.top.should.equal('100px');
-              style.left.should.equal('30px');
-              style.width.should.equal('100px');
-            });
-
-            test('Vertical dimensions with after position', () => {
-              var pos = { index: 1, method: 'after' };
-              obj.movePlaceholder(plh, vertDims, pos);
-              var style = plh.style;
-              style.top.should.equal('100px');
-              style.left.should.equal('20px');
-              style.width.should.equal('70px');
-            });
-          });
-        });
-      });
+// import Sorter from '../../../src/utils/Sorter.js'
+
+// TODO: Migrate this file to Jest
+
+describe.skip('Sorter', () => {
+  var fixture;
+  var obj;
+  var parent;
+  var plh;
+  var html;
+
+  beforeAll(function() {
+    fixture = $('<div class="sorter-fixture"></div>').get(0);
+  });
+
+  beforeEach(() => {
+    parent = document.createElement('div');
+    parent.setAttribute('class', 'parent1');
+    plh = document.createElement('div');
+    document.body.appendChild(parent);
+    obj = new Sorter({ container: '.parent1' });
+    document.body.appendChild(fixture);
+    fixture.appendChild(parent);
+    html =
+      '<div id="el1" style="overflow: hidden;">' +
+      '<div id="el2">ba' +
+      '<p id="baa">baa</p>' +
+      '<span id="elspan">bab</span>' +
+      '<span id="bac" style="display:block;">bac</span>' +
+      '<div id="eldiv">eldiv</div>' +
+      '</div>' +
+      '</div>' +
+      '<div id="a">' +
+      '<div id="aa">aa' +
+      '<p id="aaa">aaa</p>' +
+      '<span id="aab">aab</span>' +
+      '<span id="aac" style="display:block;">aac</span>' +
+      '</div>' +
+      '<div id="ab" style="float: left;">ab</div>' +
+      '<div id="ac" style="position: absolute;">ac' +
+      '<div id="aca" style="float: left;">aca</div>' +
+      '<div id="acb">acb</div>' +
+      '</div>' +
+      '<div id="ad" style="overflow: hidden;">ad' +
+      '<p id="ada">ada</p>' +
+      '<span id="adb">adb</span>' +
+      '<span id="adc" style="display:block;">adc</span>' +
+      '</div>' +
+      '</div>';
+  });
+
+  afterEach(() => {
+    document.body.removeChild(fixture);
+    obj = null;
+    parent = null;
+    html = null;
+  });
+
+  test('matches class', () => {
+    var el = document.createElement('div');
+    el.setAttribute('class', 'test test2');
+    parent.appendChild(el);
+    obj.matches(el, '.test').should.equal(true);
+    obj.matches(el, '.test2').should.equal(true);
+    obj.matches(el, '.test3').should.equal(false);
+  });
+
+  test('matches id', () => {
+    var el = document.createElement('div');
+    el.setAttribute('id', 'test2');
+    parent.appendChild(el);
+    obj.matches(el, '#test2').should.equal(true);
+    obj.matches(el, '.test2').should.equal(false);
+    obj.matches(el, '#test').should.equal(false);
+  });
+
+  test('matches tag', () => {
+    var el = document.createElement('span');
+    parent.appendChild(el);
+    obj.matches(el, 'span').should.equal(true);
+    obj.matches(el, 'div').should.equal(false);
+    obj.matches(el, '*').should.equal(true);
+  });
+
+  test('Creates placeholder', () => {
+    obj.createPlaceholder().className.should.equal('placeholder');
+  });
+
+  test('isInFlow to overflow hidden', () => {
+    parent.innerHTML = html;
+    var el = parent.querySelector('#el1');
+    obj.isInFlow(el).should.equal(false);
+  });
+
+  test('isInFlow inner to overflow', () => {
+    parent.innerHTML = html;
+    var el = parent.querySelector('#el2');
+    if (!el) {
+      console.log('phantom issue');
+      return;
+    }
+    obj.isInFlow(el).should.equal(true);
+  });
+
+  test('isInFlow for span', () => {
+    parent.innerHTML = html;
+    var el = parent.querySelector('#elspan');
+    obj.isInFlow(el).should.equal(false);
+  });
+
+  test('isInFlow for div #a', () => {
+    parent.innerHTML = html;
+    var el = parent.querySelector('#a');
+    if (!el) {
+      console.log('phantom issue');
+      return;
+    }
+    obj.isInFlow(el).should.equal(true);
+  });
+
+  test('isInFlow for div #aa', () => {
+    parent.innerHTML = html;
+    var el = parent.querySelector('#aa');
+    if (!el) {
+      console.log('phantom issue');
+      return;
     }
-  };
+    obj.isInFlow(el).should.equal(true);
+  });
+
+  test('isInFlow for p #aaa', () => {
+    parent.innerHTML = html;
+    var el = parent.querySelector('#aaa');
+    if (!el) {
+      console.log('phantom issue');
+      return;
+    }
+    obj.isInFlow(el).should.equal(true);
+  });
+
+  test('isInFlow for span #aab', () => {
+    parent.innerHTML = html;
+    var el = parent.querySelector('#aab');
+    obj.isInFlow(el).should.equal(false);
+  });
+
+  test('isInFlow for span #aac with display block', () => {
+    parent.innerHTML = html;
+    var el = parent.querySelector('#aac');
+    if (!el)
+      // in phantom doesnt work
+      return;
+    obj.isInFlow(el).should.equal(true);
+  });
+
+  test('isInFlow for div #ab with float left', () => {
+    parent.innerHTML = html;
+    var el = parent.querySelector('#ab');
+    obj.isInFlow(el).should.equal(false);
+  });
+
+  test('isInFlow for div #ac in absolute', () => {
+    parent.innerHTML = html;
+    var el = parent.querySelector('#ac');
+    obj.isInFlow(el).should.equal(false);
+  });
+
+  test('isInFlow for div #acb inside absolute', () => {
+    parent.innerHTML = html;
+    var el = parent.querySelector('#acb');
+    if (!el) {
+      console.log('phantom issue');
+      return;
+    }
+    obj.isInFlow(el).should.equal(true);
+  });
+
+  test('isInFlow for div #ad overflow hidden', () => {
+    parent.innerHTML = html;
+    var el = parent.querySelector('#ad');
+    obj.isInFlow(el).should.equal(false);
+  });
+
+  describe('Closest method', () => {
+    var parent2;
+    var parent3;
+
+    beforeEach(() => {
+      parent2 = document.createElement('span');
+      parent2.setAttribute('class', 'parent2');
+      parent3 = document.createElement('div');
+      parent3.setAttribute('class', 'parent3');
+      parent.appendChild(parent2);
+      parent2.appendChild(parent3);
+    });
+
+    test('Closest by class', () => {
+      var el = document.createElement('div');
+      parent3.appendChild(el);
+      obj.closest(el, '.parent2').should.deep.equal(parent2);
+      obj.closest(el, '.parent3').should.deep.equal(parent3);
+      obj.closest(el, '.parent1').should.deep.equal(parent);
+    });
+
+    test('Closest by tag', () => {
+      var el = document.createElement('div');
+      el.setAttribute('class', 'el');
+      parent3.appendChild(el);
+      obj.closest(el, 'span').should.deep.equal(parent2);
+      obj.closest(el, 'div').should.deep.equal(parent3);
+      obj.closest(el, '*').should.deep.equal(parent3);
+    });
+  });
+
+  describe('With elements', () => {
+    var vertDims;
+    var parent2;
+    var parent3;
+    var sib1;
+    var sib2;
+    var sib3;
+    var sib4;
+    var el;
+
+    beforeEach(() => {
+      parent2 = document.createElement('span');
+      parent2.setAttribute('class', 'parent2');
+      parent3 = document.createElement('div');
+      parent3.setAttribute('class', 'parent3');
+      parent.appendChild(parent2);
+      parent2.appendChild(parent3);
+      el = document.createElement('div');
+      el.setAttribute('class', 'el');
+      parent3.appendChild(el);
+
+      sib1 = document.createElement('div');
+      sib2 = document.createElement('div');
+      sib3 = document.createElement('div');
+      sib4 = document.createElement('div');
+      sib1.style.width = '100px';
+      sib1.style.height = '50px';
+      sib2.style.width = '100px';
+      sib2.style.height = '50px';
+      sib3.style.width = '100px';
+      sib3.style.height = '50px';
+      sib3.style.float = 'left';
+      sib4.style.width = '70px';
+      sib4.style.height = '50px';
+      sib4.style.float = 'left';
+      el.appendChild(sib1);
+      el.appendChild(sib2);
+      el.appendChild(sib3);
+      el.appendChild(sib4);
+
+      vertDims = [
+        [0, 0, 50, 100, true],
+        [50, 0, 50, 100, true],
+        [100, 0, 50, 100, true],
+        [150, 0, 50, 70, true]
+      ];
+    });
+
+    test('startSort inits correctly inits', () => {
+      obj.startSort(el);
+      obj.moved.should.equal(0);
+      obj.plh.style.display.should.equal('none');
+    });
+
+    test('onMove', () => {
+      var target = document.createElement('div');
+      obj.startSort(el);
+      obj.onMove({
+        pageX: 0,
+        pageY: 0,
+        target: target
+      });
+      obj.moved.should.equal(1);
+    });
+
+    test('getDim from element', () => {
+      var subPos = obj.offset(sib1);
+      var top = subPos.top;
+      var left = subPos.left;
+      var result = [top, left, 50, 100];
+      obj.getDim(sib1).should.deep.equal(result);
+    });
+
+    test('getChildrenDim from element', () => {
+      el.style.position = 'absolute';
+      el.style.top = '0';
+      var ch = obj.getChildrenDim(el);
+      ch = ch.map(function(v) {
+        return v.slice(0, 5);
+      });
+      var subPos = obj.offset(sib1);
+      var top = subPos.top;
+      var left = subPos.left;
+      var result = [
+        [top, left, 50, 100, true],
+        [top + 50, left + 0, 50, 100, true],
+        [top + 100, left + 0, 50, 100, true],
+        [top + 100, left + 100, 50, 70, true]
+      ];
+      ch.should.deep.equal(result);
+    });
+
+    test('nearBorders', () => {
+      obj.borderOffset = 10;
+      var dim = [0, 0, 100, 200];
+      obj.nearBorders(dim, 20, 15).should.equal(false);
+      obj.nearBorders(dim, 3, 4).should.equal(true);
+      obj.nearBorders(dim, 500, 500).should.equal(true);
+    });
+
+    test('dimsFromTarget', () => {
+      var child1 = document.createElement('div');
+      var child2 = document.createElement('div');
+      child1.style.width = '30px';
+      child1.style.height = '30px';
+      child2.style.width = '30px';
+      child2.style.height = '20px';
+      sib3.appendChild(child1);
+      sib3.appendChild(child2);
+
+      var subPos = obj.offset(sib1);
+      var top = subPos.top;
+      var left = subPos.left;
+      var topSib3 = top + 100;
+      var leftSib3 = left + 0;
+      var resultParent = [
+        [top, left, 50, 100, true],
+        [top + 50, left + 0, 50, 100, true],
+        [topSib3, leftSib3, 50, 100, true],
+        [top + 100, left + 100, 50, 70, true]
+      ];
+      var resultChildren = [
+        [topSib3, leftSib3, 30, 30, true],
+        [topSib3 + 30, left + 0, 20, 30, true]
+      ];
+
+      var dims = obj.dimsFromTarget(sib3);
+      dims = dims.map(function(v) {
+        return v.slice(0, 5);
+      });
+      dims.should.deep.equal(resultParent);
+
+      // Inside target
+      var dims = obj.dimsFromTarget(sib3, leftSib3 + 15, topSib3 + 15);
+      dims = dims.map(function(v) {
+        return v.slice(0, 5);
+      });
+      dims.should.deep.equal(resultChildren);
+
+      // Exactly on border
+      var bOffset = obj.borderOffset;
+      var dims = obj.dimsFromTarget(
+        sib3,
+        leftSib3 + bOffset,
+        topSib3 + bOffset
+      );
+      dims = dims.map(function(v) {
+        return v.slice(0, 5);
+      });
+      dims.should.deep.equal(resultChildren);
+
+      // Slightly near border
+      var dims = obj.dimsFromTarget(
+        sib3,
+        leftSib3 + bOffset - 3,
+        topSib3 + bOffset
+      );
+      dims = dims.map(function(v) {
+        return v.slice(0, 5);
+      });
+      dims.should.deep.equal(resultParent);
+    });
+
+    describe('findPosition', () => {
+      beforeEach(() => {});
+
+      test('Vertical dimensions', () => {
+        var result = { index: 0, method: 'before' };
+        obj.findPosition(vertDims, -10, -10).should.deep.equal(result);
+        obj.findPosition(vertDims, 0, 0).should.deep.equal(result);
+        obj.findPosition(vertDims, 10, 10).should.deep.equal(result);
+
+        var result = { index: 1, method: 'before' };
+        obj.findPosition(vertDims, 10, 30).should.deep.equal(result);
+        obj.findPosition(vertDims, 10, 70).should.deep.equal(result);
+
+        var result = { index: 2, method: 'before' };
+        obj.findPosition(vertDims, 10, 76).should.deep.equal(result);
+
+        var result = { index: 3, method: 'before' };
+        obj.findPosition(vertDims, 100, 140).should.deep.equal(result);
+        obj.findPosition(vertDims, 100, 160).should.deep.equal(result);
+
+        var result = { index: 3, method: 'after' };
+        obj.findPosition(vertDims, 1000, 1000).should.deep.equal(result);
+      });
+    });
+
+    describe('movePlaceholder', () => {
+      beforeEach(() => {
+        vertDims = [
+          [0, 10, 50, 100, true],
+          [50, 20, 50, 70, true],
+          [100, 30, 50, 100, true],
+          [150, 40, 50, 70, true]
+        ];
+      });
+
+      test('Vertical dimensions with before position', () => {
+        var pos = { index: 2, method: 'before' };
+        obj.movePlaceholder(plh, vertDims, pos);
+        var style = plh.style;
+        style.top.should.equal('100px');
+        style.left.should.equal('30px');
+        style.width.should.equal('100px');
+      });
+
+      test('Vertical dimensions with after position', () => {
+        var pos = { index: 1, method: 'after' };
+        obj.movePlaceholder(plh, vertDims, pos);
+        var style = plh.style;
+        style.top.should.equal('100px');
+        style.left.should.equal('20px');
+        style.width.should.equal('70px');
+      });
+    });
+  });
 });

test/specs/utils/main.js

@@ -1,9 +0,0 @@
-define((require, exports, module) => {
-  'use strict';
-  var Utils = require('Utils');
-  var Sorter = require('undefined');
-
-  describe('Utils', () => {
-    Sorter.run();
-  });
-});