b26f270ffa
The problem is that Backbone >= 0.9.9 doesn't accept updating models with:
model.set(otherModel);
That needs to be changed to:
model.set(otherModel.attributes);
Dataset.query() accepts both regular JS objects and Query models, so we need to
check the parameter type to support both.
479 lines
12 KiB
JavaScript
479 lines
12 KiB
JavaScript
(function ($) {
|
|
module("Model");
|
|
|
|
// =================================
|
|
// Field
|
|
|
|
test('Field: basics', function () {
|
|
var field = new recline.Model.Field({
|
|
id: 'x'
|
|
});
|
|
equal(field.attributes.label, 'x', 'Field label should be set from id');
|
|
|
|
var field = new recline.Model.Field({
|
|
id: 'x',
|
|
label: 'My label'
|
|
});
|
|
equal(field.attributes.label, 'My label', 'Field label should be set from id but not if explicitly provided');
|
|
|
|
raises(function() {
|
|
var field = new recline.Model.Field('xxx');
|
|
},
|
|
'should throw an error if not passed in a hash with id'
|
|
);
|
|
|
|
// toJSON
|
|
var field = new recline.Model.Field({
|
|
id: 'x',
|
|
label: 'My label'
|
|
});
|
|
var out = field.toJSON();
|
|
equal('My label', out.label);
|
|
|
|
var fieldList = new recline.Model.FieldList([
|
|
{id: 'xx', label: 'XX'},
|
|
{id: 'yy', label: 'YY'}
|
|
]);
|
|
var out = fieldList.toJSON();
|
|
equal('XX', out[0].label);
|
|
});
|
|
|
|
test('Field: type mapping', function () {
|
|
var tests = [
|
|
{ input: 'text', exp: 'string'},
|
|
{ input: 'int', exp: 'integer'},
|
|
{ input: 'float', exp: 'number'},
|
|
{ input: 'double', exp: 'number'},
|
|
{ input: 'datetime', exp: 'date-time'},
|
|
{ input: 'dateTime', exp: 'date-time'},
|
|
{ input: 'bool', exp: 'boolean'},
|
|
{ input: 'timestamp', exp: 'date-time'},
|
|
{ input: 'json', exp: 'object'}
|
|
];
|
|
|
|
_.each(tests, function(data) {
|
|
var field = new recline.Model.Field({
|
|
id: 'x',
|
|
type: data.input
|
|
});
|
|
equal(field.get('type'), data.exp);
|
|
});
|
|
});
|
|
|
|
test('Field: getFieldValue', function () {
|
|
var doc = new recline.Model.Record({
|
|
x: 12.3
|
|
});
|
|
var field = new recline.Model.Field({id: 'x'});
|
|
var out = doc.getFieldValue(field);
|
|
var exp = 12.3;
|
|
equal(out, exp);
|
|
|
|
// bad value
|
|
var out = doc.getFieldValue();
|
|
equal(out, '');
|
|
});
|
|
|
|
test('Field: default renderers', function () {
|
|
var doc = new recline.Model.Record({
|
|
x: 12.3,
|
|
myobject: {a: 1, b: 2},
|
|
link: 'http://abc.com/',
|
|
link2: 'Some text then https://abc.com/',
|
|
markdown: '### ABC',
|
|
geopoint: [18.7, -122]
|
|
});
|
|
var field = new recline.Model.Field({id: 'myobject', type: 'object'});
|
|
var out = doc.getFieldValue(field);
|
|
var exp = '{"a":1,"b":2}';
|
|
equal(out, exp);
|
|
|
|
var field = new recline.Model.Field({id: 'geopoint', type: 'geo_point'});
|
|
var out = doc.getFieldValue(field);
|
|
var exp = '[18.7,-122]';
|
|
equal(out, exp);
|
|
|
|
var field = new recline.Model.Field({id: 'x', type: 'float', format: 'percentage'});
|
|
var out = doc.getFieldValue(field);
|
|
var exp = '12.3%';
|
|
equal(out, exp);
|
|
|
|
var field = new recline.Model.Field({id: 'link'});
|
|
var out = doc.getFieldValue(field);
|
|
var exp = '<a href="http://abc.com/">http://abc.com/</a>';
|
|
equal(out, exp);
|
|
|
|
var field = new recline.Model.Field({id: 'link2'});
|
|
var out = doc.getFieldValue(field);
|
|
var exp = 'Some text then <a href="https://abc.com/">https://abc.com/</a>';
|
|
equal(out, exp);
|
|
|
|
var field = new recline.Model.Field({id: 'markdown', type: 'string', format: 'markdown'});
|
|
var out = doc.getFieldValue(field);
|
|
// Showdown is not installed so nothing should happen
|
|
var exp = doc.get('markdown');
|
|
equal(out, exp);
|
|
});
|
|
|
|
test('Field: custom deriver and renderer', function () {
|
|
var doc = new recline.Model.Record({x: 123});
|
|
var cellRenderer = function(value, field) {
|
|
return '<span class="field-' + field.id + '">' + value + '</span>';
|
|
}
|
|
var deriver = function(val, field, doc) {
|
|
return doc.get('x') * 2
|
|
}
|
|
|
|
var field = new recline.Model.Field({id: 'computed', is_derived: true}, {
|
|
deriver: deriver
|
|
});
|
|
var out1 = doc.getFieldValueUnrendered(field);
|
|
var out = doc.getFieldValue(field);
|
|
var exp = 246;
|
|
equal(out1, exp);
|
|
equal(out, exp);
|
|
|
|
var field = new recline.Model.Field({id: 'x'}, {
|
|
renderer: cellRenderer
|
|
});
|
|
var out = doc.getFieldValue(field);
|
|
var exp = '<span class="field-x">123</span>'
|
|
equal(out, exp);
|
|
|
|
var field = new recline.Model.Field({id: 'computed'}, {
|
|
renderer: cellRenderer,
|
|
deriver: deriver
|
|
});
|
|
var out = doc.getFieldValue(field);
|
|
var exp = '<span class="field-computed">246</span>'
|
|
equal(out, exp);
|
|
});
|
|
|
|
// =================================
|
|
// Dataset
|
|
|
|
module("Model Dataset");
|
|
|
|
test('Dataset', function () {
|
|
var meta = {id: 'test', title: 'xyz'};
|
|
var dataset = new recline.Model.Dataset(meta);
|
|
dataset.fields = new recline.Model.FieldList([{id: 'xx'}, {id: 'yy'}]);
|
|
var out = dataset.toTemplateJSON();
|
|
equal(out.fields.length, 2);
|
|
});
|
|
|
|
test('Dataset getFieldsSummary', function () {
|
|
var dataset = Fixture.getDataset();
|
|
dataset.getFieldsSummary().done(function() {
|
|
var countryField = dataset.fields.get('country');
|
|
var facet = countryField.facets.models[0];
|
|
equal(facet.get('terms').length, 3);
|
|
var exp = [
|
|
{ count: 3, term: 'UK' },
|
|
{ count: 2, term: 'DE' },
|
|
{ count: 1, term: 'US' }
|
|
];
|
|
deepEqual(facet.get('terms'), exp);
|
|
});
|
|
});
|
|
|
|
test('query with Query model', function () {
|
|
var dataset = new recline.Model.Dataset({
|
|
records: [{country: 'UK'}, {country: 'DE'}]
|
|
});
|
|
var query = new recline.Model.Query();
|
|
query.addFilter({type: 'term', field: 'country', term: 'DE'});
|
|
|
|
dataset.query(query).done(function (results) {
|
|
deepEqual(results.length, 1);
|
|
deepEqual(results.models[0].toJSON(), {country: 'DE'});
|
|
});
|
|
});
|
|
|
|
test('query with plain object', function () {
|
|
var dataset = new recline.Model.Dataset({
|
|
records: [{country: 'UK'}, {country: 'DE'}]
|
|
});
|
|
var query = {q: 'DE'};
|
|
|
|
dataset.query(query).done(function (results) {
|
|
deepEqual(results.length, 1);
|
|
deepEqual(results.models[0].toJSON(), {country: 'DE'});
|
|
});
|
|
});
|
|
|
|
test('fetch without and with explicit fields', function () {
|
|
var dataset = new recline.Model.Dataset({
|
|
backend: 'csv',
|
|
data: 'A,B\n1,2\n3,4'
|
|
});
|
|
dataset.fetch();
|
|
equal(dataset.fields.at(0).id, 'A');
|
|
equal(dataset.fields.at(0).get('type'), 'string');
|
|
|
|
var dataset = new recline.Model.Dataset({
|
|
fields: [{id: 'X', type: 'number'}, {id: 'Y'}],
|
|
backend: 'csv',
|
|
data: 'A,B\n1,2\n3,4'
|
|
});
|
|
dataset.fetch();
|
|
equal(dataset.fields.at(0).id, 'X');
|
|
equal(dataset.fields.at(0).get('type'), 'number');
|
|
equal(dataset.records.at(0).get('X'), 1);
|
|
});
|
|
|
|
test('_normalizeRecordsAndFields', function () {
|
|
var data = [
|
|
// fields but no records
|
|
{
|
|
in_: {
|
|
fields: [ '', 'abc', 'abc', 'xyz', '' ],
|
|
records: null
|
|
},
|
|
exp: {
|
|
fields: [
|
|
{id: '_noname_'},
|
|
{id: 'abc'},
|
|
{id: 'abc1'},
|
|
{id: 'xyz'},
|
|
{id: '_noname_1'}
|
|
],
|
|
records: null
|
|
},
|
|
},
|
|
// non-string fields
|
|
{
|
|
in_: {
|
|
fields: [ null, 1, 1, 3 ],
|
|
records: [ [1,2,3,4] ]
|
|
},
|
|
exp: {
|
|
fields: [
|
|
{id: '_noname_'},
|
|
{id: '1'},
|
|
{id: '11'},
|
|
{id: '3'}
|
|
],
|
|
records: [ { '_noname_': 1, '1': 2, '11': 3, '3': 4 } ]
|
|
},
|
|
},
|
|
// records array but no fields
|
|
{
|
|
in_: {
|
|
fields: undefined,
|
|
records: [
|
|
['col1', 'col2'],
|
|
[1,2],
|
|
[3,4]
|
|
]
|
|
},
|
|
exp: {
|
|
fields: [
|
|
{id: 'col1'},
|
|
{id: 'col2'}
|
|
],
|
|
records: [
|
|
{col1: 1, col2: 2},
|
|
{col1: 3, col2: 4}
|
|
]
|
|
}
|
|
},
|
|
// records objects but no fields
|
|
{
|
|
in_: {
|
|
fields: undefined,
|
|
records: [
|
|
{col1: 1, col2: 2},
|
|
{col1: 3, col2: 4}
|
|
]
|
|
},
|
|
exp: {
|
|
fields: [
|
|
{id: 'col1'},
|
|
{id: 'col2'}
|
|
],
|
|
records: [
|
|
{col1: 1, col2: 2},
|
|
{col1: 3, col2: 4}
|
|
]
|
|
}
|
|
},
|
|
// fields and records array
|
|
{
|
|
in_: {
|
|
fields: [{id: 'col1'}, {id: 'col2'}],
|
|
records: [
|
|
[1,2],
|
|
[3,4]
|
|
]
|
|
},
|
|
exp: {
|
|
fields: [
|
|
{id: 'col1'},
|
|
{id: 'col2'}
|
|
],
|
|
records: [
|
|
{col1: 1, col2: 2},
|
|
{col1: 3, col2: 4}
|
|
]
|
|
}
|
|
},
|
|
// everything already correct
|
|
{
|
|
in_: {
|
|
fields: [{id: 'col1'}, {id: 'col2'}],
|
|
records: [
|
|
{col1: 1, col2: 2},
|
|
{col1: 3, col2: 4}
|
|
]
|
|
},
|
|
exp: {
|
|
fields: [
|
|
{id: 'col1'},
|
|
{id: 'col2'}
|
|
],
|
|
records: [
|
|
{col1: 1, col2: 2},
|
|
{col1: 3, col2: 4}
|
|
]
|
|
}
|
|
}
|
|
];
|
|
var dataset = new recline.Model.Dataset();
|
|
_.each(data, function(item) {
|
|
out = dataset._normalizeRecordsAndFields(item.in_.records, item.in_.fields);
|
|
deepEqual(out, item.exp);
|
|
});
|
|
|
|
});
|
|
|
|
|
|
// =================================
|
|
// Record
|
|
|
|
module("Model Record");
|
|
|
|
test('summary', function () {
|
|
var dataset = new recline.Model.Dataset({
|
|
records: [ {a: 1, b: 2} ]
|
|
});
|
|
var record = dataset.records.at(0);
|
|
var out = record.summary();
|
|
var exp = '<div class="recline-record-summary"><div class="a"><strong>a</strong>: 1</div><div class="b"><strong>b</strong>: 2</div></div>'
|
|
equal(out, exp);
|
|
});
|
|
|
|
// =================================
|
|
// Query
|
|
|
|
test('Query', function () {
|
|
var query = new recline.Model.Query();
|
|
query.addFacet('xyz');
|
|
deepEqual({terms: {field: 'xyz'}}, query.get('facets')['xyz']);
|
|
});
|
|
|
|
test('Query.addFacet', function () {
|
|
var query = new recline.Model.Query();
|
|
query.addFacet('xyz', 25);
|
|
deepEqual({terms: {field: 'xyz', "size": 25}}, query.get('facets')['xyz']);
|
|
});
|
|
|
|
test('Query.removeFacet', function () {
|
|
var query = new recline.Model.Query();
|
|
query.addFacet('xyz');
|
|
deepEqual({terms: {field: 'xyz'}}, query.get('facets')['xyz']);
|
|
query.removeFacet('xyz');
|
|
equal(undefined, query.get('facets')['xyz']);
|
|
});
|
|
|
|
test('Query.clearFacets', function () {
|
|
var query = new recline.Model.Query();
|
|
query.addFacet('abc');
|
|
query.addFacet('xyz');
|
|
deepEqual({terms: {field: 'xyz'}}, query.get('facets')['xyz']);
|
|
deepEqual({terms: {field: 'abc'}}, query.get('facets')['abc']);
|
|
query.clearFacets();
|
|
deepEqual({}, query.get('facets'));
|
|
});
|
|
|
|
test('Query.addFilter', function () {
|
|
var query = new recline.Model.Query();
|
|
query.addFilter({type: 'term', field: 'xyz'});
|
|
var exp = {
|
|
field: 'xyz',
|
|
type: 'term',
|
|
term: ''
|
|
};
|
|
deepEqual(query.get('filters')[0], exp);
|
|
|
|
query.addFilter({type: 'term', field: 'abc'});
|
|
deepEqual(query.get('filters')[0], exp);
|
|
|
|
query.addFilter({type: 'geo_distance', field: 'xyz'});
|
|
var exp = {
|
|
distance: 10,
|
|
unit: 'km',
|
|
point: {
|
|
lon: 0,
|
|
lat: 0
|
|
},
|
|
field: 'xyz',
|
|
type: 'geo_distance'
|
|
};
|
|
deepEqual(exp, query.get('filters')[2]);
|
|
});
|
|
|
|
test('Query.replaceFilter', function () {
|
|
var query = new recline.Model.Query();
|
|
query.addFilter({type: 'term', field: 'xyz', term: 'one'});
|
|
var exp = {
|
|
field: 'xyz',
|
|
type: 'term',
|
|
term: 'one'
|
|
};
|
|
deepEqual(query.get('filters')[0], exp);
|
|
|
|
query.replaceFilter({type: 'term', field: 'xyz', term: 'two'});
|
|
exp = {
|
|
field: 'xyz',
|
|
type: 'term',
|
|
term: 'two'
|
|
};
|
|
deepEqual(query.get('filters')[0], exp);
|
|
|
|
});
|
|
|
|
test('Query.replaceFilter first filter', function () {
|
|
// replaceFilter changes filter order
|
|
var query = new recline.Model.Query();
|
|
query.addFilter({type: 'term', field: 'abc', term: 'one'});
|
|
query.addFilter({type: 'term', field: 'xyz', term: 'two'});
|
|
var exp0 = {
|
|
field: 'abc',
|
|
type: 'term',
|
|
term: 'one'
|
|
};
|
|
deepEqual(query.get('filters')[0], exp0);
|
|
var exp1 = {
|
|
field: 'xyz',
|
|
type: 'term',
|
|
term: 'two'
|
|
};
|
|
deepEqual(query.get('filters')[1], exp1);
|
|
|
|
var numFilters = query.get('filters').length;
|
|
query.replaceFilter({type: 'term', field: 'abc', term: 'three'});
|
|
equal(query.get('filters').length, numFilters);
|
|
exp0 = {
|
|
field: 'abc',
|
|
type: 'term',
|
|
term: 'three'
|
|
};
|
|
// deletes original filter and adds replacement to end
|
|
deepEqual(query.get('filters')[1], exp0);
|
|
deepEqual(query.get('filters')[0], exp1);
|
|
|
|
});
|
|
|
|
})(this.jQuery);
|