tests

addon/components/layers/odata-vector-layer.js

@@ -236,6 +236,11 @@ export default BaseVectorLayer.extend({
       leafletObject = this.get('_leafletObject');
     }
 
+    if (!layer) {
+      // явная ошибка, не должно быть такой ситуации
+      return leafletObject;
+    }
+
     if (layer.state && layer.state !== state.insert) {
       L.FeatureGroup.prototype.addLayer.call(leafletObject, layer);
       return;

testem.js

@@ -10,12 +10,15 @@ module.exports = {
     "Chrome"
   ],
   "browser_args": {
-    "Chrome": [
-      '--headless',
-      '--disable-gpu',
-      '--no-sandbox',
-      '--remote-debugging-port=9222',
-      '--window-size=1440,900'
-    ]
+    "Chrome": {
+      mode: 'ci',
+      args: [
+        '--headless',
+        '--disable-gpu',
+        '--no-sandbox',
+        '--remote-debugging-port=9222',
+        '--window-size=1440,900'
+      ]
+    }
   }
 };

tests/unit/components/base-layer-test.js

@@ -21,27 +21,28 @@ test('it should throw at init', function (assert) {
 
 test('it should call layer.setZIndex on _setLayerZIndex', function (assert) {
   assert.expect(1);
+  var done = assert.async(1);
 
   let setZIndex = sinon.spy();
   let component = this.subject({
-    createLayer() {
+    createLayer: function() {
       return {
-        setZIndex
+        setZIndex: setZIndex
       };
     }
   });
 
-  let leafletLayerPromiseResolved = assert.async();
   component.get('_leafletLayerPromise').then((leafletLayer) => {
     component._setLayerZIndex();
-    assert.ok(setZIndex.called);
+    assert.equal(setZIndex.callCount, 1);
   }).finally(() => {
-    leafletLayerPromiseResolved();
+    done();
   });
 });
 
 test('should call _setLayerVisibility and _setLayerZIndex on render', function (assert) {
   assert.expect(1);
+  var done = assert.async(1);
 
   let setLayerVisibility = sinon.spy();
 
@@ -52,16 +53,16 @@ test('should call _setLayerVisibility and _setLayerZIndex on render', function (
 
   this.render();
 
-  let leafletLayerPromiseResolved = assert.async();
   component.get('_leafletLayerPromise').then((leafletLayer) => {
     assert.ok(setLayerVisibility.called, 'should call visibilityDidChange');
   }).finally(() => {
-    leafletLayerPromiseResolved();
+    done();
   });
 });
 
 test('should call container addLayer/removeLayer based on visibility property', function(assert) {
   assert.expect(4);
+  var done = assert.async(1);
 
   let addLayer = sinon.spy();
   let removeLayer = sinon.spy();
@@ -81,7 +82,6 @@ test('should call container addLayer/removeLayer based on visibility property',
     }
   });
 
-  let leafletLayerPromiseResolved = assert.async();
   component.get('_leafletLayerPromise').then((leafletLayer) => {
     component.set('visibility', true);
 
@@ -94,20 +94,20 @@ test('should call container addLayer/removeLayer based on visibility property',
     assert.ok(removeLayer.calledOnce, 'removeLayer should be called once');
     assert.ok(removeLayer.calledWith(layer), 'removeLayer should be called with layer instance');
   }).finally(() => {
-    leafletLayerPromiseResolved();
+    done();
   });
 });
 
 test('should check method addCustomFilter', function (assert) {
   assert.expect(9);
+  var done = assert.async(1);
 
   let component = this.subject({
     createLayer: createLayer
   });
 
   this.render();
 
-  let leafletLayerPromiseResolved = assert.async();
   component.get('_leafletLayerPromise').then((leafletLayer) => {
     let filterEmpty = component.addCustomFilter(null);
     assert.equal(filterEmpty, null, 'filter is null');
@@ -131,6 +131,6 @@ test('should check method addCustomFilter', function (assert) {
     assert.equal(filter4.filters[1].firstValue, 'outerFilter', 'filter is contains outerFilter');
     assert.equal(filter4.filters[2].firstValue, 'customFilter', 'filter is contains customFilter');
   }).finally(() => {
-    leafletLayerPromiseResolved();
+    done();
   });
 });

tests/unit/components/flexberry-map-test.js

@@ -48,8 +48,10 @@ test('test function queryToMap', function (assert) {
     assert.deepEqual(querySpy.args[0][1], e, 'Check call second arg to method fire');
     e.results[0].features.then((result) => {
       assert.equal(result[0].id, 1, 'Cherck result id');
+      querySpy.restore();
       done(1);
     });
+
     done(1);
   });
 });

tests/unit/components/layers/group-layer-test.js

@@ -12,18 +12,31 @@ moduleForComponent('layers/group-layer', 'Unit | Component | layers/group layer'
   }
 });
 
-test('it return L.LayerGroup on createLayer', function(assert) {
+test('it return L.LayerGroup on createLayer', function (assert) {
   assert.expect(1);
 
-  let component = this.subject({ leafletMap: leafletMap });
+  let component = this.subject({
+    leafletMap: leafletMap,
+    mapApi: {
+      getFromApi() { return {}; }
+    }
+  });
+
   let layer = component.createLayer();
   assert.ok(layer instanceof L.LayerGroup, 'Expected L.LayerGroup instance');
 });
 
-test('it not call _leafletObject.setZIndex on setZIndex', function(assert) {
+test('it not call _leafletObject.setZIndex on setZIndex', function (assert) {
   assert.expect(1);
+  var done = assert.async(1);
+
+  let component = this.subject({
+    leafletMap: leafletMap,
+    mapApi: {
+      getFromApi() { return {}; }
+    }
+  });
 
-  let component = this.subject({ leafletMap: leafletMap });
   let leafletLayerPromiseResolved = assert.async();
   component.get('_leafletLayerPromise').then((leafletLayer) => {
     let layer = component.get('_leafletObject');
@@ -34,5 +47,7 @@ test('it not call _leafletObject.setZIndex on setZIndex', function(assert) {
     assert.equal(spy.callCount, 0);
   }).finally(() => {
     leafletLayerPromiseResolved();
+
+    done();
   });
 });

tests/unit/components/layers/odata-vector-layer-test.js

@@ -487,9 +487,10 @@ test('loadLayerFeatures() with featureIds=null', function(assert) {
         done();
       });
     }).finally(() => {
-      done();
       getmapApiStub.restore();
       getPkFieldStub.restore();
+
+      done();
     });
 
     assert.ok(component, 'Create odata-layer');
@@ -520,8 +521,9 @@ test('getLayerFeatures() with featureIds=null', function(assert) {
         done();
       });
     }).finally(() => {
-      done();
       getCountFeaturesStub.restore();
+
+      done();
     });
 
     assert.ok(component, 'Create odata-layer');
@@ -596,30 +598,44 @@ test('test methos identify()', function(assert) {
     assert.equal(spyGetFeature.getCall(0).args[0]._attributePath, 'shape');
     assert.equal(spyGetFeature.getCall(0).args[0]._intersectsValue,
       'SRID=4326;POLYGON((10 30, 40 40, 40 20, 20 10, 10 30))');
-    done();
     spyGetFeature.restore();
+
+    done();
   });
 });
 
 test('test method createAdapterForModel() with odataUrl', function(assert) {
   assert.expect(1);
+  var done = assert.async(1);
   Ember.$.extend(param, {
     'odataUrl': 'http://localhost:6500/odata/'
   });
-  let component = this.subject(param);
 
-  let adapterModel = component.createAdapterForModel();
+  let component = this.subject(param);
 
-  assert.ok(adapterModel);
+  component.get('_leafletLayerPromise').then((leafletLayer) => {
+    component.set('_leafletObject', leafletLayer);
+    leafletLayer.promiseLoadLayer.then(() => {
+      let adapterModel = component.createAdapterForModel();
+      assert.ok(adapterModel);
+      done();
+    });
+  });
 });
 
-test('test method createAdapterForModel() without odataUrl', function(assert) {
+test('test method createAdapterForModel() without odataUrl', function (assert) {
   assert.expect(1);
+  var done = assert.async(1);
   let component = this.subject(param);
 
-  let adapterModel = component.createAdapterForModel();
-
-  assert.notOk(adapterModel);
+  component.get('_leafletLayerPromise').then((leafletLayer) => {
+    component.set('_leafletObject', leafletLayer);
+    leafletLayer.promiseLoadLayer.then(() => {
+      let adapterModel = component.createAdapterForModel();
+      assert.notOk(adapterModel);
+      done();
+    });
+  });
 });
 
 test('test method createDynamicModel() with json', function(assert) {
@@ -757,7 +773,6 @@ test('test method createDynamicModel() with json with parent', function(assert)
 
     assert.equal(spyCreateModelHierarchy.callCount, 2);
 
-    done();
     spyRegister.restore();
     spyCreateAdapterForModel.restore();
     spyCreateModel.restore();
@@ -767,6 +782,8 @@ test('test method createDynamicModel() with json with parent', function(assert)
     stubAjax.restore();
     spyCreateModelHierarchy.restore();
     _lookupFactoryStub.restore();
+
+    done();
   });
 });
 
@@ -784,8 +801,10 @@ test('test method createDynamicModel() without json', function(assert) {
 
   component.createDynamicModel().catch((error) => {
     assert.equal(error, 'Can\'t create dynamic model: test-model. Error: ModelName and metadataUrl is empty');
-    done();
+
+    registerStub.restore();
     _lookupFactoryStub.restore();
+    done();
   });
 });
 
@@ -796,10 +815,15 @@ test('test method createDynamicModel() already registered', function(assert) {
   let _lookupFactoryStub = sinon.stub(Ember.getOwner(this), '_lookupFactory');
   _lookupFactoryStub.returns(1);
 
+  let spyContinueLoad = sinon.spy(component, 'continueLoad');
+
   component.createDynamicModel().then((msg) => {
     assert.equal(msg, 'Model already registered: test-model');
-    done();
+  }).finally(() => {
     _lookupFactoryStub.restore();
+    spyContinueLoad.restore();
+
+    done();
   });
 });
 
@@ -845,14 +869,16 @@ test('test method createVectorLayer() without dynamicModel', function(assert) {
     assert.equal(spyAjax.callCount, 0);
     assert.equal(spyCreateDynamicModel.callCount, 0);
     assert.equal(spyCreateModelHierarchy.callCount, 0);
-    done();
+
     spyContinueLoad.restore();
     _createVectorLayerSpy.restore();
     spyAjax.restore();
     spyCreateDynamicModel.restore();
     spyCreateModelHierarchy.restore();
     _lookupFactoryStub.restore();
     registerStub.restore();
+
+    done();
   });
 });
 
@@ -889,14 +915,16 @@ test('test method createVectorLayer() with dynamicModel=true', function(assert)
     assert.equal(stubAjax.getCall(0).args[0].url, 'assert/felxberry/models/test-model.json');
     assert.equal(spyCreateDynamicModel.callCount, 1);
     assert.equal(spyCreateModelHierarchy.callCount, 1);
-    done();
+
     spyContinueLoad.restore();
     _createVectorLayerSpy.restore();
     spyCreateDynamicModel.restore();
     stubAjax.restore();
     spyCreateModelHierarchy.restore();
     _lookupFactoryStub.restore();
     registerStub.restore();
+
+    done();
   });
 });
 
@@ -920,9 +948,10 @@ test('test method save() no modified objects', function(assert) {
       assert.equal(realCountArr(leafletObject.models), 0);
       assert.equal(leafletObject.getLayers().length, 2);
       assert.equal(spyBatchUpdate.callCount, 0);
-      done();
 
       spyBatchUpdate.restore();
+
+      done();
     });
   });
 });
@@ -999,11 +1028,12 @@ test('test method save() with objects', function(assert) {
         assert.equal(leafletObject.getLayers().length, 1);
         assert.equal(leafletObject._labelsLayer.getLayers().length, 0);
         assert.equal(leafletObject.getLayers()[0].state, 'exist');
-        done();
 
         spyBatchUpdate.restore();
         stubGetmapApi.restore();
         _getModelLayerFeatureStub.restore();
+
+        done();
       };
 
       leafletObject.once('save:success', saveSuccess);
@@ -1122,11 +1152,13 @@ test('test method createModelHierarchy() with 3 parent', function(assert) {
     assert.ok(model);
     assert.ok(dataModel);
     assert.ok(modelMixin);
-    done();
+
     stubAjax.restore();
     spyCreateModel.restore();
     spyCreateMixin.restore();
     spyCreateModelHierarchy.restore();
+
+    done();
   });
 });
 
@@ -1318,13 +1350,16 @@ test('test method getNearObject()', function(assert) {
       assert.equal(getObjectCenterSpy.callCount, 3);
       assert.equal(_getDistanceBetweenObjectsSpy.callCount, 1);
     }).finally(() => {
-      done(1);
       getmapApiStub.restore();
       getObjectCenterSpy.restore();
       _getDistanceBetweenObjectsSpy.restore();
       stubAjax.restore();
       _callAjaxStub.restore();
+      registerStub.restore();
+
+      done(1);
     });
+
     assert.ok(promise instanceof Ember.RSVP.Promise);
     done(1);
   });