corebasic 1.0.211 → 1.0.213

package/dist/libs/dip/suffix/tests/index.test.js

@@ -0,0 +1,441 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { reduceRanges, extractBounds } from "../index.js";
+// -----------------------------------------------------------------------------
+// reduceRanges()
+// -----------------------------------------------------------------------------
+describe("reduceRanges()", () => {
+    test("reduceRanges: empty", () => {
+        assert.deepEqual(reduceRanges([]), []);
+    });
+    test("reduceRanges: primitive passthrough", () => {
+        assert.deepEqual(reduceRanges([1, "A", true]), [1, "A", true]);
+    });
+    test("reduceRanges: null passthrough", () => {
+        assert.deepEqual(reduceRanges([null]), [null]);
+    });
+    test("reduceRanges: array passthrough", () => {
+        assert.deepEqual(reduceRanges([[1, 2]]), [[1, 2]]);
+    });
+    test("reduceRanges: unknown object passthrough", () => {
+        assert.deepEqual(reduceRanges([
+            { $regex: "abc" }
+        ]), [
+            { $regex: "abc" }
+        ]);
+    });
+    test("reduceRanges: single $gt", () => {
+        assert.deepEqual(reduceRanges([
+            { $gt: 5 }
+        ]), [
+            { $gt: 5 }
+        ]);
+    });
+    test("reduceRanges: single $gte", () => {
+        assert.deepEqual(reduceRanges([
+            { $gte: 5 }
+        ]), [
+            { $gte: 5 }
+        ]);
+    });
+    test("reduceRanges: single $lt", () => {
+        assert.deepEqual(reduceRanges([
+            { $lt: 10 }
+        ]), [
+            { $lt: 10 }
+        ]);
+    });
+    test("reduceRanges: single $lte", () => {
+        assert.deepEqual(reduceRanges([
+            { $lte: 10 }
+        ]), [
+            { $lte: 10 }
+        ]);
+    });
+    test("reduceRanges: wider $gt kept", () => {
+        assert.deepEqual(reduceRanges([
+            { $gt: 5 },
+            { $gt: 10 }
+        ]), [
+            { $gt: 5 }
+        ]);
+    });
+    test("reduceRanges: wider $gte kept", () => {
+        assert.deepEqual(reduceRanges([
+            { $gte: 5 },
+            { $gte: 10 }
+        ]), [
+            { $gte: 5 }
+        ]);
+    });
+    test("reduceRanges: wider $lt kept", () => {
+        assert.deepEqual(reduceRanges([
+            { $lt: 20 },
+            { $lt: 10 }
+        ]), [
+            { $lt: 20 }
+        ]);
+    });
+    test("reduceRanges: wider $lte kept", () => {
+        assert.deepEqual(reduceRanges([
+            { $lte: 20 },
+            { $lte: 10 }
+        ]), [
+            { $lte: 20 }
+        ]);
+    });
+    test("reduceRanges: gt + gte", () => {
+        assert.deepEqual(reduceRanges([
+            { $gt: 5 },
+            { $gte: 10 }
+        ]), [
+            { $gt: 5 }
+        ]);
+    });
+    test("reduceRanges: gte + gt", () => {
+        assert.deepEqual(reduceRanges([
+            { $gte: 5 },
+            { $gt: 10 }
+        ]), [
+            { $gte: 5 }
+        ]);
+    });
+    test("reduceRanges: gt == gte", () => {
+        assert.deepEqual(reduceRanges([
+            { $gt: 5 },
+            { $gte: 5 }
+        ]), [
+            { $gte: 5 }
+        ]);
+    });
+    test("reduceRanges: lt + lte", () => {
+        assert.deepEqual(reduceRanges([
+            { $lt: 20 },
+            { $lte: 10 }
+        ]), [
+            { $lt: 20 }
+        ]);
+    });
+    test("reduceRanges: lte + lt", () => {
+        assert.deepEqual(reduceRanges([
+            { $lte: 20 },
+            { $lt: 10 }
+        ]), [
+            { $lte: 20 }
+        ]);
+    });
+    test("reduceRanges: lt == lte", () => {
+        assert.deepEqual(reduceRanges([
+            { $lt: 20 },
+            { $lte: 20 }
+        ]), [
+            { $lte: 20 }
+        ]);
+    });
+    test("reduceRanges: lower + upper", () => {
+        assert.deepEqual(reduceRanges([
+            { $gt: 5 },
+            { $lt: 20 }
+        ]), [
+            { $gt: 5 },
+            { $lt: 20 }
+        ]);
+    });
+    test("reduceRanges: mixed objects preserved", () => {
+        assert.deepEqual(reduceRanges([
+            { $gt: 5 },
+            { $regex: "abc" },
+            { $lt: 20 }
+        ]), [
+            { $regex: "abc" },
+            { $gt: 5 },
+            { $lt: 20 }
+        ]);
+    });
+    test("reduceRanges: duplicate gt", () => {
+        assert.deepEqual(reduceRanges([
+            { $gt: 5 },
+            { $gt: 5 }
+        ]), [
+            { $gt: 5 }
+        ]);
+    });
+    test("reduceRanges: duplicate lt", () => {
+        assert.deepEqual(reduceRanges([
+            { $lt: 10 },
+            { $lt: 10 }
+        ]), [
+            { $lt: 10 }
+        ]);
+    });
+    test("reduceRanges: negative values", () => {
+        assert.deepEqual(reduceRanges([
+            { $gt: -10 },
+            { $lt: -1 }
+        ]), [
+            { $gt: -10 },
+            { $lt: -1 }
+        ]);
+    });
+    test("reduceRanges: zero", () => {
+        assert.deepEqual(reduceRanges([
+            { $gte: 0 },
+            { $lte: 0 }
+        ]), [
+            { $gte: 0 },
+            { $lte: 0 }
+        ]);
+    });
+    test("reduceRanges: idempotent", () => {
+        const input = [
+            { $gt: 5 },
+            { $gt: 10 },
+            { $lt: 20 },
+            { $lt: 10 },
+            { $regex: "abc" }
+        ];
+        assert.deepEqual(reduceRanges(reduceRanges(input)), reduceRanges(input));
+    });
+    test("reduceRanges: widens lower bounds conservatively", () => {
+        assert.deepEqual(reduceRanges([
+            { $gte: 10 },
+            { $gte: 20 }
+        ]), [
+            { $gte: 10 }
+        ]);
+    });
+    test("reduceRanges: widens upper bounds conservatively", () => {
+        assert.deepEqual(reduceRanges([
+            { $lte: 50 },
+            { $lte: 100 }
+        ]), [
+            { $lte: 100 }
+        ]);
+    });
+    test("reduceRanges: prefers inclusive bound when values match as lower bound", () => {
+        assert.deepEqual(reduceRanges([
+            { $gt: 10 },
+            { $gte: 10 }
+        ]), [
+            { $gte: 10 }
+        ]);
+    });
+    test("reduceRanges: prefers inclusive bound when values match as upper bound", () => {
+        assert.deepEqual(reduceRanges([
+            { $lt: 10 },
+            { $lte: 10 }
+        ]), [
+            { $lte: 10 }
+        ]);
+    });
+    test("reduceRanges: keeps widest lower bound", () => {
+        assert.deepEqual(reduceRanges([
+            { $gt: 20 },
+            { $gte: 10 }
+        ]), [
+            { $gte: 10 }
+        ]);
+    });
+    test("reduceRanges: keeps widest upper bound", () => {
+        assert.deepEqual(reduceRanges([
+            { $lt: 50 },
+            { $lte: 100 }
+        ]), [
+            { $lte: 100 }
+        ]);
+    });
+    test("reduceRanges: preserves non-range values", () => {
+        assert.deepEqual(reduceRanges([
+            { $gte: 10 },
+            "hello",
+            { $exists: true }
+        ]), [
+            "hello",
+            { $exists: true },
+            { $gte: 10 }
+        ]);
+    });
+});
+// -----------------------------------------------------------------------------
+// extractBounds()
+// -----------------------------------------------------------------------------
+describe("extractBounds()", () => {
+    test("extractBounds: empty", () => {
+        assert.deepEqual(extractBounds([]), {
+            values: [],
+            from: null,
+            to: null,
+            fromOp: null,
+            toOp: null,
+        });
+    });
+    test("extractBounds: primitives", () => {
+        assert.deepEqual(extractBounds([
+            1,
+            "A"
+        ]), {
+            values: [
+                1,
+                "A"
+            ],
+            from: null,
+            to: null,
+            fromOp: null,
+            toOp: null,
+        });
+    });
+    test("extractBounds: single gt", () => {
+        assert.deepEqual(extractBounds([
+            { $gt: 5 }
+        ]), {
+            values: [],
+            from: 5,
+            to: null,
+            fromOp: "$gt",
+            toOp: null,
+        });
+    });
+    test("extractBounds: single gte", () => {
+        assert.deepEqual(extractBounds([
+            { $gte: 5 }
+        ]), {
+            values: [],
+            from: 5,
+            to: null,
+            fromOp: "$gte",
+            toOp: null,
+        });
+    });
+    test("extractBounds: single lt", () => {
+        assert.deepEqual(extractBounds([
+            { $lt: 10 }
+        ]), {
+            values: [],
+            from: null,
+            to: 10,
+            fromOp: null,
+            toOp: "$lt",
+        });
+    });
+    test("extractBounds: single lte", () => {
+        assert.deepEqual(extractBounds([
+            { $lte: 10 }
+        ]), {
+            values: [],
+            from: null,
+            to: 10,
+            fromOp: null,
+            toOp: "$lte",
+        });
+    });
+    test("extractBounds: lower + upper", () => {
+        assert.deepEqual(extractBounds([
+            { $gt: 5 },
+            { $lt: 20 }
+        ]), {
+            values: [],
+            from: 5,
+            to: 20,
+            fromOp: "$gt",
+            toOp: "$lt",
+        });
+    });
+    test("extractBounds: unknown object preserved", () => {
+        assert.deepEqual(extractBounds([
+            { $regex: "abc" }
+        ]), {
+            values: [
+                { $regex: "abc" }
+            ],
+            from: null,
+            to: null,
+            fromOp: null,
+            toOp: null,
+        });
+    });
+    test("extractBounds: primitive + bounds", () => {
+        assert.deepEqual(extractBounds([
+            "Sales",
+            { $gt: 5 },
+            { $lt: 20 }
+        ]), {
+            values: [
+                "Sales"
+            ],
+            from: 5,
+            to: 20,
+            fromOp: "$gt",
+            toOp: "$lt",
+        });
+    });
+    test("extractBounds(reduceRanges()) planner pipeline", () => {
+        assert.deepEqual(extractBounds(reduceRanges([
+            { $gt: 5 },
+            { $gt: 10 },
+            { $lt: 20 },
+            { $lt: 10 }
+        ])), {
+            values: [],
+            from: 5,
+            to: 20,
+            fromOp: "$gt",
+            toOp: "$lt",
+        });
+    });
+    test("extractBounds(reduceRanges()) inclusive", () => {
+        assert.deepEqual(extractBounds(reduceRanges([
+            { $gt: 5 },
+            { $gte: 5 },
+            { $lt: 20 },
+            { $lte: 20 }
+        ])), {
+            values: [],
+            from: 5,
+            to: 20,
+            fromOp: "$gte",
+            toOp: "$lte",
+        });
+    });
+    test("extractBounds(reduceRanges()) inclusive 2", () => {
+        assert.deepEqual(extractBounds(reduceRanges([
+            { $gte: 5 },
+            { $gt: 5 },
+            { $lte: 20 },
+            { $lt: 20 },
+        ])), {
+            values: [],
+            from: 5,
+            to: 20,
+            fromOp: "$gte",
+            toOp: "$lte",
+        });
+    });
+    test("extractBounds(reduceRanges()) inclusive 3", () => {
+        assert.deepEqual(extractBounds(reduceRanges([
+            { $gt: 4 },
+            { $gte: 5 },
+            { $lt: 21 },
+            { $lte: 20 }
+        ])), {
+            values: [],
+            from: 4,
+            to: 21,
+            fromOp: "$gt",
+            toOp: "$lt",
+        });
+    });
+    test("extractBounds(reduceRanges()) inclusive 4", () => {
+        assert.deepEqual(extractBounds(reduceRanges([
+            { $gt: 5 },
+            { $gte: 4 },
+            { $lt: 20 },
+            { $lte: 21 }
+        ])), {
+            values: [],
+            from: 4,
+            to: 21,
+            fromOp: "$gte",
+            toOp: "$lte",
+        });
+    });
+});