@startinblox/components-ds4go 2.2.4 → 3.0.0

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

@@ -0,0 +1,276 @@
+import filterObjectById from "@helpers/datas/filterObjectById";
+
+describe("filterObjectById helper function", () => {
+  describe("Basic functionality", () => {
+    it("should filter objects by @id property", () => {
+      const objects = [
+        { name: "Resource 1", resource: { "@id": "/resource/1" } },
+        { name: "Resource 2", resource: { "@id": "/resource/2" } },
+        { name: "Resource 3", resource: { "@id": "/resource/3" } },
+      ];
+      const result = filterObjectById(objects, "resource", "/resource/2");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Resource 2");
+    });
+
+    it("should return all objects when propName is empty", () => {
+      const objects = [
+        { "@id": "/resource/1", name: "Resource 1" },
+        { "@id": "/resource/2", name: "Resource 2" },
+      ];
+      const result = filterObjectById(objects, "", "/resource/2");
+      expect(result).to.have.length(2);
+    });
+
+    it("should return all objects when targetId is empty", () => {
+      const objects = [
+        { "@id": "/resource/1", name: "Resource 1" },
+        { "@id": "/resource/2", name: "Resource 2" },
+      ];
+      const result = filterObjectById(objects, "@id", "");
+      expect(result).to.have.length(2);
+    });
+
+    it("should return empty array when no match found", () => {
+      const objects = [
+        { "@id": "/resource/1", name: "Resource 1" },
+        { "@id": "/resource/2", name: "Resource 2" },
+      ];
+      const result = filterObjectById(objects, "@id", "/resource/99");
+      expect(result).to.have.length(0);
+    });
+  });
+
+  describe("Nested property handling", () => {
+    it("should filter by nested property using dot notation", () => {
+      const objects = [
+        { name: "Alice", team: { "@id": "/team/1", name: "Engineering" } },
+        { name: "Bob", team: { "@id": "/team/2", name: "Marketing" } },
+        { name: "Charlie", team: { "@id": "/team/1", name: "Engineering" } },
+      ];
+      const result = filterObjectById(objects, "team", "/team/1");
+      expect(result).to.have.length(2);
+      expect(result.map((r) => r.name)).to.deep.equal(["Alice", "Charlie"]);
+    });
+
+    it("should filter by deeply nested property", () => {
+      const objects = [
+        {
+          name: "Alice",
+          user: { profile: { organization: { "@id": "/org/1" } } },
+        },
+        {
+          name: "Bob",
+          user: { profile: { organization: { "@id": "/org/2" } } },
+        },
+      ];
+      const result = filterObjectById(
+        objects,
+        "user.profile.organization",
+        "/org/1",
+      );
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+
+    it("should return empty array when nested property does not exist", () => {
+      const objects = [
+        { name: "Alice", team: { "@id": "/team/1" } },
+        { name: "Bob" },
+      ];
+      const result = filterObjectById(
+        objects,
+        "nonexistent.property",
+        "/value",
+      );
+      expect(result).to.have.length(0);
+    });
+  });
+
+  describe("Array property handling", () => {
+    it("should filter objects where property is an array containing target @id", () => {
+      const objects = [
+        {
+          name: "Project 1",
+          members: [{ "@id": "/user/1" }, { "@id": "/user/2" }],
+        },
+        { name: "Project 2", members: [{ "@id": "/user/3" }] },
+        {
+          name: "Project 3",
+          members: [{ "@id": "/user/1" }, { "@id": "/user/4" }],
+        },
+      ];
+      const result = filterObjectById(objects, "members", "/user/1");
+      expect(result).to.have.length(2);
+      expect(result.map((r) => r.name)).to.deep.equal([
+        "Project 1",
+        "Project 3",
+      ]);
+    });
+
+    it("should handle nested arrays", () => {
+      const objects = [
+        { name: "Project 1", data: { members: [{ "@id": "/user/1" }] } },
+        { name: "Project 2", data: { members: [{ "@id": "/user/2" }] } },
+      ];
+      const result = filterObjectById(objects, "data.members", "/user/1");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Project 1");
+    });
+  });
+
+  describe("Edge cases", () => {
+    it("should handle empty array", () => {
+      const result = filterObjectById([], "@id", "/resource/1");
+      expect(result).to.deep.equal([]);
+    });
+
+    it("should handle objects without @id property", () => {
+      const objects = [{ name: "Resource 1" }, { name: "Resource 2" }];
+      const result = filterObjectById(objects, "@id", "/resource/1");
+      expect(result).to.have.length(0);
+    });
+
+    it("should handle objects with null @id", () => {
+      const objects = [
+        { name: "Resource 1", ref: null },
+        { name: "Resource 2", ref: { "@id": "/resource/2" } },
+      ];
+      const result = filterObjectById(objects, "ref", "/resource/2");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Resource 2");
+    });
+
+    it("should handle objects with undefined property", () => {
+      const objects = [
+        { name: "Resource 1" },
+        { name: "Resource 2", ref: { "@id": "/resource/2" } },
+      ];
+      const result = filterObjectById(objects, "ref", "/resource/2");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Resource 2");
+    });
+
+    it("should handle objects with empty array property", () => {
+      const objects = [
+        { name: "Project 1", members: [] },
+        { name: "Project 2", members: [{ "@id": "/user/1" }] },
+      ];
+      const result = filterObjectById(objects, "members", "/user/1");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Project 2");
+    });
+
+    it("should handle array with non-object elements", () => {
+      const objects = [
+        { name: "Project 1", tags: ["tag1", "tag2"] },
+        { name: "Project 2", tags: ["tag3"] },
+      ];
+      const result = filterObjectById(objects, "tags", "/nonexistent");
+      expect(result).to.have.length(0);
+    });
+  });
+
+  describe("Mixed scenarios", () => {
+    it("should handle mix of objects with and without @id in arrays", () => {
+      const objects = [
+        {
+          name: "Project 1",
+          members: [{ "@id": "/user/1" }, { name: "Anonymous" }],
+        },
+        { name: "Project 2", members: [{ "@id": "/user/2" }] },
+      ];
+      const result = filterObjectById(objects, "members", "/user/1");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Project 1");
+    });
+
+    it("should handle nested object with @id at leaf", () => {
+      const objects = [
+        { name: "Alice", profile: { user: { "@id": "/user/1" } } },
+        { name: "Bob", profile: { user: { "@id": "/user/2" } } },
+      ];
+      const result = filterObjectById(objects, "profile.user", "/user/1");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Alice");
+    });
+
+    it("should return multiple matches when multiple objects have same @id", () => {
+      const objects = [
+        { name: "Project 1", team: { "@id": "/team/1" } },
+        { name: "Project 2", team: { "@id": "/team/1" } },
+        { name: "Project 3", team: { "@id": "/team/2" } },
+      ];
+      const result = filterObjectById(objects, "team", "/team/1");
+      expect(result).to.have.length(2);
+      expect(result.map((r) => r.name)).to.deep.equal([
+        "Project 1",
+        "Project 2",
+      ]);
+    });
+  });
+
+  describe("Invalid property paths", () => {
+    it("should handle malformed dot notation", () => {
+      const objects = [{ name: "Alice", team: { "@id": "/team/1" } }];
+      const result = filterObjectById(objects, "team..@id", "/team/1");
+      expect(result).to.have.length(0);
+    });
+
+    it("should handle trailing dot in path", () => {
+      const objects = [{ name: "Alice", team: { "@id": "/team/1" } }];
+      const result = filterObjectById(objects, "team.", "/team/1");
+      expect(result).to.have.length(0);
+    });
+
+    it("should handle leading dot in path", () => {
+      const objects = [{ name: "Alice", team: { "@id": "/team/1" } }];
+      const result = filterObjectById(objects, ".team.@id", "/team/1");
+      expect(result).to.have.length(0);
+    });
+  });
+
+  describe("Real-world scenarios", () => {
+    it("should filter projects by organization ID", () => {
+      const projects = [
+        {
+          "@id": "/project/1",
+          name: "Website",
+          organization: { "@id": "/org/1", name: "Acme" },
+        },
+        {
+          "@id": "/project/2",
+          name: "App",
+          organization: { "@id": "/org/2", name: "Beta" },
+        },
+        {
+          "@id": "/project/3",
+          name: "API",
+          organization: { "@id": "/org/1", name: "Acme" },
+        },
+      ];
+      const result = filterObjectById(projects, "organization", "/org/1");
+      expect(result).to.have.length(2);
+      expect(result.map((p) => p.name)).to.deep.equal(["Website", "API"]);
+    });
+
+    it("should filter tasks by assignee", () => {
+      const tasks = [
+        {
+          "@id": "/task/1",
+          title: "Design",
+          assignees: [{ "@id": "/user/1" }, { "@id": "/user/2" }],
+        },
+        {
+          "@id": "/task/2",
+          title: "Develop",
+          assignees: [{ "@id": "/user/3" }],
+        },
+        { "@id": "/task/3", title: "Test", assignees: [{ "@id": "/user/1" }] },
+      ];
+      const result = filterObjectById(tasks, "assignees", "/user/1");
+      expect(result).to.have.length(2);
+      expect(result.map((t) => t.title)).to.deep.equal(["Design", "Test"]);
+    });
+  });
+});

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

@@ -0,0 +1,237 @@
+import filterObjectByInterval from "@helpers/datas/filterObjectByInterval";
+
+describe("filterObjectByInterval helper function", () => {
+  describe("Numeric intervals", () => {
+    it("should filter objects by numeric property within interval", () => {
+      const objects = [
+        { name: "Item 1", value: 5 },
+        { name: "Item 2", value: 10 },
+        { name: "Item 3", value: 15 },
+      ];
+      const result = filterObjectByInterval(objects, "value", "8/12");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Item 2");
+    });
+
+    it("should include objects with value equal to start of interval", () => {
+      const objects = [
+        { name: "Item 1", value: 5 },
+        { name: "Item 2", value: 10 },
+      ];
+      const result = filterObjectByInterval(objects, "value", "5/10");
+      expect(result).to.have.length(2);
+    });
+
+    it("should include objects with value equal to end of interval", () => {
+      const objects = [
+        { name: "Item 1", value: 10 },
+        { name: "Item 2", value: 15 },
+      ];
+      const result = filterObjectByInterval(objects, "value", "5/10");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Item 1");
+    });
+
+    it("should return all objects when propName is empty", () => {
+      const objects = [
+        { name: "Item 1", value: 5 },
+        { name: "Item 2", value: 10 },
+      ];
+      const result = filterObjectByInterval(objects, "", "5/10");
+      expect(result).to.have.length(2);
+    });
+
+    it("should return all objects when interval is empty", () => {
+      const objects = [
+        { name: "Item 1", value: 5 },
+        { name: "Item 2", value: 10 },
+      ];
+      const result = filterObjectByInterval(objects, "value", "");
+      expect(result).to.have.length(2);
+    });
+
+    it("should return all objects when interval is not a string", () => {
+      const objects = [
+        { name: "Item 1", value: 5 },
+        { name: "Item 2", value: 10 },
+      ];
+      const result = filterObjectByInterval(objects, "value", null as any);
+      expect(result).to.have.length(2);
+    });
+
+    it("should return all objects when interval contains non-numbers", () => {
+      const objects = [
+        { name: "Item 1", value: 5 },
+        { name: "Item 2", value: 10 },
+      ];
+      const result = filterObjectByInterval(objects, "value", "abc/xyz");
+      expect(result).to.have.length(2);
+    });
+
+    it("should return all objects when start > end in interval", () => {
+      const objects = [
+        { name: "Item 1", value: 5 },
+        { name: "Item 2", value: 10 },
+      ];
+      const result = filterObjectByInterval(objects, "value", "10/5");
+      expect(result).to.have.length(2);
+    });
+
+    it("should handle single value interval", () => {
+      const objects = [
+        { name: "Item 1", value: 5 },
+        { name: "Item 2", value: 10 },
+        { name: "Item 3", value: 15 },
+      ];
+      const result = filterObjectByInterval(objects, "value", "10");
+      expect(result).to.have.length(0);
+    });
+
+    it("should filter negative numbers", () => {
+      const objects = [
+        { name: "Item 1", value: -10 },
+        { name: "Item 2", value: 0 },
+        { name: "Item 3", value: 10 },
+      ];
+      const result = filterObjectByInterval(objects, "value", "-5/5");
+      expect(result).to.have.length(1);
+      expect(result[0].value).to.equal(0);
+    });
+
+    it("should filter decimal numbers", () => {
+      const objects = [
+        { name: "Item 1", value: 5.5 },
+        { name: "Item 2", value: 7.5 },
+        { name: "Item 3", value: 10.0 },
+      ];
+      const result = filterObjectByInterval(objects, "value", "6/8");
+      expect(result).to.have.length(1);
+      expect(result[0].value).to.equal(7.5);
+    });
+  });
+
+  describe("Nested property handling", () => {
+    it("should filter by nested numeric property", () => {
+      const objects = [
+        { name: "Project 1", stats: { score: 85 } },
+        { name: "Project 2", stats: { score: 92 } },
+        { name: "Project 3", stats: { score: 78 } },
+      ];
+      const result = filterObjectByInterval(objects, "stats.score", "80/90");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Project 1");
+    });
+
+    it("should filter by deeply nested numeric property", () => {
+      const objects = [
+        { name: "User 1", data: { profile: { level: 5 } } },
+        { name: "User 2", data: { profile: { level: 10 } } },
+      ];
+      const result = filterObjectByInterval(
+        objects,
+        "data.profile.level",
+        "7/12",
+      );
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("User 2");
+    });
+
+    it("should search within arrays", () => {
+      const objects = [
+        { name: "Project 1", scores: [85, 90, 95] },
+        { name: "Project 2", scores: [70, 75, 80] },
+      ];
+      const result = filterObjectByInterval(objects, "scores", "85/95");
+      expect(result).to.have.length(0);
+    });
+  });
+
+  describe("Edge cases", () => {
+    it("should handle empty array", () => {
+      const result = filterObjectByInterval([], "value", "5/10");
+      expect(result).to.deep.equal([]);
+    });
+
+    it("should handle objects without the property", () => {
+      const objects = [
+        { name: "Item 1", value: 5 },
+        { name: "Item 2" },
+        { name: "Item 3", value: 15 },
+      ];
+      const result = filterObjectByInterval(objects, "value", "5/10");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Item 1");
+    });
+
+    it("should handle objects with null property", () => {
+      const objects = [
+        { name: "Item 1", value: null },
+        { name: "Item 2", value: 10 },
+      ];
+      const result = filterObjectByInterval(objects, "value", "5/15");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Item 2");
+    });
+
+    it("should handle objects with undefined property", () => {
+      const objects = [
+        { name: "Item 1", value: undefined },
+        { name: "Item 2", value: 10 },
+      ];
+      const result = filterObjectByInterval(objects, "value", "5/15");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Item 2");
+    });
+
+    it("should handle objects with non-numeric property", () => {
+      const objects = [
+        { name: "Item 1", value: "not a number" },
+        { name: "Item 2", value: 10 },
+      ];
+      const result = filterObjectByInterval(objects, "value", "5/15");
+      expect(result).to.have.length(1);
+      expect(result[0].name).to.equal("Item 2");
+    });
+  });
+
+  describe("Real-world scenarios", () => {
+    it("should filter products by price range", () => {
+      const products = [
+        { name: "Product A", price: 25 },
+        { name: "Product B", price: 50 },
+        { name: "Product C", price: 75 },
+        { name: "Product D", price: 100 },
+      ];
+      const result = filterObjectByInterval(products, "price", "40/80");
+      expect(result).to.have.length(2);
+      expect(result.map((p) => p.name)).to.deep.equal([
+        "Product B",
+        "Product C",
+      ]);
+    });
+
+    it("should filter users by age range", () => {
+      const users = [
+        { name: "Alice", age: 25 },
+        { name: "Bob", age: 30 },
+        { name: "Charlie", age: 35 },
+        { name: "Diana", age: 40 },
+      ];
+      const result = filterObjectByInterval(users, "age", "30/35");
+      expect(result).to.have.length(2);
+      expect(result.map((u) => u.name)).to.deep.equal(["Bob", "Charlie"]);
+    });
+
+    it("should filter tasks by priority score range", () => {
+      const tasks = [
+        { name: "Task 1", priority: 1 },
+        { name: "Task 2", priority: 5 },
+        { name: "Task 3", priority: 8 },
+        { name: "Task 4", priority: 10 },
+      ];
+      const result = filterObjectByInterval(tasks, "priority", "5/8");
+      expect(result).to.have.length(2);
+      expect(result.map((t) => t.name)).to.deep.equal(["Task 2", "Task 3"]);
+    });
+  });
+});