mobility-toolbox-js 2.0.0-beta.30 → 2.0.0-beta.34

package/common/api/WebSocketAPI.test.js

@@ -1,311 +0,0 @@
-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.", async () => {
-        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", async () => {
-        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();
-        await 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.", async () => {
-        const client = new WebSocketAPI();
-        client.connect(`ws://foo:1234`);
-        await server.connected;
-        client.send("hello");
-        await expect(server).toReceiveMessage("hello");
-        expect(server).toHaveReceivedMessages(["hello"]);
-      });
-      test("close previous connection.", async () => {
-        const client = new WebSocketAPI();
-        client.connect(`ws://foo:1234`);
-        await 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", async () => {
-        const onOpen = jest.fn();
-        const client = new WebSocketAPI();
-        client.subscribe = jest.fn();
-        client.connect(`ws://foo:1234`, onOpen);
-        await server.connected;
-        expect(client.websocket.readyState).toBe(WebSocket.OPEN);
-        expect(onOpen).toHaveBeenCalledTimes(1);
-      });
-      test("subscribe previous subscriptions on open (quiet or not)", async () => {
-        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`);
-        await server.connected;
-        expect(client.websocket.readyState).toBe(WebSocket.OPEN);
-        expect(client.subscribe).toHaveBeenCalledTimes(2);
-        client.subscribe.mockReset();
-        client.connect(`ws://foo:12345`);
-        await 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", async () => {
-        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();
-        await 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();
-        await server2.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"]);
-      });
-      test("doesn	 send GET and SUB for quiet previous subscriptions", async () => {
-        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();
-        await 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();
-        await server2.connected;
-        expect(client.websocket.readyState).toBe(WebSocket.OPEN);
-        expect(client.send).toHaveBeenCalledTimes(0);
-      });
-    });
-    describe("#subscribe", () => {
-      test("adds subscription to subscriptions array", async () => {
-        const client = new WebSocketAPI();
-        client.connect(`ws://foo:1234`);
-        await 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", async () => {
-        const client = new WebSocketAPI();
-        client.connect(`ws://foo:1234`);
-        await 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.", async () => {
-        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).", async () => {
-        const client = new WebSocketAPI();
-        client.connect(`ws://foo:1234`);
-        await 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", async () => {
-        const client = new WebSocketAPI();
-        client.connect(`ws://foo:1234`);
-        await 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", () => {
-        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", async () => {
-        const client = new WebSocketAPI();
-        client.connect(`ws://foo:1234`);
-        await 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", () => {
-        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.js

@@ -1,87 +0,0 @@
-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();
-    const control = new Control({
-      render: spy
-    });
-    expect(spy).toBeCalledTimes(1);
-  });
-  test("pass function params to custom render method", () => {
-    const spy = jest.fn();
-    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.js

@@ -1,134 +0,0 @@
-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(void 0);
-    expect(layer.group).toBe(void 0);
-  });
-  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(void 0);
-    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(void 0);
-      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) => {
-      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);
-        expect(console.error).toHaveBeenCalledTimes(1);
-        done();
-        console.error.mockRestore();
-      });
-    });
-  });
-});