From d8467dda4ec928b3a10e6ae0212a17e47fba9059 Mon Sep 17 00:00:00 2001 From: EuAndreh Date: Sat, 5 Jul 2025 06:36:34 -0300 Subject: Use .mjs extension; add reduce(); finish tests; export names correctly. --- tests/sjs.js | 607 ----------------------------------------------------------- 1 file changed, 607 deletions(-) delete mode 100644 tests/sjs.js (limited to 'tests/sjs.js') diff --git a/tests/sjs.js b/tests/sjs.js deleted file mode 100644 index bf5f3dd..0000000 --- a/tests/sjs.js +++ /dev/null @@ -1,607 +0,0 @@ -import { - getIn, - merge, - compareObject, - escape, - eq, - keys, - difference, - assocIn, - dissoc, - findFirst, - partial, - strSortFn, - undefinedAsNull, - first, - rest, - butlast, - last, - take, - range, - runTests, -} from "../src/sjs.js"; - - - -const test_getIn = async t => { - t.start("getIn()"); - - await t.testing("empty values", () => { - t.assertEq(getIn({}, []), {}); - t.assertEq(getIn({ k: "v" }, []), { k: "v" }); - t.assertEq(getIn({}, [0]), undefined); - }); - - await t.testing("error when getting bad path", () => { - }); - - await t.testing("mix of arrays and objects", () => { - }); - - await t.testing("missing values", () => { - t.assertEq(getIn({}, ["a", "b", "c"]), undefined); - t.assertEq(getIn({ a: {}}, ["a", "b", "c"]), undefined); - t.assertEq(getIn({ a: { b: {}}}, ["a", "b", "c"]), undefined); - t.assertEq(getIn({ a: { b: {}, c: {}}}, ["a", "b", "c"]), undefined); - }); - - await t.testing("nested valeues", () => { - t.assertEq(getIn({ a: { b: { c: { d: "e" }}}}, ["a", "b", "c", "d"]), "e"); - }); -}; - -const test_merge = async t => { - t.start("merge()"); - - await t.testing("empty values", () => { - }); - - await t.testing("rhs gets preference over lhs", () => { - }); - - await t.testing("deep merge", () => { - }); -}; - -const test_compareObject = async t => { - t.start("compareObject()"); - - await t.testing("", () => {}); -}; - -const test_escape = async t => { - t.start("escape()"); - await t.testing("", () => {}); -}; - -const test_eq = t => { - t.start("eq()"); - t.testing("scalar values equality", () => { - t.assertEq(eq(0, 0), true); - t.assertEq(eq(100, 100), true); - t.assertEq(eq(1.5, 1.5), true); - t.assertEq(eq(-9, -9), true); - - t.assertEq(eq(0, 1), false); - t.assertEq(eq(100, 99), false); - t.assertEq(eq(1.5, 1.4), false); - t.assertEq(eq(-9, 9), false); - - - t.assertEq(eq(null, null), true); - t.assertEq(eq(undefined, undefined), true); - t.assertEq(eq("", ""), true); - t.assertEq(eq("a string", "a string"), true); - - t.assertEq(eq(null, undefined), false); - t.assertEq(eq(undefined, 0), false); - t.assertEq(eq("", "0"), false); - t.assertEq(eq("a string", "another string"), false); - - - t.assertEq(eq(true, true), true); - t.assertEq(eq(false, false), true); - - t.assertEq(eq(true, false), false); - - - t.assertEq(eq(1n, 1n), true); - t.assertEq(eq(99999999999999n, 99999999999999n), true); - - // t.assertEq(eq(1, 1n), true); - }); - - t.testing("array equality", () => { - t.assertEq(eq([], []), true); - - - t.assertEq(eq([0, 1, 2], [0, 1, 2]), true); - t.assertEq(eq([0, 1, 2], new Array(0, 1, 2)), true); - - t.assertEq(eq([0, 1, 2], [0, 1]), false); - t.assertEq(eq([0, 1], new Array(0, 1, 2)), false); - - - t.assertEq(eq([undefined], [undefined]), true); - t.assertEq(eq([null, 0, "", true], [null, 0, "", true]), true); - - - t.assertEq(eq([[[[0]]]], [[[[0]]]]), true); - - t.assertEq(eq([[[[0]]]], [0]), false); - }); - - t.testing("object equality", () => { - t.assertEq(eq({}, {}), true); - t.assertEq(eq({ a: 1 }, { a: 1 }), true); - - t.assertEq(eq({ a: 1, b: undefined }, { a: 1 }), false); - - - t.assertEq(eq( - { a: 1, b: { c: { d: "e" } } }, - { a: 1, b: { c: { d: "e" } } }, - ), true); - - class C {} - // ... - }); - - t.testing("mixed values", () => { - t.assertEq(eq( - {a: ["", 1, 2, 3, [{ b: { c: [ "d", "e" ]}}]]}, - {a: ["", 1, 2, 3, [{ b: { c: [ "d", "e" ]}}]]}, - ), true); - - t.assertEq(eq(null, {}), false); - - t.assertEq(eq([], {}), false); - - - t.assertEq(eq(new Date(123), new Date(123)), true); - t.assertEq(eq({ d: new Date(123) }, { d: new Date(123) }), true); - - // FIXME - // t.assertEq(!eq(new Date(123), new Date(321))); - // t.assertEq(!eq({ d: new Date(123) }, { d: new Date(321) })); - }); -}; - -const test_keys = async t => { - t.start("keys()"); - await t.testing("happy paths", () => { - t.assertEq( - { a: 1, b: 2 }, - keys(["a", "b"], { a: 1, b: 2, c: 3 }), - ); - }); - - await t.testing("stress scenarios", () => { - t.assertEq( - {}, - keys([], {}), - "empty selection of empty object", - ); - - t.assertEq( - {}, - keys([], {a: 1}), - "empty selection of non-empty object", - ); - - t.assertEq( - {}, - keys(["a"], {}), - "non-empty selection of empty object", - ); - - t.assertEq( - { a: undefined, b: null }, - keys(["a", "b", "c"], { a: undefined, b: null }), - "falsy values", - ); - }); -}; - -const test_difference = async t => { - t.start("difference()"); - - await t.testing("empty values", () => { - t.assertEq( - difference(new Set(), new Set()), - new Set(), - ); - - t.assertEq( - difference(new Set(), new Set([1, 2])), - new Set(), - ); - - t.assertEq( - difference(new Set([1, 2]), new Set()), - new Set([1, 2]), - ); - }); - - await t.testing("different subsets", () => { - t.assertEq( - difference(new Set([1, 2]), new Set([3, 4])), - new Set([1, 2]), - ); - - t.assertEq( - difference(new Set([1, 2, 3]), new Set([2, 4, 5])), - new Set([1, 3]), - ); - - t.assertEq( - difference(new Set([1]), new Set([1, 2, 3, 4, 5])), - new Set(), - ); - - t.assertEq( - difference(new Set([1, 2, 3]), new Set([1, 2, 3])), - new Set(), - ); - }); -}; - -const test_assocIn = async t => { - t.start("assocIn()"); - - await t.testing("empty values", () => { - t.assertEq(assocIn({}, [], null), {}); - t.assertEq(assocIn({ k: "v" }, [], null), { k: "v" }); - }); - - await t.testing("adding values", () => { - t.assertEq(assocIn({}, ["k"], "v"), { k: "v" }); - t.assertEq(assocIn({}, ["k1", "k2"], "v"), { k1: { k2: "v" }}); - t.assertEq(assocIn({}, ["k1", "k2", "k3"], "v"), { k1: { k2: { k3: "v" }}}); - t.assertEq(assocIn({ k: "v" }, ["k1", "k2"], "v"), { k: "v", k1: { k2: "v" }}); - }); - - await t.testing("replacing values", () => { - t.assertEq( - assocIn( - { k1: { k2: { k3: "before" }}}, - ["k1", "k2", "k3"], - "after" - ), - { k1: { k2: { k3: "after" }}} - ); - }); -}; - -const test_dissoc = async t => { - t.start("dissoc()"); - - await t.testing("empty values", () => { - t.assertEq(dissoc({}, "k"), {}); - }); - - await t.testing("noop when key does not exist", () => { - t.assertEq(dissoc({ a: 1 }, "b"), { a: 1 }); - }); - - await t.testing("removes the key", () => { - t.assertEq(dissoc({ a: 1, b: 2}, "b"), { a: 1 }); - }); -}; - -const test_findFirst = async t => { - t.start("findFirst()"); - - await t.testing("empty values", () => { - t.assertEq(findFirst([], () => {}), null); - }); - - await t.testing("when function doesn't transform, it behaves similarly to [].find()", () => { - const arr1 = [ 0, null, undefined, "", 1, 2 ]; - t.assertEq(findFirst(arr1, x => x), 1); - t.assertEq(arr1.find(x => x), 1); - - const arr2 = [ 0, null, undefined, "", false ]; - t.assertEq(findFirst(arr2, x => x), null); - t.assertEq(arr2.find(x => x), undefined); - }); - - await t.testing("when it does transform, we return the transformed value", () => { - const arr = [ 1, 3, 5, 6 ]; - - t.assertEq( - findFirst(arr, x => x % 2 === 0 && "a brand new value"), - "a brand new value", - ); - }); -}; - -const test_partial = async t => { - t.start("partial()"); - - await t.testing("empty values", () => { - const adder = (a, b, c) => a + b + c; - - const adder1 = partial(adder); - t.assertEq(adder1(1, 2, 3), 6); - - const adder2 = partial(adder, 4, 5, 6); - t.assertEq(adder2(), 15); - - const noargs = () => "static"; - t.assertEq(partial(noargs)(), noargs()); - }); - - await t.testing("too few arguments", () => { - const threeArgs = (a, b, c) => { - assert.notEqual(c, undefined); - return a + b + c; - }; - - const add1 = partial(threeArgs, 1); - return; // FIXME - assert.throws( - () => add1(2), - assert.AssertionError, - ); - - const add1And2 = partial(threeArgs, 1, 2); - assert.throws( - () => add1And2(), - assert.AssertionError, - ); - - const addNothing = partial(threeArgs); - assert.throws( - () => addNothing(), - assert.AssertionError, - ); - }); - - await t.testing("too many arguments", () => { - const twoArgs = (a, b) => a + b; - - t.assertEq(partial(twoArgs, 1)(2, 3), 3); - t.assertEq(partial(twoArgs, 1, 2)(3), 3); - }); - - await t.testing("daily usage", () => { - const twoArg = (a, b) => a + b; - - const numbers = [ 1, 2, 3, 4, 5 ]; - t.assertEq( - numbers.map(partial(twoArg, 2)), - [ 3, 4, 5, 6, 7 ], - ); - }); - - await t.testing("nested partials", () => { - const threeArgs = (a, b, c) => a + b + c; - - const add1 = partial(threeArgs, 1); - const add1And2 = partial(add1, 2); - - t.assertEq(add1And2(3), 6); - }); -}; - -const test_strSortFn = async t => { - t.start("strSortFn()"); - - await t.testing("empty value", () => { - t.assertEq(strSortFn("", ""), 0); - }); - - await t.testing("default sort", () => { - const arr = [ "a", "Z" ]; - t.assertEq( - [...arr].sort(strSortFn), - [...arr].sort().reverse(), - ); - }); -}; - -const test_undefinedAsNull = async t => { - t.start("undefinedAsNull()"); - - await t.testing("null for undefined or null", () => { - t.assertEq(undefinedAsNull(undefined), null); - t.assertEq(undefinedAsNull(null), null); - }); - - await t.testing("identity otherwise", () => { - const expected = [ - " ", "", 0, 1, -1.1, true, false, - [], [ "" ], {}, { k: "v" }, - ]; - const given = expected.map(undefinedAsNull); - t.assertEq(given, expected); - }); -}; - -const test_first = async t => { - t.start("first()"); - - await t.testing("undefined for an empty array", () => { - t.assertEq(undefined, first([])); - t.assertEq(undefined, first("")); - }); - - await t.testing("the first element otherwise", () => { - t.assertEq(1, first([1, 2, 3])); - t.assertEq("a", first("abc")); - }); -}; - -const test_rest = async t => { - t.start("rest()"); - - await t.testing("an empty array when no more elements are available", () => { - t.assertEq([], rest([])); - t.assertEq([], rest([1])); - t.assertEq("", rest("")); - t.assertEq("bc", rest("abc")); - }); - - await t.testing("the rest of the collection otherwise", () => { - t.assertEq([2, 3], rest([1, 2, 3])); - t.assertEq("bc", rest("abc")); - }); - - await t.testing("combines with first() well", () => { - const arr = ["anything", "can", "go", "here"]; - t.assertEq(arr, [ first(arr), ...rest(arr) ]); - }); -}; - -const test_butlast = async t => { - t.start("butlast()"); - - await t.testing("empty array when ther are no more elements", () => { - t.assertEq([], butlast([])); - t.assertEq([], butlast([1])); - t.assertEq("", butlast("")); - t.assertEq("", butlast("c")); - }); - - await t.testing("the beginning of the array otherwise", () => { - t.assertEq([1, 2], butlast([1, 2, 3])); - t.assertEq("ab", butlast("abc")); - }); -}; - -const test_last = async t => { - t.start("last()"); - - await t.testing("undefined for an empty array", () => { - t.assertEq(undefined, last([])); - t.assertEq(undefined, last("")); - }); - - await t.testing("the last element otherwise", () => { - t.assertEq(3, last([1, 2, 3])); - t.assertEq("c", last("abc")); - }); - - await t.testing("combines with butlast() well", () => { - const arr = ["anything", "goes", "here", "too"]; - t.assertEq(arr, [ ...butlast(arr), last(arr) ]); - }); -}; - -const test_take = async t => { - t.start("take()"); - - await t.testing("example usage", () => { - t.assertEq(Array.from(take(3, [1, 2, 3, 4, 5, 6])), [1, 2, 3]); - t.assertEq([...take(3, [1, 2, 3, 4, 5, 6])], [1, 2, 3]); - - const gen = function*() { - yield* [1, 2, 3, 4, 5, 6]; - } - t.assertEq([...take(3, gen())], [1, 2, 3]); - - t.assertEq([...take(3, [1, 2])], [1, 2]); - - t.assertEq([...take(1, [])], []); - t.assertEq([...take(0, [1])], []); - t.assertEq([...take(-1, [1])], []); - }); -}; - -const test_range = async t => { - t.start("range()"); - - await t.testing("empty values", () => { - const [] = range(); - - const [ a ] = range(); - t.assertEq(a, 0n); - - const [ b, c, d, e ] = range(); - t.assertEq( - [ b, c, d, e ], - [ 0n, 1n, 2n, 3n ], - ); - - t.assertEq( - Array.from(take(5, range())), - [ 0n, 1n, 2n, 3n, 4n ], - ); - - t.assertEq( - Array.from(take(1, range())), - [ 0n ], - ); - - t.assertEq( - Array.from(take(0, range())), - [], - ); - }); - - await t.testing("example usage", () => { - t.assertEq( - [...range(-5, 5)], - [ -5n, -4n, -3n, -2n, -1n, 0n, 1n, 2n, 3n, 4n ], - ); - t.assertEq( - [...range(-100, 100, 10)], - [ - -100n, -90n, -80n, -70n, -60n, -50n, -40n, -30n, - -20n, -10n, 0n, 10n, 20n, 30n, 40n, 50n, 60n, - 70n, 80n, 90n, - ], - ); - - t.assertEq([...range(0, 4, 2)], [0n, 2n]); - t.assertEq([...range(0, 5, 2)], [0n, 2n, 4n]); - t.assertEq([...range(0, 6, 2)], [0n, 2n, 4n]); - t.assertEq([...range(0, 7, 2)], [0n, 2n, 4n, 6n]); - - t.assertEq( - [...range(100, 0, -10)], - [ 100n, 90n, 80n, 70n, 60n, 50n, 40n, 30n, 20n, 10n ] - ); - t.assertEq( - [...range(10, -10, -1)], - [ - 10n, 9n, 8n, 7n, 6n, 5n, 4n, 3n, 2n, 1n, 0n, - -1n, -2n, -3n, -4n, -5n, -6n, -7n, -8n, -9n, - ], - ); - - t.assertEq( - [...take(3, range(1, 10, 0))], - [ 1n, 1n, 1n ], - ); - t.assertEq( - [...take(3, range(10, 1, 0))], - [ 10n, 10n, 10n ], - ); - }); -}; - - - -await runTests([ - test_getIn, - test_merge, - test_compareObject, - test_escape, - test_eq, - test_keys, - test_difference, - test_assocIn, - test_dissoc, - test_findFirst, - test_partial, - test_strSortFn, - test_undefinedAsNull, - test_first, - test_rest, - test_butlast, - test_last, - test_take, - test_range, -]); -- cgit v1.2.3