corebasic 1.0.206 → 1.0.209

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

@@ -0,0 +1,675 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import {matchPolicy, overlaps, contains, intersects, applySuffixPolicy} from "../policy.js";
+
+
+/* ============================================================
+ * overlaps()
+ * ============================================================ */
+describe("overlaps()", () => {
+
+    test("overlaps: identical ranges", () => {
+        assert.equal(
+            overlaps({ from: 10, to: 20 }, { from: 10, to: 20 }),
+            true
+        );
+    });
+
+    test("overlaps: partial overlap", () => {
+        assert.equal(
+            overlaps({ from: 10, to: 20 }, { from: 15, to: 25 }),
+            true
+        );
+    });
+
+    test("overlaps: no overlap", () => {
+        assert.equal(
+            overlaps({ from: 10, to: 20 }, { from: 21, to: 30 }),
+            false
+        );
+    });
+
+    test("overlaps: open ended lower", () => {
+        assert.equal(
+            overlaps({ to: 10 }, { from: 5 }),
+            true
+        );
+    });
+
+    test("overlaps: open ended upper", () => {
+        assert.equal(
+            overlaps({ from: 20 }, { to: 10 }),
+            false
+        );
+    });
+
+
+    describe("overlaps() boundary semantics", () => {
+
+        test("touching: open/open does not overlap", () => {
+            assert.equal(
+                overlaps(
+                    { to: 10, toOp: "$lt" },
+                    { from: 10, fromOp: "$gt" }
+                ),
+                false
+            );
+        });
+
+        test("touching: closed/closed overlaps", () => {
+            assert.equal(
+                overlaps(
+                    { to: 10, toOp: "$lte" },
+                    { from: 10, fromOp: "$gte" }
+                ),
+                true
+            );
+        });
+
+        test("touching: closed/open does not overlap", () => {
+            assert.equal(
+                overlaps(
+                    { to: 10, toOp: "$lte" },
+                    { from: 10, fromOp: "$gt" }
+                ),
+                false
+            );
+        });
+
+        test("touching: open/closed does not overlap", () => {
+            assert.equal(
+                overlaps(
+                    { to: 10, toOp: "$lt" },
+                    { from: 10, fromOp: "$gte" }
+                ),
+                false
+            );
+        });
+
+        test("touching: reverse order closed/closed overlaps", () => {
+            assert.equal(
+                overlaps(
+                    { from: 10, fromOp: "$gte" },
+                    { to: 10, toOp: "$lte" }
+                ),
+                true
+            );
+        });
+
+        test("touching: reverse order open/open does not overlap", () => {
+            assert.equal(
+                overlaps(
+                    { from: 10, fromOp: "$gt" },
+                    { to: 10, toOp: "$lt" }
+                ),
+                false
+            );
+        });
+
+        test("identical single-point closed intervals overlap", () => {
+            assert.equal(
+                overlaps(
+                    {
+                        from: 10,
+                        to: 10,
+                        fromOp: "$gte",
+                        toOp: "$lte"
+                    },
+                    {
+                        from: 10,
+                        to: 10,
+                        fromOp: "$gte",
+                        toOp: "$lte"
+                    }
+                ),
+                true
+            );
+        });
+
+        test("identical single-point open intervals do not overlap", () => {
+            assert.equal(
+                overlaps(
+                    {
+                        from: 10,
+                        to: 10,
+                        fromOp: "$gt",
+                        toOp: "$lt"
+                    },
+                    {
+                        from: 10,
+                        to: 10,
+                        fromOp: "$gt",
+                        toOp: "$lt"
+                    }
+                ),
+                false
+            );
+        });
+
+        test("infinite lower bound with touching closed endpoint overlaps", () => {
+            assert.equal(
+                overlaps(
+                    { to: 5, toOp: "$lte" },
+                    { from: 5, fromOp: "$gte" }
+                ),
+                true
+            );
+        });
+
+        test("infinite lower bound with touching open endpoint does not overlap", () => {
+            assert.equal(
+                overlaps(
+                    { to: 5, toOp: "$lt" },
+                    { from: 5, fromOp: "$gt" }
+                ),
+                false
+            );
+        });
+
+    });
+
+});
+
+/* ============================================================
+ * contains()
+ * ============================================================ */
+
+describe("contains()", () => {
+
+    test("contains: inside", () => {
+        assert.equal(
+            contains({ from: 10, to: 20 }, 15),
+            true
+        );
+    });
+
+    test("contains: below", () => {
+        assert.equal(
+            contains({ from: 10, to: 20 }, 5),
+            false
+        );
+    });
+
+    test("contains: above", () => {
+        assert.equal(
+            contains({ from: 10, to: 20 }, 25),
+            false
+        );
+    });
+
+    test("contains: lower bound", () => {
+        assert.equal(
+            contains({ from: 10, to: 20 }, 10),
+            true
+        );
+    });
+
+    test("contains: upper bound", () => {
+        assert.equal(
+            contains({ from: 10, to: 20 }, 20),
+            true
+        );
+    });
+
+
+    test("contains: gt excludes lower bound", () => {
+        assert.equal(
+            contains({ from: 5, fromOp: "$gt" }, 5),
+                     false
+        );
+    });
+
+    test("contains: gte includes lower bound", () => {
+        assert.equal(
+            contains({ from: 5, fromOp: "$gte" }, 5),
+                     true
+        );
+    });
+
+    test("contains: lt excludes upper bound", () => {
+        assert.equal(
+            contains({ to: 10, toOp: "$lt" }, 10),
+                     false
+        );
+    });
+
+    test("contains: lte includes upper bound", () => {
+        assert.equal(
+            contains({ to: 10, toOp: "$lte" }, 10),
+                     true
+        );
+    });
+
+    test("contains: gt/lt excludes both endpoints", () => {
+        const bounds = {
+            from: 5,
+            fromOp: "$gt",
+            to: 10,
+            toOp: "$lt"
+        };
+
+        assert.equal(contains(bounds, 5), false);
+        assert.equal(contains(bounds, 10), false);
+        assert.equal(contains(bounds, 7), true);
+    });
+
+    test("contains: gte/lte includes both endpoints", () => {
+        const bounds = {
+            from: 5,
+            fromOp: "$gte",
+            to: 10,
+            toOp: "$lte"
+        };
+
+        assert.equal(contains(bounds, 5), true);
+        assert.equal(contains(bounds, 10), true);
+        assert.equal(contains(bounds, 7), true);
+    });
+
+    test("contains: gt/lte mixed", () => {
+        const bounds = {
+            from: 5,
+            fromOp: "$gt",
+            to: 10,
+            toOp: "$lte"
+        };
+
+        assert.equal(contains(bounds, 5), false);
+        assert.equal(contains(bounds, 10), true);
+    });
+
+    test("contains: gte/lt mixed", () => {
+        const bounds = {
+            from: 5,
+            fromOp: "$gte",
+            to: 10,
+            toOp: "$lt"
+        };
+
+        assert.equal(contains(bounds, 5), true);
+        assert.equal(contains(bounds, 10), false);
+    });
+
+    test("contains: value below lower bound", () => {
+        assert.equal(
+            contains({ from: 5, fromOp: "$gte" }, 4),
+                     false
+        );
+    });
+
+    test("contains: value above upper bound", () => {
+        assert.equal(
+            contains({ to: 10, toOp: "$lte" }, 11),
+                     false
+        );
+    });
+
+    test("contains: open lower bound", () => {
+        assert.equal(
+            contains({ to: 10, toOp: "$lte" }, -1000),
+                     true
+        );
+    });
+
+    test("contains: open upper bound", () => {
+        assert.equal(
+            contains({ from: 5, fromOp: "$gte" }, 1000),
+                     true
+        );
+    });
+
+    test("contains: completely unbounded", () => {
+        assert.equal(
+            contains({}, -100),
+                     true
+        );
+        assert.equal(
+            contains({}, 100),
+                     true
+        );
+    });
+
+});
+
+/* ============================================================
+ * intersects()
+ * ============================================================ */
+
+describe("intersects()", () => {
+
+    test("intersects: value ↔ value", () => {
+        assert.equal(
+            intersects(["A"], null, ["A"], null),
+            true
+        );
+    });
+
+    test("intersects: value ↔ value miss", () => {
+        assert.equal(
+            intersects(["A"], null, ["B"], null),
+            false
+        );
+    });
+
+    test("intersects: value ↔ range", () => {
+        assert.equal(
+            intersects([10], null, [], { from: 5 }),
+            true
+        );
+    });
+
+    test("intersects: value ↔ range miss", () => {
+        assert.equal(
+            intersects([2], null, [], { from: 5 }),
+            false
+        );
+    });
+
+    test("intersects: range ↔ value", () => {
+        assert.equal(
+            intersects([], { from: 5 }, [10], null),
+            true
+        );
+    });
+
+    test("intersects: range ↔ value miss", () => {
+        assert.equal(
+            intersects([], { from: 5 }, [2], null),
+            false
+        );
+    });
+
+    test("intersects: range ↔ range", () => {
+        assert.equal(
+            intersects([], { from: 10 }, [], { from: 20 }),
+            true
+        );
+    });
+
+    test("intersects: range ↔ range miss", () => {
+        assert.equal(
+            intersects([], { to: 5 }, [], { from: 10 }),
+            false
+        );
+    });
+
+});
+
+/* ============================================================
+ * matchPolicy()
+ * ============================================================ */
+describe("matchPolicy()", () => {
+
+    test("empty when", () => {
+        assert.equal(
+            matchPolicy({}, {}),
+            true
+        );
+    });
+
+    test("simple equality", () => {
+        assert.equal(
+            matchPolicy(
+                { status: "Active" },
+                { status: "Active" }
+            ),
+            true
+        );
+    });
+
+    test("simple equality fail", () => {
+        assert.equal(
+            matchPolicy(
+                { status: "Pending" },
+                { status: "Active" }
+            ),
+            false
+        );
+    });
+
+    test("$in subset", () => {
+        assert.equal(
+            matchPolicy(
+                { status: { $in: ["Active", "Pending"] } },
+                { status: { $in: ["Active"] } }
+            ),
+            true
+        );
+    });
+
+    test("$in miss", () => {
+        assert.equal(
+            matchPolicy(
+                { status: { $in: ["Pending"] } },
+                { status: { $in: ["Active"] } }
+            ),
+            false
+        );
+    });
+
+    test("value ↔ range", () => {
+        assert.equal(
+            matchPolicy(
+                { age: 10 },
+                { age: { $gt: 5 } }
+            ),
+            true
+        );
+    });
+
+    test("value ↔ range miss", () => {
+        assert.equal(
+            matchPolicy(
+                { age: 2 },
+                { age: { $gt: 5 } }
+            ),
+            false
+        );
+    });
+
+    test("range ↔ value", () => {
+        assert.equal(
+            matchPolicy(
+                { age: { $gt: 5 } },
+                { age: 10 }
+            ),
+            true
+        );
+    });
+
+    test("range ↔ value miss", () => {
+        assert.equal(
+            matchPolicy(
+                { age: { $lt: 5 } },
+                { age: 10 }
+            ),
+            false
+        );
+    });
+
+    test("range ↔ range overlap", () => {
+        assert.equal(
+            matchPolicy(
+                { age: { $gt: 15 } },
+                { age: { $gt: 10 } }
+            ),
+            true
+        );
+    });
+
+    test("range ↔ range miss", () => {
+        assert.equal(
+            matchPolicy(
+                { age: { $lt: 5 } },
+                { age: { $gt: 10 } }
+            ),
+            false
+        );
+    });
+
+    test("multiple keys", () => {
+        assert.equal(
+            matchPolicy(
+                {
+                    status: "Active",
+                    age: 20
+                },
+                {
+                    status: "Active",
+                    age: { $gt: 10 }
+                }
+            ),
+            true
+        );
+    });
+
+    test("multiple keys fail", () => {
+        assert.equal(
+            matchPolicy(
+                {
+                    status: "Pending",
+                    age: 20
+                },
+                {
+                    status: "Active",
+                    age: { $gt: 10 }
+                }
+            ),
+            false
+        );
+    });
+
+    test("$and flatten", () => {
+        assert.equal(
+            matchPolicy(
+                {
+                    status: "Active",
+                    region: "IN"
+                },
+                {
+                    $and: [
+                        { status: "Active" },
+                        { region: "IN" }
+                    ]
+                }
+            ),
+            true
+        );
+    });
+
+    test("$and flatten fail", () => {
+        assert.equal(
+            matchPolicy(
+                {
+                    status: "Active",
+                    region: "US"
+                },
+                {
+                    $and: [
+                        { status: "Active" },
+                        { region: "IN" }
+                    ]
+                }
+            ),
+            false
+        );
+    });
+
+    test("$or merge semantics", () => {
+        assert.equal(
+            matchPolicy(
+                {
+                    status: {
+                        $in: ["Active", "Pending"]
+                    }
+                },
+                {
+                    $or: [
+                        { status: "Active" },
+                        { status: "Pending" }
+                    ]
+                }
+            ),
+            true
+        );
+    });
+
+    test("$ne throws", () => {
+        assert.throws(() => {
+            matchPolicy(
+                { status: "Deleted" },
+                {
+                    status: {
+                        $ne: "Deleted"
+                    }
+                }
+            );
+        });
+    });
+
+    test("$nin throws", () => {
+        assert.throws(() => {
+            matchPolicy(
+                { status: "Deleted" },
+                {
+                    status: {
+                        $nin: ["Deleted"]
+                    }
+                }
+            );
+        });
+    });
+
+    test("$not throws", () => {
+        assert.throws(() => {
+            matchPolicy(
+                { age: 10 },
+                {
+                    age: {
+                        $not: {
+                            $gt: 5
+                        }
+                    }
+                }
+            );
+        });
+    });
+
+    test("conservative planner: identical lt", () => {
+        assert.equal(
+            matchPolicy(
+                { age: { $lt: 10 } },
+                { age: { $lt: 10 } }
+            ),
+            true
+        );
+    });
+
+    test("conservative planner: identical gt", () => {
+        assert.equal(
+            matchPolicy(
+                { age: { $gt: 10 } },
+                { age: { $gt: 10 } }
+            ),
+            true
+        );
+    });
+
+    test("mixed value + range", () => {
+        assert.equal(
+            matchPolicy(
+                {
+                    age: {
+                        $in: [10],
+                        $gt: 20
+                    }
+                },
+                {
+                    age: 10
+                }
+            ),
+            true
+        );
+    });
+
+});