corebasic 1.0.205 → 1.0.208

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

@@ -0,0 +1,416 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { formatDate, fillDates } from "../date.js";
+
+
+describe("formatDate()", () => {
+
+    test("formats full date correctly", () => {
+        const date = new Date(2026, 6, 9);
+
+        assert.equal(
+            formatDate(date, "YYYY-MM-DD"),
+                "2026-07-09"
+        );
+    });
+
+
+    test("formats all tokens", () => {
+        const date = new Date(2026, 6, 9);
+
+        assert.equal(
+            formatDate(date, "YYYY YY MMMM MMM MM DD D"),
+                "2026 26 July Jul 07 09 9"
+        );
+    });
+
+
+    test("formats month names", () => {
+        const date = new Date(2026, 0, 15);
+
+        assert.equal(
+            formatDate(date, "MMMM"),
+                "January"
+        );
+
+        assert.equal(
+            formatDate(date, "MMM"),
+                "Jan"
+        );
+    });
+
+
+    test("formats december correctly", () => {
+        const date = new Date(2026, 11, 31);
+
+        assert.equal(
+            formatDate(date, "MMMM MMM"),
+                "December Dec"
+        );
+    });
+
+
+    test("pads single digit days", () => {
+        const date = new Date(2026, 6, 1);
+
+        assert.equal(
+            formatDate(date, "DD"),
+                "01"
+        );
+    });
+
+
+    test("does not pad D token", () => {
+        const date = new Date(2026, 6, 1);
+
+        assert.equal(
+            formatDate(date, "D"),
+                "1"
+        );
+    });
+
+
+    test("pads single digit months", () => {
+        const date = new Date(2026, 0, 5);
+
+        assert.equal(
+            formatDate(date, "MM"),
+                "01"
+        );
+    });
+
+
+    test("handles Date object input", () => {
+        const date = new Date(2026, 5, 20);
+
+        assert.equal(
+            formatDate(date, "YYYY-MM-DD"),
+                "2026-06-20"
+        );
+    });
+
+
+    test("handles timestamp input", () => {
+        const timestamp = new Date(2026, 5, 20).getTime();
+
+        assert.equal(
+            formatDate(timestamp, "YYYY-MM-DD"),
+                "2026-06-20"
+        );
+    });
+
+
+    test("handles ISO string input", () => {
+
+        assert.equal(
+            formatDate("2026-07-09", "YYYY-MM-DD"),
+                "2026-07-09"
+        );
+
+    });
+
+
+    test("handles arbitrary separators", () => {
+        const date = new Date(2026, 6, 9);
+
+        assert.equal(
+            formatDate(date, "DD/MM/YYYY"),
+                "09/07/2026"
+        );
+
+
+        assert.equal(
+            formatDate(date, "D-MMM-YY"),
+                "9-Jul-26"
+        );
+    });
+
+
+    test("throws for invalid date string", () => {
+
+        assert.throws(
+            () => formatDate("invalid-date", "YYYY-MM-DD")
+        );
+
+    });
+
+
+    test("throws for invalid timestamp", () => {
+
+        assert.throws(
+            () => formatDate(NaN, "YYYY")
+        );
+
+    });
+
+
+    test("handles leap day", () => {
+        const date = new Date(2024, 1, 29);
+
+        assert.equal(
+            formatDate(date, "YYYY-MM-DD"),
+                "2024-02-29"
+        );
+    });
+
+
+    test("handles year boundary", () => {
+        const date = new Date(2025, 11, 31);
+
+        assert.equal(
+            formatDate(date, "YYYY-MM-DD"),
+                "2025-12-31"
+        );
+    });
+
+
+    test("replaces longer tokens before shorter tokens", () => {
+        const date = new Date(2026, 6, 9);
+
+        assert.equal(
+            formatDate(date, "MMMM MMM MM"),
+                "July Jul 07"
+        );
+    });
+
+
+    test("keeps unknown characters untouched", () => {
+        const date = new Date(2026, 6, 9);
+
+        assert.equal(
+            formatDate(date, "Today is DD-th"),
+                "Today is 09-th"
+        );
+    });
+
+});
+
+
+
+describe("fillDates()", () => {
+
+
+    test("fills daily dates", () => {
+        assert.deepEqual(
+            fillDates({from: "2026-07-01", to: "2026-07-05", fromOp: "$gte", toOp: "$lte"}, "YYYY-MM-DD"),
+            [
+                "2026-07-01",
+                "2026-07-02",
+                "2026-07-03",
+                "2026-07-04",
+                "2026-07-05",
+            ]
+        );
+
+    });
+
+
+
+    test("fills monthly dates", () => {
+        assert.deepEqual(
+            fillDates({from: "2026-01-01", to: "2026-05-01", fromOp: "$gte", toOp: "$lte"}, "YYYY-MM"),
+            [
+                "2026-01",
+                "2026-02",
+                "2026-03",
+                "2026-04",
+                "2026-05",
+            ]
+        );
+
+    });
+
+
+
+    test("fills yearly dates", () => {
+        assert.deepEqual(
+            fillDates({from: "2020-01-01", to: "2024-01-01", fromOp: "$gte", toOp: "$lte"}, "YYYY"),
+            [
+                "2020",
+                "2021",
+                "2022",
+                "2023",
+                "2024",
+            ]
+        );
+
+    });
+
+
+
+    test("returns one value for same date", () => {
+
+        assert.deepEqual(
+            fillDates({from: "2026-07-01", to: "2026-07-01", fromOp: "$gte", toOp: "$lte"}, "YYYY-MM-DD"),
+            [
+                "2026-07-01"
+            ]
+        );
+
+    });
+
+
+
+    test("returns empty for reversed range", () => {
+
+        assert.deepEqual(
+            fillDates({from: "2026-07-10", to: "2026-07-01", fromOp: "$gte", toOp: "$lte"}, "YYYY-MM-DD"),
+            []
+        );
+
+    });
+
+
+
+    test("removes duplicates when format loses precision", () => {
+
+        assert.deepEqual(
+            fillDates({from: "2026-01-01", to: "2026-01-31", fromOp: "$gte", toOp: "$lte"}, "MMMM"),
+            [
+                "January"
+            ]
+        );
+
+    });
+
+
+
+    test("handles leap year traversal", () => {
+
+        assert.deepEqual(
+            fillDates({from: "2024-02-28", to: "2024-03-01", fromOp: "$gte", toOp: "$lte"}, "YYYY-MM-DD"),
+            [
+                "2024-02-28",
+                "2024-02-29",
+                "2024-03-01",
+            ]
+        );
+
+    });
+
+
+
+    test("handles year rollover", () => {
+
+        assert.deepEqual(
+            fillDates({from: "2025-12-30", to: "2026-01-02", fromOp: "$gte", toOp: "$lte"}, "YYYY-MM-DD"),
+            [
+                "2025-12-30",
+                "2025-12-31",
+                "2026-01-01",
+                "2026-01-02",
+            ]
+        );
+
+    });
+
+
+
+    test("fills across years using months", () => {
+
+        assert.deepEqual(
+            fillDates({from: "2025-11-01", to: "2026-02-01", fromOp: "$gte", toOp: "$lte"}, "YYYY-MM"),
+            [
+                "2025-11",
+                "2025-12",
+                "2026-01",
+                "2026-02",
+            ]
+        );
+
+    });
+
+
+
+    test("large yearly range", () => {
+
+        const result = fillDates({from: "2000-01-01", to: "2020-01-01", fromOp: "$gte", toOp: "$lte"}, "YYYY");
+
+        assert.equal(
+            result.length,
+            21
+        );
+
+    });
+
+
+
+    test("large daily range contains no duplicates", () => {
+
+        const result = fillDates({from: "2026-01-01", to: "2026-12-31", fromOp: "$gte", toOp: "$lte"}, "YYYY-MM-DD");
+        assert.equal(new Set(result).size, result.length);
+    });
+
+
+    test("excludes lower bound with $gt", () => {
+        assert.deepEqual(
+            fillDates(
+                {
+                    from: "2026-07-01",
+                    to: "2026-07-03",
+                    fromOp: "$gt",
+                    toOp: null,
+                },
+                "YYYY-MM-DD"
+            ),
+            [
+                "2026-07-02",
+                "2026-07-03",
+            ]
+        );
+    });
+
+    test("excludes upper bound with $lt", () => {
+        assert.deepEqual(
+            fillDates(
+                {
+                    from: "2026-07-01",
+                    to: "2026-07-03",
+                    fromOp: null,
+                    toOp: "$lt",
+                },
+                "YYYY-MM-DD"
+            ),
+            [
+                "2026-07-01",
+                "2026-07-02",
+            ]
+        );
+    });
+
+    test("excludes both bounds", () => {
+        assert.deepEqual(
+            fillDates(
+                {
+                    from: "2026-07-01",
+                    to: "2026-07-05",
+                    fromOp: "$gt",
+                    toOp: "$lt",
+                },
+                "YYYY-MM-DD"
+            ),
+            [
+                "2026-07-02",
+                "2026-07-03",
+                "2026-07-04",
+            ]
+        );
+    });
+
+    test("returns empty when exclusive bounds collapse range", () => {
+        assert.deepEqual(
+            fillDates(
+                {
+                    from: "2026-07-01",
+                    to: "2026-07-02",
+                    fromOp: "$gt",
+                    toOp: "$lt",
+                },
+                "YYYY-MM-DD"
+            ),
+            []
+        );
+    });
+
+});