615 lines
23 KiB
JavaScript
615 lines
23 KiB
JavaScript
(function() {
|
|
var fixtureData, raggedFixtureData;
|
|
|
|
fixtureData = [["name", "gender", "colour", "birthday", "trials", "successes"], ["Nick", "male", "blue", "1982-11-07", 103, 12], ["Jane", "female", "red", "1982-11-08", 95, 25], ["John", "male", "blue", "1982-12-08", 112, 30], ["Carol", "female", "yellow", "1983-12-08", 102, 14]];
|
|
|
|
raggedFixtureData = [
|
|
{
|
|
name: "Nick",
|
|
"colour": "red",
|
|
"age": 34
|
|
}, {
|
|
name: "Jane",
|
|
"gender": "female"
|
|
}, {
|
|
name: "John",
|
|
"gender": "male",
|
|
"age": 12
|
|
}, {
|
|
name: "Jim",
|
|
"gender": null,
|
|
"age": 12
|
|
}
|
|
];
|
|
|
|
describe("$.pivotUI()", function() {
|
|
describe("with no rows/cols, default count aggregator, default TableRenderer", function() {
|
|
var table;
|
|
table = null;
|
|
beforeEach(function(done) {
|
|
return table = $("<div>").pivotUI(fixtureData, {
|
|
onRefresh: done
|
|
});
|
|
});
|
|
it("has all the basic UI elements", function(done) {
|
|
expect(table.find("td.pvtAxisContainer").length).toBe(3);
|
|
expect(table.find("td.pvtRendererArea").length).toBe(1);
|
|
expect(table.find("td.pvtVals").length).toBe(1);
|
|
expect(table.find("select.pvtRenderer").length).toBe(1);
|
|
expect(table.find("select.pvtAggregator").length).toBe(1);
|
|
expect(table.find("span.pvtAttr").length).toBe(6);
|
|
return done();
|
|
});
|
|
it("reflects its inputs", function(done) {
|
|
expect(table.find("td.pvtUnused span.pvtAttr").length).toBe(6);
|
|
expect(table.find("select.pvtRenderer").val()).toBe("Table");
|
|
expect(table.find("select.pvtAggregator").val()).toBe("Count");
|
|
return done();
|
|
});
|
|
it("renders a table", function(done) {
|
|
expect(table.find("table.pvtTable").length).toBe(1);
|
|
return done();
|
|
});
|
|
return describe("its renderer output", function() {
|
|
it("has the correct type and number of cells", function(done) {
|
|
expect(table.find("th.pvtTotalLabel").length).toBe(1);
|
|
expect(table.find("td.pvtGrandTotal").length).toBe(1);
|
|
return done();
|
|
});
|
|
it("has the correct textual representation", function(done) {
|
|
expect(table.find("table.pvtTable").text()).toBe(["Totals", "4"].join(""));
|
|
return done();
|
|
});
|
|
return it("has a correct grand total with data value", function(done) {
|
|
expect(table.find("td.pvtGrandTotal").text()).toBe("4");
|
|
expect(table.find("td.pvtGrandTotal").data("value")).toBe(4);
|
|
return done();
|
|
});
|
|
});
|
|
});
|
|
describe("with rows/cols, sum-over-sum aggregator, Heatmap renderer", function() {
|
|
var table;
|
|
table = null;
|
|
beforeEach(function(done) {
|
|
return table = $("<div>").pivotUI(fixtureData, {
|
|
rows: ["gender"],
|
|
cols: ["colour"],
|
|
aggregatorName: "Sum over Sum",
|
|
vals: ["successes", "trials"],
|
|
rendererName: "Heatmap",
|
|
onRefresh: done
|
|
});
|
|
});
|
|
it("has all the basic UI elements", function(done) {
|
|
expect(table.find("td.pvtAxisContainer").length).toBe(3);
|
|
expect(table.find("td.pvtRendererArea").length).toBe(1);
|
|
expect(table.find("td.pvtVals").length).toBe(1);
|
|
expect(table.find("select.pvtRenderer").length).toBe(1);
|
|
expect(table.find("select.pvtAggregator").length).toBe(1);
|
|
expect(table.find("span.pvtAttr").length).toBe(6);
|
|
return done();
|
|
});
|
|
it("reflects its inputs", function(done) {
|
|
expect(table.find("td.pvtUnused span.pvtAttr").length).toBe(4);
|
|
expect(table.find("td.pvtRows span.pvtAttr").length).toBe(1);
|
|
expect(table.find("td.pvtCols span.pvtAttr").length).toBe(1);
|
|
expect(table.find("select.pvtRenderer").val()).toBe("Heatmap");
|
|
expect(table.find("select.pvtAggregator").val()).toBe("Sum over Sum");
|
|
return done();
|
|
});
|
|
it("renders a table", function(done) {
|
|
expect(table.find("table.pvtTable").length).toBe(1);
|
|
return done();
|
|
});
|
|
return describe("its renderer output", function() {
|
|
it("has the correct type and number of cells", function(done) {
|
|
expect(table.find("th.pvtAxisLabel").length).toBe(2);
|
|
expect(table.find("th.pvtRowLabel").length).toBe(2);
|
|
expect(table.find("th.pvtColLabel").length).toBe(3);
|
|
expect(table.find("th.pvtTotalLabel").length).toBe(2);
|
|
expect(table.find("td.pvtVal").length).toBe(6);
|
|
expect(table.find("td.pvtTotal").length).toBe(5);
|
|
expect(table.find("td.pvtGrandTotal").length).toBe(1);
|
|
return done();
|
|
});
|
|
it("has the correct textual representation", function(done) {
|
|
expect(table.find("table.pvtTable").text()).toBe(["colour", "blue", "red", "yellow", "Totals", "gender", "female", "0.26", "0.14", "0.20", "male", "0.20", "0.20", "Totals", "0.20", "0.26", "0.14", "0.20"].join(""));
|
|
return done();
|
|
});
|
|
return it("has a correct spot-checked cell with data value", function(done) {
|
|
expect(table.find("td.col0.row1").text()).toBe("0.20");
|
|
expect(table.find("td.col0.row1").data("value")).toBe((12 + 30) / (103 + 112));
|
|
return done();
|
|
});
|
|
});
|
|
});
|
|
return describe("with ragged input", function() {
|
|
var table;
|
|
table = $("<div>").pivotUI(raggedFixtureData, {
|
|
rows: ["gender"],
|
|
cols: ["age"]
|
|
});
|
|
return it("renders a table with the correct textual representation", function() {
|
|
return expect(table.find("table.pvtTable").text()).toBe(["age", "12", "34", "null", "Totals", "gender", "female", "1", "1", "male", "1", "1", "null", "1", "1", "2", "Totals", "2", "1", "1", "4"].join(""));
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("$.pivot()", function() {
|
|
describe("with no rows/cols, default count aggregator, default TableRenderer", function() {
|
|
var table;
|
|
table = $("<div>").pivot(fixtureData);
|
|
it("renders a table", function() {
|
|
return expect(table.find("table.pvtTable").length).toBe(1);
|
|
});
|
|
return describe("its renderer output", function() {
|
|
it("has the correct textual representation", function() {
|
|
return expect(table.find("table.pvtTable").text()).toBe(["Totals", "4"].join(""));
|
|
});
|
|
return it("has a correct grand total with data value", function() {
|
|
expect(table.find("td.pvtGrandTotal").text()).toBe("4");
|
|
return expect(table.find("td.pvtGrandTotal").data("value")).toBe(4);
|
|
});
|
|
});
|
|
});
|
|
describe("with rows/cols, sum aggregator, derivedAttributes, filter and sorters", function() {
|
|
var aggregators, derivers, ref, sortAs, table;
|
|
ref = $.pivotUtilities, sortAs = ref.sortAs, derivers = ref.derivers, aggregators = ref.aggregators;
|
|
table = $("<div>").pivot(fixtureData, {
|
|
rows: ["gender"],
|
|
cols: ["birthyear"],
|
|
aggregator: aggregators["Sum"](["trialbins"]),
|
|
filter: function(record) {
|
|
return record.name !== "Nick";
|
|
},
|
|
derivedAttributes: {
|
|
birthyear: derivers.dateFormat("birthday", "%y"),
|
|
trialbins: derivers.bin("trials", 10)
|
|
},
|
|
sorters: function(attr) {
|
|
if (attr === "gender") {
|
|
return sortAs(["male", "female"]);
|
|
}
|
|
}
|
|
});
|
|
return it("renders a table with the correct textual representation", function() {
|
|
return expect(table.find("table.pvtTable").text()).toBe(["birthyear", "1982", "1983", "Totals", "gender", "male", "110.00", "110.00", "female", "90.00", "100.00", "190.00", "Totals", "200.00", "100.00", "300.00"].join(""));
|
|
});
|
|
});
|
|
describe("with rows/cols, fraction-of aggregator", function() {
|
|
var aggregators, table;
|
|
aggregators = $.pivotUtilities.aggregators;
|
|
table = $("<div>").pivot(fixtureData, {
|
|
rows: ["gender"],
|
|
aggregator: aggregators["Sum as Fraction of Total"](["trials"])
|
|
});
|
|
return it("renders a table with the correct textual representation", function() {
|
|
return expect(table.find("table.pvtTable").text()).toBe(["gender", "Totals", "female", "47.8%", "male", "52.2%", "Totals", "100.0%"].join(""));
|
|
});
|
|
});
|
|
describe("with rows/cols, custom aggregator, custom renderer with options", function() {
|
|
var received_PivotData, received_rendererOptions, table;
|
|
received_PivotData = null;
|
|
received_rendererOptions = null;
|
|
table = $("<div>").pivot(fixtureData, {
|
|
rows: ["name", "colour"],
|
|
cols: ["trials", "successes"],
|
|
aggregator: function() {
|
|
return {
|
|
count2x: 0,
|
|
push: function() {
|
|
return this.count2x += 2;
|
|
},
|
|
value: function() {
|
|
return this.count2x;
|
|
},
|
|
format: function(x) {
|
|
return "formatted " + x;
|
|
}
|
|
};
|
|
},
|
|
renderer: function(a, b) {
|
|
received_PivotData = a;
|
|
received_rendererOptions = b;
|
|
return $("<div>").addClass(b.greeting).text("world");
|
|
},
|
|
rendererOptions: {
|
|
greeting: "hithere"
|
|
}
|
|
});
|
|
it("renders the custom renderer as per options", function() {
|
|
return expect(table.find("div.hithere").length).toBe(1);
|
|
});
|
|
return describe("its received PivotData object", function() {
|
|
return it("has a correct grand total value and format for custom aggregator", function() {
|
|
var agg, val;
|
|
agg = received_PivotData.getAggregator([], []);
|
|
val = agg.value();
|
|
expect(val).toBe(8);
|
|
return expect(agg.format(val)).toBe("formatted 8");
|
|
});
|
|
});
|
|
});
|
|
return describe("with ragged input", function() {
|
|
var table;
|
|
table = $("<div>").pivot(raggedFixtureData, {
|
|
rows: ["gender"],
|
|
cols: ["age"]
|
|
});
|
|
return it("renders a table with the correct textual representation", function() {
|
|
return expect(table.find("table.pvtTable").text()).toBe(["age", "12", "34", "null", "Totals", "gender", "female", "1", "1", "male", "1", "1", "null", "1", "1", "2", "Totals", "2", "1", "1", "4"].join(""));
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("$.pivotUtilities", function() {
|
|
describe(".PivotData()", function() {
|
|
var sumOverSumOpts;
|
|
sumOverSumOpts = {
|
|
aggregator: $.pivotUtilities.aggregators["Sum over Sum"](["a", "b"])
|
|
};
|
|
describe("with no options", function() {
|
|
var aoaInput, pd;
|
|
aoaInput = [["a", "b"], [1, 2], [3, 4]];
|
|
pd = new $.pivotUtilities.PivotData(aoaInput);
|
|
return it("has the correct grand total value", function() {
|
|
return expect(pd.getAggregator([], []).value()).toBe(2);
|
|
});
|
|
});
|
|
describe("with array-of-array input", function() {
|
|
var aoaInput, pd;
|
|
aoaInput = [["a", "b"], [1, 2], [3, 4]];
|
|
pd = new $.pivotUtilities.PivotData(aoaInput, sumOverSumOpts);
|
|
return it("has the correct grand total value", function() {
|
|
return expect(pd.getAggregator([], []).value()).toBe((1 + 3) / (2 + 4));
|
|
});
|
|
});
|
|
describe("with array-of-object input", function() {
|
|
var aosInput, pd;
|
|
aosInput = [
|
|
{
|
|
a: 1,
|
|
b: 2
|
|
}, {
|
|
a: 3,
|
|
b: 4
|
|
}
|
|
];
|
|
pd = new $.pivotUtilities.PivotData(aosInput, sumOverSumOpts);
|
|
return it("has the correct grand total value", function() {
|
|
return expect(pd.getAggregator([], []).value()).toBe((1 + 3) / (2 + 4));
|
|
});
|
|
});
|
|
describe("with ragged array-of-object input", function() {
|
|
var pd, raggedAosInput;
|
|
raggedAosInput = [
|
|
{
|
|
a: 1
|
|
}, {
|
|
b: 4
|
|
}, {
|
|
a: 3,
|
|
b: 2
|
|
}
|
|
];
|
|
pd = new $.pivotUtilities.PivotData(raggedAosInput, sumOverSumOpts);
|
|
return it("has the correct grand total value", function() {
|
|
return expect(pd.getAggregator([], []).value()).toBe((1 + 3) / (2 + 4));
|
|
});
|
|
});
|
|
describe("with function input", function() {
|
|
var functionInput, pd;
|
|
functionInput = function(record) {
|
|
record({
|
|
a: 1,
|
|
b: 2
|
|
});
|
|
return record({
|
|
a: 3,
|
|
b: 4
|
|
});
|
|
};
|
|
pd = new $.pivotUtilities.PivotData(functionInput, sumOverSumOpts);
|
|
return it("has the correct grand total value", function() {
|
|
return expect(pd.getAggregator([], []).value()).toBe((1 + 3) / (2 + 4));
|
|
});
|
|
});
|
|
describe("with jQuery table element input", function() {
|
|
var pd, tableInput;
|
|
tableInput = $("<table>\n <thead>\n <tr> <th>a</th><th>b</th> </tr>\n </thead>\n <tbody>\n <tr> <td>1</td> <td>2</td> </tr>\n <tr> <td>3</td> <td>4</td> </tr>\n </tbody>\n</table>");
|
|
pd = new $.pivotUtilities.PivotData(tableInput, sumOverSumOpts);
|
|
return it("has the correct grand total value", function() {
|
|
return expect(pd.getAggregator([], []).value()).toBe((1 + 3) / (2 + 4));
|
|
});
|
|
});
|
|
return describe("with rows/cols", function() {
|
|
var pd;
|
|
pd = new $.pivotUtilities.PivotData(fixtureData, {
|
|
rows: ["name", "colour"],
|
|
cols: ["trials", "successes"]
|
|
});
|
|
it("has correctly-ordered row keys", function() {
|
|
return expect(pd.getRowKeys()).toEqual([['Carol', 'yellow'], ['Jane', 'red'], ['John', 'blue'], ['Nick', 'blue']]);
|
|
});
|
|
it("has correctly-ordered col keys", function() {
|
|
return expect(pd.getColKeys()).toEqual([[95, 25], [102, 14], [103, 12], [112, 30]]);
|
|
});
|
|
it("can be iterated over", function() {
|
|
var c, i, j, len, len1, numNotNull, numNull, r, ref, ref1;
|
|
numNotNull = 0;
|
|
numNull = 0;
|
|
ref = pd.getRowKeys();
|
|
for (i = 0, len = ref.length; i < len; i++) {
|
|
r = ref[i];
|
|
ref1 = pd.getColKeys();
|
|
for (j = 0, len1 = ref1.length; j < len1; j++) {
|
|
c = ref1[j];
|
|
if (pd.getAggregator(r, c).value() != null) {
|
|
numNotNull++;
|
|
} else {
|
|
numNull++;
|
|
}
|
|
}
|
|
}
|
|
expect(numNotNull).toBe(4);
|
|
return expect(numNull).toBe(12);
|
|
});
|
|
it("returns matching records", function() {
|
|
var records;
|
|
records = [];
|
|
pd.forEachMatchingRecord({
|
|
gender: "male"
|
|
}, function(x) {
|
|
return records.push(x.name);
|
|
});
|
|
return expect(records).toEqual(["Nick", "John"]);
|
|
});
|
|
it("has a correct spot-checked aggregator", function() {
|
|
var agg, val;
|
|
agg = pd.getAggregator(['Carol', 'yellow'], [102, 14]);
|
|
val = agg.value();
|
|
expect(val).toBe(1);
|
|
return expect(agg.format(val)).toBe("1");
|
|
});
|
|
return it("has a correct grand total aggregator", function() {
|
|
var agg, val;
|
|
agg = pd.getAggregator([], []);
|
|
val = agg.value();
|
|
expect(val).toBe(4);
|
|
return expect(agg.format(val)).toBe("4");
|
|
});
|
|
});
|
|
});
|
|
describe(".aggregatorTemplates", function() {
|
|
var getVal, tpl;
|
|
getVal = function(aggregator) {
|
|
var pd;
|
|
pd = new $.pivotUtilities.PivotData(fixtureData, {
|
|
aggregator: aggregator
|
|
});
|
|
return pd.getAggregator([], []).value();
|
|
};
|
|
tpl = $.pivotUtilities.aggregatorTemplates;
|
|
describe(".count", function() {
|
|
return it("works", function() {
|
|
return expect(getVal(tpl.count()())).toBe(4);
|
|
});
|
|
});
|
|
describe(".countUnique", function() {
|
|
return it("works", function() {
|
|
return expect(getVal(tpl.countUnique()(['gender']))).toBe(2);
|
|
});
|
|
});
|
|
describe(".listUnique", function() {
|
|
return it("works", function() {
|
|
return expect(getVal(tpl.listUnique()(['gender']))).toBe('male,female');
|
|
});
|
|
});
|
|
describe(".average", function() {
|
|
return it("works", function() {
|
|
return expect(getVal(tpl.average()(['trials']))).toBe(103);
|
|
});
|
|
});
|
|
describe(".sum", function() {
|
|
return it("works", function() {
|
|
return expect(getVal(tpl.sum()(['trials']))).toBe(412);
|
|
});
|
|
});
|
|
describe(".min", function() {
|
|
return it("works", function() {
|
|
return expect(getVal(tpl.min()(['trials']))).toBe(95);
|
|
});
|
|
});
|
|
describe(".max", function() {
|
|
return it("works", function() {
|
|
return expect(getVal(tpl.max()(['trials']))).toBe(112);
|
|
});
|
|
});
|
|
describe(".first", function() {
|
|
return it("works", function() {
|
|
return expect(getVal(tpl.first()(['name']))).toBe('Carol');
|
|
});
|
|
});
|
|
describe(".last", function() {
|
|
return it("works", function() {
|
|
return expect(getVal(tpl.last()(['name']))).toBe('Nick');
|
|
});
|
|
});
|
|
describe(".average", function() {
|
|
return it("works", function() {
|
|
return expect(getVal(tpl.average()(['trials']))).toBe(103);
|
|
});
|
|
});
|
|
describe(".median", function() {
|
|
return it("works", function() {
|
|
return expect(getVal(tpl.median()(['trials']))).toBe(102.5);
|
|
});
|
|
});
|
|
describe(".quantile", function() {
|
|
return it("works", function() {
|
|
expect(getVal(tpl.quantile(0)(['trials']))).toBe(95);
|
|
expect(getVal(tpl.quantile(0.1)(['trials']))).toBe(98.5);
|
|
expect(getVal(tpl.quantile(0.25)(['trials']))).toBe(98.5);
|
|
expect(getVal(tpl.quantile(1 / 3)(['trials']))).toBe(102);
|
|
return expect(getVal(tpl.quantile(1)(['trials']))).toBe(112);
|
|
});
|
|
});
|
|
describe(".var", function() {
|
|
return it("works", function() {
|
|
return expect(getVal(tpl["var"]()(['trials']))).toBe(48.666666666666686);
|
|
});
|
|
});
|
|
describe(".stdev", function() {
|
|
return it("works", function() {
|
|
return expect(getVal(tpl.stdev()(['trials']))).toBe(6.976149845485451);
|
|
});
|
|
});
|
|
return describe(".sumOverSum", function() {
|
|
return it("works", function() {
|
|
return expect(getVal(tpl.sumOverSum()(['successes', 'trials']))).toBe((12 + 25 + 30 + 14) / (95 + 102 + 103 + 112));
|
|
});
|
|
});
|
|
});
|
|
describe(".naturalSort()", function() {
|
|
var naturalSort, sortedArr;
|
|
naturalSort = $.pivotUtilities.naturalSort;
|
|
sortedArr = [null, 0/0, -2e308, '-Infinity', -3, '-3', -2, '-2', -1, '-1', 0, '2e-1', 1, '01', '1', 2, '002', '002e0', '02', '2', '2e-0', 3, 10, '10', '11', '12', '1e2', '112', 2e308, 'Infinity', '1a', '2a', '12a', '20a', 'A', 'A', 'NaN', 'a', 'a', 'a01', 'a012', 'a02', 'a1', 'a2', 'a12', 'a12', 'a21', 'a21', 'b', 'c', 'd', 'null'];
|
|
return it("sorts naturally (null, NaN, numbers & numbery strings, Alphanum for text strings)", function() {
|
|
return expect(sortedArr.slice().sort(naturalSort)).toEqual(sortedArr);
|
|
});
|
|
});
|
|
describe(".sortAs()", function() {
|
|
var sortAs;
|
|
sortAs = $.pivotUtilities.sortAs;
|
|
it("sorts with unknown values sorted at the end", function() {
|
|
return expect([5, 2, 3, 4, 1].sort(sortAs([4, 3, 2]))).toEqual([4, 3, 2, 1, 5]);
|
|
});
|
|
return it("sorts lowercase after uppercase", function() {
|
|
return expect(["Ab", "aA", "aa", "ab"].sort(sortAs(["Ab", "Aa"]))).toEqual(["Ab", "ab", "aa", "aA"]);
|
|
});
|
|
});
|
|
describe(".numberFormat()", function() {
|
|
var numberFormat;
|
|
numberFormat = $.pivotUtilities.numberFormat;
|
|
it("formats numbers", function() {
|
|
var nf;
|
|
nf = numberFormat();
|
|
return expect(nf(1234567.89123456)).toEqual("1,234,567.89");
|
|
});
|
|
it("formats booleans", function() {
|
|
var nf;
|
|
nf = numberFormat();
|
|
return expect(nf(true)).toEqual("1.00");
|
|
});
|
|
it("formats numbers in strings", function() {
|
|
var nf;
|
|
nf = numberFormat();
|
|
return expect(nf("1234567.89123456")).toEqual("1,234,567.89");
|
|
});
|
|
it("doesn't formats strings", function() {
|
|
var nf;
|
|
nf = numberFormat();
|
|
return expect(nf("hi there")).toEqual("");
|
|
});
|
|
it("doesn't formats objects", function() {
|
|
var nf;
|
|
nf = numberFormat();
|
|
return expect(nf({
|
|
a: 1
|
|
})).toEqual("");
|
|
});
|
|
it("formats percentages", function() {
|
|
var nf;
|
|
nf = numberFormat({
|
|
scaler: 100,
|
|
suffix: "%"
|
|
});
|
|
return expect(nf(0.12345)).toEqual("12.35%");
|
|
});
|
|
it("adds separators", function() {
|
|
var nf;
|
|
nf = numberFormat({
|
|
thousandsSep: "a",
|
|
decimalSep: "b"
|
|
});
|
|
return expect(nf(1234567.89123456)).toEqual("1a234a567b89");
|
|
});
|
|
it("adds prefixes and suffixes", function() {
|
|
var nf;
|
|
nf = numberFormat({
|
|
prefix: "a",
|
|
suffix: "b"
|
|
});
|
|
return expect(nf(1234567.89123456)).toEqual("a1,234,567.89b");
|
|
});
|
|
return it("scales and rounds", function() {
|
|
var nf;
|
|
nf = numberFormat({
|
|
digitsAfterDecimal: 3,
|
|
scaler: 1000
|
|
});
|
|
return expect(nf(1234567.89123456)).toEqual("1,234,567,891.235");
|
|
});
|
|
});
|
|
return describe(".derivers", function() {
|
|
describe(".dateFormat()", function() {
|
|
var df;
|
|
df = $.pivotUtilities.derivers.dateFormat("x", "abc % %% %%% %a %y %m %n %d %w %x %H %M %S", true);
|
|
it("formats date objects", function() {
|
|
return expect(df({
|
|
x: new Date("2015-01-02T23:43:11Z")
|
|
})).toBe('abc % %% %%% %a 2015 01 Jan 02 Fri 5 23 43 11');
|
|
});
|
|
return it("formats input parsed by Date.parse()", function() {
|
|
expect(df({
|
|
x: "2015-01-02T23:43:11Z"
|
|
})).toBe('abc % %% %%% %a 2015 01 Jan 02 Fri 5 23 43 11');
|
|
return expect(df({
|
|
x: "bla"
|
|
})).toBe('');
|
|
});
|
|
});
|
|
return describe(".bin()", function() {
|
|
var binner;
|
|
binner = $.pivotUtilities.derivers.bin("x", 10);
|
|
it("bins numbers", function() {
|
|
expect(binner({
|
|
x: 11
|
|
})).toBe(10);
|
|
expect(binner({
|
|
x: 9
|
|
})).toBe(0);
|
|
return expect(binner({
|
|
x: 111
|
|
})).toBe(110);
|
|
});
|
|
it("bins booleans", function() {
|
|
return expect(binner({
|
|
x: true
|
|
})).toBe(0);
|
|
});
|
|
it("bins negative numbers", function() {
|
|
return expect(binner({
|
|
x: -12
|
|
})).toBe(-10);
|
|
});
|
|
it("doesn't bin strings", function() {
|
|
return expect(binner({
|
|
x: "a"
|
|
})).toBeNaN();
|
|
});
|
|
return it("doesn't bin objects", function() {
|
|
return expect(binner({
|
|
x: {
|
|
a: 1
|
|
}
|
|
})).toBeNaN();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
}).call(this);
|
|
|
|
//# sourceMappingURL=pivot_spec.js.map
|