mobility-toolbox-js 2.0.0-beta.35 → 2.0.0-beta.38

package/common/api/WebSocketAPI.test.js

@@ -0,0 +1,380 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import WS from 'jest-websocket-mock';
+import WebSocketAPI from './WebSocketAPI';
+describe('WebSocketAPI', () => {
+    describe('#constructor', () => {
+        let server;
+        let server2;
+        beforeEach(() => {
+            server = new WS(`ws://foo:1234`);
+            server2 = new WS(`ws://foo:12345`);
+        });
+        afterEach(() => {
+            server.close();
+            server2.close();
+            WS.clean();
+        });
+        describe('#constructor', () => {
+            test("doesn't connect.", () => __awaiter(void 0, void 0, void 0, function* () {
+                const client = new WebSocketAPI();
+                expect(client.websocket).toBe();
+                expect(client.closed).toBe(false);
+                expect(client.closing).toBe(false);
+                expect(client.connecting).toBe(false);
+                expect(client.open).toBe(false);
+            }));
+        });
+        describe('#close', () => {
+            test('should close the websocket and clear some property', () => __awaiter(void 0, void 0, void 0, function* () {
+                // eslint-disable-next-line no-unused-vars
+                const client = new WebSocketAPI();
+                const subsc2 = {
+                    params: 'foo',
+                    cb: () => { },
+                    errorCb: () => { },
+                    quiet: false,
+                };
+                client.subscriptions = [subsc2];
+                client.messagesOnOpen = ['GET foo'];
+                client.connect(`ws://foo:1234`);
+                client.websocket.addEventListener = jest.fn();
+                client.websocket.removeEventListener = jest.fn();
+                client.websocket.close = jest.fn();
+                yield server.connected;
+                expect(client.websocket).toBeDefined();
+                expect(client.messagesOnOpen).toEqual(['GET foo']);
+                client.close();
+                expect(client.messagesOnOpen).toEqual([]);
+                expect(client.websocket).toBeNull();
+            }));
+        });
+        describe('#connect', () => {
+            test('create a new WebSocket.', () => __awaiter(void 0, void 0, void 0, function* () {
+                const client = new WebSocketAPI();
+                client.connect(`ws://foo:1234`);
+                yield server.connected;
+                client.send('hello');
+                yield expect(server).toReceiveMessage('hello');
+                expect(server).toHaveReceivedMessages(['hello']);
+            }));
+            test('close previous connection.', () => __awaiter(void 0, void 0, void 0, function* () {
+                const client = new WebSocketAPI();
+                client.connect(`ws://foo:1234`);
+                yield server.connected;
+                expect(client.websocket).toBeDefined();
+                const old = client.websocket;
+                expect(old.readyState).toBe(WebSocket.OPEN);
+                client.connect(`ws://foo:12345`);
+                expect(old.readyState).toBe(WebSocket.CLOSING);
+                expect(client.websocket.readyState).toBe(WebSocket.CONNECTING);
+            }));
+            test('call onOpen function', () => __awaiter(void 0, void 0, void 0, function* () {
+                const onOpen = jest.fn();
+                const client = new WebSocketAPI();
+                client.subscribe = jest.fn();
+                client.connect(`ws://foo:1234`, onOpen);
+                yield server.connected;
+                expect(client.websocket.readyState).toBe(WebSocket.OPEN);
+                expect(onOpen).toHaveBeenCalledTimes(1);
+            }));
+            test('subscribe previous subscriptions on open (quiet or not)', () => __awaiter(void 0, void 0, void 0, function* () {
+                const client = new WebSocketAPI();
+                client.subscribe = jest.fn();
+                client.send = jest.fn();
+                const subsc = {
+                    params: 'foo',
+                    cb: () => { },
+                    errorCb: () => { },
+                    quiet: true,
+                };
+                const subsc2 = {
+                    params: 'foo',
+                    cb: () => { },
+                    errorCb: () => { },
+                    quiet: false,
+                };
+                client.subscriptions = [subsc, subsc2];
+                client.connect(`ws://foo:1234`);
+                yield server.connected;
+                expect(client.websocket.readyState).toBe(WebSocket.OPEN);
+                expect(client.subscribe).toHaveBeenCalledTimes(2);
+                client.subscribe.mockReset();
+                client.connect(`ws://foo:12345`);
+                yield server2.connected;
+                expect(client.websocket.readyState).toBe(WebSocket.OPEN);
+                expect(client.subscribe).toHaveBeenCalledTimes(2);
+                expect(client.subscribe).toHaveBeenCalledWith(subsc.params, subsc.cb, subsc.errorCb, subsc.quiet);
+            }));
+            test('send GET and SUB for not quiet previous subscriptions', () => __awaiter(void 0, void 0, void 0, function* () {
+                const client = new WebSocketAPI();
+                client.send = jest.fn();
+                const subsc = {
+                    params: { channel: 'foo' },
+                    cb: () => { },
+                    errorCb: () => { },
+                    quiet: false,
+                };
+                client.subscriptions = [subsc];
+                client.connect(`ws://foo:1234`);
+                client.websocket.addEventListener = jest.fn();
+                client.websocket.removeEventListener = jest.fn();
+                yield server.connected;
+                expect(client.websocket.readyState).toBe(WebSocket.OPEN);
+                expect(client.send).toHaveBeenCalledTimes(2);
+                expect(client.send.mock.calls[0]).toEqual(['GET foo']);
+                expect(client.send.mock.calls[1]).toEqual(['SUB foo']);
+                client.send.mockReset();
+                client.connect(`ws://foo:12345`);
+                client.websocket.addEventListener = jest.fn();
+                client.websocket.removeEventListener = jest.fn();
+                yield server2.connected;
+                expect(client.websocket.readyState).toBe(WebSocket.OPEN);
+                // not quiet subscriptions will send GET and SUB requests.
+                expect(client.send).toHaveBeenCalledTimes(2);
+                expect(client.send.mock.calls[0]).toEqual(['GET foo']);
+                expect(client.send.mock.calls[1]).toEqual(['SUB foo']);
+            }));
+            test('doesn\t send GET and SUB for quiet previous subscriptions', () => __awaiter(void 0, void 0, void 0, function* () {
+                const client = new WebSocketAPI();
+                client.send = jest.fn();
+                const subsc = {
+                    params: { channel: 'foo' },
+                    cb: () => { },
+                    errorCb: () => { },
+                    quiet: true,
+                };
+                client.subscriptions = [subsc];
+                client.connect(`ws://foo:1234`);
+                client.websocket.addEventListener = jest.fn();
+                client.websocket.removeEventListener = jest.fn();
+                yield server.connected;
+                expect(client.websocket.readyState).toBe(WebSocket.OPEN);
+                expect(client.send).toHaveBeenCalledTimes(0);
+                client.send.mockReset();
+                client.connect(`ws://foo:12345`);
+                client.websocket.addEventListener = jest.fn();
+                client.websocket.removeEventListener = jest.fn();
+                yield server2.connected;
+                expect(client.websocket.readyState).toBe(WebSocket.OPEN);
+                // not quiet subscriptions will send GET and SUB requests.
+                expect(client.send).toHaveBeenCalledTimes(0);
+            }));
+        });
+        describe('#get', () => {
+            test('listen to message event', () => __awaiter(void 0, void 0, void 0, function* () {
+                // eslint-disable-next-line no-unused-vars
+                const client = new WebSocketAPI();
+                client.connect(`ws://foo:1234`);
+                yield server.connected;
+                const params = { channel: 'get', args: ['baz'], id: 'id' };
+                const cb = jest.fn();
+                const errorCb = jest.fn();
+                client.get(params, cb, errorCb);
+                expect(cb).toHaveBeenCalledTimes(0);
+                const obj = { source: 'get baz', client_reference: 'id' };
+                server.send(JSON.stringify(obj));
+                expect(cb).toHaveBeenCalledTimes(1);
+                expect(cb).toHaveBeenCalledWith(obj);
+            }));
+            test('unlisten after receiving one response', () => __awaiter(void 0, void 0, void 0, function* () {
+                // eslint-disable-next-line no-unused-vars
+                const client = new WebSocketAPI();
+                client.connect(`ws://foo:1234`);
+                yield server.connected;
+                const params = { channel: 'get', args: ['baz'], id: 'id' };
+                const cb = jest.fn();
+                const errorCb = jest.fn();
+                client.get(params, cb, errorCb);
+                expect(cb).toHaveBeenCalledTimes(0);
+                const obj = { source: 'get baz', client_reference: 'id' };
+                server.send(JSON.stringify(obj));
+                expect(cb).toHaveBeenCalledTimes(1);
+                server.send(JSON.stringify(obj));
+                server.send(JSON.stringify(obj));
+                server.send(JSON.stringify(obj));
+                server.send(JSON.stringify(obj));
+                expect(cb).toHaveBeenCalledTimes(1);
+            }));
+            test('call (then remove) good callbacks on multiple requests', () => __awaiter(void 0, void 0, void 0, function* () {
+                // eslint-disable-next-line no-unused-vars
+                const client = new WebSocketAPI();
+                client.connect(`ws://foo:1234`);
+                yield server.connected;
+                const params = { channel: 'get', args: ['baz'], id: 'id' };
+                const cb = jest.fn();
+                const errorCb = jest.fn();
+                client.get(params, cb, errorCb);
+                const params2 = { channel: 'get', args: ['foo'], id: 'id' };
+                const cb2 = jest.fn();
+                const errorCb2 = jest.fn();
+                client.get(params2, cb2, errorCb2);
+                client.get(params, cb2, errorCb);
+                expect(cb).toHaveBeenCalledTimes(0);
+                const obj = { source: 'get baz', client_reference: 'id' };
+                server.send(JSON.stringify(obj));
+                expect(cb).toHaveBeenCalledTimes(1);
+                expect(cb2).toHaveBeenCalledTimes(1);
+                server.send(JSON.stringify({ source: 'get foo', client_reference: 'id' }));
+                expect(cb).toHaveBeenCalledTimes(1);
+                expect(cb2).toHaveBeenCalledTimes(2);
+            }));
+        });
+        describe('#subscribe', () => {
+            test('adds subscription to subscriptions array', () => __awaiter(void 0, void 0, void 0, function* () {
+                // eslint-disable-next-line no-unused-vars
+                const client = new WebSocketAPI();
+                client.connect(`ws://foo:1234`);
+                yield server.connected;
+                const params = { channel: 'bar', args: ['baz'], id: 'id' };
+                const cb = jest.fn();
+                const errorCb = jest.fn();
+                client.subscribe(params, cb, errorCb);
+                expect(client.subscriptions.length).toBe(1);
+                expect(client.subscriptions[0].params).toBe(params);
+                expect(client.subscriptions[0].cb).toBe(cb);
+                expect(client.subscriptions[0].errorCb).toBe(errorCb);
+                expect(client.subscriptions[0].quiet).toBe(false);
+                const obj = { source: 'bar baz', client_reference: 'id' };
+                server.send(JSON.stringify(obj));
+                expect(cb).toHaveBeenCalledTimes(1);
+                expect(cb).toHaveBeenCalledWith(obj);
+            }));
+            test("doesn't duplicate subscriptions", () => __awaiter(void 0, void 0, void 0, function* () {
+                // eslint-disable-next-line no-unused-vars
+                const client = new WebSocketAPI();
+                client.connect(`ws://foo:1234`);
+                yield server.connected;
+                const params = { channel: 'bar', args: ['baz'], id: 'id' };
+                const cb = jest.fn();
+                const errorCb = jest.fn();
+                client.subscribe(params, cb, errorCb, true);
+                client.subscribe(params, cb, errorCb, true);
+                expect(client.subscriptions.length).toBe(1);
+                const obj = { source: 'bar baz', client_reference: 'id' };
+                server.send(JSON.stringify(obj));
+                expect(cb).toHaveBeenCalledTimes(1);
+                expect(cb).toHaveBeenCalledWith(obj);
+            }));
+            test('send GET and SUB requests.', () => __awaiter(void 0, void 0, void 0, function* () {
+                // eslint-disable-next-line no-unused-vars
+                const client = new WebSocketAPI();
+                client.connect(`ws://foo:1234`);
+                client.send = jest.fn();
+                const params = { channel: 'bar', args: ['baz'], id: 'id' };
+                const cb = jest.fn();
+                const errorCb = jest.fn();
+                client.subscribe(params, cb, errorCb);
+                expect(client.send).toHaveBeenCalledTimes(2);
+                expect(client.send).toHaveBeenCalledWith('GET bar baz id');
+                expect(client.send).toHaveBeenCalledWith('SUB bar baz id');
+                client.send.mockRestore();
+            }));
+            test('should register callback without sending GET and SUB requests (quiet=true).', () => __awaiter(void 0, void 0, void 0, function* () {
+                // eslint-disable-next-line no-unused-vars
+                const client = new WebSocketAPI();
+                client.connect(`ws://foo:1234`);
+                yield server.connected;
+                const params = { channel: 'bar', args: ['baz'], id: 'id' };
+                const cb = jest.fn();
+                const errorCb = jest.fn();
+                client.send = jest.fn();
+                client.subscribe(params, cb, errorCb, true);
+                expect(client.subscriptions.length).toBe(1);
+                expect(client.subscriptions[0].params).toBe(params);
+                expect(client.subscriptions[0].cb).toBe(cb);
+                expect(client.subscriptions[0].errorCb).toBe(errorCb);
+                expect(client.subscriptions[0].quiet).toBe(true);
+                expect(client.send).toBeCalledTimes(0);
+                client.send.mockRestore();
+            }));
+        });
+        describe('#unsubscribe', () => {
+            test('should only unsubscribe the subscription using the good cb', () => __awaiter(void 0, void 0, void 0, function* () {
+                // eslint-disable-next-line no-unused-vars
+                const client = new WebSocketAPI();
+                client.connect(`ws://foo:1234`);
+                yield server.connected;
+                const params = { channel: 'foo', id: 'id' };
+                const cb = jest.fn();
+                const cb2 = jest.fn();
+                client.subscribe(params, cb);
+                client.subscribe(params, cb2);
+                expect(client.subscriptions.length).toBe(2);
+                expect(client.subscriptions[0].params).toBe(params);
+                expect(client.subscriptions[0].cb).toBe(cb);
+                expect(client.subscriptions[1].params).toBe(params);
+                expect(client.subscriptions[1].cb).toBe(cb2);
+                client.unsubscribe('foo', cb);
+                expect(client.subscriptions.length).toBe(1);
+                expect(cb).toHaveBeenCalledTimes(0);
+                expect(cb2).toHaveBeenCalledTimes(0);
+                const obj = { source: 'foo', client_reference: 'id' };
+                server.send(JSON.stringify(obj));
+                expect(cb2).toHaveBeenCalledTimes(1);
+                expect(cb).toHaveBeenCalledTimes(0);
+            }));
+            test('should unsubscribe all subscriptions related to a channel', () => {
+                // eslint-disable-next-line no-unused-vars
+                const client = new WebSocketAPI();
+                client.connect(`ws://foo:1234`);
+                client.websocket.removeEventListener = jest.fn();
+                client.websocket.addEventListener = jest.fn();
+                const params = { channel: 'foo' };
+                const params2 = { channel: 'bar' };
+                const cb = jest.fn();
+                const cb2 = jest.fn();
+                client.subscribe(params, cb);
+                client.subscribe(params, cb);
+                client.subscribe(params, cb);
+                client.subscribe(params, cb2);
+                client.subscribe(params2, cb2);
+                expect(client.subscriptions.length).toBe(3);
+                expect(client.websocket.removeEventListener).toBeCalledTimes(2);
+                expect(client.websocket.addEventListener.mock.calls.filter((c) => c[0] === 'message').length).toBe(5);
+                client.unsubscribe('foo');
+                expect(client.subscriptions.length).toBe(1);
+                expect(client.subscriptions[0].params).toBe(params2);
+                expect(client.subscriptions[0].cb).toBe(cb2);
+            });
+            test('send DEL when there is no more unquiet subscriptions on the channel', () => __awaiter(void 0, void 0, void 0, function* () {
+                // eslint-disable-next-line no-unused-vars
+                const client = new WebSocketAPI();
+                client.connect(`ws://foo:1234`);
+                yield server.connected;
+                client.send = jest.fn();
+                client.websocket.removeEventListener = jest.fn();
+                client.websocket.addEventListener = jest.fn();
+                const params = { channel: 'foo' };
+                const cb = jest.fn();
+                client.subscribe(params, cb);
+                expect(client.send).toHaveBeenCalledWith('GET foo');
+                expect(client.send).toHaveBeenCalledWith('SUB foo');
+                client.unsubscribe('foo');
+                expect(client.send).toHaveBeenCalledWith('DEL foo');
+            }));
+            test("doesn't send DEL when we unsubscribe a quiet channel", () => {
+                // eslint-disable-next-line no-unused-vars
+                const client = new WebSocketAPI();
+                client.connect(`ws://foo:1234`);
+                client.send = jest.fn();
+                client.websocket.removeEventListener = jest.fn();
+                client.websocket.addEventListener = jest.fn();
+                const params = { channel: 'foo' };
+                const cb = jest.fn();
+                client.subscribe(params, cb, null, true);
+                expect(cb).toHaveBeenCalledTimes(0);
+                client.unsubscribe('foo');
+                expect(cb).toHaveBeenCalledTimes(0);
+                client.send.mockRestore();
+            });
+        });
+    });
+});

package/common/controls/Control.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Control.test.d.ts.map

package/common/controls/Control.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Control.test.d.ts","sourceRoot":"","sources":["../../../src/common/controls/Control.test.js"],"names":[],"mappings":""}

package/common/controls/Control.test.js

@@ -0,0 +1,89 @@
+import Control from './Control';
+describe('Control', () => {
+    test('should be activated by default', () => {
+        const control = new Control();
+        expect(control.active).toBe(true);
+    });
+    test('should not be activated if set to false in the options', () => {
+        const control = new Control({ active: false });
+        expect(control.active).toBe(false);
+    });
+    test('should call activate/deactivate when active is set to true/false', () => {
+        const control = new Control();
+        const spy1 = jest.spyOn(control, 'activate');
+        const spy2 = jest.spyOn(control, 'deactivate');
+        const spy3 = jest.spyOn(control, 'render');
+        control.active = false;
+        expect(spy1).toBeCalledTimes(0);
+        expect(spy2).toBeCalledTimes(1);
+        expect(spy3).toBeCalledTimes(1);
+        control.active = true;
+        expect(spy1).toBeCalledTimes(1);
+        expect(spy2).toBeCalledTimes(2);
+        expect(spy3).toBeCalledTimes(2);
+    });
+    test('should append/remove the element to the map container when map is set', () => {
+        const element = document.createElement('div');
+        const target = document.createElement('div');
+        const control = new Control({
+            element,
+        });
+        const spy1 = jest.spyOn(control, 'activate');
+        const spy2 = jest.spyOn(control, 'deactivate');
+        const spy3 = jest.spyOn(control, 'render');
+        control.map = {
+            getContainer() {
+                return target;
+            },
+        };
+        expect(target.childNodes[0]).toBe(element);
+        expect(spy1).toBeCalledTimes(1);
+        expect(spy2).toBeCalledTimes(2);
+        expect(spy3).toBeCalledTimes(1);
+        control.detachFromMap();
+        expect(target.childNodes[0]).toBe();
+        expect(spy1).toBeCalledTimes(1);
+        expect(spy2).toBeCalledTimes(3);
+        expect(spy3).toBeCalledTimes(2);
+    });
+    test('should append/remove the element to the target property when map is set', () => {
+        const element = document.createElement('div');
+        const target = document.createElement('div');
+        const control = new Control({
+            target,
+            element,
+        });
+        const spy1 = jest.spyOn(control, 'activate');
+        const spy2 = jest.spyOn(control, 'deactivate');
+        const spy3 = jest.spyOn(control, 'render');
+        control.map = {};
+        expect(target.childNodes[0]).toBe(element);
+        expect(spy1).toBeCalledTimes(1);
+        expect(spy2).toBeCalledTimes(2);
+        expect(spy3).toBeCalledTimes(1);
+        control.detachFromMap();
+        expect(target.childNodes[0]).toBe();
+        expect(spy1).toBeCalledTimes(1);
+        expect(spy2).toBeCalledTimes(3);
+        expect(spy3).toBeCalledTimes(2);
+    });
+    test('set a custom render method', () => {
+        const spy = jest.fn();
+        // eslint-disable-next-line no-unused-vars
+        const control = new Control({
+            render: spy,
+        });
+        expect(spy).toBeCalledTimes(1);
+    });
+    test('pass function params to custom render method', () => {
+        const spy = jest.fn();
+        // eslint-disable-next-line no-unused-vars
+        const control = new Control({
+            render: spy,
+        });
+        control.render('foo', 'bar');
+        expect(spy).toBeCalledTimes(2);
+        expect(spy.mock.calls[1][0]).toBe('foo');
+        expect(spy.mock.calls[1][1]).toBe('bar');
+    });
+});

package/common/layers/Layer.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Layer.test.d.ts.map

package/common/layers/Layer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Layer.test.d.ts","sourceRoot":"","sources":["../../../src/common/layers/Layer.test.js"],"names":[],"mappings":""}

package/common/layers/Layer.test.js

@@ -0,0 +1,137 @@
+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 });
+        expect(layer).toBeInstanceOf(Layer);
+    });
+    test('should define default properties.', () => {
+        const options = {
+            name: 'Layer',
+            key: 'Layerkey',
+            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('Layerkey');
+        expect(layer.hitTolerance).toBe(5);
+        expect(layer.copyrights).toEqual([]);
+        expect(layer.visible).toBe(true);
+        expect(layer.properties).toEqual({});
+        expect(layer.map).toBe(undefined);
+        expect(layer.group).toBe(undefined);
+    });
+    test('should be visible by default.', () => {
+        const layer = new Layer();
+        expect(layer.visible).toBe(true);
+    });
+    test('should be hidden using constructor.', () => {
+        const layer = new Layer({ visible: false });
+        expect(layer.visible).toBe(false);
+    });
+    test('should be hidden using setter.', () => {
+        const layer = new Layer();
+        layer.visible = false;
+        expect(layer.visible).toBe(false);
+    });
+    test('should visibility stay unchanged', () => {
+        const layer = new Layer();
+        layer.visible = false;
+        expect(layer.visible).toBe(false);
+    });
+    test('should return its name.', () => {
+        const layer = new Layer({ name: 'Layer' });
+        expect(layer.name).toEqual('Layer');
+    });
+    test('should called detachFromMap on initialization.', () => {
+        const layer = new Layer();
+        const spy = jest.spyOn(layer, 'detachFromMap');
+        layer.attachToMap();
+        expect(spy).toHaveBeenCalledTimes(1);
+    });
+    test('should properties correctly set and get.', () => {
+        const layer = new Layer({
+            name: 'Layer',
+            olLayer,
+            properties: {
+                abc: 'foo',
+            },
+        });
+        expect(layer).toBeInstanceOf(Layer);
+        expect(layer.get('abc')).toEqual('foo');
+        layer.set('abc', 'bar');
+        expect(layer.get('abc')).toEqual('bar');
+    });
+    test('should set children', () => {
+        const layer = new Layer({
+            children: [new Layer(), new Layer()],
+        });
+        expect(layer.children.length).toBe(2);
+        expect(layer.children[0].parent).toBe(layer);
+        expect(layer.children[1].parent).toBe(layer);
+    });
+    test('should initialize copyrights property.', () => {
+        const layer = new Layer({
+            name: 'Layer',
+            olLayer,
+            copyrights: ['&copy: copyright', 'another copyright'],
+        });
+        expect(layer.copyrights[0]).toEqual('&copy: copyright');
+    });
+    test('should set and get copyright property.', () => {
+        const layer = new Layer({
+            name: 'Layer',
+            olLayer,
+        });
+        expect(layer).toBeInstanceOf(Layer);
+        expect(layer.copyright).toEqual(undefined);
+        layer.copyright = '© OSM Contributors';
+        expect(layer.copyright).toEqual('© OSM Contributors');
+    });
+    describe('#attachToMap()', () => {
+        test('should set map.', () => {
+            const layer = new Layer({
+                name: 'Layer',
+                olLayer,
+            });
+            expect(layer.map).toBe(undefined);
+            const obj = {};
+            layer.attachToMap(obj);
+            expect(layer.map).toBe(obj);
+        });
+        test('should call terminate.', () => {
+            const layer = new Layer({
+                name: 'Layer',
+                olLayer,
+            });
+            const spy = jest.spyOn(layer, 'detachFromMap');
+            layer.attachToMap();
+            expect(spy).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('#getFeatureInfoAtCoordinate()', () => {
+        test('return an empty fetaureInfo object and display an error message', (done) => {
+            // eslint-disable-next-line no-console
+            console.error = jest.fn();
+            const layer = new Layer({
+                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();
+            });
+        });
+    });
+});

package/common/mixins/UserInteractionsLayerMixin.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=UserInteractionsLayerMixin.test.d.ts.map

package/common/mixins/UserInteractionsLayerMixin.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UserInteractionsLayerMixin.test.d.ts","sourceRoot":"","sources":["../../../src/common/mixins/UserInteractionsLayerMixin.test.js"],"names":[],"mappings":""}