@startinblox/components-ds4go 2.3.0 → 3.0.0

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

@@ -0,0 +1,508 @@
+import { dataBuilder, recusiveRemovePath } from "@helpers/datas/dataBuilder";
+
+describe("dataBuilder helper function", () => {
+  describe("Basic functionality", () => {
+    it("should clone the resource object", () => {
+      const resource = { name: "Alice", age: 30 };
+      const result = dataBuilder(resource);
+      expect(result).to.deep.equal(resource);
+      expect(result).to.not.equal(resource);
+    });
+
+    it("should remove specified paths", () => {
+      const resource = { name: "Alice", age: 30, email: "alice@example.com" };
+      const result = dataBuilder(resource, ["age"]);
+      expect(result).to.deep.equal({
+        name: "Alice",
+        email: "alice@example.com",
+      });
+      expect(result).to.not.have.property("age");
+    });
+
+    it("should replace specified properties", () => {
+      const resource = { name: "Alice", age: 30 };
+      const replacements = { age: 35, email: "alice@example.com" };
+      const result = dataBuilder(resource, [], replacements);
+      expect(result).to.deep.equal({
+        name: "Alice",
+        age: 35,
+        email: "alice@example.com",
+      });
+    });
+
+    it("should handle both removals and replacements (default order: remove then replace)", () => {
+      const resource = { name: "Alice", age: 30, email: "alice@example.com" };
+      const replacements = { email: "newemail@example.com" };
+      const result = dataBuilder(resource, ["age"], replacements);
+      expect(result).to.deep.equal({
+        name: "Alice",
+        email: "newemail@example.com",
+      });
+    });
+
+    it("should handle both removals and replacements with removeThenReplace=true", () => {
+      const resource = { name: "Alice", age: 30 };
+      const replacements = { email: "alice@example.com", age: 35 };
+      const result = dataBuilder(resource, ["age"], replacements, true);
+      expect(result).to.deep.equal({
+        name: "Alice",
+        email: "alice@example.com",
+      });
+    });
+
+    it("should not mutate the original resource", () => {
+      const resource = { name: "Alice", age: 30 };
+      const originalData = JSON.stringify(resource);
+      dataBuilder(resource, ["name"]);
+      expect(JSON.stringify(resource)).to.equal(originalData);
+    });
+  });
+
+  describe("recusiveRemovePath", () => {
+    it("should remove top-level property", () => {
+      const obj = { name: "Alice", age: 30 };
+      recusiveRemovePath(obj, ["age"]);
+      expect(obj).to.deep.equal({ name: "Alice" });
+    });
+
+    it("should remove nested property", () => {
+      const obj = {
+        name: "Alice",
+        profile: { age: 30, email: "alice@example.com" },
+      };
+      recusiveRemovePath(obj, ["profile", "age"]);
+      expect(obj.profile).to.deep.equal({ email: "alice@example.com" });
+    });
+
+    it("should remove deeply nested property", () => {
+      const obj = {
+        name: "Alice",
+        data: { profile: { settings: { theme: "dark" } } },
+      };
+      recusiveRemovePath(obj, ["data", "profile", "settings", "theme"]);
+      expect(obj.data.profile.settings).to.deep.equal({});
+    });
+
+    it("should handle non-existent paths", () => {
+      const obj = { name: "Alice", age: 30 };
+      const original = JSON.stringify(obj);
+      recusiveRemovePath(obj, ["nonexistent", "property"]);
+      expect(JSON.stringify(obj)).to.equal(original);
+    });
+
+    it("should handle undefined object", () => {
+      const obj = undefined as any;
+      recusiveRemovePath(obj, ["name"]);
+      expect(obj).to.be.undefined;
+    });
+
+    it("should handle null object", () => {
+      const obj = null as any;
+      recusiveRemovePath(obj, ["name"]);
+      expect(obj).to.be.null;
+    });
+
+    it("should handle empty path array", () => {
+      const obj = { name: "Alice", age: 30 };
+      const original = JSON.stringify(obj);
+      recusiveRemovePath(obj, []);
+      expect(JSON.stringify(obj)).to.equal(original);
+    });
+
+    it("should not mutate path array", () => {
+      const obj = { name: "Alice", profile: { age: 30 } };
+      const path = ["profile", "age"];
+      const originalPath = [...path];
+      recusiveRemovePath(obj, path);
+      expect(path).to.deep.equal([]);
+    });
+  });
+
+  describe("Path removal", () => {
+    it("should remove multiple paths", () => {
+      const resource = {
+        name: "Alice",
+        age: 30,
+        email: "alice@example.com",
+        city: "Paris",
+      };
+      const result = dataBuilder(resource, ["age", "email"]);
+      expect(result).to.deep.equal({ name: "Alice", city: "Paris" });
+    });
+
+    it("should handle nested paths using dot notation", () => {
+      const resource = {
+        name: "Alice",
+        profile: {
+          age: 30,
+          email: "alice@example.com",
+          address: {
+            city: "Paris",
+            country: "France",
+          },
+        },
+      };
+      const result = dataBuilder(resource, [
+        "profile.age",
+        "profile.address.city",
+      ]);
+      expect(result).to.deep.equal({
+        name: "Alice",
+        profile: {
+          email: "alice@example.com",
+          address: {
+            country: "France",
+          },
+        },
+      });
+    });
+
+    it("should handle paths with same prefix", () => {
+      const resource = {
+        name: "Alice",
+        profile: {
+          age: 30,
+          address: {
+            city: "Paris",
+            country: "France",
+          },
+        },
+      };
+      const result = dataBuilder(resource, ["profile.age", "profile.address"]);
+      expect(result).to.deep.equal({
+        name: "Alice",
+        profile: {},
+      });
+    });
+
+    it("should remove entire nested object", () => {
+      const resource = {
+        name: "Alice",
+        profile: {
+          age: 30,
+          email: "alice@example.com",
+        },
+      };
+      const result = dataBuilder(resource, ["profile"]);
+      expect(result).to.deep.equal({ name: "Alice" });
+    });
+
+    it("should handle removing from nested arrays", () => {
+      const resource = {
+        name: "Alice",
+        items: [
+          { id: 1, name: "Item 1" },
+          { id: 2, name: "Item 2" },
+        ],
+      };
+      const result = dataBuilder(resource, ["items"]);
+      expect(result).to.deep.equal({ name: "Alice" });
+    });
+
+    it("should handle removing property that does not exist", () => {
+      const resource = { name: "Alice", age: 30 };
+      const result = dataBuilder(resource, ["nonexistent"]);
+      expect(result).to.deep.equal({ name: "Alice", age: 30 });
+    });
+
+    it("should handle removing deeply nested non-existent property", () => {
+      const resource = { name: "Alice", age: 30 };
+      const result = dataBuilder(resource, ["profile", "age"]);
+      expect(result).to.deep.equal({ name: "Alice" });
+    });
+  });
+
+  describe("Replacements", () => {
+    it("should add new properties", () => {
+      const resource = { name: "Alice" };
+      const replacements = { age: 30, email: "alice@example.com" };
+      const result = dataBuilder(resource, [], replacements);
+      expect(result).to.deep.equal({
+        name: "Alice",
+        age: 30,
+        email: "alice@example.com",
+      });
+    });
+
+    it("should overwrite existing properties", () => {
+      const resource = { name: "Alice", age: 30 };
+      const replacements = { age: 35 };
+      const result = dataBuilder(resource, [], replacements);
+      expect(result).to.deep.equal({ name: "Alice", age: 35 });
+    });
+
+    it("should handle complex replacement values", () => {
+      const resource = { name: "Alice" };
+      const replacements = {
+        profile: { age: 30, email: "alice@example.com" },
+        tags: ["engineer", "developer"],
+      };
+      const result = dataBuilder(resource, [], replacements);
+      expect(result).to.deep.equal({
+        name: "Alice",
+        profile: { age: 30, email: "alice@example.com" },
+        tags: ["engineer", "developer"],
+      });
+    });
+
+    it("should handle null replacements", () => {
+      const resource = { name: "Alice", age: 30 };
+      const replacements = { age: null };
+      const result = dataBuilder(resource, [], replacements);
+      expect(result).to.deep.equal({ name: "Alice", age: null });
+    });
+
+    it("should handle undefined replacements", () => {
+      const resource = { name: "Alice", age: 30 };
+      const replacements = { age: undefined };
+      const result = dataBuilder(resource, [], replacements);
+      expect(result).to.deep.equal({ name: "Alice", age: undefined });
+    });
+
+    it("should handle empty replacements object", () => {
+      const resource = { name: "Alice", age: 30 };
+      const result = dataBuilder(resource, [], {});
+      expect(result).to.deep.equal({ name: "Alice", age: 30 });
+    });
+  });
+
+  describe("removeThenReplace flag", () => {
+    it("should remove first, then replace when removeThenReplace=false (default)", () => {
+      const resource = { name: "Alice", age: 30 };
+      const replacements = { age: 35 };
+      const result = dataBuilder(resource, ["age"], replacements, false);
+      expect(result).to.deep.equal({ name: "Alice", age: 35 });
+    });
+
+    it("should replace first, then remove when removeThenReplace=true", () => {
+      const resource = { name: "Alice", age: 30 };
+      const replacements = { age: 35 };
+      const result = dataBuilder(resource, ["age"], replacements, true);
+      expect(result).to.deep.equal({ name: "Alice" });
+    });
+
+    it("should replace nested object then remove when removeThenReplace=true", () => {
+      const resource = { name: "Alice", profile: { age: 30 } };
+      const replacements = { profile: { age: 35, email: "alice@example.com" } };
+      const result = dataBuilder(resource, ["profile.age"], replacements, true);
+      expect(result).to.deep.equal({
+        name: "Alice",
+        profile: { email: "alice@example.com" },
+      });
+    });
+
+    it("should handle multiple paths with removeThenReplace=true", () => {
+      const resource = { name: "Alice", age: 30, email: "old@example.com" };
+      const replacements = { age: 35, email: "new@example.com" };
+      const result = dataBuilder(
+        resource,
+        ["age", "email"],
+        replacements,
+        true,
+      );
+      expect(result).to.deep.equal({ name: "Alice" });
+    });
+  });
+
+  describe("Edge cases", () => {
+    it("should handle empty resource", () => {
+      const resource = {};
+      const result = dataBuilder(resource);
+      expect(result).to.deep.equal({});
+    });
+
+    it("should handle null resource", () => {
+      const resource = null as any;
+      const result = dataBuilder(resource);
+      expect(result).to.be.null;
+    });
+
+    it("should handle undefined resource", () => {
+      const resource = undefined as any;
+      const result = dataBuilder(resource);
+      expect(result).to.be.undefined;
+    });
+
+    it("should handle empty path array", () => {
+      const resource = { name: "Alice", age: 30 };
+      const result = dataBuilder(resource, [], {});
+      expect(result).to.deep.equal({ name: "Alice", age: 30 });
+    });
+
+    it("should handle resource with nested objects", () => {
+      const resource = {
+        name: "Alice",
+        profile: {
+          age: 30,
+          address: {
+            city: "Paris",
+            country: "France",
+          },
+        },
+      };
+      const result = dataBuilder(resource);
+      expect(result).to.deep.equal(JSON.parse(JSON.stringify(resource)));
+    });
+
+    it("should handle resource with arrays", () => {
+      const resource = {
+        name: "Alice",
+        tags: ["engineer", "developer"],
+        items: [{ id: 1 }, { id: 2 }],
+      };
+      const result = dataBuilder(resource);
+      expect(result).to.deep.equal(JSON.parse(JSON.stringify(resource)));
+    });
+
+    it("should handle resource with mixed types", () => {
+      const resource = {
+        name: "Alice",
+        age: 30,
+        active: true,
+        score: 95.5,
+        data: null,
+      };
+      const result = dataBuilder(resource);
+      expect(result).to.deep.equal(JSON.parse(JSON.stringify(resource)));
+    });
+
+    it("should handle circular references by using structuredClone", () => {
+      const resource: any = { name: "Alice" };
+      resource.self = resource;
+      const result = dataBuilder(resource);
+      expect(result.name).to.equal("Alice");
+      expect(result.self).to.equal(result);
+    });
+  });
+
+  describe("Complex scenarios", () => {
+    it("should handle complex nested removal and replacement", () => {
+      const resource = {
+        id: 1,
+        name: "Alice",
+        metadata: {
+          createdAt: "2023-01-01",
+          updatedAt: "2023-02-01",
+          createdBy: { id: 10, name: "Admin" },
+        },
+        settings: {
+          theme: "dark",
+          notifications: true,
+        },
+      };
+      const replacements = {
+        id: 2,
+        metadata: { createdAt: "2023-03-01" },
+      };
+      const result = dataBuilder(
+        resource,
+        ["metadata.updatedBy", "settings.theme"],
+        replacements,
+        false,
+      );
+      expect(result).to.deep.equal({
+        id: 2,
+        name: "Alice",
+        metadata: {
+          createdAt: "2023-03-01",
+        },
+        settings: {
+          notifications: true,
+        },
+      });
+    });
+
+    it("should remove path and replace with different structure", () => {
+      const resource = {
+        name: "Alice",
+        profile: { age: 30, email: "old@example.com" },
+      };
+      const replacements = {
+        profile: { name: "Alice Profile", bio: "Software engineer" },
+      };
+      const result = dataBuilder(
+        resource,
+        ["profile.age"],
+        replacements,
+        false,
+      );
+      expect(result).to.deep.equal({
+        name: "Alice",
+        profile: {
+          name: "Alice Profile",
+          bio: "Software engineer",
+        },
+      });
+    });
+  });
+
+  describe("Real-world scenarios", () => {
+    it("should prepare resource for API request by removing internal fields", () => {
+      const resource = {
+        "@id": "/resource/1",
+        "@type": "User",
+        name: "Alice",
+        _internalId: 123,
+        _metadata: { created: true },
+      };
+      const result = dataBuilder(resource, ["_internalId", "_metadata"]);
+      expect(result).to.deep.equal({
+        "@id": "/resource/1",
+        "@type": "User",
+        name: "Alice",
+      });
+    });
+
+    it("should sanitize user data for response", () => {
+      const user = {
+        id: 1,
+        name: "Alice",
+        email: "alice@example.com",
+        password: "secret123",
+        salt: "abc123",
+      };
+      const result = dataBuilder(user, ["password", "salt"]);
+      expect(result).to.deep.equal({
+        id: 1,
+        name: "Alice",
+        email: "alice@example.com",
+      });
+    });
+
+    it("should update partial data while preserving other fields", () => {
+      const resource = {
+        id: 1,
+        name: "Alice",
+        age: 30,
+        email: "alice@example.com",
+      };
+      const updates = { age: 31, email: "newalice@example.com" };
+      const result = dataBuilder(resource, [], updates);
+      expect(result).to.deep.equal({
+        id: 1,
+        name: "Alice",
+        age: 31,
+        email: "newalice@example.com",
+      });
+    });
+
+    it("should clone and prepare resource for creation", () => {
+      const template = {
+        "@type": "Task",
+        status: "pending",
+        priority: "medium",
+      };
+      const newResource = dataBuilder(template, [], {
+        name: "New Task",
+        "@id": "",
+      });
+      expect(newResource).to.deep.equal({
+        "@type": "Task",
+        status: "pending",
+        priority: "medium",
+        name: "New Task",
+        "@id": "",
+      });
+    });
+  });
+});