corebasic 1.0.212 → 1.0.213

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

@@ -0,0 +1,489 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { applySuffixPolicy } from "../policy.js";
+// -----------------------------------------------------------------------------
+// applySuffixPolicy()
+// -----------------------------------------------------------------------------
+describe("applySuffixPolicy()", () => {
+    test("no collection", async () => {
+        const collections = {};
+        const result = await applySuffixPolicy(collections, "missing", {});
+        assert.deepEqual(result, []);
+    });
+    test("collection without policy", async () => {
+        const collections = {
+            invoices: {}
+        };
+        const result = await applySuffixPolicy(collections, "invoices", {});
+        assert.deepEqual(result, []);
+    });
+    test("empty policy array", async () => {
+        const collections = {
+            invoices: {
+                policy: []
+            }
+        };
+        const result = await applySuffixPolicy(collections, "invoices", {});
+        assert.deepEqual(result, []);
+    });
+    test("single policy object", async () => {
+        const collections = {
+            invoices: {
+                policy: {
+                    suffix: [
+                        { key: "type" }
+                    ]
+                }
+            }
+        };
+        const result = await applySuffixPolicy(collections, "invoices", {
+            type: "Sales"
+        });
+        assert.deepEqual(result, [
+            "/Sales"
+        ]);
+    });
+    test("single policy array", async () => {
+        const collections = {
+            invoices: {
+                policy: [
+                    {
+                        suffix: [
+                            { key: "type" }
+                        ]
+                    }
+                ]
+            }
+        };
+        const result = await applySuffixPolicy(collections, "invoices", {
+            type: "Sales"
+        });
+        assert.deepEqual(result, [
+            "/Sales"
+        ]);
+    });
+    test("unconditional policy", async () => {
+        const collections = {
+            invoices: {
+                policy: {
+                    when: {},
+                    suffix: [
+                        { key: "type" }
+                    ]
+                }
+            }
+        };
+        const result = await applySuffixPolicy(collections, "invoices", {
+            type: "Sales"
+        });
+        assert.deepEqual(result, [
+            "/Sales"
+        ]);
+    });
+    test("policy matches equality", async () => {
+        const collections = {
+            invoices: {
+                policy: {
+                    when: {
+                        status: "Active"
+                    },
+                    suffix: [
+                        { key: "type" }
+                    ]
+                }
+            }
+        };
+        const result = await applySuffixPolicy(collections, "invoices", {
+            status: "Active",
+            type: "Sales"
+        });
+        assert.deepEqual(result, [
+            "/Sales"
+        ]);
+    });
+    test("policy does not match equality", async () => {
+        const collections = {
+            invoices: {
+                policy: {
+                    when: {
+                        status: "Active"
+                    },
+                    suffix: [
+                        { key: "type" }
+                    ]
+                }
+            }
+        };
+        const result = await applySuffixPolicy(collections, "invoices", {
+            status: "Deleted",
+            type: "Sales"
+        });
+        assert.deepEqual(result, []);
+    });
+    test("$in subset", async () => {
+        const collections = {
+            invoices: {
+                policy: {
+                    when: {
+                        status: { $in: ["Active"] }
+                    },
+                    suffix: [
+                        { key: "type" }
+                    ]
+                }
+            }
+        };
+        const result = await applySuffixPolicy(collections, "invoices", {
+            status: { $in: ["Active", "Pending"] },
+            type: "Sales"
+        });
+        assert.deepEqual(result, [
+            "/Sales"
+        ]);
+    });
+    test("multiple matching policies", async () => {
+        const collections = {
+            invoices: {
+                policy: [
+                    {
+                        when: {
+                            status: "Active"
+                        },
+                        suffix: [
+                            { key: "type" }
+                        ]
+                    },
+                    {
+                        when: {
+                            status: "Active"
+                        },
+                        suffix: [
+                            { key: "region" }
+                        ]
+                    }
+                ]
+            }
+        };
+        const result = await applySuffixPolicy(collections, "invoices", {
+            status: "Active",
+            type: "Sales",
+            region: "IN"
+        });
+        assert.deepEqual(result.sort(), [
+            "/Sales",
+            "/IN"
+        ].sort());
+    });
+    test("one policy matches one skipped", async () => {
+        const collections = {
+            invoices: {
+                policy: [
+                    {
+                        when: {
+                            status: "Active"
+                        },
+                        suffix: [
+                            { key: "type" }
+                        ]
+                    },
+                    {
+                        when: {
+                            status: "Deleted"
+                        },
+                        suffix: [
+                            { key: "region" }
+                        ]
+                    }
+                ]
+            }
+        };
+        const result = await applySuffixPolicy(collections, "invoices", {
+            status: "Active",
+            type: "Sales",
+            region: "IN"
+        });
+        assert.deepEqual(result, [
+            "/Sales"
+        ]);
+    });
+    test("duplicate suffix removed", async () => {
+        const collections = {
+            invoices: {
+                policy: [
+                    {
+                        suffix: [
+                            { key: "type" }
+                        ]
+                    },
+                    {
+                        suffix: [
+                            { key: "type" }
+                        ]
+                    }
+                ]
+            }
+        };
+        const result = await applySuffixPolicy(collections, "invoices", {
+            type: "Sales"
+        });
+        assert.deepEqual(result, [
+            "/Sales"
+        ]);
+    });
+    test("date suffix", async () => {
+        const collections = {
+            invoices: {
+                policy: {
+                    suffix: [
+                        {
+                            key: "date",
+                            type: "date:YYYY"
+                        }
+                    ]
+                }
+            }
+        };
+        const result = await applySuffixPolicy(collections, "invoices", {
+            date: new Date(2026, 4, 3).getTime()
+        });
+        assert.deepEqual(result, [
+            "/2026"
+        ]);
+    });
+    test("multiple suffix parts", async () => {
+        const collections = {
+            invoices: {
+                policy: {
+                    suffix: [
+                        { key: "type" },
+                        {
+                            key: "date",
+                            type: "date:YYYY"
+                        }
+                    ]
+                }
+            }
+        };
+        const result = await applySuffixPolicy(collections, "invoices", {
+            type: "Sales",
+            date: new Date(2026, 4, 3).getTime()
+        });
+        assert.deepEqual(result, [
+            "/Sales/2026"
+        ]);
+    });
+    test("range policy", async () => {
+        const collections = {
+            invoices: {
+                policy: {
+                    when: {
+                        age: {
+                            $gt: 10
+                        }
+                    },
+                    suffix: [
+                        { key: "type" }
+                    ]
+                }
+            }
+        };
+        const result = await applySuffixPolicy(collections, "invoices", {
+            age: {
+                $gt: 20
+            },
+            type: "Sales"
+        });
+        assert.deepEqual(result, [
+            "/Sales"
+        ]);
+    });
+    test("range policy miss", async () => {
+        const collections = {
+            invoices: {
+                policy: {
+                    when: {
+                        age: {
+                            $gt: 50
+                        }
+                    },
+                    suffix: [
+                        { key: "type" }
+                    ]
+                }
+            }
+        };
+        const result = await applySuffixPolicy(collections, "invoices", {
+            age: {
+                $lt: 10
+            },
+            type: "Sales"
+        });
+        assert.deepEqual(result, []);
+    });
+    test("$ne throws", async () => {
+        const collections = {
+            invoices: {
+                policy: {
+                    when: {
+                        status: {
+                            $ne: "Deleted"
+                        }
+                    },
+                    suffix: [
+                        { key: "type" }
+                    ]
+                }
+            }
+        };
+        await assert.rejects(async () => {
+            await applySuffixPolicy(collections, "invoices", {
+                status: "Active",
+                type: "Sales"
+            });
+        });
+    });
+    test("policy value inside query range", async () => {
+        const collections = {
+            invoices: {
+                policy: {
+                    when: {
+                        age: { $in: [10] }
+                    },
+                    suffix: [
+                        { key: "type" }
+                    ]
+                }
+            }
+        };
+        const result = await applySuffixPolicy(collections, "invoices", {
+            age: {
+                $gt: 5,
+                $lt: 15
+            },
+            type: "Sales"
+        });
+        assert.deepEqual(result, [
+            "/Sales"
+        ]);
+    });
+    test("policy value outside query range", async () => {
+        const collections = {
+            invoices: {
+                policy: {
+                    when: {
+                        age: { $in: [20] }
+                    },
+                    suffix: [
+                        { key: "type" }
+                    ]
+                }
+            }
+        };
+        const result = await applySuffixPolicy(collections, "invoices", {
+            age: {
+                $gt: 5,
+                $lt: 15
+            },
+            type: "Sales"
+        });
+        assert.deepEqual(result, []);
+    });
+    test("policy range intersects query value", async () => {
+        const collections = {
+            invoices: {
+                policy: {
+                    when: {
+                        age: {
+                            $gt: 5,
+                            $lt: 15
+                        }
+                    },
+                    suffix: [
+                        { key: "type" }
+                    ]
+                }
+            }
+        };
+        const result = await applySuffixPolicy(collections, "invoices", {
+            age: { $in: [10] },
+            type: "Sales"
+        });
+        assert.deepEqual(result, [
+            "/Sales"
+        ]);
+    });
+    test("policy range does not intersect query value", async () => {
+        const collections = {
+            invoices: {
+                policy: {
+                    when: {
+                        age: {
+                            $gt: 20,
+                            $lt: 30
+                        }
+                    },
+                    suffix: [
+                        { key: "type" }
+                    ]
+                }
+            }
+        };
+        const result = await applySuffixPolicy(collections, "invoices", {
+            age: { $in: [10] },
+            type: "Sales"
+        });
+        assert.deepEqual(result, []);
+    });
+    test("policy range intersects query range", async () => {
+        const collections = {
+            invoices: {
+                policy: {
+                    when: {
+                        age: {
+                            $gt: 10,
+                            $lt: 30
+                        }
+                    },
+                    suffix: [
+                        { key: "type" }
+                    ]
+                }
+            }
+        };
+        const result = await applySuffixPolicy(collections, "invoices", {
+            age: {
+                $gt: 20,
+                $lt: 40
+            },
+            type: "Sales"
+        });
+        assert.deepEqual(result, [
+            "/Sales"
+        ]);
+    });
+    test("policy range does not intersect query range", async () => {
+        const collections = {
+            invoices: {
+                policy: {
+                    when: {
+                        age: {
+                            $gt: 50,
+                            $lt: 60
+                        }
+                    },
+                    suffix: [
+                        { key: "type" }
+                    ]
+                }
+            }
+        };
+        const result = await applySuffixPolicy(collections, "invoices", {
+            age: {
+                $gt: 10,
+                $lt: 20
+            },
+            type: "Sales"
+        });
+        assert.deepEqual(result, []);
+    });
+});