@o3co/auth.policy-verifier.builtins 0.1.1 → 0.3.0

package/dist/__tests__/rules/AttrLiteralNotIn.test.mjs

@@ -0,0 +1,168 @@
+import { describe, expect, it } from "vitest";
+import { AttrLiteralNotIn } from "#/rules/AttrLiteralNotIn.mjs";
+describe("AttrLiteralNotIn", () => {
+    // ---------------------------------------------------------------------------
+    // Happy path: attr not in set → true
+    // ---------------------------------------------------------------------------
+    it("returns true when attr is a string NOT in the configured values set", () => {
+        const rule = new AttrLiteralNotIn({ a: "role", values: ["admin", "editor"] });
+        const attrs = new Map([["role", "viewer"]]);
+        expect(rule.verify(attrs)).toBe(true);
+    });
+    it("returns true when attr is a number NOT in the configured values set", () => {
+        const rule = new AttrLiteralNotIn({ a: "level", values: [1, 2, 3] });
+        const attrs = new Map([["level", 5]]);
+        expect(rule.verify(attrs)).toBe(true);
+    });
+    it("returns true when attr is a boolean NOT in the configured values set", () => {
+        const rule = new AttrLiteralNotIn({ a: "active", values: [false] });
+        const attrs = new Map([["active", true]]);
+        expect(rule.verify(attrs)).toBe(true);
+    });
+    // ---------------------------------------------------------------------------
+    // Happy path: attr in set → false
+    // ---------------------------------------------------------------------------
+    it("returns false when attr is a string IN the configured values set", () => {
+        const rule = new AttrLiteralNotIn({ a: "role", values: ["admin", "editor"] });
+        const attrs = new Map([["role", "admin"]]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    it("returns false when attr is a number IN the configured values set", () => {
+        const rule = new AttrLiteralNotIn({ a: "level", values: [1, 2, 3] });
+        const attrs = new Map([["level", 2]]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    it("returns false when attr is a boolean IN the configured values set", () => {
+        const rule = new AttrLiteralNotIn({ a: "active", values: [true] });
+        const attrs = new Map([["active", true]]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    // ---------------------------------------------------------------------------
+    // Type mismatch: safe-deny (no coercion)
+    // ---------------------------------------------------------------------------
+    it("returns false when values are strings but attr is a number (type mismatch)", () => {
+        const rule = new AttrLiteralNotIn({ a: "x", values: ["a", "b"] });
+        const attrs = new Map([["x", 42]]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    it("returns false when values are numbers but attr is a string (type mismatch)", () => {
+        const rule = new AttrLiteralNotIn({ a: "x", values: [1, 2, 3] });
+        const attrs = new Map([["x", "1"]]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    // ---------------------------------------------------------------------------
+    // Evaluation-time safe-deny: missing / null attr
+    // ---------------------------------------------------------------------------
+    it("returns false when the target attribute is missing", () => {
+        const rule = new AttrLiteralNotIn({ a: "role", values: ["admin"] });
+        const attrs = new Map();
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    it("returns false when the target attribute is null", () => {
+        const rule = new AttrLiteralNotIn({ a: "role", values: ["admin"] });
+        const attrs = new Map([["role", null]]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    // ---------------------------------------------------------------------------
+    // Construction errors: invalid 'a'
+    // ---------------------------------------------------------------------------
+    it("throws when 'a' is undefined", () => {
+        expect(() => new AttrLiteralNotIn({ a: undefined, values: ["x"] })).toThrow(/AttrLiteralNotIn.*'a'.*(non-empty string|got undefined)/);
+    });
+    it("throws when 'a' is an empty string", () => {
+        expect(() => new AttrLiteralNotIn({ a: "", values: ["x"] })).toThrow(/AttrLiteralNotIn.*'a'.*empty string/);
+    });
+    it("throws when 'a' is a non-string (number 42)", () => {
+        expect(() => new AttrLiteralNotIn({ a: 42, values: ["x"] })).toThrow(/AttrLiteralNotIn.*'a'.*got number/);
+    });
+    // ---------------------------------------------------------------------------
+    // Construction errors: invalid 'values'
+    // ---------------------------------------------------------------------------
+    it("throws when 'values' is missing (undefined)", () => {
+        expect(() => new AttrLiteralNotIn({ a: "role", values: undefined })).toThrow(/AttrLiteralNotIn.*'values'/);
+    });
+    it("throws when 'values' is not an array (a string)", () => {
+        expect(() => new AttrLiteralNotIn({ a: "role", values: "admin" })).toThrow(/AttrLiteralNotIn.*'values'/);
+    });
+    it("throws when 'values' is an empty array", () => {
+        expect(() => new AttrLiteralNotIn({ a: "role", values: [] })).toThrow(/AttrLiteralNotIn.*'values'/);
+    });
+    it("throws when 'values' contains null", () => {
+        expect(() => new AttrLiteralNotIn({ a: "role", values: [null] })).toThrow(/AttrLiteralNotIn.*'values'/);
+    });
+    it("throws when 'values' contains undefined", () => {
+        expect(() => new AttrLiteralNotIn({ a: "role", values: [undefined] })).toThrow(/AttrLiteralNotIn.*'values'/);
+    });
+    it("throws when 'values' contains mixed types (string and number)", () => {
+        expect(() => new AttrLiteralNotIn({ a: "role", values: ["a", 1] })).toThrow(/AttrLiteralNotIn.*'values'.*mixed/);
+    });
+    it("throws when 'values' contains an object element", () => {
+        expect(() => new AttrLiteralNotIn({ a: "role", values: [{}] })).toThrow(/AttrLiteralNotIn.*'values'/);
+    });
+    it("throws when 'values' contains NaN", () => {
+        // A NaN element could never match any numeric attribute (NaN !== NaN),
+        // so including it in a "deny these" list is a silent policy mistake.
+        expect(() => new AttrLiteralNotIn({ a: "score", values: [1, Number.NaN, 3] })).toThrow(/AttrLiteralNotIn.*must not contain NaN/);
+    });
+    // ---------------------------------------------------------------------------
+    // Construction errors: invalid 'group'
+    // ---------------------------------------------------------------------------
+    it("throws when 'group' is present but is an empty string", () => {
+        expect(() => new AttrLiteralNotIn({ a: "role", values: ["admin"], group: "" })).toThrow(/AttrLiteralNotIn.*'group'.*empty string/);
+    });
+    it("throws when 'group' is present but is a non-string (number 42)", () => {
+        expect(() => new AttrLiteralNotIn({ a: "role", values: ["admin"], group: 42 })).toThrow(/AttrLiteralNotIn.*'group'.*got number/);
+    });
+    // ---------------------------------------------------------------------------
+    // ruleType: default includes valuesKey
+    // ---------------------------------------------------------------------------
+    it("derives default ruleType containing the attribute name and valuesKey", () => {
+        const rule = new AttrLiteralNotIn({ a: "role", values: ["admin", "editor"] });
+        expect(rule.ruleType).toMatch(/^attr_literal_not_in:role:string:2:[0-9a-f]{8}$/);
+    });
+    it("two instances with same 'a' but different values produce different ruleTypes", () => {
+        const r1 = new AttrLiteralNotIn({ a: "role", values: ["admin"] });
+        const r2 = new AttrLiteralNotIn({ a: "role", values: ["editor"] });
+        expect(r1.ruleType).not.toBe(r2.ruleType);
+    });
+    it("two instances with same 'a' and identical values (same order) produce same ruleType", () => {
+        const r1 = new AttrLiteralNotIn({ a: "role", values: ["admin", "editor"] });
+        const r2 = new AttrLiteralNotIn({ a: "role", values: ["admin", "editor"] });
+        expect(r1.ruleType).toBe(r2.ruleType);
+    });
+    it("two instances with same 'a' and same values in different order produce same ruleType (content-based sort)", () => {
+        const r1 = new AttrLiteralNotIn({ a: "role", values: ["admin", "editor"] });
+        const r2 = new AttrLiteralNotIn({ a: "role", values: ["editor", "admin"] });
+        expect(r1.ruleType).toBe(r2.ruleType);
+    });
+    // ---------------------------------------------------------------------------
+    // ruleType: group override
+    // ---------------------------------------------------------------------------
+    it("uses the provided group string as ruleType, overriding the valuesKey-based default", () => {
+        const r1 = new AttrLiteralNotIn({ a: "role", values: ["admin"], group: "not-admin-set" });
+        const r2 = new AttrLiteralNotIn({ a: "role", values: ["editor"], group: "not-admin-set" });
+        expect(r1.ruleType).toBe("not-admin-set");
+        expect(r2.ruleType).toBe("not-admin-set");
+    });
+    // ---------------------------------------------------------------------------
+    // code and message fields
+    // ---------------------------------------------------------------------------
+    it("has code 'attr_in_set'", () => {
+        const rule = new AttrLiteralNotIn({ a: "role", values: ["admin"] });
+        expect(rule.code).toBe("attr_in_set");
+    });
+    it("message contains the attribute name and lists all values", () => {
+        const rule = new AttrLiteralNotIn({ a: "role", values: ["admin", "editor"] });
+        expect(rule.message).toContain("role");
+        expect(rule.message).toContain("admin");
+        expect(rule.message).toContain("editor");
+    });
+    it("message contains 'must not be one of'", () => {
+        const rule = new AttrLiteralNotIn({ a: "role", values: ["admin"] });
+        expect(rule.message).toContain("must not be one of");
+    });
+    it("message starts with a capital letter", () => {
+        const rule = new AttrLiteralNotIn({ a: "role", values: ["admin"] });
+        expect(rule.message[0]).toBe(rule.message[0]?.toUpperCase());
+    });
+});

package/dist/__tests__/rules/AttrMatchRule.test.d.mts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=AttrMatchRule.test.d.mts.map

package/dist/__tests__/rules/AttrMatchRule.test.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AttrMatchRule.test.d.mts","sourceRoot":"","sources":["../../../src/__tests__/rules/AttrMatchRule.test.mts"],"names":[],"mappings":""}

package/dist/__tests__/rules/AttrMatchRule.test.mjs

@@ -0,0 +1,79 @@
+import { describe, expect, it } from "vitest";
+import { AttrMatchRule } from "#/rules/AttrMatchRule.mjs";
+describe("AttrMatchRule", () => {
+    const rule = new AttrMatchRule({ a: "x", b: "y" });
+    it("returns true when both attrs are non-empty strings and equal", () => {
+        const attrs = new Map([
+            ["x", "same"],
+            ["y", "same"],
+        ]);
+        expect(rule.verify(attrs)).toBe(true);
+    });
+    it("returns false when the two attrs differ", () => {
+        const attrs = new Map([
+            ["x", "foo"],
+            ["y", "bar"],
+        ]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    it("returns false when the first attr is missing", () => {
+        const attrs = new Map([["y", "same"]]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    it("returns false when the second attr is missing", () => {
+        const attrs = new Map([["x", "same"]]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    it("returns false when either attr is a non-string value", () => {
+        const attrs = new Map([
+            ["x", 42],
+            ["y", 42],
+        ]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    it("returns false when either attr is an empty string", () => {
+        const attrs = new Map([
+            ["x", ""],
+            ["y", ""],
+        ]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    it("derives ruleType from the pair of attribute keys by default", () => {
+        // Distinct pairs must produce distinct ruleType values. Otherwise
+        // evaluate() would OR them together within a single group, which
+        // weakens "require both comparisons to pass" intent.
+        const r1 = new AttrMatchRule({ a: "userId", b: "sub" });
+        const r2 = new AttrMatchRule({ a: "orgId", b: "org" });
+        expect(r1.ruleType).not.toBe(r2.ruleType);
+        expect(r1.ruleType).toContain("userId");
+        expect(r1.ruleType).toContain("sub");
+    });
+    it("preserves the legacy ruleType prefix 'attr_match:' for backward compatibility", () => {
+        // AttrMatchRule is a deprecated wrapper around AttrPairEqual. To keep
+        // downstream consumers (e.g. dplaas.auth) working without code changes
+        // across this release, the default ruleType must remain `attr_match:{a}:{b}`
+        // rather than adopting AttrPairEqual's `attr_pair_equal:...` form.
+        const r = new AttrMatchRule({ a: "userId", b: "sub" });
+        expect(r.ruleType).toBe("attr_match:userId:sub");
+    });
+    it("uses the provided group override when set, to enable explicit grouping", () => {
+        // When callers want two comparisons to be OR'd together (e.g. match by
+        // either DID or email), they opt in by passing the same `group`.
+        const r1 = new AttrMatchRule({ a: "x", b: "y", group: "identity" });
+        const r2 = new AttrMatchRule({ a: "e", b: "f", group: "identity" });
+        expect(r1.ruleType).toBe("identity");
+        expect(r2.ruleType).toBe("identity");
+    });
+    it("has code 'attr_mismatch'", () => {
+        expect(rule.code).toBe("attr_mismatch");
+    });
+    it("message describes the contract (both attrs must be non-empty strings and equal)", () => {
+        // The message should make the rule's contract explicit, not just say "do not match",
+        // because verify() fails closed on missing, non-string, and empty inputs too.
+        expect(rule.message).toContain("x");
+        expect(rule.message).toContain("y");
+        expect(rule.message).toMatch(/non-empty/i);
+        expect(rule.message).toMatch(/equal/i);
+        expect(rule.message[0]).toBe(rule.message[0]?.toUpperCase());
+    });
+});

package/dist/__tests__/rules/AttrPairCompare.test.d.mts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=AttrPairCompare.test.d.mts.map

package/dist/__tests__/rules/AttrPairCompare.test.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AttrPairCompare.test.d.mts","sourceRoot":"","sources":["../../../src/__tests__/rules/AttrPairCompare.test.mts"],"names":[],"mappings":""}

package/dist/__tests__/rules/AttrPairCompare.test.mjs

@@ -0,0 +1,319 @@
+import { describe, expect, it } from "vitest";
+import { AttrPairCompare } from "#/rules/AttrPairCompare.mjs";
+describe("AttrPairCompare", () => {
+    // ---------------------------------------------------------------------------
+    // Happy path: each op at boundary values
+    // ---------------------------------------------------------------------------
+    it("op=lt: returns true when attr(a) < attr(b) (5 < 10)", () => {
+        const rule = new AttrPairCompare({ a: "low", op: "lt", b: "high" });
+        const attrs = new Map([
+            ["low", 5],
+            ["high", 10],
+        ]);
+        expect(rule.verify(attrs)).toBe(true);
+    });
+    it("op=lt: returns false when attr(a) === attr(b) (10 < 10 is false)", () => {
+        const rule = new AttrPairCompare({ a: "low", op: "lt", b: "high" });
+        const attrs = new Map([
+            ["low", 10],
+            ["high", 10],
+        ]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    it("op=lt: returns false when attr(a) > attr(b) (15 < 10 is false)", () => {
+        const rule = new AttrPairCompare({ a: "low", op: "lt", b: "high" });
+        const attrs = new Map([
+            ["low", 15],
+            ["high", 10],
+        ]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    it("op=le: returns true when attr(a) === attr(b) (10 <= 10)", () => {
+        const rule = new AttrPairCompare({ a: "low", op: "le", b: "high" });
+        const attrs = new Map([
+            ["low", 10],
+            ["high", 10],
+        ]);
+        expect(rule.verify(attrs)).toBe(true);
+    });
+    it("op=le: returns true when attr(a) < attr(b) (5 <= 10)", () => {
+        const rule = new AttrPairCompare({ a: "low", op: "le", b: "high" });
+        const attrs = new Map([
+            ["low", 5],
+            ["high", 10],
+        ]);
+        expect(rule.verify(attrs)).toBe(true);
+    });
+    it("op=le: returns false when attr(a) > attr(b) (15 <= 10 is false)", () => {
+        const rule = new AttrPairCompare({ a: "low", op: "le", b: "high" });
+        const attrs = new Map([
+            ["low", 15],
+            ["high", 10],
+        ]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    it("op=gt: returns true when attr(a) > attr(b) (15 > 10)", () => {
+        const rule = new AttrPairCompare({ a: "score", op: "gt", b: "threshold" });
+        const attrs = new Map([
+            ["score", 15],
+            ["threshold", 10],
+        ]);
+        expect(rule.verify(attrs)).toBe(true);
+    });
+    it("op=gt: returns false when attr(a) === attr(b) (10 > 10 is false)", () => {
+        const rule = new AttrPairCompare({ a: "score", op: "gt", b: "threshold" });
+        const attrs = new Map([
+            ["score", 10],
+            ["threshold", 10],
+        ]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    it("op=gt: returns false when attr(a) < attr(b) (5 > 10 is false)", () => {
+        const rule = new AttrPairCompare({ a: "score", op: "gt", b: "threshold" });
+        const attrs = new Map([
+            ["score", 5],
+            ["threshold", 10],
+        ]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    it("op=ge: returns true when attr(a) === attr(b) (10 >= 10)", () => {
+        const rule = new AttrPairCompare({ a: "score", op: "ge", b: "threshold" });
+        const attrs = new Map([
+            ["score", 10],
+            ["threshold", 10],
+        ]);
+        expect(rule.verify(attrs)).toBe(true);
+    });
+    it("op=ge: returns true when attr(a) > attr(b) (15 >= 10)", () => {
+        const rule = new AttrPairCompare({ a: "score", op: "ge", b: "threshold" });
+        const attrs = new Map([
+            ["score", 15],
+            ["threshold", 10],
+        ]);
+        expect(rule.verify(attrs)).toBe(true);
+    });
+    it("op=ge: returns false when attr(a) < attr(b) (5 >= 10 is false)", () => {
+        const rule = new AttrPairCompare({ a: "score", op: "ge", b: "threshold" });
+        const attrs = new Map([
+            ["score", 5],
+            ["threshold", 10],
+        ]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    // ---------------------------------------------------------------------------
+    // Evaluation-time safe-deny: attr is not a number
+    // ---------------------------------------------------------------------------
+    it("returns false when attr(a) is a string (not a number)", () => {
+        const rule = new AttrPairCompare({ a: "score", op: "gt", b: "threshold" });
+        const attrs = new Map([
+            ["score", "10"],
+            ["threshold", 5],
+        ]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    it("returns false when attr(b) is a string (not a number)", () => {
+        const rule = new AttrPairCompare({ a: "score", op: "gt", b: "threshold" });
+        const attrs = new Map([
+            ["score", 10],
+            ["threshold", "5"],
+        ]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    // ---------------------------------------------------------------------------
+    // Evaluation-time safe-deny: missing attr
+    // ---------------------------------------------------------------------------
+    it("returns false when attr(a) is missing", () => {
+        const rule = new AttrPairCompare({ a: "score", op: "gt", b: "threshold" });
+        const attrs = new Map([["threshold", 5]]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    it("returns false when attr(b) is missing", () => {
+        const rule = new AttrPairCompare({ a: "score", op: "gt", b: "threshold" });
+        const attrs = new Map([["score", 10]]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    // ---------------------------------------------------------------------------
+    // Evaluation-time: NaN attribute → false for all ops
+    // ---------------------------------------------------------------------------
+    it("op=lt: returns false when attr(a) is NaN", () => {
+        const rule = new AttrPairCompare({ a: "score", op: "lt", b: "threshold" });
+        const attrs = new Map([
+            ["score", NaN],
+            ["threshold", 10],
+        ]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    it("op=le: returns false when attr(a) is NaN", () => {
+        const rule = new AttrPairCompare({ a: "score", op: "le", b: "threshold" });
+        const attrs = new Map([
+            ["score", NaN],
+            ["threshold", 10],
+        ]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    it("op=gt: returns false when attr(a) is NaN", () => {
+        const rule = new AttrPairCompare({ a: "score", op: "gt", b: "threshold" });
+        const attrs = new Map([
+            ["score", NaN],
+            ["threshold", 10],
+        ]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    it("op=ge: returns false when attr(a) is NaN", () => {
+        const rule = new AttrPairCompare({ a: "score", op: "ge", b: "threshold" });
+        const attrs = new Map([
+            ["score", NaN],
+            ["threshold", 10],
+        ]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    it("op=lt: returns false when attr(b) is NaN", () => {
+        const rule = new AttrPairCompare({ a: "score", op: "lt", b: "threshold" });
+        const attrs = new Map([
+            ["score", 5],
+            ["threshold", NaN],
+        ]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    it("op=le: returns false when attr(b) is NaN", () => {
+        const rule = new AttrPairCompare({ a: "score", op: "le", b: "threshold" });
+        const attrs = new Map([
+            ["score", 5],
+            ["threshold", NaN],
+        ]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    it("op=gt: returns false when attr(b) is NaN", () => {
+        const rule = new AttrPairCompare({ a: "score", op: "gt", b: "threshold" });
+        const attrs = new Map([
+            ["score", 15],
+            ["threshold", NaN],
+        ]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    it("op=ge: returns false when attr(b) is NaN", () => {
+        const rule = new AttrPairCompare({ a: "score", op: "ge", b: "threshold" });
+        const attrs = new Map([
+            ["score", 15],
+            ["threshold", NaN],
+        ]);
+        expect(rule.verify(attrs)).toBe(false);
+    });
+    // ---------------------------------------------------------------------------
+    // Evaluation-time: Infinity / -Infinity attributes
+    // ---------------------------------------------------------------------------
+    it("op=gt: Infinity > 100 returns true", () => {
+        const rule = new AttrPairCompare({ a: "score", op: "gt", b: "threshold" });
+        const attrs = new Map([
+            ["score", Infinity],
+            ["threshold", 100],
+        ]);
+        expect(rule.verify(attrs)).toBe(true);
+    });
+    it("op=lt: -Infinity < 0 returns true", () => {
+        const rule = new AttrPairCompare({ a: "score", op: "lt", b: "threshold" });
+        const attrs = new Map([
+            ["score", -Infinity],
+            ["threshold", 0],
+        ]);
+        expect(rule.verify(attrs)).toBe(true);
+    });
+    it("op=ge: Infinity >= Infinity returns true", () => {
+        const rule = new AttrPairCompare({ a: "score", op: "ge", b: "threshold" });
+        const attrs = new Map([
+            ["score", Infinity],
+            ["threshold", Infinity],
+        ]);
+        expect(rule.verify(attrs)).toBe(true);
+    });
+    // ---------------------------------------------------------------------------
+    // Construction errors: invalid 'a'
+    // ---------------------------------------------------------------------------
+    it("throws when 'a' is undefined", () => {
+        expect(() => new AttrPairCompare({ a: undefined, op: "gt", b: "threshold" })).toThrow(/AttrPairCompare.*'a'.*(non-empty string|got undefined)/);
+    });
+    it("throws when 'a' is a non-string (number 42)", () => {
+        expect(() => new AttrPairCompare({ a: 42, op: "gt", b: "threshold" })).toThrow(/AttrPairCompare.*'a'.*got number/);
+    });
+    it("throws when 'a' is an empty string", () => {
+        expect(() => new AttrPairCompare({ a: "", op: "gt", b: "threshold" })).toThrow(/AttrPairCompare.*'a'.*empty string/);
+    });
+    // ---------------------------------------------------------------------------
+    // Construction errors: invalid 'b'
+    // ---------------------------------------------------------------------------
+    it("throws when 'b' is undefined", () => {
+        expect(() => new AttrPairCompare({ a: "score", op: "gt", b: undefined })).toThrow(/AttrPairCompare.*'b'.*(non-empty string|got undefined)/);
+    });
+    it("throws when 'b' is a non-string (number 42)", () => {
+        expect(() => new AttrPairCompare({ a: "score", op: "gt", b: 42 })).toThrow(/AttrPairCompare.*'b'.*got number/);
+    });
+    it("throws when 'b' is an empty string", () => {
+        expect(() => new AttrPairCompare({ a: "score", op: "gt", b: "" })).toThrow(/AttrPairCompare.*'b'.*empty string/);
+    });
+    // ---------------------------------------------------------------------------
+    // Construction errors: invalid 'op'
+    // ---------------------------------------------------------------------------
+    it("throws when 'op' is missing (undefined)", () => {
+        expect(() => new AttrPairCompare({ a: "score", op: undefined, b: "threshold" })).toThrow(/AttrPairCompare.*'op'/);
+    });
+    it("throws when 'op' is not a string (number 42)", () => {
+        expect(() => new AttrPairCompare({ a: "score", op: 42, b: "threshold" })).toThrow(/AttrPairCompare.*'op'/);
+    });
+    it("throws when 'op' is an invalid string ('eq')", () => {
+        expect(() => new AttrPairCompare({ a: "score", op: "eq", b: "threshold" })).toThrow(/AttrPairCompare.*'op'/);
+    });
+    // ---------------------------------------------------------------------------
+    // Construction errors: invalid 'group'
+    // ---------------------------------------------------------------------------
+    it("throws when 'group' is present but is a non-string (number 42)", () => {
+        expect(() => new AttrPairCompare({
+            a: "score",
+            op: "gt",
+            b: "threshold",
+            group: 42,
+        })).toThrow(/AttrPairCompare.*'group'.*got number/);
+    });
+    it("throws when 'group' is present but is an empty string", () => {
+        expect(() => new AttrPairCompare({ a: "score", op: "gt", b: "threshold", group: "" })).toThrow(/AttrPairCompare.*'group'.*empty string/);
+    });
+    // ---------------------------------------------------------------------------
+    // ruleType: default derived from a, op, b
+    // ---------------------------------------------------------------------------
+    it("derives default ruleType from a, op, and b", () => {
+        const rule = new AttrPairCompare({ a: "score", op: "gt", b: "threshold" });
+        expect(rule.ruleType).toBe("attr_pair_compare:score:gt:threshold");
+    });
+    it("distinct op or b produce distinct ruleTypes (AND semantics)", () => {
+        const r1 = new AttrPairCompare({ a: "score", op: "gt", b: "threshold" });
+        const r2 = new AttrPairCompare({ a: "score", op: "ge", b: "threshold" });
+        const r3 = new AttrPairCompare({ a: "score", op: "gt", b: "limit" });
+        expect(r1.ruleType).not.toBe(r2.ruleType);
+        expect(r1.ruleType).not.toBe(r3.ruleType);
+    });
+    // ---------------------------------------------------------------------------
+    // ruleType: group override
+    // ---------------------------------------------------------------------------
+    it("uses the provided group string as ruleType, overriding the default", () => {
+        const r1 = new AttrPairCompare({ a: "score", op: "gt", b: "threshold", group: "score-check" });
+        const r2 = new AttrPairCompare({ a: "score", op: "ge", b: "limit", group: "score-check" });
+        expect(r1.ruleType).toBe("score-check");
+        expect(r2.ruleType).toBe("score-check");
+    });
+    // ---------------------------------------------------------------------------
+    // code and message fields
+    // ---------------------------------------------------------------------------
+    it("has code 'attr_compare_violated'", () => {
+        const rule = new AttrPairCompare({ a: "score", op: "gt", b: "threshold" });
+        expect(rule.code).toBe("attr_compare_violated");
+    });
+    it("message contains a name, op, and b name", () => {
+        const rule = new AttrPairCompare({ a: "score", op: "gt", b: "threshold" });
+        expect(rule.message).toContain("score");
+        expect(rule.message).toContain("gt");
+        expect(rule.message).toContain("threshold");
+    });
+    it("message starts with a capital letter", () => {
+        const rule = new AttrPairCompare({ a: "score", op: "gt", b: "threshold" });
+        expect(rule.message[0]).toBe(rule.message[0]?.toUpperCase());
+    });
+});

package/dist/__tests__/rules/AttrPairEqual.test.d.mts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=AttrPairEqual.test.d.mts.map

package/dist/__tests__/rules/AttrPairEqual.test.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AttrPairEqual.test.d.mts","sourceRoot":"","sources":["../../../src/__tests__/rules/AttrPairEqual.test.mts"],"names":[],"mappings":""}