lucid-ui
Version:
A UI component library from AppNexus.
342 lines • 9.02 kB
JavaScript
import _times from "lodash/times";
import assert from 'assert';
import { byFields, minByFields, maxByFields, maxByFieldsStacked, discreteTicks, groupByFields, stackByFields, extractFields, transformFromCenter, nearest } from './chart-helpers';
describe('chart-helpers', function () {
// Testing `formatDate` will require us to mock our time zone. Since the
// function was taken from d3, I'm going to leave out testing it since the
// value isn't worth the cost of adding a time mocking library.
//
// describe('formatDate', () => {});
describe('transformFromCenter', function () {
it('should work', function () {
assert.equal(transformFromCenter(10, 10, 20, 20, 2), 'translate(-30, -30) scale(2)');
assert.equal(transformFromCenter(10, 10, 12, 16, 3), 'translate(-26, -38) scale(3)');
});
});
describe('extractFields', function () {
it('should have a similar format to stackByFields', function () {
var data = [{
a: 1,
b: 2,
c: 3,
d: 4
}, {
a: 4,
b: 3,
c: 2,
d: 1
}, {
a: 10,
b: 15,
c: 20,
d: 100
}];
assert.deepEqual(extractFields(data, ['a', 'b', 'c', 'd']), [[[0, 1], [0, 2], [0, 3], [0, 4]], [[0, 4], [0, 3], [0, 2], [0, 1]], [[0, 10], [0, 15], [0, 20], [0, 100]]]);
});
it('should handle missing data points', function () {
var data = [{
a: 1,
c: 3,
d: 4
}, {
a: 4,
b: 3,
c: 2,
d: 1
}, {
a: 10,
d: 100
}];
assert.deepEqual(extractFields(data, ['a', 'b', 'c', 'd']), [[[0, 1], [0, 0], [0, 3], [0, 4]], [[0, 4], [0, 3], [0, 2], [0, 1]], [[0, 10], [0, 0], [0, 0], [0, 100]]]);
});
it('should use minimum domain value', function () {
var data = [{
y: 1
}, {
y: 10
}, {
y: 100
}];
assert.deepEqual(extractFields(data, ['y'], 1), [[[1, 1]], [[1, 10]], [[1, 100]]]);
});
});
describe('stackByFields', function () {
it('should stack data by fields', function () {
var data = [{
a: 1,
b: 2,
c: 3,
d: 4
}, {
a: 4,
b: 3,
c: 2,
d: 1
}, {
a: 10,
b: 15,
c: 20,
d: 100
}];
assert.deepEqual(stackByFields(data, ['a', 'b', 'c', 'd']), [[[0, 1], [1, 3], [3, 6], [6, 10]], [[0, 4], [4, 7], [7, 9], [9, 10]], [[0, 10], [10, 25], [25, 45], [45, 145]]]);
});
it('should handle missing data points', function () {
var data = [{
a: 1,
c: 3,
d: 4
}, {
a: 4,
b: 3,
c: 2,
d: 1
}, {
a: 10,
d: 100
}];
assert.deepEqual(stackByFields(data, ['a', 'b', 'c', 'd']), [[[0, 1], [1, 1], [1, 4], [4, 8]], [[0, 4], [4, 7], [7, 9], [9, 10]], [[0, 10], [10, 10], [10, 10], [10, 110]]]);
});
});
describe('nearest', function () {
it('should work with a range of inputs', function () {
assert.equal(nearest([0, 10, 20, 50], 12.3), 10);
assert.equal(nearest([0, 10, 20, 50], 15.1), 20);
assert.equal(nearest([0, 10, 20, 50], 49), 50);
assert.equal(nearest([0, 10, 20, 50], 49), 50);
});
it('should handle numbers smaller than the range', function () {
assert.equal(nearest([5, 15], -15), 5);
});
it('should handle numbers larger than the range', function () {
assert.equal(nearest([5, 15], -15), 5);
});
it('should should favor the left side', function () {
assert.equal(nearest([0, 10], 5), 0);
});
});
describe('groupByFields', function () {
it('should work', function () {
var data = [{
a: 'one',
b: 20,
c: 30,
d: 40
}, {
a: 'two',
b: 21,
c: 31,
d: 41
}, {
a: 'two',
b: 22,
c: 32,
d: 42
}];
assert.deepEqual(groupByFields(data, ['b', 'c', 'd']), [[20, 21, 22], [30, 31, 32], [40, 41, 42]]);
});
it('should handle missing and extra data points', function () {
var data = [{
a: 'one',
b: 20,
c: 30,
d: 40
}, {
a: 'two',
b: 21,
d: 41
}, {
a: 'two',
b: 22,
c: 32,
d: 42,
e: 100
}];
assert.deepEqual(groupByFields(data, ['b', 'c', 'd']), [[20, 21, 22], [30, undefined, 32], [40, 41, 42]]);
});
it('should handle non-array fields', function () {
var data = [{
a: 'one',
b: 1
}, {
a: 'two',
b: 3
}, {
a: 'two',
b: 10
}];
assert.deepEqual(groupByFields(data, 'b'), [[1, 3, 10]]);
});
});
describe('maxByFieldsStacked', function () {
it('should return the max for a collection', function () {
var data = [{
a: 'one',
b: 1,
c: 3,
d: 5
}, {
a: 'two',
b: 3,
c: 4,
d: 7
}, {
a: 'two',
b: 10,
c: 10,
d: 10
}];
assert.equal(maxByFieldsStacked(data, ['b', 'c', 'd']), 30);
});
});
describe('discreteTicks', function () {
it('should work on a myriad of ranges', function () {
assert.deepEqual(discreteTicks(_times(100), 1), [0]);
assert.deepEqual(discreteTicks(_times(100), 2), [0, 99]);
assert.deepEqual(discreteTicks(_times(100), 3), [0, 50, 99]);
assert.deepEqual(discreteTicks(_times(100), 4), [0, 33, 66, 99]);
});
it('should return the plain array if count is too big', function () {
assert.deepEqual(discreteTicks([1, 2, 3], 3), [1, 2, 3]);
assert.deepEqual(discreteTicks([1, 2, 3], 4), [1, 2, 3]);
});
it('should handle empty arrays', function () {
assert.deepEqual(discreteTicks([], 100), []);
});
it('should handle no count', function () {
assert.deepEqual(discreteTicks([1, 2, 3]), [1, 2, 3]);
assert.deepEqual(discreteTicks([1, 2, 3]), [1, 2, 3]);
});
});
describe('byFields', function () {
it('should work with a single field', function () {
var data = [{
rev: 1
}, {
rev: 2
}, {
rev: 'foo',
extra: 2
}];
assert.deepEqual(byFields(data, 'rev'), [1, 2, 'foo'], 'got the wrong value back byFields');
});
it('should work with a single field in an array', function () {
var data = [{
rev: 1
}, {
rev: 2
}, {
rev: 'foo',
extra: 2
}];
assert.deepEqual(byFields(data, ['rev']), [1, 2, 'foo'], 'got the wrong value back byFields');
});
it('should work with multiple fields', function () {
var data = [{
rev: 1,
imps: 100
}, {
rev: 2,
imps: 200
}, {
rev: 'foo',
extra: 2,
imps: 300
}];
assert.deepEqual(byFields(data, ['rev', 'imps']), [1, 2, 'foo', 100, 200, 300], 'got the wrong value back byFields');
});
});
describe('minByFields', function () {
it('should take a single field and return the minimum', function () {
var data = [{
a: 1
}, {
a: 3
}, {
a: 10
}, {
a: 3
}, {
a: 2
}, {
a: 1
}];
assert.equal(minByFields(data, 'a'), 1, 'did not get the correct min back');
});
it('should take an array of fields and return the minimum', function () {
var data = [{
a: 1,
b: 10
}, {
a: 3
}, {
a: 10,
b: 0
}, {
a: 3,
b: 1
}, {
a: 2,
b: 0
}, {
a: 1,
b: 10
}];
assert.equal(minByFields(data, ['a', 'b']), 0, 'did not get the correct min back');
});
});
describe('maxByFields', function () {
it('should take a single field and return the maximum', function () {
var data = [{
foo: 1
}, {
foo: 3
}, {
foo: 10
}, {
foo: 3
}, {
foo: 2000
}, {
foo: 1
}];
assert.equal(maxByFields(data, 'foo'), 2000, 'did not get the correct max back');
});
it('should take a single field in an array and return the maximum', function () {
var data = [{
foo: 1
}, {
foo: 3
}, {
foo: 10
}, {
foo: 3
}, {
foo: 3000
}, {
foo: 1
}];
assert.equal(maxByFields(data, ['foo']), 3000, 'did not get the correct max back');
});
it('should take an array of fields and return the maximum', function () {
var data = [{
a: 1,
b: 10
}, {
a: 3,
b: 20
}, {
a: 10,
b: 0
}, {
a: 3,
b: 1
}, {
a: 2,
b: 0
}, {
a: 1
}];
assert.equal(maxByFields(data, ['a', 'b']), 20, 'did not get the correct max back');
});
});
});