@startinblox/components-ds4go 2.3.0 → 3.0.1

package/cypress/e2e/helpers/components/setupComponentSubscriptions.cy.ts

@@ -0,0 +1,239 @@
+import setupComponentSubscriptions from "@helpers/components/setupComponentSubscriptions";
+
+describe("setupComponentSubscriptions helper function", () => {
+  const createMockComponent = () => {
+    const _subscriptions = new Set();
+
+    const mockComponent: any = {
+      _subscriptions,
+      _subscribe() {
+        for (const subscription of this._subscriptions) {
+          document.addEventListener(subscription[0], subscription[1]);
+        }
+      },
+      _unsubscribe() {
+        for (const subscription of this._subscriptions) {
+          document.removeEventListener(subscription[0], subscription[1]);
+        }
+      },
+      requestUpdate: cy.stub(),
+    };
+
+    return mockComponent;
+  };
+
+  before(() => {
+    cy.window().then((win) => {
+      (win as any).orbit = {
+        getRoute: cy.stub(),
+      };
+      (win as any).sibRouter = {
+        currentResource: "https://example.com/current-resource",
+      };
+    });
+  });
+
+  beforeEach(() => {
+    cy.window().then((win) => {
+      (win as any).sibRouter = {
+        currentResource: "https://example.com/current-resource",
+      };
+    });
+  });
+
+  afterEach(() => {
+    const routers = document.querySelectorAll("solid-router");
+    for (const router of routers) {
+      router.remove();
+    }
+  });
+
+  const ensureSibRouterExists = () => {
+    return cy.window().then((win) => {
+      if (!(win as any).sibRouter) {
+        (win as any).sibRouter = {
+          currentResource: "https://example.com/current-resource",
+        };
+      }
+    });
+  };
+
+  describe("Basic functionality", () => {
+    it("should create _subscriptions Set", () => {
+      const mockComponent = createMockComponent();
+
+      setupComponentSubscriptions({
+        component: mockComponent,
+        defaultRoute: false,
+        ignoreRouter: true,
+      });
+
+      expect(mockComponent._subscriptions).to.be.an.instanceOf(Set);
+    });
+
+    it("should not set noRouter when ignoring router", () => {
+      const mockComponent = createMockComponent();
+
+      setupComponentSubscriptions({
+        component: mockComponent,
+        defaultRoute: false,
+        ignoreRouter: true,
+      });
+
+      expect(mockComponent.noRouter).to.be.undefined;
+    });
+
+    it("should set up _subscribe method", () => {
+      const mockComponent: any = {
+        requestUpdate: cy.stub(),
+      };
+
+      setupComponentSubscriptions({
+        component: mockComponent,
+        defaultRoute: false,
+        ignoreRouter: true,
+      });
+
+      expect(mockComponent._subscribe).to.be.a("function");
+    });
+  });
+
+  describe("Uniq property", () => {
+    it("should set uniq property if not already set", () => {
+      const mockComponent = createMockComponent();
+
+      setupComponentSubscriptions({
+        component: mockComponent,
+        defaultRoute: false,
+        ignoreRouter: true,
+      });
+
+      expect(mockComponent.uniq).to.be.a("string");
+      expect(mockComponent.uniq).to.not.equal("");
+    });
+
+    it("should not override existing uniq property", () => {
+      const mockComponent = createMockComponent();
+      mockComponent.uniq = "existing-id";
+
+      setupComponentSubscriptions({
+        component: mockComponent,
+        defaultRoute: false,
+        ignoreRouter: true,
+      });
+
+      expect(mockComponent.uniq).to.equal("existing-id");
+    });
+  });
+
+  describe("Subscription management", () => {
+    it("should provide _subscribe method to add event listeners", () => {
+      const mockComponent = createMockComponent();
+
+      setupComponentSubscriptions({
+        component: mockComponent,
+        defaultRoute: false,
+        ignoreRouter: true,
+      });
+
+      const mockListener = cy.stub();
+      mockComponent._subscriptions.add(["test-event", mockListener]);
+      mockComponent._subscribe();
+
+      document.dispatchEvent(new Event("test-event"));
+
+      expect(mockListener).to.be.called;
+
+      mockComponent._unsubscribe();
+    });
+
+    it("should provide _unsubscribe method to remove event listeners", () => {
+      const mockComponent = createMockComponent();
+
+      setupComponentSubscriptions({
+        component: mockComponent,
+        defaultRoute: false,
+        ignoreRouter: true,
+      });
+
+      const mockListener = cy.stub();
+      mockComponent._subscriptions.add(["test-event", mockListener]);
+      mockComponent._subscribe();
+
+      mockComponent._unsubscribe();
+
+      document.dispatchEvent(new Event("test-event"));
+
+      expect(mockListener).to.not.be.called;
+    });
+  });
+
+  describe("Navigation event handling", () => {
+    it("should not listen to navigate events when ignoring router", () => {
+      const mockComponent = createMockComponent();
+
+      setupComponentSubscriptions({
+        component: mockComponent,
+        defaultRoute: false,
+        ignoreRouter: true,
+      });
+
+      const subscriptions = Array.from(mockComponent._subscriptions);
+      expect(subscriptions.some((sub: any) => sub[0] === "navigate")).to.be
+        .false;
+    });
+  });
+
+  describe("ignoreRouter parameter", () => {
+    it("should skip router setup when ignoreRouter is true", () => {
+      return ensureSibRouterExists().then(() => {
+        return cy.document().then((doc) => {
+          const router = doc.createElement("solid-router");
+          router.setAttribute("currentRouteName", "test-route");
+          doc.body.appendChild(router);
+
+          const mockComponent = createMockComponent();
+          mockComponent.route = "/custom-route";
+
+          setupComponentSubscriptions({
+            component: mockComponent,
+            defaultRoute: false,
+            ignoreRouter: true,
+          });
+
+          expect(mockComponent.noRouter).to.be.undefined;
+          expect(mockComponent.currentRoute).to.be.undefined;
+          expect(mockComponent.currentResource).to.be.undefined;
+          expect(mockComponent.route).to.equal("/custom-route");
+        });
+      });
+    });
+
+    it("should skip navigation listener when ignoreRouter is true", () => {
+      const mockComponent = createMockComponent();
+
+      setupComponentSubscriptions({
+        component: mockComponent,
+        defaultRoute: false,
+        ignoreRouter: true,
+      });
+
+      const subscriptions = Array.from(mockComponent._subscriptions);
+      expect(subscriptions.some((sub: any) => sub[0] === "navigate")).to.be
+        .false;
+    });
+
+    it("should not set defaultRoute when ignoreRouter is true", () => {
+      const mockComponent = createMockComponent();
+
+      setupComponentSubscriptions({
+        component: mockComponent,
+        defaultRoute: "/default",
+        ignoreRouter: true,
+      });
+
+      expect(mockComponent.route).to.not.equal("/default");
+      expect(mockComponent.uniq).to.be.a("string");
+    });
+  });
+});

package/cypress/e2e/helpers/components/setupOnSaveReset.cy.ts

@@ -0,0 +1,380 @@
+import setupOnSaveReset from "@helpers/components/setupOnSaveReset";
+
+describe("setupOnSaveReset helper function", () => {
+  const createMockComponent = () => {
+    const _subscriptions = new Set();
+
+    const mockComponent: any = {
+      _subscriptions,
+      _subscribe() {
+        for (const subscription of this._subscriptions) {
+          document.addEventListener(subscription[0], subscription[1]);
+        }
+      },
+      _unsubscribe() {
+        for (const subscription of this._subscriptions) {
+          document.removeEventListener(subscription[0], subscription[1]);
+        }
+      },
+      _setValue: cy.stub(),
+    };
+
+    return mockComponent;
+  };
+
+  describe("Basic functionality", () => {
+    it("should set up save listener on component", () => {
+      const mockComponent = createMockComponent();
+
+      setupOnSaveReset(mockComponent, { keywords: ["test"] });
+
+      expect(mockComponent._subscriptions.size).to.be.greaterThan(0);
+    });
+
+    it("should subscribe to save event", () => {
+      const mockComponent = createMockComponent();
+
+      setupOnSaveReset(mockComponent, { keywords: ["test"] });
+
+      const subscriptions = Array.from(mockComponent._subscriptions);
+      expect(subscriptions.some((sub: any) => sub[0] === "save")).to.be.true;
+    });
+
+    it("should call _subscribe method", () => {
+      const mockComponent: any = {
+        _subscriptions: new Set(),
+        _subscribe: cy.stub(),
+        _setValue: cy.stub(),
+      };
+
+      setupOnSaveReset(mockComponent, { keywords: ["test"] });
+
+      expect(mockComponent._subscribe).to.be.calledOnce;
+    });
+  });
+
+  describe("Keyword matching", () => {
+    it("should not call _setValue when keyword doesn't match", () => {
+      const mockComponent = createMockComponent();
+
+      setupOnSaveReset(mockComponent, { keywords: ["test"] });
+
+      const saveEvent = new CustomEvent("save", {
+        detail: { id: "https://example.com/nomatch/resource" },
+      });
+      document.dispatchEvent(saveEvent);
+
+      expect(mockComponent._setValue).to.not.be.called;
+
+      mockComponent._unsubscribe();
+    });
+
+    it("should call _setValue when keyword matches at start", () => {
+      const mockComponent = createMockComponent();
+
+      setupOnSaveReset(mockComponent, { keywords: ["test"] });
+
+      const saveEvent = new CustomEvent("save", {
+        detail: { id: "https://test.com/resource" },
+      });
+      document.dispatchEvent(saveEvent);
+
+      expect(mockComponent._setValue).to.be.calledOnce;
+
+      mockComponent._unsubscribe();
+    });
+
+    it("should call _setValue when keyword matches after slash", () => {
+      const mockComponent = createMockComponent();
+
+      setupOnSaveReset(mockComponent, { keywords: ["test"] });
+
+      const saveEvent = new CustomEvent("save", {
+        detail: { id: "https://example.com/test/resource" },
+      });
+      document.dispatchEvent(saveEvent);
+
+      expect(mockComponent._setValue).to.be.calledOnce;
+
+      mockComponent._unsubscribe();
+    });
+
+    it("should not match keyword in middle of path segment", () => {
+      const mockComponent = createMockComponent();
+
+      setupOnSaveReset(mockComponent, { keywords: ["test"] });
+
+      const saveEvent = new CustomEvent("save", {
+        detail: { id: "https://example.com/atestresource" },
+      });
+      document.dispatchEvent(saveEvent);
+
+      expect(mockComponent._setValue).to.not.be.called;
+
+      mockComponent._unsubscribe();
+    });
+
+    it("should match keyword in last segment", () => {
+      const mockComponent = createMockComponent();
+
+      setupOnSaveReset(mockComponent, { keywords: ["test"] });
+
+      const saveEvent = new CustomEvent("save", {
+        detail: { id: "https://example.com/path/test" },
+      });
+      document.dispatchEvent(saveEvent);
+
+      expect(mockComponent._setValue).to.be.calledOnce;
+
+      mockComponent._unsubscribe();
+    });
+
+    it("should handle multiple keywords", () => {
+      const mockComponent = createMockComponent();
+
+      setupOnSaveReset(mockComponent, { keywords: ["test", "project", "user"] });
+
+      const saveEvent1 = new CustomEvent("save", {
+        detail: { id: "https://example.com/test/resource" },
+      });
+      document.dispatchEvent(saveEvent1);
+
+      const saveEvent2 = new CustomEvent("save", {
+        detail: { id: "https://example.com/user/profile" },
+      });
+      document.dispatchEvent(saveEvent2);
+
+      expect(mockComponent._setValue).to.be.calledTwice;
+
+      mockComponent._unsubscribe();
+    });
+
+    it("should support keyword with special characters", () => {
+      const mockComponent = createMockComponent();
+
+      setupOnSaveReset(mockComponent, { keywords: ["@type"] });
+
+      const saveEvent = new CustomEvent("save", {
+        detail: { id: "https://example.com/@type/resource" },
+      });
+      document.dispatchEvent(saveEvent);
+
+      expect(mockComponent._setValue).to.be.calledOnce;
+
+      mockComponent._unsubscribe();
+    });
+  });
+
+  describe("Event detail resource handling", () => {
+    it("should handle resource with @id property", () => {
+      const mockComponent = createMockComponent();
+
+      setupOnSaveReset(mockComponent, { keywords: ["test"] });
+
+      const saveEvent = new CustomEvent("save", {
+        detail: {
+          resource: { "@id": "https://example.com/test/resource" },
+        },
+      });
+      document.dispatchEvent(saveEvent);
+
+      expect(mockComponent._setValue).to.be.calledOnce;
+
+      mockComponent._unsubscribe();
+    });
+
+    it("should prioritize id over resource.@id", () => {
+      const mockComponent = createMockComponent();
+
+      setupOnSaveReset(mockComponent, { keywords: ["test"] });
+
+      const saveEvent = new CustomEvent("save", {
+        detail: {
+          id: "https://example.com/test/id",
+          resource: { "@id": "https://example.com/test/resource" },
+        },
+      });
+      document.dispatchEvent(saveEvent);
+
+      expect(mockComponent._setValue).to.be.calledOnce;
+      const setValueCall = mockComponent._setValue.getCall(0);
+      expect(setValueCall).to.exist;
+
+      mockComponent._unsubscribe();
+    });
+
+    it("should not call _setValue when id is missing", () => {
+      const mockComponent = createMockComponent();
+
+      setupOnSaveReset(mockComponent, { keywords: ["test"] });
+
+      const saveEvent = new CustomEvent("save", {
+        detail: { resource: { name: "test" } },
+      });
+      document.dispatchEvent(saveEvent);
+
+      expect(mockComponent._setValue).to.not.be.called;
+
+      mockComponent._unsubscribe();
+    });
+  });
+
+  describe("_setValue call behavior", () => {
+    it("should call _setValue with empty value object", () => {
+      const mockComponent = createMockComponent();
+
+      setupOnSaveReset(mockComponent, { keywords: ["test"] });
+
+      const saveEvent = new CustomEvent("save", {
+        detail: { id: "https://example.com/test/resource" },
+      });
+      document.dispatchEvent(saveEvent);
+
+      expect(mockComponent._setValue).to.be.calledOnce;
+      const callArgs = mockComponent._setValue.getCall(0).args[0];
+      expect(callArgs).to.be.an("object");
+      expect(callArgs.target).to.be.an("object");
+      expect(callArgs.target.value).to.equal("");
+
+      mockComponent._unsubscribe();
+    });
+  });
+
+  describe("Empty keywords handling", () => {
+    it("should not set up listener when keywords array is empty", () => {
+      const mockComponent = createMockComponent();
+
+      setupOnSaveReset(mockComponent, { keywords: [] });
+
+      expect(mockComponent._subscriptions.size).to.equal(0);
+    });
+
+    it("should not set up listener when keywords is undefined", () => {
+      const mockComponent = createMockComponent();
+
+      setupOnSaveReset(mockComponent, {});
+
+      expect(mockComponent._subscriptions.size).to.equal(0);
+    });
+  });
+
+  describe("Document ready state", () => {
+    it("should set up immediately when document is complete", () => {
+      const mockComponent: any = {
+        _subscriptions: new Set(),
+        _subscribe: cy.stub(),
+        _setValue: cy.stub(),
+      };
+
+      cy.document().then((doc) => {
+        const originalReadyState = Object.getOwnPropertyDescriptor(
+          Document.prototype,
+          "readyState",
+        );
+        Object.defineProperty(doc, "readyState", {
+          get: () => "complete",
+          configurable: true,
+        });
+
+        setupOnSaveReset(mockComponent, { keywords: ["test"] });
+
+        expect(mockComponent._subscribe).to.be.calledOnce;
+
+        if (originalReadyState) {
+          Object.defineProperty(doc, "readyState", originalReadyState);
+        }
+      });
+    });
+  });
+
+  describe("Multiple save events", () => {
+    it("should handle multiple save events", () => {
+      const mockComponent = createMockComponent();
+
+      setupOnSaveReset(mockComponent, { keywords: ["test"] });
+
+      for (let i = 0; i < 5; i++) {
+        const saveEvent = new CustomEvent("save", {
+          detail: { id: `https://example.com/test/resource${i}` },
+        });
+        document.dispatchEvent(saveEvent);
+      }
+
+      expect(mockComponent._setValue).to.have.callCount(5);
+
+      mockComponent._unsubscribe();
+    });
+  });
+
+  describe("Edge cases", () => {
+    it("should handle URL with no path", () => {
+      const mockComponent = createMockComponent();
+
+      setupOnSaveReset(mockComponent, { keywords: ["example.com"] });
+
+      const saveEvent = new CustomEvent("save", {
+        detail: { id: "https://example.com" },
+      });
+      document.dispatchEvent(saveEvent);
+
+      expect(mockComponent._setValue).to.be.calledOnce;
+
+      mockComponent._unsubscribe();
+    });
+
+    it("should handle URL with multiple slashes", () => {
+      const mockComponent = createMockComponent();
+
+      setupOnSaveReset(mockComponent, { keywords: ["test"] });
+
+      const saveEvent = new CustomEvent("save", {
+        detail: { id: "https://example.com///test///resource" },
+      });
+      document.dispatchEvent(saveEvent);
+
+      expect(mockComponent._setValue).to.be.calledOnce;
+
+      mockComponent._unsubscribe();
+    });
+
+    it("should handle duplicate keywords", () => {
+      const mockComponent = createMockComponent();
+
+      setupOnSaveReset(mockComponent, { keywords: ["test", "test", "test"] });
+
+      const saveEvent = new CustomEvent("save", {
+        detail: { id: "https://example.com/test/resource" },
+      });
+      document.dispatchEvent(saveEvent);
+
+      expect(mockComponent._setValue).to.be.calledOnce;
+
+      mockComponent._unsubscribe();
+    });
+  });
+
+  describe("Component property requirements", () => {
+    it("should require component to provide _subscriptions Set", () => {
+      const mockComponent: any = {
+        _subscriptions: new Set(),
+        _subscribe: cy.stub(),
+        _setValue: cy.stub(),
+      };
+
+      setupOnSaveReset(mockComponent, { keywords: ["test"] });
+
+      expect(mockComponent._subscriptions).to.be.an.instanceOf(Set);
+      expect(mockComponent._subscriptions.size).to.be.greaterThan(0);
+    });
+
+    it("should create saveListener property", () => {
+      const mockComponent = createMockComponent();
+
+      setupOnSaveReset(mockComponent, { keywords: ["test"] });
+
+      expect(mockComponent.saveListener).to.be.a("function");
+
+      mockComponent._unsubscribe();
+    });
+  });
+});