@netdata/charts
Version:
Netdata frontend SDK and chart utilities
610 lines • 27.5 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, getNormalizedUnit, getNormalizedUnitConfig, getAlias, isScalable, isMetric, isBinary, isBit, isDecimalByte, getScales, getUnitsString } from ".";
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);
expect(unitsMissing("requests/s")).toBe(false);
expect(unitsMissing("unknown")).toBe(false);
expect(unitsMissing("m3/min")).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("uses the micro sign for microsecond display labels", function () {
var config = getUnitConfig("us");
expect(config.print_symbol).toBe("\xB5s");
expect(config.print_symbol).not.toBe("\u03BCs");
});
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("accepts both microsecond characters as aliases", function () {
expect(getAlias("\xB5s")).toBe("us");
expect(getAlias("\u03BCs")).toBe("us");
});
it("aliases source-scaled Agent units without losing their denominator", function () {
expect(getAlias("KB")).toBe("KBy");
expect(getAlias("MiB")).toBe("MiBy");
expect(getAlias("MB")).toBe("MBy");
expect(getAlias("GB")).toBe("GBy");
expect(getAlias("TB")).toBe("TBy");
expect(getAlias("PB")).toBe("PBy");
expect(getAlias("GBy")).toBe("GBy");
expect(getAlias("TiB")).toBe("TiBy");
expect(getAlias("PiB")).toBe("PiBy");
expect(getAlias("MB/s")).toBe("MBy/s");
expect(getAlias("GB/s")).toBe("GBy/s");
expect(getAlias("kilobytes/s")).toBe("KBy/s");
expect(getAlias("kilobytes per operation")).toBe("KBy/{operation}");
expect(getAlias("bits")).toBe("bit");
expect(getAlias("bits/s")).toBe("bit/s");
expect(getAlias("kilobits")).toBe("Kibit");
expect(getAlias("kbit/s")).toBe("Kibit/s");
expect(getAlias("megabits")).toBe("Mibit");
expect(getAlias("Mbps")).toBe("Mibit/s");
expect(getAlias("MHz")).toBe("MHz");
expect(getAlias("microsecond")).toBe("us");
expect(getAlias("millisecond")).toBe("ms");
expect(getAlias("nanosecond")).toBe("ns");
expect(getAlias("nanoseconds")).toBe("ns");
expect(getAlias("second")).toBe("s");
expect(getAlias("sec")).toBe("s");
expect(getAlias("secs")).toBe("s");
expect(getAlias("hr")).toBe("h");
expect(getAlias("hrs")).toBe("h");
expect(getAlias("Celcius")).toBe("Cel");
expect(getAlias("Joules")).toBe("J");
expect(getAlias("pcent")).toBe("%");
expect(getAlias("minutes")).toBe("min");
expect(getAlias("hours")).toBe("h");
expect(getAlias("weeks")).toBe("wk");
expect(getAlias("months")).toBe("mo");
expect(getAlias("years")).toBe("a");
expect(getAlias("KiB/operation")).toBe("KiBy/{operation}");
expect(getAlias("milliseconds/request")).toBe("ms/{request}");
expect(getAlias("milliseconds/run")).toBe("ms/{run}");
expect(getAlias("milliseconds/operation")).toBe("ms/{operation}");
expect(getAlias("usec/s")).toBe("us/s");
expect(getAlias("gigabytes")).toBe("GBy");
expect(getAlias("GiB/s")).toBe("GiBy/s");
expect(getAlias("millicpu")).toBe("m[CPU]");
expect(getAlias("milliamps")).toBe("mA");
expect(getAlias("millivolts")).toBe("mV");
expect(getAlias("mJ/s")).toBe("mW");
expect(getAlias("dBm")).toBe("dB[mW]");
});
it("aliases the additional verified Netdata unit strings", function () {
expect(getAlias("scopes")).toBe("{scope}");
expect(getAlias("values")).toBe("{value}");
expect(getAlias("fields")).toBe("{field}");
expect(getAlias("buckets")).toBe("{bucket}");
expect(getAlias("buckets/s")).toBe("{bucket}/s");
expect(getAlias("count/s")).toBe("{count}/s");
expect(getAlias("unknown")).toBe("{item}");
expect(getAlias("m3/min")).toBe("m3/min");
expect(getAlias("dimensions")).toBe("{dimension}");
expect(getAlias("models")).toBe("{model}");
expect(getAlias("profile_units")).toBe("{profile unit}");
expect(getAlias("vus")).toBe("{virtual user}");
expect(getAlias("iterations")).toBe("{iteration}");
expect(getAlias("kb/s")).toBe("Kibit/s");
expect(getAlias("tests/s")).toBe("{test}/s");
expect(getAlias("worker processes")).toBe("{worker process}");
expect(getAlias("app pool status")).toBe("{status}");
expect(getAlias("app pool worker processes")).toBe("{worker process}");
expect(getAlias("app pool failures")).toBe("{app pool failure}");
expect(getAlias("app pool recycles")).toBe("{app pool recycle}");
expect(getAlias("app pool uptime")).toBe("app pool uptime");
expect(getAlias("w3svc w3wp")).toBe("w3svc w3wp");
expect(getAlias("failed servers")).toBe("{failed server}");
expect(getAlias("health servers")).toBe("{health server}");
expect(getAlias("maintenance servers")).toBe("{maintenance server}");
expect(getAlias("responses")).toBe("{response}");
});
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("getNormalizedUnit", function () {
it("returns the base unit for pre-scaled binary and metric units", function () {
expect(getNormalizedUnit("KiBy")).toBe("By");
expect(getNormalizedUnit("KiBy/s")).toBe("By/s");
expect(getNormalizedUnit("KiBy/{operation}")).toBe("By/{operation}");
expect(getNormalizedUnit("GiBy")).toBe("By");
expect(getNormalizedUnit("GiBy/s")).toBe("By/s");
expect(getNormalizedUnit("TiBy")).toBe("By");
expect(getNormalizedUnit("PiBy")).toBe("By");
expect(getNormalizedUnit("KBy")).toBe("By");
expect(getNormalizedUnit("MBy")).toBe("By");
expect(getNormalizedUnit("GBy")).toBe("By");
expect(getNormalizedUnit("TBy")).toBe("By");
expect(getNormalizedUnit("PBy")).toBe("By");
expect(getNormalizedUnit("GBy/s")).toBe("By/s");
expect(getNormalizedUnit("KBy/{operation}")).toBe("By/{operation}");
expect(getNormalizedUnit("ms")).toBe("s");
expect(getNormalizedUnit("ms/{request}")).toBe("s/{request}");
expect(getNormalizedUnit("Mibit/s")).toBe("bit/s");
expect(getNormalizedUnit("kb/s")).toBe("bit/s");
expect(getNormalizedUnit("MHz")).toBe("Hz");
expect(getNormalizedUnit("m[CPU]")).toBe("[CPU]");
expect(getNormalizedUnit("min")).toBe("s");
expect(getNormalizedUnit("h")).toBe("s");
expect(getNormalizedUnit("d")).toBe("s");
expect(getNormalizedUnit("wk")).toBe("s");
expect(getNormalizedUnit("mo")).toBe("s");
expect(getNormalizedUnit("a")).toBe("s");
expect(getNormalizedUnit("mA")).toBe("Ampere");
expect(getNormalizedUnit("mW")).toBe("W");
expect(getNormalizedUnit("unknown")).toBe("{item}");
});
it("keeps non-scalable special units in their source unit", function () {
expect(getNormalizedUnit("dB[mW]")).toBe("dB[mW]");
});
it("returns normalized unit config labels", function () {
expect(getNormalizedUnitConfig("KiBy").name).toBe("bytes");
expect(getNormalizedUnitConfig("ms/{request}").name).toBe("seconds per request");
expect(getNormalizedUnitConfig("m[CPU]").name).toBe("cores");
expect(getNormalizedUnitConfig("dB[mW]").name).toBe("decibel milliwatts");
expect(getNormalizedUnitConfig("unknown").name).toBe("items");
});
});
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);
expect(isScalable("unknown")).toBe(true);
});
it("returns false for non-scalable units", function () {
expect(isScalable("%")).toBe(false);
expect(isScalable("m3/min")).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("isDecimalByte", function () {
it("returns true for decimal byte units", function () {
expect(isDecimalByte("KBy")).toBe(true);
expect(isDecimalByte("MBy")).toBe(true);
expect(isDecimalByte("GBy")).toBe(true);
expect(isDecimalByte("TBy")).toBe(true);
expect(isDecimalByte("PBy")).toBe(true);
expect(isDecimalByte("MBy/s")).toBe(true);
expect(isDecimalByte("KBy/{operation}")).toBe(true);
});
it("returns false for binary byte units", function () {
expect(isDecimalByte("KiBy")).toBe(false);
expect(isDecimalByte("MiBy")).toBe(false);
expect(isDecimalByte("GiBy")).toBe(false);
expect(isDecimalByte("TiBy")).toBe(false);
expect(isDecimalByte("PiBy")).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 decimal byte scales for decimal byte units", function () {
var _getScales5 = getScales("MBy"),
_getScales6 = _slicedToArray(_getScales5, 2),
keys = _getScales6[0],
values = _getScales6[1];
expect(keys).toContain("K");
expect(keys).toContain("G");
expect(values).toBe(scalableUnits.decimalBytes);
});
it("returns num scales for bit units", function () {
var _getScales7 = getScales("bit"),
_getScales8 = _slicedToArray(_getScales7, 2),
keys = _getScales8[0],
values = _getScales8[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 _getScales9 = getScales("s"),
_getScales0 = _slicedToArray(_getScales9, 2),
keys = _getScales0[0],
values = _getScales0[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 _getScales1 = getScales("unknown_scalable"),
_getScales10 = _slicedToArray(_getScales1, 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 scale-only format for counted scalable units", function () {
var result = getUnitsString("unknown_scalable", "K", "items");
expect(result).toBe("K");
});
it("uses scale-only format for request rate units", function () {
var result = getUnitsString("{request}/s", "M", "requests/s");
expect(result).toBe("M");
});
it("uses scale-only format for raw alias request rate units", function () {
var result = getUnitsString("requests/s", "M", "requests/s");
expect(result).toBe("M");
});
it("uses scale-only format for verified count rate aliases", function () {
expect(getUnitsString("buckets/s", "M", "buckets/s")).toBe("M");
expect(getUnitsString("count/s", "M", "count/s")).toBe("M");
});
it("treats the unknown sentinel as a generic scalable item count", function () {
expect(getUnitsString("unknown", "", "items")).toBe("");
expect(getUnitsString("unknown", "M", "items")).toBe("M");
});
it("keeps verified literal units non-scaled", function () {
expect(getUnitsString("m3/min", "K", "m3/min")).toBe("m3/min");
});
it("can force full decimal prefix format for counted scalable units", function () {
var result = getUnitsString("unknown_scalable", "K", "items", false, {
mode: "full"
});
expect(result).toBe("K items");
});
it("handles empty prefix", function () {
var result = getUnitsString("s", "", "s");
expect(result).toBe("s");
});
it("hides unit labels for compact duration values", function () {
var result = getUnitsString("s", "", "h:mm:ss");
expect(result).toBe("");
});
it("handles long format for prefixes", function () {
var result = getUnitsString("s", "k", "seconds", true);
expect(result).toBe("kiloseconds");
});
it("uses the generic item label when full units are requested", function () {
var result = getUnitsString("unknown", "", "", false, {
mode: "full"
});
expect(result).toBe("items");
});
it("hides units with empty print_symbol like {boolean}", function () {
var result = getUnitsString("{boolean}", "", "{boolean}");
expect(result).toBe("");
});
it("shows non-scalable units like percentage when base is empty", function () {
var result = getUnitsString("%", "", "");
expect(result).toBe("%");
});
it("uses base over print_symbol for scaled units", function () {
var result = getUnitsString("By", "Mi", "B");
expect(result).toBe("MiB");
});
it("shows the prefix once for pre-scaled units with normalized base units", function () {
expect(getUnitsString("KiBy/{operation}", "Mi", "By/{operation}")).toBe("MiB/op");
expect(getUnitsString("MBy", "G", "By")).toBe("GB");
expect(getUnitsString("MBy/s", "K", "By/s")).toBe("KB/s");
expect(getUnitsString("kb/s", "M", "bit/s")).toBe("Mbit/s");
expect(getUnitsString("KBy/{operation}", "M", "By/{operation}")).toBe("MB/op");
expect(getUnitsString("ms/{request}", "u", "s/{request}")).toBe("\xB5s/req");
expect(getUnitsString("ms/{operation}", "", "s/{operation}")).toBe("s/op");
expect(getUnitsString("mA", "k", "Ampere")).toBe("kA");
});
it("keeps full compound units when explicitly requested", function () {
expect(getUnitsString("KiBy/{operation}", "Mi", "By/{operation}", false, {
mode: "full"
})).toBe("MiB/operation");
expect(getUnitsString("ms/{request}", "u", "s/{request}", true)).toBe("microseconds per request");
});
it("does not compact per-second duration rate units", function () {
expect(getUnitsString("ms/s", "m", "s/s")).toBe("ms/s");
expect(getUnitsString("ms/s", "", "s/s")).toBe("s/s");
});
it("labels CPU cores without using CPU for whole-core scale", function () {
expect(getUnitsString("m[CPU]", "m", "[CPU]")).toBe("mCPU");
expect(getUnitsString("c[CPU]", "c", "[CPU]")).toBe("cCPU");
expect(getUnitsString("m[CPU]", "", "[CPU]")).toBe("core");
expect(getUnitsString("m[CPU]", "", "[CPU]", true)).toBe("cores");
});
});
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);
});
});
});