@nativerent/js-utils 1.0.0 → 1.0.2

package/tests/tests.ts

@@ -0,0 +1,521 @@
+import {
+  areDiff,
+  arrayDiff,
+  capitalize,
+  debounce,
+  filterObjectKeysByValues,
+  formatNumber,
+  formatNumberWithSign,
+  formatWithSign,
+  getFromObject,
+  getRandomItem,
+  getRandomStr,
+  isBool,
+  isDefined,
+  isFn,
+  isNum,
+  isObject,
+  isStr,
+  isString,
+  isUndef,
+  objectHasProp,
+  objectToQueryString,
+  parseObjectPathStr,
+  parseURL,
+  roundBigNum,
+  roundDown,
+  roundUp,
+  sortByAlphabet,
+  sumArray,
+  toCamelCase,
+  toPercent,
+  toSnakeCase,
+} from "../src";
+
+test.each([
+  [20, 40, 50],
+  [12, 56, 21.428571428571427],
+  [489, 232, 210.77586206896552],
+])("toPercent", (a, b, expected) => {
+  const res = toPercent(a, b);
+  expect(res).toBe(expected);
+  expect(typeof res).toBe("number");
+});
+
+test.each([
+  ["camelcase", "camelcase"],
+  ["camelCase", "camelCase"],
+  ["camel-case", "camelCase"],
+  ["CAMEL_CASE", "CAMELCASE"],
+  ["CAMEL.CASE", "CAMELCASE"],
+  ["CAMELCASE", "CAMELCASE"],
+  ["fullScreenTGB", "fullScreenTGB"],
+  ["typesWith-POPUP_TEASER", "typesWithPOPUPTEASER"],
+  ["typesWith-ADVICE", "typesWithADVICE"],
+  ["typesWith-button_phone", "typesWithButtonPhone"],
+  ["typesWith-buttonPhone", "typesWithButtonPhone"],
+  ["item.button_phone", "itemButtonPhone"],
+  ["item.buttonPhone", "itemButtonPhone"],
+  ["camel.case-camel_CASE", "camelCaseCamelCASE"],
+])("toCamelCase", (str, expected) => {
+  expect(toCamelCase(str)).toBe(expected);
+});
+
+test.each([
+  ["camelcase", "camelcase"],
+  ["camelCase", "camel_case"],
+  ["camel-case", "camel_case"],
+  ["CAMEL_CASE", "c_a_m_e_l_c_a_s_e"],
+  ["CAMEL.CASE", "c_a_m_e_l_c_a_s_e"],
+  ["CAMELCASE", "c_a_m_e_l_c_a_s_e"],
+  ["fullScreenTGB", "full_screen_t_g_b"],
+  ["typesWith-POPUP_TEASER", "types_with_p_o_p_u_p_t_e_a_s_e_r"],
+  ["typesWith-ADVICE", "types_with_a_d_v_i_c_e"],
+  ["typesWith-button_phone", "types_with_button_phone"],
+  ["typesWith-buttonPhone", "types_with_button_phone"],
+  ["item.button_phone", "item_button_phone"],
+  ["item.buttonPhone", "item_button_phone"],
+  ["camel.case-camel_CASE", "camel_case_camel_c_a_s_e"],
+])("toSnakeCase", (str, expected) => {
+  expect(toSnakeCase(str)).toBe(expected);
+});
+
+test.each([
+  ["title", "Title"],
+  ["another title", "Another title"],
+  ["UPPER CASE TITLE", "UPPER CASE TITLE"],
+  ["CapitalizedTitle", "CapitalizedTitle"],
+  ["item.title", "Item.title"],
+  ["item-title", "Item-title"],
+  ["item_title", "Item_title"],
+])("capitalize", (str, expected) => {
+  expect(capitalize(str)).toBe(expected);
+});
+
+test.each([
+  ["title", "Title", -1],
+  ["another title", "title", -1],
+  ["simple title", "compound title", 1],
+  ["UPPER CASE TITLE", "TITLE", 1],
+  ["кириллица", "сортировка", -1],
+  ["ясень", "береза", 1],
+  ["Водолей", "Лев", -1],
+  ["питер", "мск", 1],
+  ["zebra", "зебра", -1],
+  ["аббревиатура", "York", 1],
+])("sortByAlphabet", (first, second, expected) => {
+  expect(sortByAlphabet(first, second)).toBe(expected);
+});
+
+test.each([
+  [undefined, 10],
+  [1, 1],
+  [43, 43],
+  [71, 71],
+  [100, 100],
+  [450, 100],
+])("getRandomStr", (len, expectedLen) => {
+  const str = getRandomStr(len);
+  expect(str.length).toBe(expectedLen);
+  expect(typeof str).toBe("string");
+});
+
+test.each([
+  [[3, "ff", 3434]],
+  [[423434234]],
+  [[{ ff: "dd" }, 7, ["rrr", "tt", "y"]]],
+])("getRandomItem", (arr) => {
+  expect(arr).toContain(getRandomItem(arr));
+  expect(arr).toEqual(arr);
+});
+
+test.each([
+  [[2, 2, 1, 2], 7],
+  [[52, 122, 17, 368], 559],
+  [[0.099999999, 1.3028475, 1556.54677, 1000000.02], 1001557.969617499],
+  [[undefined, 456, "99", 13, "qwerty", null, 0.46778], 568.46778],
+])("sumArray", (arr, expected) => {
+  expect(sumArray(arr)).toBe(expected);
+});
+
+test.each([
+  [{ wq: "qwqw", q: 22, add: { s: [1, 2] } }, [22, "qwqw"], ["add"]],
+  [{ wq: "qwqw", q: 22, add: { s: [1, 2] } }, ["q", 22], ["wq", "add"]],
+  [{ 1: 2, key: "value", t: [1, 2], tt: false }, [false], ["1", "key", "t"]],
+  [{ type: undefined, enabled: true, date: null }, [undefined, null, true], []],
+])("filterObjectKeysByValues", (array, value, expected) => {
+  expect(filterObjectKeysByValues(array, value)).toEqual(expected);
+});
+
+test.each([
+  [{ k: "d" }, "k", "d"],
+  [{ title: null }, "title", null],
+  [{ 2: null, POS: undefined, g: { f: "roubles" } }, "POS", undefined],
+  [{ 2: null, POS: undefined, g: { f: "roubles" } }, "g", { f: "roubles" }],
+  [
+    {
+      array: [5, 657, 7],
+      obj: { q: 3, fdf: "gdfg", d: null, e: undefined },
+    },
+    "obj",
+    { q: 3, fdf: "gdfg", d: null, e: undefined },
+  ],
+  [
+    {
+      array: [5, 657, 7],
+      obj: {
+        q: 3,
+        fdf: "gdfg",
+        d: null,
+        e: undefined,
+        g: () => {},
+      },
+    },
+    "array",
+    [5, 657, 7],
+  ],
+])("getFromObject", (obj, key, expected) => {
+  expect(getFromObject(obj, key)).toEqual(expected);
+});
+
+test.each([
+  ["item.title.value", ["item", "title", "value"]],
+  ["item[title][value]", ["item", "title", "value"]],
+  ["rules[1][fields.title]", ["rules", "1", "fields", "title"]],
+  ["rules[1][fields[title]]", ["rules", "1", "fields", "title"]],
+  ["rules.1[fields.title]", ["rules", "1", "fields", "title"]],
+  [
+    "rules.1[fields.title[regular][NR]]",
+    ["rules", "1", "fields", "title", "regular", "NR"],
+  ],
+])("parseObjectPathStr", (path, expected) => {
+  expect(parseObjectPathStr(path)).toEqual(expected);
+});
+
+test.each([
+  [34, 5, "34.00000"],
+  ["4546.77", 1, "4 546.8"],
+  ["1000.009", 4, "1 000.0090"],
+  ["1000.009", 2, "1 000.01"],
+])("formatNumber", (num, digits, expected) => {
+  expect(formatNumber(num, digits)).toBe(expected);
+});
+
+test.each([
+  [34, 5, "+34.00000"],
+  [-4545, 2, "-4 545.00"],
+  ["4546.77", 1, "+4 546.8"],
+  ["-1000.009", 4, "-1 000.0090"],
+  ["1000.009", 2, "+1 000.01"],
+])("formatNumberWithSign", (num, digits, expected) => {
+  expect(formatNumberWithSign(num, digits)).toBe(expected);
+});
+
+test.each([
+  [34, undefined, "+34"],
+  [4545, undefined, "+4545"],
+  [4546.77, "4 546.77 руб", "+4 546.77 руб"],
+  [-1000.009, "1 000.01 ₽", "1 000.01 ₽"],
+  [1000.009, "1000.01$", "+1000.01$"],
+  [-0.009, undefined, "-0.009"],
+])("formatWithSign", (num, numStr, expected) => {
+  expect(formatWithSign(num, numStr)).toBe(expected);
+});
+
+test.each([
+  [
+    [1, 2, 3],
+    [4, 5, 6],
+    [1, 2, 3, 4, 5, 6],
+  ],
+  [
+    ["q", "w", "e", "r", "t", "y"],
+    ["w", "q", "r"],
+    ["e", "t", "y"],
+  ],
+  [
+    ["multi dimensional array", "t", "e", "y"],
+    ["e", "t", "multi dimensional array", "y"],
+    [],
+  ],
+  [
+    [true, false, false, true, 1, 0],
+    [true, true, false, 0, false, 0, false, false],
+    [1],
+  ],
+  [
+    [null, false, "657", "#000"],
+    ["black", undefined, 0, false, 657, null],
+    ["657", "#000", "black", undefined, 0, 657],
+  ],
+])("arrayDiff", (arr1, arr2, expected) => {
+  expect(arrayDiff(arr1, arr2)).toEqual(expected);
+});
+
+test.each([
+  [{ d: "d" }, true],
+  [["d"], false],
+  [null, false],
+  [undefined, false],
+  [0, false],
+  [NaN, false],
+  ["str", false],
+  [120, false],
+  [Symbol("s"), false],
+  [false, false],
+  [true, false],
+])("isObject", (val, expected) => {
+  expect(isObject(val)).toBe(expected);
+});
+
+test.each([
+  [{ d: "d" }, false],
+  [["d"], false],
+  [null, false],
+  [undefined, false],
+  [0, false],
+  [() => "g", true],
+  [NaN, false],
+  ["str", false],
+  [120, false],
+  [Symbol("s"), false],
+  [function () {}, true],
+  [false, false],
+  [true, false],
+])("isFn", (val, expected) => {
+  expect(isFn(val)).toBe(expected);
+});
+
+test.each([
+  [{ d: "d" }, false],
+  [["d"], false],
+  [null, false],
+  [undefined, false],
+  [0, false],
+  [() => "g", false],
+  [NaN, false],
+  ["str", true],
+  [120, false],
+  [Symbol("s"), false],
+  [function () {}, false],
+  [false, false],
+  [true, false],
+  ["false", true],
+  ["true", true],
+  ["1", true],
+])("isStr", (val, expected) => {
+  expect(isStr(val)).toBe(expected);
+});
+
+test.each([
+  [{ d: "d" }, false],
+  [["d"], false],
+  [null, false],
+  [undefined, false],
+  [0, false],
+  [() => "g", false],
+  [NaN, false],
+  ["str", true],
+  [120, false],
+  [Symbol("s"), false],
+  [function () {}, false],
+  [false, false],
+  [true, false],
+  ["false", true],
+  ["true", true],
+  ["1", true],
+])("isString", (val, expected) => {
+  expect(isString(val)).toBe(expected);
+});
+
+test.each([
+  [{ d: "d" }, false],
+  [["d"], false],
+  [null, false],
+  [undefined, false],
+  [0, true],
+  [() => "g", false],
+  [NaN, true],
+  ["str", false],
+  [120, true],
+  [Symbol("s"), false],
+  [function () {}, false],
+  [false, false],
+  [true, false],
+  ["1", false],
+])("isNum", (val, expected) => {
+  expect(isNum(val)).toBe(expected);
+});
+
+test.each([
+  [{ d: "d" }, false],
+  [["d"], false],
+  [null, false],
+  [undefined, false],
+  [0, false],
+  [() => "g", false],
+  [NaN, false],
+  ["str", false],
+  [120, false],
+  [Symbol("s"), false],
+  [function () {}, false],
+  [false, true],
+  [true, true],
+  ["1", false],
+])("isBool", (val, expected) => {
+  expect(isBool(val)).toBe(expected);
+});
+
+test.each([
+  [{ d: "d" }, false],
+  [["d"], false],
+  [null, false],
+  [undefined, true],
+  [0, false],
+  [() => "g", false],
+  [NaN, false],
+  ["str", false],
+  [120, false],
+  [Symbol("s"), false],
+  [function () {}, false],
+  [false, false],
+  [true, false],
+  ["1", false],
+])("isUndef", (val, expected) => {
+  expect(isUndef(val)).toBe(expected);
+});
+
+test.each([
+  [{ d: "d" }, true],
+  [["d"], true],
+  [null, true],
+  [undefined, false],
+  [0, true],
+  [() => "g", true],
+  [NaN, true],
+  ["str", true],
+  [120, true],
+  [Symbol("s"), true],
+  [function () {}, true],
+  [false, true],
+  [true, true],
+  ["1", true],
+])("isDefined", (val, expected) => {
+  expect(isDefined(val)).toBe(expected);
+});
+
+test.each([[isDefined], [parseURL]])("debounce", (fn) => {
+  expect(typeof debounce(fn, 100)).toBe("function");
+});
+
+test.each([
+  [
+    { start: 134356456456, end: null, status: [1, 2, 4, 7] },
+    "start=134356456456&end=&status[]=1&status[]=2&status[]=4&status[]=7",
+  ],
+  [{}, ""],
+  [{ 1: 2 }, "1=2"],
+  [
+    { params: { checked: true, num: 2 } },
+    "params=%7B%22checked%22%3Atrue%2C%22num%22%3A2%7D",
+  ],
+])("objectToQueryString", (obj, expected) => {
+  expect(objectToQueryString(obj)).toBe(expected);
+});
+
+test.each([
+  [{ b: "b" }, "b", true],
+  [{ a: "b" }, "b", false],
+  [{ bb: "b" }, "b", false],
+])("objectHasProp", (obj, prop, expected) => {
+  expect(objectHasProp(obj, prop)).toBe(expected);
+});
+
+test.each([
+  ["str", null, true, true],
+  ["str", null, false, true],
+  ["", null, false, false],
+  ["", null, true, true],
+  ["", undefined, false, false],
+  ["", undefined, true, true],
+  ["", "", true, false],
+  ["", "", false, false],
+  ["1", "11", false, true],
+  ["1", "11", true, true],
+  ["{}", "object", true, true],
+  ["{}", "object", false, true],
+  ["{}", "[]", true, true],
+  ["{}", "[]", false, true],
+  ["{}", "[]", true, true],
+  ["title", "Title", false, true],
+  ["title", "Title", true, true],
+  ["title", "title", true, false],
+  [true, "true", true, true],
+  [true, "true", false, true],
+  ["4", 4, false, false],
+  ["4", 4, true, true],
+  [1, true, false, false],
+  ["1", true, false, false],
+  [1, true, true, true],
+  [0, false, false, false],
+  [0, false, true, true],
+  ["0", false, false, false],
+])("areDiff", (val1, val2, strict, expected) => {
+  expect(areDiff(val1, val2, strict)).toBe(expected);
+});
+
+test.each([
+  [0, 0],
+  [27, 27],
+  [99, 99],
+  [101, 100],
+  [277, 300],
+  [937, 900],
+  [967, 1000],
+  [1836, 1800],
+  [9284, 9300],
+  [29487, 30000],
+  [2569424, 2570000],
+  [11111111, 11110000],
+  [9999999000, 10000000000],
+])("roundBigNum", (num, expected) => {
+  expect(roundBigNum(num)).toBe(expected);
+});
+
+test.each([
+  [0.9999889999, 0, 1.0],
+  [0.9999889999, 1, 1.0],
+  [0.9999889999, 2, 1.0],
+  [0.0000000001, 0, 1],
+  [0.0000000001, 1, 0.1],
+  [0.0000000001, 2, 0.01],
+  [0.0000000001, 3, 0.001],
+  [0.0000000001, 14, 0.0000000001],
+  [78.3333333333, 1, 78.4],
+  [78.3333333333, 0, 79],
+  [10000.354, 3, 10000.354],
+  [10000.354, 2, 10000.36],
+  [10000.354, 1, 10000.4],
+  [10000.354, 0, 10001],
+])("roundUp", (num, precision, expected) => {
+  expect(roundUp(num, precision)).toBe(expected);
+});
+
+test.each([
+  [0.9999889999, 0, 0],
+  [0.9999889999, 1, 0.9],
+  [0.9999889999, 2, 0.99],
+  [0.0000000001, 0, 0],
+  [0.0000000001, 1, 0],
+  [0.0000000001, 2, 0],
+  [0.0000000001, 3, 0],
+  [0.0000000001, 14, 0.0000000001],
+  [78.3333333333, 1, 78.3],
+  [78.3333333333, 0, 78],
+  [10000.354, 3, 10000.354],
+  [10000.354, 2, 10000.35],
+  [10000.354, 1, 10000.3],
+  [10000.354, 0, 10000],
+])("roundDown", (num, precision, expected) => {
+  expect(roundDown(num, precision)).toBe(expected);
+});