439 lines
15 KiB
JavaScript
439 lines
15 KiB
JavaScript
var Backbone = require('backbone');
|
|
var _ = require('underscore');
|
|
var carto = require('../../../../../src/api/v4/index');
|
|
var createEngine = require('../../../fixtures/engine.fixture.js');
|
|
|
|
function createInternalModelMock () {
|
|
var internalModelMock = {
|
|
set: function () {},
|
|
get: function () {}
|
|
};
|
|
spyOn(internalModelMock, 'set');
|
|
spyOn(internalModelMock, 'get').and.callFake(function (key) {
|
|
switch (key) {
|
|
case 'count': return 42;
|
|
case 'max': return 9;
|
|
case 'min': return 1;
|
|
case 'nulls': return 0;
|
|
case 'data': return [
|
|
{
|
|
name: 'cat1',
|
|
value: 1,
|
|
agg: false
|
|
},
|
|
{
|
|
name: 'others',
|
|
value: 9,
|
|
agg: true
|
|
}
|
|
];
|
|
}
|
|
});
|
|
_.extend(internalModelMock, Backbone.Events);
|
|
|
|
return internalModelMock;
|
|
}
|
|
|
|
function createSourceMock () {
|
|
return new carto.source.Dataset('foo');
|
|
}
|
|
|
|
describe('api/v4/dataview/category', function () {
|
|
var source = createSourceMock();
|
|
|
|
describe('initialization', function () {
|
|
it('source must be provided', function () {
|
|
var error;
|
|
try { new carto.dataview.Category(); } catch (err) { error = err; } // eslint-disable-line no-new
|
|
|
|
expect(error).toEqual(jasmine.objectContaining({
|
|
message: 'Source property is required.',
|
|
type: 'dataview',
|
|
errorCode: 'validation:dataview:source-required'
|
|
}));
|
|
});
|
|
|
|
it('column must be provided', function () {
|
|
var error;
|
|
try { new carto.dataview.Category(source); } catch (err) { error = err; } // eslint-disable-line no-new
|
|
|
|
expect(error).toEqual(jasmine.objectContaining({
|
|
message: 'Column property is required.',
|
|
type: 'dataview',
|
|
errorCode: 'validation:dataview:column-required'
|
|
}));
|
|
});
|
|
|
|
it('options set to default if not provided', function () {
|
|
var column = 'population';
|
|
|
|
var dataview = new carto.dataview.Category(source, column);
|
|
|
|
expect(dataview._limit).toEqual(6);
|
|
expect(dataview._operation).toEqual(carto.operation.COUNT);
|
|
expect(dataview._operationColumn).toEqual('population');
|
|
});
|
|
|
|
it('options set to the provided value', function () {
|
|
var dataview = new carto.dataview.Category(source, 'population', {
|
|
limit: 10,
|
|
operation: carto.operation.AVG,
|
|
operationColumn: 'column-test'
|
|
});
|
|
|
|
expect(dataview._limit).toEqual(10);
|
|
expect(dataview._operation).toEqual(carto.operation.AVG);
|
|
expect(dataview._operationColumn).toEqual('column-test');
|
|
});
|
|
|
|
it('throw error if no correct operation is provided', function () {
|
|
var error;
|
|
var test = function () {
|
|
new carto.dataview.Category(source, 'population', { // eslint-disable-line no-new
|
|
operation: 'exponential'
|
|
});
|
|
};
|
|
|
|
try { test(); } catch (err) { error = err; }
|
|
|
|
expect(error).toEqual(jasmine.objectContaining({
|
|
message: 'Operation for category dataview is not valid. Use carto.operation',
|
|
type: 'dataview',
|
|
errorCode: 'validation:dataview:category-invalid-operation'
|
|
}));
|
|
});
|
|
});
|
|
|
|
describe('.setLimit', function () {
|
|
var dataview;
|
|
|
|
beforeEach(function () {
|
|
dataview = new carto.dataview.Category(source, 'population');
|
|
});
|
|
|
|
it('checks if limit is valid', function () {
|
|
var requiredError;
|
|
var numberError;
|
|
var positiveError;
|
|
|
|
try { dataview.setLimit(); } catch (err) { requiredError = err; }
|
|
try { dataview.setLimit('12'); } catch (err) { numberError = err; }
|
|
try { dataview.setLimit(0); } catch (err) { positiveError = err; }
|
|
|
|
expect(requiredError).toEqual(jasmine.objectContaining({
|
|
message: 'Limit for category dataview is required.',
|
|
type: 'dataview',
|
|
errorCode: 'validation:dataview:category-limit-required'
|
|
}));
|
|
expect(numberError).toEqual(jasmine.objectContaining({
|
|
message: 'Limit for category dataview must be a number.',
|
|
type: 'dataview',
|
|
errorCode: 'validation:dataview:category-limit-number'
|
|
}));
|
|
expect(positiveError).toEqual(jasmine.objectContaining({
|
|
message: 'Limit for category dataview must be greater than 0.',
|
|
type: 'dataview',
|
|
errorCode: 'validation:dataview:category-limit-positive'
|
|
}));
|
|
});
|
|
|
|
it('if limit is valid, it assigns it to property, returns this and nothing else if there is no internaModel', function () {
|
|
var returnedObject = dataview.setLimit(10);
|
|
|
|
expect(dataview.getLimit()).toEqual(10);
|
|
expect(returnedObject).toBe(dataview);
|
|
});
|
|
|
|
it('sets limit in internal model if exists', function () {
|
|
var internalModelMock = createInternalModelMock();
|
|
dataview._internalModel = internalModelMock;
|
|
|
|
dataview.setLimit(1);
|
|
|
|
var operationArgs = internalModelMock.set.calls.mostRecent().args;
|
|
expect(operationArgs[0]).toEqual('categories');
|
|
expect(operationArgs[1]).toEqual(1);
|
|
});
|
|
|
|
it('should trigger a limitChanged event', function () {
|
|
var limitChangedSpy = jasmine.createSpy('operationaChangedSpy');
|
|
dataview.on('limitChanged', limitChangedSpy);
|
|
|
|
expect(limitChangedSpy).not.toHaveBeenCalled();
|
|
dataview.$setEngine(createEngine());
|
|
dataview.setLimit(7);
|
|
|
|
expect(limitChangedSpy).toHaveBeenCalledWith(7);
|
|
});
|
|
});
|
|
|
|
describe('.setOperation', function () {
|
|
var dataview;
|
|
|
|
beforeEach(function () {
|
|
dataview = new carto.dataview.Category(source, 'population');
|
|
});
|
|
|
|
it('checks if operation is valid', function () {
|
|
var error;
|
|
var test = function () {
|
|
dataview.setOperation('swordfish');
|
|
};
|
|
|
|
try { test(); } catch (err) { error = err; }
|
|
|
|
expect(error).toEqual(jasmine.objectContaining({
|
|
message: 'Operation for category dataview is not valid. Use carto.operation',
|
|
type: 'dataview',
|
|
errorCode: 'validation:dataview:category-invalid-operation'
|
|
}));
|
|
});
|
|
|
|
it('if operation is valid, it assigns it to property, returns this and nothing else if there is no internaModel', function () {
|
|
var returnedObject = dataview.setOperation(carto.operation.AVG);
|
|
|
|
expect(dataview.getOperation()).toEqual(carto.operation.AVG);
|
|
expect(returnedObject).toBe(dataview);
|
|
});
|
|
|
|
it('sets operation in internal model if exists', function () {
|
|
var internalModelMock = createInternalModelMock();
|
|
dataview._internalModel = internalModelMock;
|
|
|
|
dataview.setOperation(carto.operation.AVG);
|
|
|
|
var operationArgs = internalModelMock.set.calls.mostRecent().args;
|
|
expect(operationArgs[0]).toEqual('aggregation');
|
|
expect(operationArgs[1]).toEqual(carto.operation.AVG);
|
|
});
|
|
|
|
it('should trigger a operationChanged event', function () {
|
|
var operationChangedSpy = jasmine.createSpy('operationaChangedSpy');
|
|
dataview.on('operationChanged', operationChangedSpy);
|
|
|
|
expect(operationChangedSpy).not.toHaveBeenCalled();
|
|
dataview.$setEngine(createEngine());
|
|
dataview.setOperation(carto.operation.AVG);
|
|
|
|
expect(operationChangedSpy).toHaveBeenCalledWith(carto.operation.AVG);
|
|
});
|
|
});
|
|
|
|
describe('.setOperationColumn', function () {
|
|
var dataview;
|
|
|
|
beforeEach(function () {
|
|
dataview = new carto.dataview.Category(source, 'population');
|
|
});
|
|
|
|
it('checks if operation is valid', function () {
|
|
var requiredError;
|
|
var numberError;
|
|
var emptyError;
|
|
|
|
try { dataview.setOperationColumn(); } catch (err) { requiredError = err; }
|
|
try { dataview.setOperationColumn(12); } catch (err) { numberError = err; }
|
|
try { dataview.setOperationColumn(''); } catch (err) { emptyError = err; }
|
|
|
|
expect(requiredError).toEqual(jasmine.objectContaining({
|
|
message: 'Operation column for category dataview is required.',
|
|
type: 'dataview',
|
|
errorCode: 'validation:dataview:category-operation-required'
|
|
}));
|
|
expect(numberError).toEqual(jasmine.objectContaining({
|
|
message: 'Operation column for category dataview must be a string.',
|
|
type: 'dataview',
|
|
errorCode: 'validation:dataview:category-operation-string'
|
|
}));
|
|
expect(emptyError).toEqual(jasmine.objectContaining({
|
|
message: 'Operation column for category dataview must be not empty.',
|
|
type: 'dataview',
|
|
errorCode: 'validation:dataview:category-operation-empty'
|
|
}));
|
|
});
|
|
|
|
it('if operation is valid, it assigns it to property, returns this and nothing else if there is no internaModel', function () {
|
|
var returnedObject = dataview.setOperationColumn('columnA');
|
|
|
|
expect(dataview.getOperationColumn()).toEqual('columnA');
|
|
expect(returnedObject).toBe(dataview);
|
|
});
|
|
|
|
it('sets operation in internal model if exists', function () {
|
|
var internalModelMock = createInternalModelMock();
|
|
dataview._internalModel = internalModelMock;
|
|
|
|
dataview.setOperationColumn('columnB');
|
|
|
|
var operationArgs = internalModelMock.set.calls.mostRecent().args;
|
|
expect(operationArgs[0]).toEqual('aggregation_column');
|
|
expect(operationArgs[1]).toEqual('columnB');
|
|
});
|
|
|
|
it('should trigger a operationColumnChanged event', function () {
|
|
var operationColumnChangedSpy = jasmine.createSpy('operationaChangedSpy');
|
|
dataview.on('operationColumnChanged', operationColumnChangedSpy);
|
|
|
|
expect(operationColumnChangedSpy).not.toHaveBeenCalled();
|
|
dataview.$setEngine(createEngine());
|
|
dataview.setOperationColumn('column2');
|
|
|
|
expect(operationColumnChangedSpy).toHaveBeenCalledWith('column2');
|
|
});
|
|
});
|
|
|
|
describe('.getData', function () {
|
|
var dataview;
|
|
|
|
beforeEach(function () {
|
|
dataview = new carto.dataview.Category(source, 'population', {
|
|
operation: carto.operation.SUM,
|
|
operationColumn: 'column-test'
|
|
});
|
|
});
|
|
|
|
it('returns null if there is no internalModel', function () {
|
|
var data = dataview.getData();
|
|
|
|
expect(data).toBeNull();
|
|
});
|
|
|
|
it('returns data from internalModel', function () {
|
|
var internalModelMock = createInternalModelMock();
|
|
dataview._internalModel = internalModelMock;
|
|
|
|
var data = dataview.getData();
|
|
|
|
expect(data).toEqual({
|
|
count: 42,
|
|
max: 9,
|
|
min: 1,
|
|
nulls: 0,
|
|
operation: carto.operation.SUM,
|
|
categories: [
|
|
{
|
|
name: 'cat1',
|
|
value: 1,
|
|
group: false
|
|
},
|
|
{
|
|
name: 'others',
|
|
value: 9,
|
|
group: true
|
|
}
|
|
]
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('.$setEngine', function () {
|
|
var engine;
|
|
var dataview;
|
|
|
|
beforeEach(function () {
|
|
dataview = new carto.dataview.Category(source, 'population', {
|
|
operation: carto.operation.MIN,
|
|
operationColumn: 'column-test'
|
|
});
|
|
engine = createEngine();
|
|
});
|
|
|
|
it('creates the internal model', function () {
|
|
dataview.disable(); // To test that it passes the ._enabled property to the internal model
|
|
dataview.$setEngine(engine);
|
|
|
|
var internalModel = dataview.$getInternalModel();
|
|
expect(internalModel.get('source')).toBe(dataview._source.$getInternalModel());
|
|
expect(internalModel.get('column')).toEqual(dataview._column);
|
|
expect(internalModel.get('categories')).toEqual(dataview._limit);
|
|
expect(internalModel.get('aggregation')).toEqual(dataview._operation);
|
|
expect(internalModel.get('aggregation_column')).toEqual(dataview._operationColumn);
|
|
expect(internalModel.isEnabled()).toBe(false);
|
|
expect(internalModel._engine).toBe(engine);
|
|
});
|
|
|
|
it('calling twice to $setEngine does not create another internalModel', function () {
|
|
spyOn(dataview, '_createInternalModel').and.callThrough();
|
|
|
|
dataview.$setEngine(engine);
|
|
dataview.$setEngine(engine);
|
|
|
|
expect(dataview._createInternalModel.calls.count()).toBe(1);
|
|
});
|
|
|
|
describe('spatial filters', function () {
|
|
it('creates the internal model with BoundingBox filter if provided', function () {
|
|
var filter = new carto.filter.BoundingBox();
|
|
dataview.addFilter(filter);
|
|
dataview.$setEngine(engine);
|
|
|
|
var internalModel = dataview.$getInternalModel();
|
|
expect(internalModel._bboxFilter).toBeDefined();
|
|
expect(internalModel.syncsOnBoundingBoxChanges()).toBe(true);
|
|
});
|
|
|
|
it('allows removing a BoundingBox filter', function () {
|
|
var filter = new carto.filter.BoundingBox();
|
|
dataview.addFilter(filter);
|
|
dataview.$setEngine(engine);
|
|
expect(dataview.hasFilter(filter)).toBe(true);
|
|
|
|
dataview.removeFilter(filter);
|
|
|
|
expect(dataview.hasFilter(filter)).toBe(false);
|
|
var internalModel = dataview.$getInternalModel();
|
|
expect(internalModel._bboxFilter).toBeNull();
|
|
expect(internalModel.syncsOnBoundingBoxChanges()).toBe(false);
|
|
});
|
|
|
|
it('creates the internal model with Circle filter if provided', function () {
|
|
var filter = new carto.filter.Circle();
|
|
dataview.addFilter(filter);
|
|
dataview.$setEngine(engine);
|
|
|
|
var internalModel = dataview.$getInternalModel();
|
|
expect(internalModel._circleFilter).toBeDefined();
|
|
expect(internalModel.syncsOnCircleChanges()).toBe(true);
|
|
});
|
|
|
|
it('allows removing a Circle filter', function () {
|
|
var filter = new carto.filter.Circle();
|
|
dataview.addFilter(filter);
|
|
dataview.$setEngine(engine);
|
|
expect(dataview.hasFilter(filter)).toBe(true);
|
|
|
|
dataview.removeFilter(filter);
|
|
|
|
expect(dataview.hasFilter(filter)).toBe(false);
|
|
var internalModel = dataview.$getInternalModel();
|
|
expect(internalModel._circleFilter).toBeNull();
|
|
expect(internalModel.syncsOnCircleChanges()).toBe(false);
|
|
});
|
|
|
|
it('creates the internal model with Polygon filter if provided', function () {
|
|
var filter = new carto.filter.Polygon();
|
|
dataview.addFilter(filter);
|
|
dataview.$setEngine(engine);
|
|
|
|
var internalModel = dataview.$getInternalModel();
|
|
expect(internalModel._polygonFilter).toBeDefined();
|
|
expect(internalModel.syncsOnPolygonChanges()).toBe(true);
|
|
});
|
|
|
|
it('allows removing a Polygon filter', function () {
|
|
var filter = new carto.filter.Polygon();
|
|
dataview.addFilter(filter);
|
|
dataview.$setEngine(engine);
|
|
expect(dataview.hasFilter(filter)).toBe(true);
|
|
|
|
dataview.removeFilter(filter);
|
|
|
|
expect(dataview.hasFilter(filter)).toBe(false);
|
|
var internalModel = dataview.$getInternalModel();
|
|
expect(internalModel._polygonFilter).toBeNull();
|
|
expect(internalModel.syncsOnPolygonChanges()).toBe(false);
|
|
});
|
|
});
|
|
});
|
|
});
|