654 lines
22 KiB
JavaScript
654 lines
22 KiB
JavaScript
var _ = require('underscore');
|
|
var Backbone = require('backbone');
|
|
var deepInsightsIntegrationSpecHelpers = require('./deep-insights-integration-spec-helpers');
|
|
var WidgetsIntegration = require('builder/deep-insights-integration/widgets-integration');
|
|
var WidgetsService = require('builder/editor/widgets/widgets-service');
|
|
var LayerDefinitionModel = require('builder/data/layer-definition-model');
|
|
|
|
function flattenObject (object) { // To avoid infinite loop in Jasmine while checking an object with source AnalysisModel against jasmine.objectContaining
|
|
return JSON.parse(JSON.stringify(object));
|
|
}
|
|
|
|
describe('deep-insights-integrations/widgets-integration', function () {
|
|
var mapElement;
|
|
var setSelectedSpy;
|
|
|
|
beforeAll(function () {
|
|
spyOn(_, 'debounce').and.callFake(function (func) {
|
|
return function () {
|
|
func.apply(this, arguments);
|
|
};
|
|
});
|
|
|
|
spyOn(_, 'delay').and.callFake(function (func) {
|
|
return function () {
|
|
func.apply(this, arguments);
|
|
};
|
|
});
|
|
});
|
|
|
|
beforeEach(function (done) {
|
|
jasmine.Ajax.install();
|
|
|
|
// Mock Map instantiation response
|
|
jasmine.Ajax.stubRequest(new RegExp(/api\/v1\/map/)).andReturn({
|
|
status: 200,
|
|
contentType: 'application/json; charset=utf-8',
|
|
responseText: '{ "layergroupid": "123456789", "metadata": { "layers": [] } }'
|
|
});
|
|
|
|
var onDashboardCreated = function (dashboard) {
|
|
var fakeObjects = deepInsightsIntegrationSpecHelpers.createFakeObjects(dashboard);
|
|
_.extend(this, fakeObjects);
|
|
|
|
spyOn(this.diDashboardHelpers.getDashboard(), 'onStateChanged').and.callThrough();
|
|
spyOn(this.stateDefinitionModel, 'updateState');
|
|
spyOn(WidgetsIntegration, '_invalidateSize');
|
|
setSelectedSpy = spyOn(WidgetsIntegration, '_setSelectedWidget');
|
|
|
|
// Track map integration
|
|
this.integration = WidgetsIntegration.track({
|
|
diDashboardHelpers: this.diDashboardHelpers,
|
|
layerDefinitionsCollection: this.layerDefinitionsCollection,
|
|
widgetDefinitionsCollection: this.widgetDefinitionsCollection,
|
|
analysisDefinitionNodesCollection: this.analysisDefinitionNodesCollection
|
|
});
|
|
|
|
done();
|
|
}.bind(this);
|
|
|
|
mapElement = deepInsightsIntegrationSpecHelpers.createFakeDOMElement();
|
|
|
|
deepInsightsIntegrationSpecHelpers.createFakeDashboard(mapElement, onDashboardCreated);
|
|
});
|
|
|
|
afterEach(function () {
|
|
this.integration._widgetDefinitionsCollection.off();
|
|
this.integration = null;
|
|
document.body.removeChild(mapElement);
|
|
jasmine.Ajax.uninstall();
|
|
});
|
|
|
|
describe('when a widget-definition is created', function () {
|
|
beforeEach(function () {
|
|
spyOn(this.integration, '_bindWidgetChanges').and.callThrough();
|
|
spyOn(this.diDashboardHelpers.getDashboard(), 'createFormulaWidget').and.callThrough();
|
|
spyOn(WidgetsService, 'editWidget');
|
|
spyOn(WidgetsService, 'removeWidget');
|
|
|
|
this.model = this.widgetDefinitionsCollection.add({
|
|
id: 'w-100',
|
|
type: 'formula',
|
|
title: 'avg of something',
|
|
layer_id: 'l-1',
|
|
source: {
|
|
id: 'a0'
|
|
},
|
|
options: {
|
|
column: 'col',
|
|
operation: 'avg'
|
|
}
|
|
});
|
|
this.model.trigger('sync', this.model);
|
|
});
|
|
|
|
afterEach(function () {
|
|
// delete widget after test case
|
|
this.widgetModel = this.diDashboardHelpers.getWidget(this.model.id);
|
|
spyOn(this.widgetModel, 'remove').and.callThrough();
|
|
|
|
// Fake deletion
|
|
this.model.trigger('destroy', this.model);
|
|
expect(this.widgetModel.remove).toHaveBeenCalled();
|
|
});
|
|
|
|
it('should bind widgets changes', function () {
|
|
expect(this.integration._bindWidgetChanges).toHaveBeenCalled();
|
|
});
|
|
|
|
it('should call widgets service properly', function () {
|
|
var widget = this.diDashboardHelpers.getWidget(this.model.id);
|
|
widget.trigger('editWidget', widget);
|
|
expect(WidgetsService.editWidget).toHaveBeenCalled();
|
|
|
|
widget.trigger('removeWidget', widget);
|
|
expect(WidgetsService.removeWidget).toHaveBeenCalled();
|
|
});
|
|
|
|
it('should create the corresponding widget model for the dashboard', function () {
|
|
expect(this.diDashboardHelpers.getDashboard().createFormulaWidget).toHaveBeenCalled();
|
|
|
|
var args = this.diDashboardHelpers.getDashboard().createFormulaWidget.calls.argsFor(0);
|
|
var flattenedObject = flattenObject(args[0]);
|
|
expect(flattenedObject).toEqual(jasmine.objectContaining({
|
|
title: 'avg of something',
|
|
layer_id: 'l-1',
|
|
column: 'col',
|
|
operation: 'avg'
|
|
}));
|
|
expect(flattenedObject.source).toBeDefined();
|
|
expect(flattenedObject.source.id).toEqual('a0');
|
|
expect(args[1]).toBe(this.diDashboardHelpers.getLayers().first());
|
|
});
|
|
|
|
it('should enable show_stats and show_options for the created widget model', function () {
|
|
var widgetModel = this.diDashboardHelpers.getWidget(this.model.id);
|
|
expect(widgetModel.get('show_stats')).toBeTruthy();
|
|
expect(widgetModel.get('show_options')).toBeTruthy();
|
|
});
|
|
|
|
describe('when definition changes data', function () {
|
|
beforeEach(function () {
|
|
this.widgetModel = this.diDashboardHelpers.getWidget(this.model.id);
|
|
spyOn(this.widgetModel, 'update');
|
|
});
|
|
|
|
describe('of any normal param', function () {
|
|
beforeEach(function () {
|
|
this.model.set('operation', 'max');
|
|
});
|
|
|
|
it('should update the corresponding widget model', function () {
|
|
expect(this.widgetModel.update).toHaveBeenCalled();
|
|
expect(this.widgetModel.update).toHaveBeenCalledWith({ operation: 'max' });
|
|
});
|
|
});
|
|
|
|
describe('of the source', function () {
|
|
beforeEach(function () {
|
|
spyOn(this.diDashboardHelpers, 'getAnalysisByNodeId').and.returnValue({
|
|
id: 'a1',
|
|
cid: 'c808'
|
|
});
|
|
this.model.set({
|
|
operation: 'max',
|
|
source: 'a1'
|
|
});
|
|
});
|
|
|
|
it('should maintain normal params but massage the source', function () {
|
|
expect(this.widgetModel.update).toHaveBeenCalledWith({
|
|
operation: 'max',
|
|
source: {
|
|
id: 'a1',
|
|
cid: 'c808'
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('color', function () {
|
|
it('should set widget color changed to true', function () {
|
|
expect(this.model.get('widget_color_changed')).toBe(false);
|
|
this.model.set({
|
|
widget_style_definition: {
|
|
color: {
|
|
fixed: '#fabada',
|
|
opacity: 1
|
|
}
|
|
}
|
|
});
|
|
expect(this.model.get('widget_color_changed')).toBe(true);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('when definition changes type', function () {
|
|
beforeEach(function () {
|
|
this.widgetModel = this.diDashboardHelpers.getWidget(this.model.id);
|
|
spyOn(this.widgetModel, 'remove').and.callThrough();
|
|
spyOn(this.diDashboardHelpers.getDashboard(), 'createCategoryWidget').and.callThrough();
|
|
|
|
this.model.set('type', 'category');
|
|
});
|
|
|
|
it('should remove the corresponding widget model', function () {
|
|
expect(this.widgetModel.remove).toHaveBeenCalled();
|
|
});
|
|
|
|
describe('should create a new widget model for the type', function () {
|
|
beforeEach(function () {
|
|
expect(this.diDashboardHelpers.getDashboard().createCategoryWidget).toHaveBeenCalled();
|
|
// Same ceation flow as previously tested, so don't test more into detail for now
|
|
expect(this.diDashboardHelpers.getDashboard().createCategoryWidget).toHaveBeenCalledWith(jasmine.any(Object), jasmine.any(Object));
|
|
});
|
|
|
|
it('with new attrs', function () {
|
|
var widget = this.diDashboardHelpers.getDashboard().createCategoryWidget.calls.argsFor(0)[0];
|
|
var flattenedWidget = flattenObject(widget);
|
|
expect(flattenedWidget).toEqual(
|
|
jasmine.objectContaining({
|
|
id: 'w-100',
|
|
type: 'category'
|
|
})
|
|
);
|
|
expect(flattenedWidget.source).toBeDefined();
|
|
expect(flattenedWidget.source.id).toEqual('a0');
|
|
});
|
|
|
|
it('with prev layer-defintion', function () {
|
|
expect(this.diDashboardHelpers.getDashboard().createCategoryWidget.calls.argsFor(0)[1].id).toEqual('l-1');
|
|
});
|
|
});
|
|
|
|
it('should set show_stats in the new widget model', function () {
|
|
var widgetModel = this.diDashboardHelpers.getDashboard().getWidget(this.model.id);
|
|
expect(widgetModel.get('show_stats')).toBeTruthy();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('autoStyle', function () {
|
|
var category;
|
|
var histogram;
|
|
var layerDefinitionModel;
|
|
var nodeDefinitionModel;
|
|
var originalAjax;
|
|
|
|
beforeEach(function () {
|
|
originalAjax = Backbone.ajax;
|
|
Backbone.ajax = function () {
|
|
return {
|
|
always: function (cb) {
|
|
cb();
|
|
}
|
|
};
|
|
};
|
|
|
|
this.a0 = this.analysisDefinitionNodesCollection.add({
|
|
id: 'a0',
|
|
type: 'source',
|
|
params: {
|
|
query: 'SELECT * FROM foobar'
|
|
}
|
|
});
|
|
|
|
var nodeMod = this.diDashboardHelpers.analyse(this.a0.toJSON());
|
|
|
|
layerDefinitionModel = this.layerDefinitionsCollection.add({
|
|
id: 'integration-test',
|
|
kind: 'carto',
|
|
options: {
|
|
table_name: 'something',
|
|
cartocss: '#layer {}',
|
|
source: 'a0',
|
|
tile_style: '#layer {}'
|
|
}
|
|
});
|
|
|
|
// We have to add the analysis and the layer manually due to in this class
|
|
// there is no bindings for those purposes (layers-integration will have it)
|
|
var visMap = this.diDashboardHelpers.visMap();
|
|
var attrs = layerDefinitionModel.toJSON();
|
|
attrs.source = nodeMod;
|
|
attrs.cartocss = attrs.options.tile_style;
|
|
visMap.createCartoDBLayer(attrs);
|
|
|
|
spyOn(layerDefinitionModel.styleModel, 'resetPropertiesFromAutoStyle').and.callThrough();
|
|
spyOn(layerDefinitionModel.styleModel, 'setPropertiesFromAutoStyle').and.callThrough();
|
|
|
|
nodeDefinitionModel = layerDefinitionModel.getAnalysisDefinitionNodeModel();
|
|
nodeDefinitionModel.set('simple_geom', 'point');
|
|
|
|
category = this.widgetDefinitionsCollection.add({
|
|
id: 'as1',
|
|
type: 'category',
|
|
title: 'category',
|
|
layer_id: 'integration-test',
|
|
options: {
|
|
column: 'col'
|
|
},
|
|
source: {
|
|
id: 'a0'
|
|
}
|
|
});
|
|
category.trigger('sync', category);
|
|
|
|
histogram = this.widgetDefinitionsCollection.add({
|
|
id: 'as2',
|
|
type: 'histogram',
|
|
title: 'histogram',
|
|
layer_id: 'integration-test',
|
|
options: {
|
|
column: 'col'
|
|
},
|
|
source: {
|
|
id: 'a0'
|
|
}
|
|
});
|
|
histogram.trigger('sync', histogram);
|
|
});
|
|
|
|
afterEach(function () {
|
|
Backbone.ajax = originalAjax;
|
|
category.trigger('destroy', category);
|
|
histogram.trigger('destroy', category);
|
|
});
|
|
|
|
it('should cancel autostyle on remove widget', function () {
|
|
var model = this.diDashboardHelpers.getWidget(category.id);
|
|
spyOn(model, 'cancelAutoStyle');
|
|
model.set({autoStyle: true});
|
|
|
|
category.trigger('destroy', category);
|
|
expect(model.cancelAutoStyle).toHaveBeenCalled();
|
|
});
|
|
|
|
it('should update layer definition model\'s autostyle properly', function () {
|
|
var model = this.diDashboardHelpers.getWidget(category.id);
|
|
model.set({autoStyle: true});
|
|
expect(layerDefinitionModel.get('autoStyle')).toBe(model.id);
|
|
expect(layerDefinitionModel.styleModel.setPropertiesFromAutoStyle).toHaveBeenCalled();
|
|
|
|
model.set({autoStyle: false});
|
|
expect(layerDefinitionModel.get('autoStyle')).toBe(false);
|
|
expect(layerDefinitionModel.styleModel.resetPropertiesFromAutoStyle).toHaveBeenCalled();
|
|
});
|
|
|
|
it('should update layer definition model\'s previousCartoCSS only if not autoStyle applied', function () {
|
|
layerDefinitionModel.attributes.cartocss = 'wadus';
|
|
|
|
spyOn(layerDefinitionModel, 'set').and.callThrough();
|
|
var categoryModel = this.diDashboardHelpers.getWidget(category.id);
|
|
var histogramModel = this.diDashboardHelpers.getWidget(histogram.id);
|
|
|
|
spyOn(categoryModel, 'getAutoStyle').and.returnValue({
|
|
cartocss: '#dummy {}',
|
|
definition: {
|
|
point: {
|
|
color: {
|
|
range: {}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
spyOn(histogramModel, 'getAutoStyle').and.returnValue({
|
|
cartocss: '#dummy {}',
|
|
definition: {
|
|
point: {
|
|
color: {
|
|
range: {}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
layerDefinitionModel.styleModel.setPropertiesFromAutoStyle = function () {};
|
|
|
|
categoryModel.set({autoStyle: true});
|
|
expect(layerDefinitionModel.get('autoStyle')).toBe(categoryModel.id);
|
|
expect(layerDefinitionModel.get('cartocss')).toBe('#dummy {}');
|
|
expect(layerDefinitionModel.set).toHaveBeenCalledWith(jasmine.objectContaining({
|
|
previousCartoCSS: 'wadus'
|
|
}));
|
|
|
|
histogramModel.set({autoStyle: true});
|
|
expect(layerDefinitionModel.get('autoStyle')).toBe(histogramModel.id);
|
|
expect(categoryModel.get('autoStyle')).toBe(false);
|
|
expect(layerDefinitionModel.set).not.toHaveBeenCalledWith(jasmine.objectContaining({
|
|
previousCartoCSS: '#dummy {}'
|
|
}));
|
|
});
|
|
|
|
it('should update layer definition model\'s style properly based on previous custom style', function () {
|
|
var css = '#layer { marker-width: 5; marker-fill: red; marker-fill-opacity: 1; marker-line-width: 1; marker-line-color: #ff0e0e; marker-line-opacity: 1; }';
|
|
var model = this.diDashboardHelpers.getWidget(category.id);
|
|
|
|
model.set({ autoStyle: true });
|
|
|
|
expect(layerDefinitionModel.get('cartocss_custom')).toBe(false);
|
|
|
|
layerDefinitionModel.set({
|
|
previousCartoCSSCustom: true,
|
|
previousCartoCSS: css
|
|
});
|
|
|
|
model.set({ autoStyle: false });
|
|
|
|
expect(layerDefinitionModel.get('cartocss_custom')).toBe(true);
|
|
expect(layerDefinitionModel.get('cartocss')).toBe(css);
|
|
});
|
|
|
|
it('should update layer definition model\'s color properly', function () {
|
|
var model = this.diDashboardHelpers.getWidget(category.id);
|
|
model.set({autoStyle: true}, {silent: true});
|
|
model.set({color: '#fabada'});
|
|
expect(layerDefinitionModel.get('autoStyle')).toBe(model.id);
|
|
expect(layerDefinitionModel.styleModel.setPropertiesFromAutoStyle).toHaveBeenCalled();
|
|
|
|
layerDefinitionModel.styleModel.setPropertiesFromAutoStyle.calls.reset();
|
|
|
|
model.set({autoStyle: false}, {silent: true});
|
|
model.set({color: '#f4b4d4'});
|
|
expect(layerDefinitionModel.get('autoStyle')).toBe(false);
|
|
expect(layerDefinitionModel.styleModel.setPropertiesFromAutoStyle).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should disable autoStyle if aggregation is not simple', function () {
|
|
var model = this.diDashboardHelpers.getWidget(category.id);
|
|
model.set({autoStyle: true});
|
|
expect(layerDefinitionModel.get('autoStyle')).toBe(model.id);
|
|
expect(layerDefinitionModel.styleModel.setPropertiesFromAutoStyle).toHaveBeenCalled();
|
|
|
|
layerDefinitionModel.styleModel.set({type: 'squares'});
|
|
layerDefinitionModel.save();
|
|
|
|
expect(layerDefinitionModel.get('autoStyle')).toBe(false);
|
|
expect(model.get('autoStyle')).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('when the layer style has changed', function () {
|
|
it("should disable any activated widgets' autoStyle", function () {
|
|
this.a0 = this.analysisDefinitionNodesCollection.add({
|
|
id: 'a0',
|
|
type: 'source',
|
|
params: {
|
|
query: 'SELECT * FROM foobar'
|
|
}
|
|
});
|
|
|
|
var nodeMod = this.diDashboardHelpers.analyse(this.a0.toJSON());
|
|
|
|
var layerDefinitionModel = this.layerDefinitionsCollection.add({
|
|
id: 'integration-test',
|
|
kind: 'carto',
|
|
options: {
|
|
table_name: 'something',
|
|
source: 'a0',
|
|
cartocss: '#layer {}'
|
|
}
|
|
});
|
|
|
|
// We have to add the analysis and the layer manually due to in this class
|
|
// there is no bindings for those purposes (layers-integration will have it)
|
|
var visMap = this.diDashboardHelpers.visMap();
|
|
var attrs = layerDefinitionModel.toJSON();
|
|
attrs.source = nodeMod;
|
|
attrs.cartocss = attrs.options.tile_style;
|
|
visMap.createCartoDBLayer(attrs);
|
|
|
|
var nodeDef = layerDefinitionModel.getAnalysisDefinitionNodeModel();
|
|
nodeDef.queryGeometryModel.set('simple_geom', 'point');
|
|
spyOn(layerDefinitionModel, 'save');
|
|
|
|
var model = this.widgetDefinitionsCollection.add({
|
|
id: 'w-100',
|
|
type: 'category',
|
|
title: 'test',
|
|
layer_id: 'integration-test',
|
|
options: {
|
|
column: 'col'
|
|
},
|
|
source: {
|
|
id: 'a0'
|
|
}
|
|
});
|
|
model.trigger('sync', model);
|
|
|
|
var widgetModel = this.diDashboardHelpers.getWidgets()[0];
|
|
widgetModel.set('autoStyle', true);
|
|
layerDefinitionModel.set('cartocss', 'differentCartocss');
|
|
expect(widgetModel.get('autoStyle')).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('time series', function () {
|
|
var xhrSpy = jasmine.createSpyObj('xhr', ['abort', 'always', 'fail']);
|
|
|
|
var cartocss = 'Map {-torque-frame-count: 256;-torque-animation-duration: 30;-torque-time-attribute: cartodb_id";-torque-aggregation-function: "count(1)";-torque-resolution: 4;-torque-data-aggregation: linear;} #layer {}, #layer[frame-offset=1] {marker-width: 9; marker-fill-opacity: 0.45;} #layer[frame-offset=2] {marker-width: 11; marker-fill-opacity: 0.225;}';
|
|
|
|
var animatedChanged1 = {attribute: 'longitude', duration: 24, overlap: false, resolution: 4, steps: 256, trails: 2};
|
|
var animatedChanged2 = {attribute: 'latitude', duration: 24, overlap: false, resolution: 4, steps: 256, trails: 3};
|
|
|
|
beforeEach(function () {
|
|
spyOn(Backbone.Model.prototype, 'sync').and.returnValue(xhrSpy);
|
|
|
|
this.layerDefModel = new LayerDefinitionModel({
|
|
id: 'wadus',
|
|
kind: 'torque',
|
|
options: {
|
|
tile_style: cartocss,
|
|
query: 'SELECT * FROM fooo',
|
|
table_name: 'fooo',
|
|
source: 'd0',
|
|
style_properties: {
|
|
type: 'animation',
|
|
properties: {
|
|
animated: {
|
|
attribute: 'cartodb_id',
|
|
duration: 30,
|
|
overlap: false,
|
|
resolution: 4,
|
|
steps: 256,
|
|
trails: 2
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}, { parse: true, configModel: 'c' });
|
|
|
|
this.d0 = this.analysisDefinitionNodesCollection.add({
|
|
id: 'd0',
|
|
type: 'source',
|
|
params: {
|
|
query: 'SELECT * FROM fooo'
|
|
}
|
|
});
|
|
|
|
var nodeMod = this.diDashboardHelpers.analyse(this.d0.toJSON());
|
|
|
|
this.layerDefinitionsCollection.add(this.layerDefModel);
|
|
|
|
// We have to add the analysis and the layer manually due to in this class
|
|
// there is no bindings for those purposes (layers-integration will have it)
|
|
var visMap = this.diDashboardHelpers.visMap();
|
|
var attrs = this.layerDefModel.toJSON();
|
|
attrs.source = nodeMod;
|
|
attrs.cartocss = attrs.options.tile_style;
|
|
visMap.createTorqueLayer(attrs, _.extend({
|
|
at: 0
|
|
}));
|
|
|
|
spyOn(nodeMod, 'isDone');
|
|
});
|
|
|
|
it('should create only one time-series widget', function () {
|
|
this.layerDefModel.styleModel.set({animated: animatedChanged1});
|
|
this.layerDefModel.set({alias: 'wadus'});
|
|
|
|
// Manually we launch the method
|
|
this.integration.manageTimeSeriesForTorque(this.layerDefModel);
|
|
|
|
Backbone.Model.prototype.sync.calls.argsFor(0)[2].error({
|
|
error: 'abort'
|
|
});
|
|
|
|
this.layerDefModel.styleModel.set({animated: animatedChanged2});
|
|
this.layerDefModel.set({alias: 'wadus wadus'});
|
|
|
|
// Manually we launch the method
|
|
this.integration.manageTimeSeriesForTorque(this.layerDefModel);
|
|
|
|
Backbone.Model.prototype.sync.calls.argsFor(0)[2].success({
|
|
id: '1',
|
|
layer_id: 'wadus',
|
|
options: {
|
|
column: 'cartodb_id',
|
|
bins: 256,
|
|
animated: true,
|
|
sync_on_bbox_change: true
|
|
},
|
|
order: 0,
|
|
source: {
|
|
id: 'a0'
|
|
},
|
|
style: {
|
|
widget_style: {
|
|
definition: {
|
|
color: {
|
|
fixed: '#F2CC8F',
|
|
opacity: 1
|
|
}
|
|
}
|
|
}
|
|
},
|
|
title: 'time_date__t',
|
|
type: 'time-series'
|
|
});
|
|
|
|
expect(this.widgetDefinitionsCollection.length).toBe(1);
|
|
});
|
|
});
|
|
|
|
describe('._initBinds', function () {
|
|
it('should call _setSelectedWidget on _widgetDefinitionsCollection:setSelected', function () {
|
|
this.widgetDefinitionsCollection.trigger('setSelected');
|
|
|
|
expect(this.integration._setSelectedWidget).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('._setSelectedWidget', function () {
|
|
it('should trigger setDisabled with the correct value', function () {
|
|
setSelectedSpy.and.callThrough();
|
|
|
|
var selectedModel = this.widgetDefinitionsCollection.add({
|
|
id: 'w-100',
|
|
type: 'category',
|
|
title: 'test',
|
|
layer_id: 'integration-test',
|
|
options: {
|
|
column: 'col'
|
|
},
|
|
source: {
|
|
id: 'a0'
|
|
}
|
|
});
|
|
|
|
var disabledModel = this.widgetDefinitionsCollection.add({
|
|
id: 'w-200',
|
|
type: 'category',
|
|
title: 'test',
|
|
layer_id: 'integration-test',
|
|
options: {
|
|
column: 'col'
|
|
},
|
|
source: {
|
|
id: 'a0'
|
|
}
|
|
});
|
|
|
|
spyOn(selectedModel, 'trigger');
|
|
spyOn(disabledModel, 'trigger');
|
|
spyOn(this.diDashboardHelpers, 'getWidgets').and.returnValue(this.widgetDefinitionsCollection);
|
|
|
|
this.integration._setSelectedWidget(selectedModel.get('id'));
|
|
|
|
expect(selectedModel.trigger).toHaveBeenCalledWith('setDisabled', selectedModel, selectedModel.get('id'));
|
|
expect(disabledModel.trigger).toHaveBeenCalledWith('setDisabled', disabledModel, selectedModel.get('id'));
|
|
});
|
|
});
|
|
});
|