@netdata/charts
Version:
Netdata frontend SDK and chart utilities
379 lines • 15.8 kB
JavaScript
function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
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 unitConverter, { unitsMissing, getUnitConfig, getAlias, isScalable, isMetric, isBinary, isBit, getScales, getUnitsString } from ".";
import allUnits from "./all";
import scalableUnits from "./scalableUnits";
describe("units helpers", function () {
describe("unitsMissing", function () {
it("returns true for undefined units", function () {
expect(unitsMissing("nonexistent_unit")).toBe(true);
});
it("returns false for existing units", function () {
expect(unitsMissing("By")).toBe(false);
expect(unitsMissing("s")).toBe(false);
expect(unitsMissing("%")).toBe(false);
});
it("returns boolean for any input", function () {
expect(_typeof(unitsMissing("any_unit"))).toBe("boolean");
expect(_typeof(unitsMissing(""))).toBe("boolean");
expect(_typeof(unitsMissing(null))).toBe("boolean");
expect(_typeof(unitsMissing(undefined))).toBe("boolean");
});
});
describe("getUnitConfig", function () {
it("returns config object with required properties", function () {
var config = getUnitConfig("By");
expect(config).toHaveProperty("is_scalable", true);
expect(config).toHaveProperty("is_metric", true);
expect(config).toHaveProperty("is_binary", true);
expect(config).toHaveProperty("print_symbol", "B");
expect(config).toHaveProperty("name", "bytes");
// is_bit is added by getUnitConfig for unknown units, but By doesn't have it
expect(config.is_bit).toBeUndefined();
});
it("returns actual unit config for known units", function () {
var config = getUnitConfig("s");
expect(config.is_metric).toBe(true);
expect(config.is_scalable).toBe(true);
expect(config.print_symbol).toBe("s");
expect(config.name).toBe("seconds");
});
it("returns default config for unknown units", function () {
var config = getUnitConfig("unknown_unit");
expect(config).toEqual({
is_scalable: true,
is_metric: false,
is_binary: false,
is_bit: false,
print_symbol: "unknown_unit",
name: "unknown_unit"
});
});
it("handles null units", function () {
var config = getUnitConfig(null);
expect(config.print_symbol).toBe("");
expect(config.name).toBe("");
});
it("handles undefined units", function () {
var config = getUnitConfig(undefined);
expect(config.print_symbol).toBe("");
expect(config.name).toBe("");
});
it("preserves unit string for unknown units", function () {
var config = getUnitConfig("custom/second");
expect(config.print_symbol).toBe("custom/second");
expect(config.name).toBe("custom/second");
});
});
describe("getAlias", function () {
it("returns alias for known aliases", function () {
expect(getAlias("% of time working")).toBe("%");
expect(getAlias("seconds")).toBe("s");
expect(getAlias("bytes")).toBe("By");
});
it("returns original unit if no alias exists but unit is known", function () {
expect(getAlias("By")).toBe("By");
expect(getAlias("s")).toBe("s");
expect(getAlias("%")).toBe("%");
});
it("finds curly brace variants", function () {
// Test with actual curly brace units from all.js
var result = getAlias("custom");
// If {custom} doesn't exist, it should return "custom"
expect(_typeof(result)).toBe("string");
});
it("handles units with slashes", function () {
// Mock the all.js structure to test slash handling
// Test with existing slash patterns from all.js
// actions/s is aliased to {action}/s
expect(getAlias("actions/s")).toBe("{action}/s");
});
it("returns original unit if no match found", function () {
expect(getAlias("completely_unknown")).toBe("completely_unknown");
});
});
describe("isScalable", function () {
it("returns true for scalable units", function () {
expect(isScalable("By")).toBe(true);
expect(isScalable("s")).toBe(true);
expect(isScalable("bit")).toBe(true);
});
it("returns false for non-scalable units", function () {
expect(isScalable("%")).toBe(false);
// Most units default to scalable, find actual non-scalable ones
var config = getUnitConfig("%");
expect(config.is_scalable).toBe(false);
});
it("handles string input", function () {
expect(isScalable("unknown_unit")).toBe(true); // defaults to scalable
});
it("handles unit config object input", function () {
var scalableConfig = {
is_scalable: true
};
var nonScalableConfig = {
is_scalable: false
};
expect(isScalable(scalableConfig)).toBe(true);
expect(isScalable(nonScalableConfig)).toBe(false);
});
it("handles empty or undefined input", function () {
expect(isScalable("")).toBe(true);
expect(isScalable()).toBe(true);
expect(isScalable(null)).toBeUndefined();
});
});
describe("isMetric", function () {
it("returns true for metric units", function () {
expect(isMetric("s")).toBe(true);
expect(isMetric("By")).toBe(true); // bytes is metric in all.js
});
it("returns false for non-metric units", function () {
expect(isMetric("%")).toBe(false);
// Note: By (bytes) is actually metric:true in all.js
});
it("handles unit config object input", function () {
var metricConfig = {
is_metric: true
};
var nonMetricConfig = {
is_metric: false
};
expect(isMetric(metricConfig)).toBe(true);
expect(isMetric(nonMetricConfig)).toBe(false);
});
it("handles empty or undefined input", function () {
expect(isMetric("")).toBe(false);
expect(isMetric()).toBe(false);
});
});
describe("isBinary", function () {
it("returns true for binary units", function () {
expect(isBinary("By")).toBe(true);
});
it("returns false for non-binary units", function () {
expect(isBinary("s")).toBe(false);
expect(isBinary("bit")).toBe(false);
expect(isBinary("%")).toBe(false);
});
it("handles unit config object input", function () {
var binaryConfig = {
is_binary: true
};
var nonBinaryConfig = {
is_binary: false
};
expect(isBinary(binaryConfig)).toBe(true);
expect(isBinary(nonBinaryConfig)).toBe(false);
});
it("handles empty or undefined input", function () {
expect(isBinary("")).toBe(false);
expect(isBinary()).toBe(false);
});
});
describe("isBit", function () {
it("returns true for bit units", function () {
expect(isBit("bit")).toBe(true);
});
it("returns false for non-bit units", function () {
// Units without is_bit property return undefined
expect(isBit("By")).toBeUndefined();
expect(isBit("s")).toBeUndefined();
expect(isBit("%")).toBeUndefined();
});
it("handles unit config object input", function () {
var bitConfig = {
is_bit: true
};
var nonBitConfig = {
is_bit: false
};
expect(isBit(bitConfig)).toBe(true);
expect(isBit(nonBitConfig)).toBe(false);
});
it("handles empty or undefined input", function () {
expect(isBit("")).toBe(false);
expect(isBit()).toBe(false);
});
});
describe("getScales", function () {
it("returns empty arrays for non-scalable units", function () {
var _getScales = getScales("%"),
_getScales2 = _slicedToArray(_getScales, 2),
keys = _getScales2[0],
values = _getScales2[1];
expect(keys).toEqual([]);
expect(values).toEqual({});
});
it("returns binary scales for binary units", function () {
var _getScales3 = getScales("By"),
_getScales4 = _slicedToArray(_getScales3, 2),
keys = _getScales4[0],
values = _getScales4[1];
expect(keys).toContain("1");
expect(keys).toContain("Ki");
expect(keys).toContain("Mi");
expect(values).toBe(scalableUnits.binary);
});
it("returns num scales for bit units", function () {
var _getScales5 = getScales("bit"),
_getScales6 = _slicedToArray(_getScales5, 2),
keys = _getScales6[0],
values = _getScales6[1];
expect(keys).toContain("1");
expect(keys).toContain("k");
expect(keys).toContain("M");
expect(values).toBe(scalableUnits.num);
});
it("returns num scales for metric units", function () {
var _getScales7 = getScales("s"),
_getScales8 = _slicedToArray(_getScales7, 2),
keys = _getScales8[0],
values = _getScales8[1];
expect(keys).toContain("1");
expect(keys).toContain("k");
expect(keys).toContain("m");
expect(keys).toContain("u");
expect(values).toBe(scalableUnits.num);
});
it("returns decimal scales for other scalable units", function () {
var _getScales9 = getScales("unknown_scalable"),
_getScales10 = _slicedToArray(_getScales9, 2),
keys = _getScales10[0],
values = _getScales10[1];
expect(keys).toEqual(["1", "K", "M", "B", "T"]);
expect(values).toBe(scalableUnits.decimal);
});
});
describe("getUnitsString", function () {
it("returns base label for non-scalable units", function () {
var result = getUnitsString("%", "", "%");
expect(result).toBe("%");
});
it("returns base label with config for non-scalable units", function () {
var config = {
print_symbol: "%",
name: "percentage"
};
var result = getUnitsString(config, "", "percent");
expect(result).toBe("%");
});
it("returns long name when requested for non-scalable units", function () {
var config = {
print_symbol: "%",
name: "percentage"
};
var result = getUnitsString(config, "", "percent", true);
expect(result).toBe("percentage");
});
it("combines prefix and base for metric units", function () {
var result = getUnitsString("s", "k", "s");
expect(result).toBe("ks");
});
it("combines prefix and base for binary units", function () {
var result = getUnitsString("By", "Ki", "B");
expect(result).toBe("KiB");
});
it("combines prefix and base for bit units", function () {
var result = getUnitsString("bit", "k", "bit");
expect(result).toBe("kbit");
});
it("uses decimal prefix format for other units", function () {
var result = getUnitsString("unknown_scalable", "K", "items");
expect(result).toBe("K items");
});
it("handles empty prefix", function () {
var result = getUnitsString("s", "", "s");
expect(result).toBe("s");
});
it("handles long format for prefixes", function () {
var result = getUnitsString("s", "k", "seconds", true);
expect(result).toBe("kiloseconds");
});
it("trims whitespace correctly", function () {
var result = getUnitsString("unknown", "", "");
expect(result).toBe("");
});
});
describe("default export (unitConverter)", function () {
var mockChart;
beforeEach(function () {
mockChart = {
getAttribute: jest.fn(),
updateAttribute: jest.fn()
};
});
it("returns original value for original method", function () {
var result = unitConverter(mockChart, "original", 100);
expect(result).toBe(100);
});
it("divides value for divide method", function () {
var result = unitConverter(mockChart, "divide", 1000, 10);
expect(result).toBe(100);
});
it("applies make function for adjust method", function () {
var makeFn = jest.fn(function (value) {
return value * 2;
});
var result = unitConverter(mockChart, "adjust", 50, makeFn);
expect(result).toBe(100);
expect(makeFn).toHaveBeenCalledWith(50);
});
it("falls back to original for unknown methods", function () {
var result = unitConverter(mockChart, "unknown_method", 42);
expect(result).toBe(42);
});
it("handles conversable unit methods", function () {
// This would be tested more thoroughly with actual conversableUnits data
var result = unitConverter(mockChart, "seconds-ms", 1000);
expect(_typeof(result)).toBe("number");
});
it("handles null/undefined values gracefully", function () {
expect(unitConverter(mockChart, "original", null)).toBeNull();
expect(unitConverter(mockChart, "original", undefined)).toBeUndefined();
expect(unitConverter(mockChart, "original", 0)).toBe(0);
});
});
describe("edge cases and error handling", function () {
it("handles malformed unit strings", function () {
expect(function () {
return getUnitConfig("");
}).not.toThrow();
expect(function () {
return getAlias("");
}).not.toThrow();
expect(function () {
return isScalable("");
}).not.toThrow();
});
it("handles numeric inputs where strings expected", function () {
expect(function () {
return getUnitConfig(123);
}).not.toThrow();
expect(function () {
return getAlias(123);
}).not.toThrow();
});
it("handles complex slash patterns in getAlias", function () {
// Test deep slash patterns
var complexUnit = "requests/per/second/avg";
var result = getAlias(complexUnit);
expect(_typeof(result)).toBe("string");
});
it("preserves object references for scale data", function () {
var _getScales11 = getScales("By"),
_getScales12 = _slicedToArray(_getScales11, 2),
binaryScales = _getScales12[1];
var _getScales13 = getScales("s"),
_getScales14 = _slicedToArray(_getScales13, 2),
metricScales = _getScales14[1];
expect(binaryScales).toBe(scalableUnits.binary);
expect(metricScales).toBe(scalableUnits.num);
});
});
});