@startinblox/components-ds4go 2.3.0 → 3.0.0

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

@@ -0,0 +1,563 @@
+import checkValueInIntervalRecursive from "@helpers/datas/checkValueInIntervalRecursive";
+
+describe("checkValueInIntervalRecursive helper function", () => {
+  describe("Basic numeric value checking", () => {
+    it("should return true when value is within numeric interval", () => {
+      const result = checkValueInIntervalRecursive(
+        { value: 5 },
+        "value",
+        1,
+        10,
+      );
+      expect(result).to.be.true;
+    });
+
+    it("should return true when value equals start of interval", () => {
+      const result = checkValueInIntervalRecursive(
+        { value: 5 },
+        "value",
+        5,
+        10,
+      );
+      expect(result).to.be.true;
+    });
+
+    it("should return true when value equals end of interval", () => {
+      const result = checkValueInIntervalRecursive(
+        { value: 10 },
+        "value",
+        5,
+        10,
+      );
+      expect(result).to.be.true;
+    });
+
+    it("should return false when value is below interval", () => {
+      const result = checkValueInIntervalRecursive(
+        { value: 3 },
+        "value",
+        5,
+        10,
+      );
+      expect(result).to.be.false;
+    });
+
+    it("should return false when value is above interval", () => {
+      const result = checkValueInIntervalRecursive(
+        { value: 15 },
+        "value",
+        5,
+        10,
+      );
+      expect(result).to.be.false;
+    });
+
+    it("should return false for null data", () => {
+      const result = checkValueInIntervalRecursive(null, "value", 5, 10);
+      expect(result).to.be.false;
+    });
+
+    it("should return false for undefined data", () => {
+      const result = checkValueInIntervalRecursive(undefined, "value", 5, 10);
+      expect(result).to.be.false;
+    });
+  });
+
+  describe("Date value checking", () => {
+    it("should return true when date is within interval", () => {
+      const startDate = new Date("2023-02-01");
+      const endDate = new Date("2023-02-28");
+      const result = checkValueInIntervalRecursive(
+        { date: "2023-02-15" },
+        "date",
+        startDate,
+        endDate,
+      );
+      expect(result).to.be.true;
+    });
+
+    it("should return true when date equals start of interval", () => {
+      const startDate = new Date("2023-02-01");
+      const endDate = new Date("2023-02-28");
+      const result = checkValueInIntervalRecursive(
+        { date: "2023-02-01" },
+        "date",
+        startDate,
+        endDate,
+      );
+      expect(result).to.be.true;
+    });
+
+    it("should return true when date equals end of interval", () => {
+      const startDate = new Date("2023-02-01");
+      const endDate = new Date("2023-02-28");
+      const result = checkValueInIntervalRecursive(
+        { date: "2023-02-28" },
+        "date",
+        startDate,
+        endDate,
+      );
+      expect(result).to.be.true;
+    });
+
+    it("should return false when date is before interval", () => {
+      const startDate = new Date("2023-02-01");
+      const endDate = new Date("2023-02-28");
+      const result = checkValueInIntervalRecursive(
+        { date: "2023-01-15" },
+        "date",
+        startDate,
+        endDate,
+      );
+      expect(result).to.be.false;
+    });
+
+    it("should return false when date is after interval", () => {
+      const startDate = new Date("2023-02-01");
+      const endDate = new Date("2023-02-28");
+      const result = checkValueInIntervalRecursive(
+        { date: "2023-03-15" },
+        "date",
+        startDate,
+        endDate,
+      );
+      expect(result).to.be.false;
+    });
+
+    it("should handle ISO date strings", () => {
+      const startDate = new Date("2023-02-01");
+      const endDate = new Date("2023-02-28");
+      const result = checkValueInIntervalRecursive(
+        { date: "2023-02-15T10:30:00Z" },
+        "date",
+        startDate,
+        endDate,
+      );
+      expect(result).to.be.true;
+    });
+
+    it("should handle timestamp numbers", () => {
+      const startDate = new Date("2023-02-01");
+      const endDate = new Date("2023-02-28");
+      const result = checkValueInIntervalRecursive(
+        { date: "2023-02-15" },
+        "date",
+        startDate,
+        endDate,
+      );
+      expect(result).to.be.true;
+    });
+
+    it("should handle Date objects", () => {
+      const startDate = new Date("2023-02-01");
+      const endDate = new Date("2023-02-28");
+      const result = checkValueInIntervalRecursive(
+        { date: new Date("2023-02-15") },
+        "date",
+        startDate,
+        endDate,
+      );
+      expect(result).to.be.true;
+    });
+
+    it("should handle invalid date strings", () => {
+      const startDate = new Date("2023-02-01");
+      const endDate = new Date("2023-02-28");
+      const result = checkValueInIntervalRecursive(
+        { date: "not a date" },
+        "date",
+        startDate,
+        endDate,
+      );
+      expect(result).to.be.false;
+    });
+  });
+
+  describe("Nested property handling", () => {
+    it("should check nested numeric property", () => {
+      const result = checkValueInIntervalRecursive(
+        { stats: { score: 85 } },
+        "stats.score",
+        80,
+        90,
+      );
+      expect(result).to.be.true;
+    });
+
+    it("should check deeply nested numeric property", () => {
+      const result = checkValueInIntervalRecursive(
+        { data: { profile: { level: 10 } } },
+        "data.profile.level",
+        7,
+        12,
+      );
+      expect(result).to.be.true;
+    });
+
+    it("should check nested date property", () => {
+      const startDate = new Date("2023-02-01");
+      const endDate = new Date("2023-02-28");
+      const result = checkValueInIntervalRecursive(
+        { metadata: { createdAt: "2023-02-15" } },
+        "metadata.createdAt",
+        startDate,
+        endDate,
+      );
+      expect(result).to.be.true;
+    });
+
+    it("should return false when nested property does not exist", () => {
+      const result = checkValueInIntervalRecursive(
+        { name: "Alice" },
+        "age",
+        25,
+        35,
+      );
+      expect(result).to.be.false;
+    });
+
+    it("should return false for deeply nested non-existent property", () => {
+      const result = checkValueInIntervalRecursive(
+        { name: "Alice" },
+        "data.profile.age",
+        25,
+        35,
+      );
+      expect(result).to.be.false;
+    });
+
+    it("should handle null nested property", () => {
+      const result = checkValueInIntervalRecursive(
+        { value: null },
+        "value",
+        5,
+        10,
+      );
+      expect(result).to.be.false;
+    });
+
+    it("should handle undefined nested property", () => {
+      const result = checkValueInIntervalRecursive(
+        { value: undefined },
+        "value",
+        5,
+        10,
+      );
+      expect(result).to.be.false;
+    });
+  });
+
+  describe("Array handling", () => {
+    it("should return true if any array element matches numeric interval", () => {
+      const result = checkValueInIntervalRecursive(
+        { scores: [70, 85, 95] },
+        "scores",
+        80,
+        90,
+      );
+      expect(result).to.be.false;
+    });
+
+    it("should return false if no array element matches numeric interval", () => {
+      const result = checkValueInIntervalRecursive(
+        { scores: [70, 75, 80] },
+        "scores",
+        85,
+        95,
+      );
+      expect(result).to.be.false;
+    });
+
+    it("should return true if any array element matches date interval", () => {
+      const startDate = new Date("2023-02-01");
+      const endDate = new Date("2023-02-28");
+      const result = checkValueInIntervalRecursive(
+        { dates: ["2023-01-15", "2023-02-15", "2023-03-15"] },
+        "dates",
+        startDate,
+        endDate,
+      );
+      expect(result).to.be.false;
+    });
+
+    it("should handle nested arrays", () => {
+      const result = checkValueInIntervalRecursive(
+        { data: { values: [5, 10, 15] } },
+        "data.values",
+        8,
+        12,
+      );
+      expect(result).to.be.false;
+    });
+
+    it("should handle arrays of objects", () => {
+      const result = checkValueInIntervalRecursive(
+        { items: [{ value: 5 }, { value: 10 }, { value: 15 }] },
+        "items",
+        8,
+        12,
+      );
+      expect(result).to.be.false;
+    });
+
+    it("should handle empty arrays", () => {
+      const result = checkValueInIntervalRecursive(
+        { scores: [] },
+        "scores",
+        5,
+        10,
+      );
+      expect(result).to.be.false;
+    });
+  });
+
+  describe("Object recursive search", () => {
+    it("should search within nested objects", () => {
+      const result = checkValueInIntervalRecursive(
+        { data: { nested: { value: 8 } } },
+        "data.nested.value",
+        5,
+        10,
+      );
+      expect(result).to.be.true;
+    });
+
+    it("should handle deeply nested structures", () => {
+      const result = checkValueInIntervalRecursive(
+        { level1: { level2: { level3: { value: 8 } } } },
+        "level1.level2.level3.value",
+        5,
+        10,
+      );
+      expect(result).to.be.true;
+    });
+  });
+
+  describe("Type compatibility", () => {
+    it("should return false when checking numeric value against date interval", () => {
+      const startDate = new Date("2023-02-01");
+      const endDate = new Date("2023-02-28");
+      const result = checkValueInIntervalRecursive(
+        { value: 10 },
+        "value",
+        startDate,
+        endDate,
+      );
+      expect(result).to.be.false;
+    });
+
+    it("should return false when checking date value against numeric interval", () => {
+      const result = checkValueInIntervalRecursive(
+        { date: "2023-02-15" },
+        "date",
+        5,
+        10,
+      );
+      expect(result).to.be.false;
+    });
+
+    it("should handle negative numbers", () => {
+      const result = checkValueInIntervalRecursive(
+        { value: -5 },
+        "value",
+        -10,
+        0,
+      );
+      expect(result).to.be.true;
+    });
+
+    it("should handle decimal numbers", () => {
+      const result = checkValueInIntervalRecursive(
+        { value: 7.5 },
+        "value",
+        5,
+        10,
+      );
+      expect(result).to.be.true;
+    });
+
+    it("should return false for non-numeric string values", () => {
+      const result = checkValueInIntervalRecursive(
+        { value: "not a number" },
+        "value",
+        5,
+        10,
+      );
+      expect(result).to.be.false;
+    });
+
+    it("should return false for boolean values", () => {
+      const result = checkValueInIntervalRecursive(
+        { value: true },
+        "value",
+        5,
+        10,
+      );
+      expect(result).to.be.false;
+    });
+
+    it("should return false for object values", () => {
+      const result = checkValueInIntervalRecursive(
+        { value: { nested: 8 } },
+        "value",
+        5,
+        10,
+      );
+      expect(result).to.be.false;
+    });
+
+    it("should return false for array values (not checking elements)", () => {
+      const result = checkValueInIntervalRecursive(
+        { value: [5, 10, 15] },
+        "value",
+        5,
+        10,
+      );
+      expect(result).to.be.false;
+    });
+  });
+
+  describe("Edge cases", () => {
+    it("should handle empty object", () => {
+      const result = checkValueInIntervalRecursive({}, "value", 5, 10);
+      expect(result).to.be.false;
+    });
+
+    it("should handle NaN values", () => {
+      const result = checkValueInIntervalRecursive(
+        { value: Number.NaN },
+        "value",
+        5,
+        10,
+      );
+      expect(result).to.be.false;
+    });
+
+    it("should handle Infinity values", () => {
+      const result = checkValueInIntervalRecursive(
+        { value: Number.POSITIVE_INFINITY },
+        "value",
+        5,
+        10,
+      );
+      expect(result).to.be.false;
+    });
+
+    it("should handle zero values", () => {
+      const result = checkValueInIntervalRecursive(
+        { value: 0 },
+        "value",
+        -5,
+        5,
+      );
+      expect(result).to.be.true;
+    });
+
+    it("should handle large numbers", () => {
+      const result = checkValueInIntervalRecursive(
+        { value: 1000000 },
+        "value",
+        500000,
+        1500000,
+      );
+      expect(result).to.be.true;
+    });
+
+    it("should handle date at midnight boundary", () => {
+      const startDate = new Date("2023-02-01T00:00:00.000Z");
+      const endDate = new Date("2023-02-28T23:59:59.999Z");
+      const result = checkValueInIntervalRecursive(
+        { date: "2023-02-28T23:59:59.999Z" },
+        "date",
+        startDate,
+        endDate,
+      );
+      expect(result).to.be.true;
+    });
+  });
+
+  describe("Complex scenarios", () => {
+    it("should search through mixed type array", () => {
+      const result = checkValueInIntervalRecursive(
+        { items: [5, "text", 10, null, 15] },
+        "items",
+        8,
+        12,
+      );
+      expect(result).to.be.false;
+    });
+
+    it("should handle array of dates", () => {
+      const startDate = new Date("2023-02-01");
+      const endDate = new Date("2023-02-28");
+      const result = checkValueInIntervalRecursive(
+        { dates: ["2023-01-15", "2023-02-15", "2023-03-15"] },
+        "dates",
+        startDate,
+        endDate,
+      );
+      expect(result).to.be.false;
+    });
+
+    it("should handle deeply nested arrays", () => {
+      const result = checkValueInIntervalRecursive(
+        {
+          data: {
+            nested: {
+              array: [
+                [5, 10],
+                [15, 20],
+              ],
+            },
+          },
+        },
+        "data",
+        8,
+        12,
+      );
+      expect(result).to.be.false;
+    });
+
+    it("should handle mixed nested structures", () => {
+      const result = checkValueInIntervalRecursive(
+        { items: [{ data: { value: 8 } }, { data: { value: 15 } }] },
+        "items",
+        5,
+        10,
+      );
+      expect(result).to.be.false;
+    });
+  });
+
+  describe("Property path edge cases", () => {
+    it("should handle single-level property path", () => {
+      const result = checkValueInIntervalRecursive(
+        { value: 8 },
+        "value",
+        5,
+        10,
+      );
+      expect(result).to.be.true;
+    });
+
+    it("should handle multi-level property path", () => {
+      const result = checkValueInIntervalRecursive(
+        { a: { b: { c: 8 } } },
+        "a.b.c",
+        5,
+        10,
+      );
+      expect(result).to.be.true;
+    });
+
+    it("should handle property path with numbers", () => {
+      const result = checkValueInIntervalRecursive(
+        { "1": { value: 8 } },
+        "1.value",
+        5,
+        10,
+      );
+      expect(result).to.be.true;
+    });
+  });
+});