corebasic 1.0.205 → 1.0.208

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

@@ -0,0 +1,653 @@
+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",
+            }
+        );
+    });
+
+});