mobility-toolbox-js 2.0.0-beta.8 → 2.0.1-beta.13

package/{src/common → common}/layers/Layer.test.js

@@ -1,26 +1,22 @@
-import VectorLayer from 'ol/layer/Vector';
-import VectorSource from 'ol/source/Vector';
-import Layer from './Layer';
-
+import VectorLayer from "ol/layer/Vector";
+import VectorSource from "ol/source/Vector";
+import Layer from "./Layer";
 const olLayer = new VectorLayer({ source: new VectorSource() });
-
-describe('Layer', () => {
-  test('should initialize.', () => {
-    const layer = new Layer({ name: 'Layer', olLayer });
+describe("Layer", () => {
+  test("should initialize.", () => {
+    const layer = new Layer({ name: "Layer", olLayer });
     expect(layer).toBeInstanceOf(Layer);
   });
-
-  test('should define default properties.', () => {
+  test("should define default properties.", () => {
     const options = {
-      name: 'Layer',
-      olLayer,
+      name: "Layer",
+      olLayer
     };
     const layer = new Layer(options);
-
     expect(layer).toBeInstanceOf(Layer);
     expect(layer.options).toEqual(options);
     expect(layer.name).toEqual(options.name);
-    expect(layer.key).toEqual('layer');
+    expect(layer.key).toEqual("layer");
     expect(layer.isBaseLayer).toBe(false);
     expect(layer.isBaseLayer).toBe(false);
     expect(layer.isQueryable).toBe(true);
@@ -31,45 +27,39 @@ describe('Layer', () => {
     expect(layer.copyrights).toBe();
     expect(layer.visible).toBe(true);
     expect(layer.properties).toEqual({});
-    expect(layer.map).toBe(undefined);
+    expect(layer.map).toBe(void 0);
     expect(layer.clickCallbacks).toEqual([]);
     expect(layer.hoverCallbacks).toEqual([]);
   });
-
-  test('should be visible by default.', () => {
-    const layer = new Layer({ name: 'Layer', olLayer });
+  test("should be visible by default.", () => {
+    const layer = new Layer({ name: "Layer", olLayer });
     expect(layer.visible).toBe(true);
   });
-
-  test('should be hidden using constructor.', () => {
-    const layer = new Layer({ name: 'Layer', visible: false, olLayer });
+  test("should be hidden using constructor.", () => {
+    const layer = new Layer({ name: "Layer", visible: false, olLayer });
     expect(layer.visible).toBe(false);
   });
-
-  test('should be hidden using setter.', () => {
-    const layer = new Layer({ name: 'Layer', olLayer });
+  test("should be hidden using setter.", () => {
+    const layer = new Layer({ name: "Layer", olLayer });
     layer.setVisible(false);
     expect(layer.visible).toBe(false);
   });
-
-  test('should visibility stay unchanged', () => {
-    const layer = new Layer({ name: 'Layer', visible: false, olLayer });
+  test("should visibility stay unchanged", () => {
+    const layer = new Layer({ name: "Layer", visible: false, olLayer });
     layer.setVisible(false);
     expect(layer.visible).toBe(false);
   });
-
-  test('should return its name.', () => {
-    const layer = new Layer({ name: 'Layer', visible: false, olLayer });
-    expect(layer.name).toEqual('Layer');
+  test("should return its name.", () => {
+    const layer = new Layer({ name: "Layer", visible: false, olLayer });
+    expect(layer.name).toEqual("Layer");
   });
-
-  test('should set isClickActive and isHoverActive to false if isQueryable is set to false.', () => {
+  test("should set isClickActive and isHoverActive to false if isQueryable is set to false.", () => {
     const options = {
-      name: 'Layer',
+      name: "Layer",
       isQueryable: false,
       isClickActive: true,
       isHoverActive: true,
-      olLayer,
+      olLayer
     };
     const layer = new Layer(options);
     expect(layer).toBeInstanceOf(Layer);
@@ -77,235 +67,211 @@ describe('Layer', () => {
     expect(layer.isClickActive).toBe(false);
     expect(layer.isHoverActive).toBe(false);
   });
-
-  test('should called terminate on initialization.', () => {
-    const layer = new Layer({ name: 'Layer', olLayer });
-    const spy = jest.spyOn(layer, 'terminate');
-    layer.init();
+  test("should called terminate on initialization.", () => {
+    const layer = new Layer({ name: "Layer", olLayer });
+    const spy = jest.spyOn(layer, "detachFromMap");
+    layer.attachToMap();
     expect(spy).toHaveBeenCalledTimes(1);
   });
-
-  test('should properties correctly set and get.', () => {
+  test("should properties correctly set and get.", () => {
     const layer = new Layer({
-      name: 'Layer',
+      name: "Layer",
       olLayer,
       properties: {
-        abc: 'foo',
-      },
+        abc: "foo"
+      }
     });
     expect(layer).toBeInstanceOf(Layer);
-    expect(layer.get('abc')).toEqual('foo');
-
-    layer.set('abc', 'bar');
-    expect(layer.get('abc')).toEqual('bar');
+    expect(layer.get("abc")).toEqual("foo");
+    layer.set("abc", "bar");
+    expect(layer.get("abc")).toEqual("bar");
   });
-
-  test('should set children', () => {
+  test("should set children", () => {
     const layer = new Layer({
-      name: 'foo',
+      name: "foo",
       children: [
         new Layer({
-          name: 'bar',
+          name: "bar"
         }),
         new Layer({
-          name: 'foobar',
-          visible: false,
-        }),
-      ],
+          name: "foobar",
+          visible: false
+        })
+      ]
     });
     expect(layer.getVisibleChildren().length).toBe(1);
     expect(layer.hasVisibleChildren()).toBe(true);
   });
-
-  test('should set onClick using constructor.', () => {
-    const fn = () => {};
+  test("should set onClick using constructor.", () => {
+    const fn = () => {
+    };
     const layer = new Layer({
-      name: 'Layer',
+      name: "Layer",
       olLayer,
       onClick: fn,
-      onHover: fn,
+      onHover: fn
     });
     expect(layer.clickCallbacks[0]).toBe(fn);
     expect(layer.hoverCallbacks[0]).toBe(fn);
   });
-
-  test('should onClick throw error.', () => {
-    const layer = new Layer({ name: 'Layer', olLayer });
+  test("should onClick throw error.", () => {
+    const layer = new Layer({ name: "Layer", olLayer });
     expect(() => {
-      layer.onClick('not of type function');
+      layer.onClick("not of type function");
     }).toThrow(Error);
   });
-
-  test('should initialize copyrights property.', () => {
+  test("should initialize copyrights property.", () => {
     const layer = new Layer({
-      name: 'Layer',
+      name: "Layer",
       olLayer,
-      copyrights: ['&copy: copyright', 'another copyright'],
+      copyrights: ["&copy: copyright", "another copyright"]
     });
-
-    expect(layer.copyrights[0]).toEqual('&copy: copyright');
+    expect(layer.copyrights[0]).toEqual("&copy: copyright");
   });
-
-  test('should set and get copyright property.', () => {
+  test("should set and get copyright property.", () => {
     const layer = new Layer({
-      name: 'Layer',
-      olLayer,
+      name: "Layer",
+      olLayer
     });
     expect(layer).toBeInstanceOf(Layer);
-    expect(layer.copyright).toEqual(undefined);
-
-    layer.copyright = '© OSM Contributors';
-    expect(layer.copyright).toEqual('© OSM Contributors');
+    expect(layer.copyright).toEqual(void 0);
+    layer.copyright = "© OSM Contributors";
+    expect(layer.copyright).toEqual("© OSM Contributors");
   });
-
-  describe('#init()', () => {
-    test('should set map.', () => {
+  describe("#attachToMap()", () => {
+    test("should set map.", () => {
       const layer = new Layer({
-        name: 'Layer',
-        olLayer,
+        name: "Layer",
+        olLayer
       });
-
-      expect(layer.map).toBe(undefined);
+      expect(layer.map).toBe(void 0);
       const obj = {};
-      layer.init(obj);
+      layer.attachToMap(obj);
       expect(layer.map).toBe(obj);
     });
-
-    test('should call terminate.', () => {
+    test("should call terminate.", () => {
       const layer = new Layer({
-        name: 'Layer',
-        olLayer,
+        name: "Layer",
+        olLayer
       });
-      const spy = jest.spyOn(layer, 'terminate');
-      layer.init();
+      const spy = jest.spyOn(layer, "detachFromMap");
+      layer.attachToMap();
       expect(spy).toHaveBeenCalledTimes(1);
     });
   });
-
-  describe('#get() and #set()', () => {
-    test('should get/set a properties.', () => {
+  describe("#get() and #set()", () => {
+    test("should get/set a properties.", () => {
       const layer = new Layer({
-        name: 'Layer',
-        olLayer,
+        name: "Layer",
+        olLayer
       });
-      expect(layer.get('foo')).toBe(undefined);
-      layer.set('foo', 'bar');
-      expect(layer.get('foo')).toBe('bar');
+      expect(layer.get("foo")).toBe(void 0);
+      layer.set("foo", "bar");
+      expect(layer.get("foo")).toBe("bar");
     });
   });
-
-  describe('#set()', () => {
-    test('should dispatch a change event.', () => {
+  describe("#set()", () => {
+    test("should dispatch a change event.", () => {
       const layer = new Layer({
-        name: 'Layer',
-        olLayer,
+        name: "Layer",
+        olLayer
       });
-      const spy = jest.spyOn(layer, 'dispatchEvent');
-      layer.set('foo', 'bar');
-      expect(spy).toHaveBeenCalledWith({ type: 'change:foo', target: layer });
+      const spy = jest.spyOn(layer, "dispatchEvent");
+      layer.set("foo", "bar");
+      expect(spy).toHaveBeenCalledWith({ type: "change:foo", target: layer });
     });
   });
-
-  describe('#setVisible()', () => {
+  describe("#setVisible()", () => {
     test("should not trigger a change event if the visiblity hasn't changed.", () => {
       const layer = new Layer({
-        name: 'Layer',
+        name: "Layer",
         visible: false,
-        olLayer,
+        olLayer
       });
-      const spy = jest.spyOn(layer, 'dispatchEvent');
-      layer.setVisible(false, 'foo', 'bar', 'qux');
+      const spy = jest.spyOn(layer, "dispatchEvent");
+      layer.setVisible(false, "foo", "bar", "qux");
       expect(spy).toHaveBeenCalledTimes(0);
     });
-
-    test('should trigger a change event only if the visiblity change.', () => {
+    test("should trigger a change event only if the visiblity change.", () => {
       const layer = new Layer({
-        name: 'Layer',
+        name: "Layer",
         visible: false,
-        olLayer,
+        olLayer
       });
-      const spy = jest.spyOn(layer, 'dispatchEvent');
-      layer.setVisible(true, 'foo', 'bar', 'qux');
+      const spy = jest.spyOn(layer, "dispatchEvent");
+      layer.setVisible(true, "foo", "bar", "qux");
       expect(layer.visible).toBe(true);
       expect(spy).toHaveBeenCalledTimes(1);
       expect(spy).toHaveBeenCalledWith({
-        type: 'change:visible',
+        type: "change:visible",
         target: layer,
-        stopPropagationDown: 'foo',
-        stopPropagationUp: 'bar',
-        stopPropagationSiblings: 'qux',
+        stopPropagationDown: "foo",
+        stopPropagationUp: "bar",
+        stopPropagationSiblings: "qux"
       });
     });
   });
-
-  describe('#getVisibleChildren()', () => {
-    test('should return only visible child.', () => {
+  describe("#getVisibleChildren()", () => {
+    test("should return only visible child.", () => {
       const layerVisible = { visible: true };
       const layerVisible2 = { visible: true };
       const layerHidden = { visible: false };
       const layer = new Layer({
-        name: 'Layer',
+        name: "Layer",
         visible: false,
         olLayer,
-        children: [layerVisible, layerHidden, layerVisible2],
+        children: [layerVisible, layerHidden, layerVisible2]
       });
       expect(layer.getVisibleChildren()).toEqual([layerVisible, layerVisible2]);
     });
   });
-
-  describe('#hasVisibleChildren()', () => {
-    test('should return true.', () => {
+  describe("#hasVisibleChildren()", () => {
+    test("should return true.", () => {
       const layerVisible = { visible: true };
       const layerVisible2 = { visible: true };
       const layerHidden = { visible: false };
       const layer = new Layer({
-        name: 'Layer',
+        name: "Layer",
         visible: false,
         olLayer,
-        children: [layerVisible, layerHidden, layerVisible2],
+        children: [layerVisible, layerHidden, layerVisible2]
       });
       expect(layer.hasVisibleChildren()).toEqual(true);
     });
-
-    test('should return false.', () => {
+    test("should return false.", () => {
       const layerHidden = { visible: false };
       const layer = new Layer({
-        name: 'Layer',
+        name: "Layer",
         visible: false,
         olLayer,
-        children: [layerHidden],
+        children: [layerHidden]
       });
       expect(layer.hasVisibleChildren()).toEqual(false);
     });
   });
-
-  describe('#getFeatureInfoAtCoordinate()', () => {
-    test('return an empty fetaureInfo object and display an error message', (done) => {
-      // eslint-disable-next-line no-console
+  describe("#getFeatureInfoAtCoordinate()", () => {
+    test("return an empty fetaureInfo object and display an error message", (done) => {
       console.error = jest.fn();
       const layer = new Layer({
-        name: 'Layer',
-        olLayer,
+        name: "Layer",
+        olLayer
       });
       const coord = [0, 0];
       layer.getFeatureInfoAtCoordinate(coord).then((featureInfo) => {
         expect(featureInfo.features).toEqual([]);
         expect(featureInfo.layer).toEqual(layer);
         expect(featureInfo.coordinate).toEqual(coord);
-        // eslint-disable-next-line no-console
         expect(console.error).toHaveBeenCalledTimes(1);
         done();
-        // eslint-disable-next-line no-console
         console.error.mockRestore();
       });
     });
   });
-
-  describe('#onClick()', () => {
-    test('adds function to clickCallbacks array', () => {
+  describe("#onClick()", () => {
+    test("adds function to clickCallbacks array", () => {
       const layer = new Layer({
-        name: 'Layer',
-        olLayer,
+        name: "Layer",
+        olLayer
       });
       const fn = jest.fn();
       const fn2 = jest.fn();
@@ -314,26 +280,24 @@ describe('Layer', () => {
       layer.onClick(fn2);
       expect(layer.clickCallbacks).toEqual([fn, fn2]);
     });
-
-    test('triggers Error if parameter is not a function', (done) => {
+    test("triggers Error if parameter is not a function", (done) => {
       const layer = new Layer({
-        name: 'Layer',
-        olLayer,
+        name: "Layer",
+        olLayer
       });
       try {
-        layer.onClick('test');
+        layer.onClick("test");
       } catch (e) {
         expect(e).toBeDefined();
         done();
       }
     });
   });
-
-  describe('#unClick()', () => {
-    test('removes function from clickCallbacks array', () => {
+  describe("#unClick()", () => {
+    test("removes function from clickCallbacks array", () => {
       const layer = new Layer({
-        name: 'Layer',
-        olLayer,
+        name: "Layer",
+        olLayer
       });
       const fn = jest.fn();
       const fn2 = jest.fn();
@@ -343,33 +307,27 @@ describe('Layer', () => {
       expect(layer.clickCallbacks).toEqual([fn, fn2]);
       layer.unClick(fn);
       expect(layer.clickCallbacks).toEqual([fn2]);
-      // Make sure no callbacks are removed if the callback is not in the list.
       layer.unClick(fn);
       expect(layer.clickCallbacks).toEqual([fn2]);
     });
   });
-
-  describe('#onUserClickCallback()', () => {
-    const evt = { type: 'signleclick', coordinate: [0, 0] };
-
+  describe("#onUserClickCallback()", () => {
+    const evt = { type: "signleclick", coordinate: [0, 0] };
     const getFeatureInfo = (layer, features = []) => ({
       features,
       layer,
       coordinate: evt.coordinate,
-      event: evt,
+      event: evt
     });
-
-    test('calls click callback functions', (done) => {
+    test("calls click callback functions", (done) => {
       const layer = new Layer({
-        name: 'Layer',
-        olLayer,
+        name: "Layer",
+        olLayer
       });
-      const goodFeatureInfo = getFeatureInfo(layer, [{ name: 'test' }]);
+      const goodFeatureInfo = getFeatureInfo(layer, [{ name: "test" }]);
       const fn = jest.fn();
       const fn2 = jest.fn();
-      const spy = jest
-        .spyOn(layer, 'getFeatureInfoAtCoordinate')
-        .mockResolvedValue(goodFeatureInfo);
+      const spy = jest.spyOn(layer, "getFeatureInfoAtCoordinate").mockResolvedValue(goodFeatureInfo);
       layer.onClick(fn);
       layer.onClick(fn2);
       layer.onUserClickCallback(evt).then((featureInfo) => {
@@ -387,13 +345,12 @@ describe('Layer', () => {
         done();
       });
     });
-
-    describe('returns empty feature info', () => {
-      test('if isClickActive = false', (done) => {
+    describe("returns empty feature info", () => {
+      test("if isClickActive = false", (done) => {
         const layer = new Layer({
-          name: 'Layer',
+          name: "Layer",
           isClickActive: false,
-          olLayer,
+          olLayer
         });
         layer.onClick(jest.fn());
         layer.onUserClickCallback(evt).then((featureInfo) => {
@@ -401,25 +358,23 @@ describe('Layer', () => {
           done();
         });
       });
-
-      test('if clickCallbacks is empty', (done) => {
+      test("if clickCallbacks is empty", (done) => {
         const layer = new Layer({
-          name: 'Layer',
-          olLayer,
+          name: "Layer",
+          olLayer
         });
         layer.onUserClickCallback(evt).then((featureInfo) => {
           expect(featureInfo).toEqual(getFeatureInfo(layer));
           done();
         });
       });
-
-      test('if an error is thrown in click callback', (done) => {
+      test("if an error is thrown in click callback", (done) => {
         const layer = new Layer({
-          name: 'Layer',
-          olLayer,
+          name: "Layer",
+          olLayer
         });
         layer.onClick(() => {
-          throw new Error('foo');
+          throw new Error("foo");
         });
         layer.onUserClickCallback(evt).then((featureInfo) => {
           expect(featureInfo).toEqual(getFeatureInfo(layer));
@@ -427,26 +382,24 @@ describe('Layer', () => {
         });
       });
     });
-
-    test('triggers Error if parameter is not a function', (done) => {
+    test("triggers Error if parameter is not a function", (done) => {
       const layer = new Layer({
-        name: 'Layer',
-        olLayer,
+        name: "Layer",
+        olLayer
       });
       try {
-        layer.onClick('test');
+        layer.onClick("test");
       } catch (e) {
         expect(e).toBeDefined();
         done();
       }
     });
   });
-
-  describe('#onHover()', () => {
-    test('adds function to clickCallbacks array', () => {
+  describe("#onHover()", () => {
+    test("adds function to clickCallbacks array", () => {
       const layer = new Layer({
-        name: 'Layer',
-        olLayer,
+        name: "Layer",
+        olLayer
       });
       const fn = jest.fn();
       const fn2 = jest.fn();
@@ -455,26 +408,24 @@ describe('Layer', () => {
       layer.onHover(fn2);
       expect(layer.hoverCallbacks).toEqual([fn, fn2]);
     });
-
-    test('triggers Error if parameter is not a function', (done) => {
+    test("triggers Error if parameter is not a function", (done) => {
       const layer = new Layer({
-        name: 'Layer',
-        olLayer,
+        name: "Layer",
+        olLayer
       });
       try {
-        layer.onHover('test');
+        layer.onHover("test");
       } catch (e) {
         expect(e).toBeDefined();
         done();
       }
     });
   });
-
-  describe('#unHover()', () => {
-    test('removes function from clickCallbacks array', () => {
+  describe("#unHover()", () => {
+    test("removes function from clickCallbacks array", () => {
       const layer = new Layer({
-        name: 'Layer',
-        olLayer,
+        name: "Layer",
+        olLayer
       });
       const fn = jest.fn();
       const fn2 = jest.fn();
@@ -484,33 +435,27 @@ describe('Layer', () => {
       expect(layer.hoverCallbacks).toEqual([fn, fn2]);
       layer.unHover(fn);
       expect(layer.hoverCallbacks).toEqual([fn2]);
-      // Make sure no callbacks are removed if the callback is not in the list.
       layer.unHover(fn);
       expect(layer.hoverCallbacks).toEqual([fn2]);
     });
   });
-
-  describe('#onUserMoveCallback()', () => {
-    const evt = { type: 'pointermove', coordinate: [0, 0] };
-
+  describe("#onUserMoveCallback()", () => {
+    const evt = { type: "pointermove", coordinate: [0, 0] };
     const getFeatureInfo = (layer, features = []) => ({
       features,
       layer,
       coordinate: evt.coordinate,
-      event: evt,
+      event: evt
     });
-
-    test('calls hover callback functions', (done) => {
+    test("calls hover callback functions", (done) => {
       const layer = new Layer({
-        name: 'Layer',
-        olLayer,
+        name: "Layer",
+        olLayer
       });
-      const goodFeatureInfo = getFeatureInfo(layer, [{ name: 'test' }]);
+      const goodFeatureInfo = getFeatureInfo(layer, [{ name: "test" }]);
       const fn = jest.fn();
       const fn2 = jest.fn();
-      const spy = jest
-        .spyOn(layer, 'getFeatureInfoAtCoordinate')
-        .mockResolvedValue(goodFeatureInfo);
+      const spy = jest.spyOn(layer, "getFeatureInfoAtCoordinate").mockResolvedValue(goodFeatureInfo);
       layer.onHover(fn);
       layer.onHover(fn2);
       layer.onUserMoveCallback(evt).then((featureInfo) => {
@@ -528,13 +473,12 @@ describe('Layer', () => {
         done();
       });
     });
-
-    describe('returns empty feature info', () => {
-      test('if isHoverActive = false', (done) => {
+    describe("returns empty feature info", () => {
+      test("if isHoverActive = false", (done) => {
         const layer = new Layer({
-          name: 'Layer',
+          name: "Layer",
           isHoverActive: false,
-          olLayer,
+          olLayer
         });
         layer.onHover(jest.fn());
         layer.onUserMoveCallback(evt).then((featureInfo) => {
@@ -542,25 +486,23 @@ describe('Layer', () => {
           done();
         });
       });
-
-      test('if hoverCallbacks is empty', (done) => {
+      test("if hoverCallbacks is empty", (done) => {
         const layer = new Layer({
-          name: 'Layer',
-          olLayer,
+          name: "Layer",
+          olLayer
         });
         layer.onUserMoveCallback(evt).then((featureInfo) => {
           expect(featureInfo).toEqual(getFeatureInfo(layer));
           done();
         });
       });
-
-      test('if an error is thrown in hover callback', (done) => {
+      test("if an error is thrown in hover callback", (done) => {
         const layer = new Layer({
-          name: 'Layer',
-          olLayer,
+          name: "Layer",
+          olLayer
         });
         layer.onHover(() => {
-          throw new Error('foo');
+          throw new Error("foo");
         });
         layer.onUserMoveCallback(evt).then((featureInfo) => {
           expect(featureInfo).toEqual(getFeatureInfo(layer));
@@ -568,14 +510,13 @@ describe('Layer', () => {
         });
       });
     });
-
-    test('triggers Error if parameter is not a function', (done) => {
+    test("triggers Error if parameter is not a function", (done) => {
       const layer = new Layer({
-        name: 'Layer',
-        olLayer,
+        name: "Layer",
+        olLayer
       });
       try {
-        layer.onHover('test');
+        layer.onHover("test");
       } catch (e) {
         expect(e).toBeDefined();
         done();