MinervaPluginProxy-test.js

"use strict";

require("../mocha-config");

var Alias = require('../../../main/js/map/data/Alias');
var DataOverlay = require('../../../main/js/map/data/DataOverlay');
var MinervaPluginProxy = require('../../../main/js/plugin/MinervaPluginProxy');
var ServerConnector = require('../ServerConnector-mock');

var logger = require('../logger');

var chai = require('chai');
var assert = chai.assert;

function createProxy(map) {
  return new MinervaPluginProxy({
    hash: "8f2112859d40de86dacc1994a224ea3d",
    map: map,
    element: testDiv,
    pluginId: "xx",
    configuration: helper.getConfiguration()
  });
}

describe('MinervaPluginProxy', function () {
  it('constructor', function () {
    var map = helper.createCustomMap();
    var proxy = new MinervaPluginProxy({
      map: map,
      element: testDiv,
      pluginId: "xx",
      configuration: helper.getConfiguration()
    });
    assert.ok(proxy);
    assert.ok(proxy.pluginId);
    assert.ok(proxy.element);
    assert.ok(proxy.project);
    assert.ok(proxy.configuration);
    assert.equal(0, logger.getWarnings().length);
  });

  it('add search listener', function () {
    var callbackOk = false;
    var map;
    return ServerConnector.getProject().then(function (project) {
      map = helper.createCustomMap(project);
      helper.createSearchDbOverlay(map);
      var proxy = createProxy(map);

      proxy.project.map.addListener({
        dbOverlayName: "search",
        type: "onSearch",
        callback: function (elements) {
          assert.ok(elements.length > 0);
          assert.ok(elements[0].length !== undefined, "Array of arrays expected as onSearch result");
          callbackOk = true;
        }
      });
      return map.getOverlayByName("search").searchByQuery("s1");
    }).then(function () {
      assert.ok(callbackOk);
      callbackOk = false;
      return map.getOverlayByName("search").searchByQuery("s1");
    }).then(function () {
      assert.ok(callbackOk);
      callbackOk = false;
      var params = {
        coordinates: new google.maps.Point(184.79, 365.76),
        zoom: 2,
        modelId: map.getProject().getModel().getId()
      };
      return map.getOverlayByName("search").searchByCoordinates(params);
    }).then(function () {
      assert.ok(callbackOk);
      return map.destroy();
    });
  });

  describe('removeListener', function () {
    it('valid listener', function () {
      var callbackOk = false;
      var map, options;
      return ServerConnector.getProject().then(function (project) {
        map = helper.createCustomMap(project);
        helper.createSearchDbOverlay(map);
        var proxy = createProxy(map);

        options = {
          dbOverlayName: "search",
          type: "onSearch",
          callback: function (elements) {
            assert.ok(elements.length > 0);
            assert.ok(elements[0].length !== undefined, "Array of arrays expected as onSearch result");
            callbackOk = true;
          }
        };
        proxy.project.map.addListener(options);
        proxy.project.map.removeListener(options);
        assert.equal(0, logger.getWarnings().length);
        return map.destroy();
      });
    });
    it('unknown listener', function () {
      var callbackOk = false;
      var map, options;
      return ServerConnector.getProject().then(function (project) {
        map = helper.createCustomMap(project);
        helper.createSearchDbOverlay(map);
        var proxy = createProxy(map);

        options = {
          dbOverlayName: "search",
          type: "onSearch",
          callback: function (elements) {
            assert.ok(elements.length > 0);
            assert.ok(elements[0].length !== undefined, "Array of arrays expected as onSearch result");
            callbackOk = true;
          }
        };
        proxy.project.map.addListener(options);
        proxy.project.map.removeListener({});
      }).then(function () {
        assert.notOk("Exception expected");
      }, function (error) {
        assert.ok(error.message.indexOf("Listener doesn't exist") >= 0);

        return map.destroy();
      });
    });
  });
  describe('removeAllListeners', function () {
    it('valid listener', function () {
      var callbackOk = false;
      var map, options;
      return ServerConnector.getProject().then(function (project) {
        map = helper.createCustomMap(project);
        helper.createSearchDbOverlay(map);
        var proxy = createProxy(map);

        options = {
          dbOverlayName: "search",
          type: "onSearch",
          callback: function (elements) {
            assert.ok(elements.length > 0);
            assert.ok(elements[0].length !== undefined, "Array of arrays expected as onSearch result");
            callbackOk = true;
          }
        };
        proxy.project.map.addListener(options);
        var removedListeners = proxy.project.map.removeAllListeners();
        assert.equal(1, removedListeners.length);
        return map.destroy();
      });
    });
    it('no listeners', function () {
      var map;
      return ServerConnector.getProject().then(function (project) {
        map = helper.createCustomMap(project);
        helper.createSearchDbOverlay(map);
        var proxy = createProxy(map);
        var removedListeners = proxy.project.map.removeAllListeners();
        assert.equal(0, removedListeners.length);
        return map.destroy();
      });
    });
  });

  describe("getBioEntityById", function () {
    it("for alias", function () {
      var map, proxy;
      return ServerConnector.getProject().then(function (project) {
        map = helper.createCustomMap(project);
        proxy = createProxy(map);
        return proxy.project.data.getBioEntityById({
          id: 329177,
          modelId: 15781,
          type: "ALIAS"
        });
      }).then(function (result) {
        assert.ok(result);
      }).then(function () {
        map.destroy();
      });
    });

    it("for reaction", function () {
      var map, proxy;
      return ServerConnector.getProject().then(function (project) {
        map = helper.createCustomMap(project);
        proxy = createProxy(map);
        return proxy.project.data.getBioEntityById({
          id: 153508,
          modelId: 15781,
          type: "REACTION"
        });
      }).then(function (result) {
        assert.ok(result);
        assert.ok(result.getReactants()[0] instanceof Alias);
      }).then(function () {
        map.destroy();
      });
    });
  });

  describe("showElement", function () {
    it("alias", function () {
      var elementToShow = {
        element: {
          id: 329171,
          modelId: 15781,
          type: "ALIAS"
        },
        type: "ICON"
      };

      var elementToShow2 = {
        element: {
          id: 329171,
          modelId: 15781,
          type: "ALIAS"
        },
        type: "SURFACE",
        options: {
          color: "#FF0000"
        }
      };
      var map, proxy;
      return ServerConnector.getProject().then(function (project) {
        map = helper.createCustomMap(project);
        proxy = createProxy(map);
        return proxy.project.map.showBioEntity(elementToShow);
      }).then(function () {
        return proxy.project.map.getHighlightedBioEntities();
      }).then(function (elements) {
        assert.equal(elements.length, 1);
        return proxy.project.map.showBioEntity(elementToShow2);
      }).then(function () {
        return proxy.project.map.getHighlightedBioEntities();
      }).then(function (elements) {
        assert.equal(elements.length, 2);
        return proxy.project.map.hideBioEntity(elementToShow);
      }).then(function () {
        return proxy.project.map.getHighlightedBioEntities();
      }).then(function (elements) {
        assert.equal(elements.length, 1);
        return proxy.project.map.hideBioEntity(elementToShow2);
      }).then(function () {
        return proxy.project.map.getHighlightedBioEntities();
      }).then(function (elements) {
        assert.equal(elements.length, 0);
        map.destroy();
      });
    });

    it("show twice", function () {
      var elementToShow = {
        element: {
          id: 329171,
          modelId: 15781,
          type: "ALIAS"
        },
        type: "ICON"
      };
      var elementToShow2 = {
        element: {
          id: 329171,
          modelId: 15781,
          type: "ALIAS"
        },
        type: "SURFACE",
        options: {
          color: "#FF0000"
        }
      };

      var map, proxy;
      return ServerConnector.getProject().then(function (project) {
        map = helper.createCustomMap(project);
        proxy = createProxy(map);
        proxy.project.map.showBioEntity(elementToShow);
        return proxy.project.map.showBioEntity(elementToShow2);
      }).then(function () {
        map.destroy();
        assert.ok(false, "Should be rejected due to fact that there is show in progress");
      }, function (error) {
        assert.ok(error.message.indexOf("wait until previous Promise for showBioEntity/hideBioEntity is resolved") >= 0);
        map.destroy();
      });
    });
  });

  it("setCenter", function () {
    var map, proxy;
    return ServerConnector.getProject().then(function (project) {
      map = helper.createCustomMap(project);
      proxy = createProxy(map);
      return proxy.project.map.setCenter({
        modelId: 15781,
        x: 10,
        y: 20
      });
    }).then(function () {
      var sessionData = ServerConnector.getSessionData(map.getProject());
      var center = sessionData.getCenter(map.getProject().getModel());
      assert.ok(center instanceof google.maps.Point);
      assert.closeTo(parseFloat(center.x), 10, helper.EPSILON);
      assert.closeTo(parseFloat(center.y), 20, helper.EPSILON);
    }).then(function () {
      map.destroy();
    });
  });

  it("getCenter", function () {
    var map, proxy;
    return ServerConnector.getProject().then(function (project) {
      map = helper.createCustomMap(project);
      proxy = createProxy(map);
      return proxy.project.map.setCenter({
        modelId: 15781,
        x: 10,
        y: 20
      });
    }).then(function () {
      var center = proxy.project.map.getCenter({modelId: 15781});
      assert.ok(center instanceof google.maps.Point);
      assert.closeTo(parseFloat(center.x), 10, helper.EPSILON);
      assert.closeTo(parseFloat(center.y), 20, helper.EPSILON);
    }).then(function () {
      map.destroy();
    });
  });

  it("setZoom", function () {
    var map, proxy;
    return ServerConnector.getProject().then(function (project) {
      map = helper.createCustomMap(project);
      proxy = createProxy(map);
      return proxy.project.map.setZoom({
        modelId: 15781,
        zoom: 10
      });
    }).then(function () {
      var sessionData = ServerConnector.getSessionData(map.getProject());
      var zoom = sessionData.getZoomLevel(map.getProject().getModel());
      assert.equal(zoom, 10);
    }).then(function () {
      map.destroy();
    });
  });

  it("getZoom", function () {
    var map, proxy;
    return ServerConnector.getProject().then(function (project) {
      map = helper.createCustomMap(project);
      proxy = createProxy(map);
      return proxy.project.map.setZoom({
        modelId: 15781,
        zoom: 10
      });
    }).then(function () {
      var zoom = proxy.project.map.getZoom({modelId: 15781});
      assert.equal(zoom, 10);
    }).then(function () {
      map.destroy();
    });
  });

  it("getReactionByParticipantId", function () {
    var ie = {
      modelId: 15781,
      type: "ALIAS",
      id: 329167
    };

    var map, proxy;
    return ServerConnector.getProject().then(function (project) {
      map = helper.createCustomMap(project);
      proxy = createProxy(map);
      return proxy.project.data.getReactionsWithElement(ie);
    }).then(function (reactions) {
      assert.equal(reactions.length, 5);
    }).then(function () {
      map.destroy();
    });

  });

  it("getAllBioEntities", function () {
    var map, proxy;
    return ServerConnector.getProject().then(function (project) {
      map = helper.createCustomMap(project);
      proxy = createProxy(map);
      return proxy.project.data.getAllBioEntities();
    }).then(function (result) {
      assert.ok(result);
      assert.ok(result.length > 0);
    }).then(function () {
      map.destroy();
    });
  });

  describe("configuration", function () {
    it("elementTypes", function () {
      var map, proxy;
      return ServerConnector.getProject().then(function (project) {
        map = helper.createCustomMap(project);
        proxy = createProxy(map);
        assert.ok(proxy.configuration.elementTypes.length > 0);
        map.destroy();
      });
    });
  });

  it("fitBounds", function () {
    var map, proxy;
    return ServerConnector.getProject().then(function (project) {
      map = helper.createCustomMap(project);
      proxy = createProxy(map);
      var center = map.getGoogleMap().getCenter();
      proxy.project.map.fitBounds({
        id: 329177,
        modelId: 15781,
        type: "ALIAS"
      });
      var center2 = map.getGoogleMap().getCenter();
      assert.ok(center.lat() !== center2.lat() || center.lng() !== center2.lng());
    }).then(function () {
      map.destroy();
    });
  });

  it("getProjectId", function () {
    return ServerConnector.getProject().then(function (project) {
      var map = helper.createCustomMap(project);
      var proxy = createProxy(map);
      assert.equal("sample", proxy.project.data.getProjectId());
      map.destroy();
    });
  });
  it("getName", function () {
    return ServerConnector.getProject().then(function (project) {
      var map = helper.createCustomMap(project);
      var proxy = createProxy(map);
      assert.equal("UNKNOWN DISEASE MAP", proxy.project.data.getName());
      map.destroy();
    });
  });
  it("getVersion", function () {
    return ServerConnector.getProject().then(function (project) {
      var map = helper.createCustomMap(project);
      var proxy = createProxy(map);
      assert.equal("0", proxy.project.data.getVersion());
      map.destroy();
    });
  });
  it("getDisease", function () {
    return ServerConnector.getProject().then(function (project) {
      var map = helper.createCustomMap(project);
      var proxy = createProxy(map);
      assert.ok(proxy.project.data.getDisease());
      map.destroy();
    });
  });
  it("getOrganism", function () {
    return ServerConnector.getProject().then(function (project) {
      var map = helper.createCustomMap(project);
      var proxy = createProxy(map);
      assert.ok(proxy.project.data.getOrganism());
      map.destroy();
    });
  });
  it("getModels", function () {
    return ServerConnector.getProject().then(function (project) {
      var map = helper.createCustomMap(project);
      var proxy = createProxy(map);
      assert.equal(1, proxy.project.data.getModels().length);
      map.destroy();
    });
  });

  describe("plugin params", function () {
    it("getGlobalParam", function () {
      var map;
      return ServerConnector.getProject().then(function (project) {
        map = helper.createCustomMap(project);
        var proxy = createProxy(map);
        return proxy.pluginData.getGlobalParam("test");
      }).then(function (result) {
        assert.ok(result);
        map.destroy();
      });
    });
    it("setGlobalParam", function () {
      var map;
      return ServerConnector.getProject().then(function (project) {
        map = helper.createCustomMap(project);
        var proxy = createProxy(map);
        return proxy.pluginData.setGlobalParam("test", "y");
      }).then(function (result) {
        assert.ok(result);
        map.destroy();
      });
    });
    it("getUserParam", function () {
      var map;
      return ServerConnector.getProject().then(function (project) {
        map = helper.createCustomMap(project);
        var proxy = createProxy(map);
        return proxy.pluginData.getUserParam("test2");
      }).then(function (result) {
        assert.ok(result);
        map.destroy();
      });
    });
    it("setUserParam", function () {
      var map;
      return ServerConnector.getProject().then(function (project) {
        map = helper.createCustomMap(project);
        var proxy = createProxy(map);
        return proxy.pluginData.setUserParam("test2", "y");
      }).then(function (result) {
        assert.ok(result);
        map.destroy();
      });
    });
  });

  describe('addListener', function () {
    it('on show overlay', function () {
      var callbackOk = false;
      var map;
      return ServerConnector.getProject().then(function (project) {
        map = helper.createCustomMap(project);
        helper.createSearchDbOverlay(map);
        var proxy = createProxy(map);

        proxy.project.map.addListener({
          object: "overlay",
          type: "onShow",
          callback: function (overlay) {
            assert.ok(overlay instanceof DataOverlay);
            callbackOk = true;
          }
        });
        return map.openDataOverlay(map.getProject().getDataOverlays()[0]);
      }).then(function () {
        assert.ok(callbackOk);
        return map.destroy();
      });
    });
    it('on hide overlay', function () {
      var callbackOk = false;
      var map;
      return ServerConnector.getProject().then(function (project) {
        map = helper.createCustomMap(project);
        helper.createSearchDbOverlay(map);
        var proxy = createProxy(map);

        proxy.project.map.addListener({
          object: "overlay",
          type: "onHide",
          callback: function (overlay) {
            assert.ok(overlay instanceof DataOverlay);
            callbackOk = true;
          }
        });
        return map.openDataOverlay(18077);
      }).then(function () {
        assert.notOk(callbackOk);
        return map.hideDataOverlay(18077);
      }).then(function () {
        assert.ok(callbackOk);
        return map.destroy();
      });
    });
    it('on zoom changed', function () {
      var callbackOk = false;
      var map;
      return ServerConnector.getProject().then(function (project) {
        map = helper.createCustomMap(project);
        helper.createSearchDbOverlay(map);
        var proxy = createProxy(map);

        proxy.project.map.addListener({
          object: "map",
          type: "onZoomChanged",
          callback: function (data) {
            assert.equal(map.getId(), data.modelId);
            assert.equal(4, data.zoom);
            callbackOk = true;
          }
        });
        return map.setZoom(4);
      }).then(function () {
        assert.ok(callbackOk);
        return map.destroy();
      });
    });
  });


});