@netdata/charts
Version:
Netdata frontend SDK and chart utilities
150 lines • 7.04 kB
JavaScript
function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
import scalableUnits, { keys } from "./scalableUnits";
describe("scalableUnits", function () {
describe("keys export", function () {
it("contains binary scale keys", function () {
expect(keys.binary).toEqual(["1", "Ki", "Mi", "Gi", "Ti", "Pi"]);
});
it("contains bit scale keys", function () {
expect(keys.bit).toEqual(["1", "k", "M", "G", "T", "P", "E", "Z", "Y"]);
});
it("contains decimal scale keys", function () {
expect(keys.decimal).toEqual(["1", "K", "M", "B", "T"]);
});
it("contains decimal byte scale keys", function () {
expect(keys.decimalBytes).toEqual(["1", "K", "M", "G", "T", "P", "E", "Z", "Y"]);
});
it("contains num scale keys", function () {
expect(keys.num).toEqual(["y", "z", "a", "f", "p", "n", "u", "m", "1", "k", "M", "G", "T", "P", "E", "Z", "Y"]);
});
});
describe("binary scales", function () {
it("contains correct binary multipliers", function () {
expect(scalableUnits.binary.Ki).toBe(1024);
expect(scalableUnits.binary.Mi).toBe(1048576);
expect(scalableUnits.binary.Gi).toBe(1073741824);
expect(scalableUnits.binary.Ti).toBe(1099511627776);
expect(scalableUnits.binary.Pi).toBe(1125899906842624);
});
it("uses powers of 1024", function () {
expect(scalableUnits.binary.Ki).toBe(Math.pow(1024, 1));
expect(scalableUnits.binary.Mi).toBe(Math.pow(1024, 2));
expect(scalableUnits.binary.Gi).toBe(Math.pow(1024, 3));
expect(scalableUnits.binary.Ti).toBe(Math.pow(1024, 4));
expect(scalableUnits.binary.Pi).toBe(Math.pow(1024, 5));
});
});
describe("decimal scales", function () {
it("contains correct decimal multipliers", function () {
expect(scalableUnits.decimal.K).toBe(1000);
expect(scalableUnits.decimal.M).toBe(1000000);
expect(scalableUnits.decimal.B).toBe(1000000000);
expect(scalableUnits.decimal.T).toBe(1000000000000);
});
it("uses powers of 1000", function () {
expect(scalableUnits.decimal.K).toBe(Math.pow(1000, 1));
expect(scalableUnits.decimal.M).toBe(Math.pow(1000, 2));
expect(scalableUnits.decimal.B).toBe(Math.pow(1000, 3));
expect(scalableUnits.decimal.T).toBe(Math.pow(1000, 4));
});
});
describe("decimal byte scales", function () {
it("contains SI byte multipliers", function () {
expect(scalableUnits.decimalBytes.K).toBe(1000);
expect(scalableUnits.decimalBytes.M).toBe(1000000);
expect(scalableUnits.decimalBytes.G).toBe(1000000000);
expect(scalableUnits.decimalBytes.T).toBe(1000000000000);
});
});
describe("num scales", function () {
it("contains scientific notation multipliers", function () {
expect(scalableUnits.num.y).toBe(0.000000000000000000000001); // yocto
expect(scalableUnits.num.z).toBe(0.000000000000000000001); // zepto
expect(scalableUnits.num.a).toBe(0.000000000000000001); // atto
expect(scalableUnits.num.f).toBe(0.000000000000001); // femto
expect(scalableUnits.num.p).toBe(0.000000000001); // pico
expect(scalableUnits.num.n).toBe(0.000000001); // nano
expect(scalableUnits.num.u).toBe(0.000001); // micro
expect(scalableUnits.num.m).toBe(0.001); // milli
});
it("contains large scale multipliers", function () {
expect(scalableUnits.num.k).toBe(1000); // kilo
expect(scalableUnits.num.M).toBe(1000000); // mega
expect(scalableUnits.num.G).toBe(1000000000); // giga
expect(scalableUnits.num.T).toBe(1000000000000); // tera
expect(scalableUnits.num.P).toBe(1000000000000000); // peta
expect(scalableUnits.num.E).toBe(1e18); // exa
expect(scalableUnits.num.Z).toBe(1e21); // zetta
expect(scalableUnits.num.Y).toBe(1e24); // yotta
});
it("uses correct scientific notation for very large numbers", function () {
expect(scalableUnits.num.E).toBe(1e18);
expect(scalableUnits.num.Z).toBe(1e21);
expect(scalableUnits.num.Y).toBe(1e24);
});
it("uses correct scientific notation for very small numbers", function () {
expect(scalableUnits.num.y).toBe(1e-24);
expect(scalableUnits.num.z).toBe(1e-21);
expect(scalableUnits.num.a).toBe(1e-18);
expect(scalableUnits.num.f).toBe(1e-15);
expect(scalableUnits.num.p).toBe(1e-12);
expect(scalableUnits.num.n).toBe(1e-9);
expect(scalableUnits.num.u).toBe(1e-6);
expect(scalableUnits.num.m).toBe(1e-3);
});
});
describe("structure validation", function () {
it("exports object with expected structure", function () {
expect(scalableUnits).toHaveProperty("binary");
expect(scalableUnits).toHaveProperty("decimal");
expect(scalableUnits).toHaveProperty("num");
});
it("contains only expected scale types", function () {
var expectedKeys = ["binary", "decimal", "decimalBytes", "chronos", "num"];
expect(Object.keys(scalableUnits)).toEqual(expectedKeys);
});
it("all scale values are numbers", function () {
Object.values(scalableUnits).forEach(function (scaleGroup) {
Object.values(scaleGroup).forEach(function (value) {
expect(_typeof(value)).toBe("number");
expect(Number.isFinite(value)).toBe(true);
});
});
});
it("all scale values are positive", function () {
Object.values(scalableUnits).forEach(function (scaleGroup) {
Object.values(scaleGroup).forEach(function (value) {
expect(value).toBeGreaterThan(0);
});
});
});
});
describe("mathematical relationships", function () {
it("binary scales follow 1024 progression", function () {
var binary = scalableUnits.binary;
expect(binary.Mi / binary.Ki).toBe(1024);
expect(binary.Gi / binary.Mi).toBe(1024);
expect(binary.Ti / binary.Gi).toBe(1024);
});
it("decimal scales follow 1000 progression", function () {
var decimal = scalableUnits.decimal;
expect(decimal.M / decimal.K).toBe(1000);
expect(decimal.B / decimal.M).toBe(1000);
expect(decimal.T / decimal.B).toBe(1000);
});
it("num scales follow 1000 progression for positive powers", function () {
var num = scalableUnits.num;
expect(num.M / num.k).toBe(1000);
expect(num.G / num.M).toBe(1000);
expect(num.T / num.G).toBe(1000);
expect(num.P / num.T).toBe(1000);
});
it("num scales follow 1000 division for negative powers", function () {
var num = scalableUnits.num;
expect(num.m / num.u).toBeCloseTo(1000, 6);
expect(num.u / num.n).toBeCloseTo(1000, 6);
expect(num.n / num.p).toBeCloseTo(1000, 6);
expect(num.p / num.f).toBeCloseTo(1000, 6);
});
});
});