@startinblox/components-ds4go 2.2.4 → 3.0.0

package/cypress/e2e/helpers/datas/filterObjectByDateInterval.cy.ts

@@ -0,0 +1,613 @@
+import filterObjectByDateInterval from "@helpers/datas/filterObjectByDateInterval";
+
+describe("filterObjectByDateInterval helper function", () => {
+  describe("Basic date interval filtering", () => {
+    it("should filter objects by date property within interval", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-01-15" },
+        { name: "Event 2", date: "2023-02-15" },
+        { name: "Event 3", date: "2023-03-15" },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "date",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Event 2");
+    });
+
+    it("should include objects with date equal to start of interval", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-02-01" },
+        { name: "Event 2", date: "2023-02-15" },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "date",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(2);
+    });
+
+    it("should include objects with date equal to end of interval (end of day)", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-02-28" },
+        { name: "Event 2", date: "2023-03-01" },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "date",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Event 1");
+    });
+
+    it("should handle single date interval", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-02-15" },
+        { name: "Event 2", date: "2023-03-15" },
+      ];
+      const result = filterObjectByDateInterval(objects, "date", "2023-02-15");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Event 1");
+    });
+
+    it("should return all objects when propName is empty", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-01-15" },
+        { name: "Event 2", date: "2023-02-15" },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(2);
+    });
+
+    it("should return all objects when interval is empty", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-01-15" },
+        { name: "Event 2", date: "2023-02-15" },
+      ];
+      const result = filterObjectByDateInterval(objects, "date", "");
+      expect(result).to.have.length(2);
+    });
+
+    it("should return all objects when interval is not a string", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-01-15" },
+        { name: "Event 2", date: "2023-02-15" },
+      ];
+      const result = filterObjectByDateInterval(objects, "date", null as any);
+      expect(result).to.have.length(2);
+    });
+
+    it("should return all objects when start date is invalid", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-01-15" },
+        { name: "Event 2", date: "2023-02-15" },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "date",
+        "invalid/2023-02-28",
+      );
+      expect(result).to.have.length(2);
+    });
+
+    it("should return all objects when end date is invalid", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-01-15" },
+        { name: "Event 2", date: "2023-02-15" },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "date",
+        "2023-01-01/invalid",
+      );
+      expect(result).to.have.length(2);
+    });
+
+    it("should return all objects when start date is after end date", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-01-15" },
+        { name: "Event 2", date: "2023-02-15" },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "date",
+        "2023-03-01/2023-02-01",
+      );
+      expect(result).to.have.length(2);
+    });
+  });
+
+  describe("Date format handling", () => {
+    it("should handle ISO date strings", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-02-15T10:30:00Z" },
+        { name: "Event 2", date: "2023-03-15T10:30:00Z" },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "date",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Event 1");
+    });
+
+    it("should handle ISO date strings with timezone", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-02-15T10:30:00+05:00" },
+        { name: "Event 2", date: "2023-01-15T10:30:00+05:00" },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "date",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Event 1");
+    });
+
+    it("should handle timestamp numbers", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-02-15" },
+        { name: "Event 2", date: "2023-03-15" },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "date",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Event 1");
+    });
+
+    it("should handle Date objects", () => {
+      const objects = [
+        { name: "Event 1", date: new Date("2023-02-15") },
+        { name: "Event 2", date: new Date("2023-03-15") },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "date",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Event 1");
+    });
+
+    it("should handle various date formats", () => {
+      const objects = [
+        { name: "Event 1", date: "2023/02/15" },
+        { name: "Event 2", date: "2023-03-15" },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "date",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Event 1");
+    });
+
+    it("should set end date to end of day (23:59:59.999)", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-02-28" },
+        { name: "Event 2", date: "2023-02-28" },
+        { name: "Event 3", date: "2023-03-01" },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "date",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(2);
+    });
+  });
+
+  describe("Nested property handling", () => {
+    it("should filter by nested date property", () => {
+      const objects = [
+        { name: "Project 1", metadata: { createdAt: "2023-02-15" } },
+        { name: "Project 2", metadata: { createdAt: "2023-01-15" } },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "metadata.createdAt",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Project 1");
+    });
+
+    it("should filter by deeply nested date property", () => {
+      const objects = [
+        { name: "User 1", data: { profile: { joined: "2023-02-15" } } },
+        { name: "User 2", data: { profile: { joined: "2023-01-15" } } },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "data.profile.joined",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("User 1");
+    });
+
+    it("should search within arrays", () => {
+      const objects = [
+        {
+          name: "Project 1",
+          milestones: [{ date: "2023-02-15" }, { date: "2023-03-15" }],
+        },
+        { name: "Project 2", milestones: [{ date: "2023-01-15" }] },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "milestones",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(0);
+    });
+
+    it("should return empty array when nested property does not exist", () => {
+      const objects = [
+        { name: "Event 1", metadata: { createdAt: "2023-02-15" } },
+        { name: "Event 2", metadata: { createdAt: "2023-01-15" } },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "nonexistent.property",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(0);
+    });
+  });
+
+  describe("Edge cases", () => {
+    it("should handle empty array", () => {
+      const result = filterObjectByDateInterval(
+        [],
+        "date",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.deep.equal([]);
+    });
+
+    it("should handle objects without the property", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-02-15" },
+        { name: "Event 2" },
+        { name: "Event 3", date: "2023-03-15" },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "date",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Event 1");
+    });
+
+    it("should handle objects with null property", () => {
+      const objects = [
+        { name: "Event 1", date: null },
+        { name: "Event 2", date: "2023-02-15" },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "date",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Event 2");
+    });
+
+    it("should handle objects with undefined property", () => {
+      const objects = [
+        { name: "Event 1", date: undefined },
+        { name: "Event 2", date: "2023-02-15" },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "date",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Event 2");
+    });
+
+    it("should handle objects with invalid date string", () => {
+      const objects = [
+        { name: "Event 1", date: "not a date" },
+        { name: "Event 2", date: "2023-02-15" },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "date",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Event 2");
+    });
+
+    it("should handle invalid date values", () => {
+      const objects = [
+        { name: "Event 1", date: Number.NaN },
+        { name: "Event 2", date: "2023-02-15" },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "date",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Event 2");
+    });
+
+    it("should handle empty string date values", () => {
+      const objects = [
+        { name: "Event 1", date: "" },
+        { name: "Event 2", date: "2023-02-15" },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "date",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Event 2");
+    });
+
+    it("should return empty array when no dates are within interval", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-01-15" },
+        { name: "Event 2", date: "2023-01-20" },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "date",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(0);
+    });
+
+    it("should return all objects when all dates are within interval", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-02-15" },
+        { name: "Event 2", date: "2023-02-20" },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "date",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(2);
+    });
+  });
+
+  describe("Precision handling", () => {
+    it("should compare dates with millisecond precision", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-02-01T00:00:00.000Z" },
+        { name: "Event 2", date: "2023-02-01T00:00:00.001Z" },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "date",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(2);
+    });
+
+    it("should handle dates with time components", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-02-01T08:00:00Z" },
+        { name: "Event 2", date: "2023-02-01T12:00:00Z" },
+        { name: "Event 3", date: "2023-02-01T16:00:00Z" },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "date",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(3);
+    });
+  });
+
+  describe("Real-world scenarios", () => {
+    it("should filter projects by creation date range", () => {
+      const projects = [
+        { name: "Project A", createdAt: "2023-01-15" },
+        { name: "Project B", createdAt: "2023-02-15" },
+        { name: "Project C", createdAt: "2023-03-15" },
+        { name: "Project D", createdAt: "2023-04-15" },
+      ];
+      const result = filterObjectByDateInterval(
+        projects,
+        "createdAt",
+        "2023-02-01/2023-03-31",
+      );
+      expect(result).to.have.length(2);
+      expect(result.map((p) => p.name)).to.deep.equal([
+        "Project B",
+        "Project C",
+      ]);
+    });
+
+    it("should filter events by date range", () => {
+      const events = [
+        { name: "Conference", date: "2023-06-15" },
+        { name: "Workshop", date: "2023-06-20" },
+        { name: "Meetup", date: "2023-07-01" },
+      ];
+      const result = filterObjectByDateInterval(
+        events,
+        "date",
+        "2023-06-01/2023-06-30",
+      );
+      expect(result).to.have.length(2);
+      expect(result.map((e) => e.name)).to.deep.equal([
+        "Conference",
+        "Workshop",
+      ]);
+    });
+
+    it("should filter tasks by due date", () => {
+      const tasks = [
+        { name: "Task 1", dueDate: "2023-05-01" },
+        { name: "Task 2", dueDate: "2023-05-15" },
+        { name: "Task 3", dueDate: "2023-04-01" },
+      ];
+      const result = filterObjectByDateInterval(
+        tasks,
+        "dueDate",
+        "2023-05-01/2023-05-31",
+      );
+      expect(result).to.have.length(2);
+      expect(result.map((t) => t.name)).to.deep.equal(["Task 1", "Task 2"]);
+    });
+
+    it("should filter articles by publication date", () => {
+      const articles = [
+        { title: "Article 1", publishedAt: "2023-01-10" },
+        { title: "Article 2", publishedAt: "2023-01-20" },
+        { title: "Article 3", publishedAt: "2023-02-05" },
+      ];
+      const result = filterObjectByDateInterval(
+        articles,
+        "publishedAt",
+        "2023-01-01/2023-01-31",
+      );
+      expect(result).to.have.length(2);
+      expect(result.map((a) => a.title)).to.deep.equal([
+        "Article 1",
+        "Article 2",
+      ]);
+    });
+
+    it("should filter invoices by due date", () => {
+      const invoices = [
+        { id: 1, dueDate: "2023-12-15" },
+        { id: 2, dueDate: "2023-12-31" },
+        { id: 3, dueDate: "2024-01-15" },
+      ];
+      const result = filterObjectByDateInterval(
+        invoices,
+        "dueDate",
+        "2023-12-01/2023-12-31",
+      );
+      expect(result).to.have.length(2);
+      expect(result.map((i) => i.id)).to.deep.equal([1, 2]);
+    });
+  });
+
+  describe("Complex nested structures", () => {
+    it("should find dates in deeply nested structures", () => {
+      const objects = [
+        {
+          name: "Project 1",
+          data: { history: { entry: { date: "2023-02-15" } } },
+        },
+        {
+          name: "Project 2",
+          data: { history: { entry: { date: "2023-01-15" } } },
+        },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "data.history.entry.date",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(1);
+    });
+
+    it("should handle mixed date types in nested arrays", () => {
+      const objects = [
+        {
+          name: "Project 1",
+          events: ["2023-02-15", "2023-03-15", { date: "2023-04-15" }],
+        },
+        { name: "Project 2", events: ["2023-01-15"] },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "events",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(0);
+    });
+
+    it("should handle multiple date properties in nested objects", () => {
+      const objects = [
+        {
+          name: "Project 1",
+          schedule: { start: "2023-02-10", end: "2023-02-20" },
+        },
+        {
+          name: "Project 2",
+          schedule: { start: "2023-03-10", end: "2023-03-20" },
+        },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "schedule",
+        "2023-02-01/2023-02-28",
+      );
+      expect(result).to.have.length(0);
+    });
+  });
+
+  describe("Boundary conditions", () => {
+    it("should handle interval across year boundary", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-12-15" },
+        { name: "Event 2", date: "2024-01-15" },
+        { name: "Event 3", date: "2024-02-15" },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "date",
+        "2023-12-01/2024-01-31",
+      );
+      expect(result).to.have.length(2);
+      expect(result.map((e) => e.name)).to.deep.equal(["Event 1", "Event 2"]);
+    });
+
+    it("should handle interval across month boundary", () => {
+      const objects = [
+        { name: "Event 1", date: "2023-01-25" },
+        { name: "Event 2", date: "2023-02-05" },
+        { name: "Event 3", date: "2023-02-15" },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "date",
+        "2023-01-20/2023-02-10",
+      );
+      expect(result).to.have.length(2);
+      expect(result.map((e) => e.name)).to.deep.equal(["Event 1", "Event 2"]);
+    });
+
+    it("should handle leap year dates", () => {
+      const objects = [
+        { name: "Event 1", date: "2024-02-28" },
+        { name: "Event 2", date: "2024-02-29" },
+        { name: "Event 3", date: "2024-03-01" },
+      ];
+      const result = filterObjectByDateInterval(
+        objects,
+        "date",
+        "2024-02-01/2024-02-29",
+      );
+      expect(result).to.have.length(2);
+      expect(result.map((e) => e.name)).to.deep.equal(["Event 1", "Event 2"]);
+    });
+  });
+});