@tomo-inc/inject-providers 0.0.16 → 0.0.18

package/src/__tests__/dapp-info.test.ts

@@ -0,0 +1,603 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { getDappInfo } from "../utils/dapp-info";
+
+describe("dapp-info", () => {
+  let originalQuerySelector: typeof document.querySelector;
+  let originalCreateElement: typeof document.createElement;
+  let originalWindowTop: Window | null;
+
+  beforeEach(() => {
+    originalQuerySelector = document.querySelector;
+    originalCreateElement = document.createElement;
+    originalWindowTop = window.top;
+
+    // Mock window.top
+    Object.defineProperty(window, "top", {
+      value: {
+        location: {
+          origin: "https://example.com",
+        },
+      },
+      writable: true,
+      configurable: true,
+    });
+  });
+
+  afterEach(() => {
+    document.querySelector = originalQuerySelector;
+    document.createElement = originalCreateElement;
+    Object.defineProperty(window, "top", {
+      value: originalWindowTop,
+      writable: true,
+      configurable: true,
+    });
+  });
+
+  describe("getDappInfo", () => {
+    it("should return dapp info with origin", async () => {
+      // Mock document.querySelector to return null (no meta tags)
+      document.querySelector = vi.fn().mockReturnValue(null);
+      document.title = "Test Page";
+
+      // Mock createElement for img
+      const mockImg = {
+        onload: null as any,
+        onerror: null as any,
+        src: "",
+      };
+      document.createElement = vi.fn((tagName: string) => {
+        if (tagName === "img") {
+          return mockImg as any;
+        }
+        return originalCreateElement.call(document, tagName);
+      });
+
+      // Simulate image load success
+      setTimeout(() => {
+        if (mockImg.onload) {
+          mockImg.onload();
+        }
+      }, 10);
+
+      const info = await getDappInfo();
+
+      expect(info.origin).toBe("https://example.com");
+      expect(info.title).toBe("Test Page");
+    });
+
+    it("should extract site name from og:site_name meta tag", async () => {
+      const mockMeta = {
+        content: "Test Site Name",
+      } as HTMLMetaElement;
+
+      document.querySelector = vi.fn((selector: string) => {
+        if (selector === 'head > meta[property="og:site_name"]') {
+          return mockMeta;
+        }
+        return null;
+      });
+
+      const mockImg = {
+        onload: null as any,
+        onerror: null as any,
+        src: "",
+      };
+      document.createElement = vi.fn((tagName: string) => {
+        if (tagName === "img") {
+          return mockImg as any;
+        }
+        return originalCreateElement.call(document, tagName);
+      });
+
+      setTimeout(() => {
+        if (mockImg.onload) {
+          mockImg.onload();
+        }
+      }, 10);
+
+      const info = await getDappInfo();
+      expect(info.title).toBe("Test Site Name");
+    });
+
+    it("should extract description from og:description meta tag", async () => {
+      const mockMeta = {
+        content: "Test Description",
+      } as HTMLMetaElement;
+
+      document.querySelector = vi.fn((selector: string) => {
+        if (selector === 'head > meta[property="og:description"]') {
+          return mockMeta;
+        }
+        return null;
+      });
+
+      const mockImg = {
+        onload: null as any,
+        onerror: null as any,
+        src: "",
+      };
+      document.createElement = vi.fn((tagName: string) => {
+        if (tagName === "img") {
+          return mockImg as any;
+        }
+        return originalCreateElement.call(document, tagName);
+      });
+
+      setTimeout(() => {
+        if (mockImg.onload) {
+          mockImg.onload();
+        }
+      }, 10);
+
+      const info = await getDappInfo();
+      expect(info.desc).toBe("Test Description");
+    });
+
+    it("should handle image load error", async () => {
+      document.querySelector = vi.fn((selector: string) => {
+        if (selector === 'head > link[rel~="icon"]') {
+          return {
+            href: "https://example.com/favicon.ico",
+          } as HTMLLinkElement;
+        }
+        return null;
+      });
+
+      const mockImg = {
+        onload: null as any,
+        onerror: null as any,
+        src: "",
+      };
+      document.createElement = vi.fn((tagName: string) => {
+        if (tagName === "img") {
+          return mockImg as any;
+        }
+        return originalCreateElement.call(document, tagName);
+      });
+
+      // Simulate image load error
+      setTimeout(() => {
+        if (mockImg.onerror) {
+          mockImg.onerror();
+        }
+      }, 10);
+
+      const info = await getDappInfo();
+      expect(info.favicon).toBe("");
+    });
+
+    it("should extract site name from meta[name='title'] if og:site_name is not available", async () => {
+      const mockMeta = {
+        content: "Meta Title",
+      } as HTMLMetaElement;
+
+      document.querySelector = vi.fn((selector: string) => {
+        if (selector === 'head > meta[name="title"]') {
+          return mockMeta;
+        }
+        return null;
+      });
+
+      const mockImg = {
+        onload: null as any,
+        onerror: null as any,
+        src: "",
+      };
+      document.createElement = vi.fn((tagName: string) => {
+        if (tagName === "img") {
+          return mockImg as any;
+        }
+        return originalCreateElement.call(document, tagName);
+      });
+
+      setTimeout(() => {
+        if (mockImg.onload) {
+          mockImg.onload();
+        }
+      }, 10);
+
+      const info = await getDappInfo();
+      expect(info.title).toBe("Meta Title");
+    });
+
+    it("should use document.title if no meta tags are available", async () => {
+      document.querySelector = vi.fn().mockReturnValue(null);
+      document.title = "Document Title";
+
+      const mockImg = {
+        onload: null as any,
+        onerror: null as any,
+        src: "",
+      };
+      document.createElement = vi.fn((tagName: string) => {
+        if (tagName === "img") {
+          return mockImg as any;
+        }
+        return originalCreateElement.call(document, tagName);
+      });
+
+      setTimeout(() => {
+        if (mockImg.onload) {
+          mockImg.onload();
+        }
+      }, 10);
+
+      const info = await getDappInfo();
+      expect(info.title).toBe("Document Title");
+    });
+
+    it("should use hostname if document.title is empty", async () => {
+      document.querySelector = vi.fn().mockReturnValue(null);
+      document.title = "";
+      // Mock document.body to have innerText
+      Object.defineProperty(document, "body", {
+        value: {
+          innerText: "",
+        },
+        writable: true,
+        configurable: true,
+      });
+      // Mock location.hostname without triggering navigation
+      Object.defineProperty(window, "location", {
+        value: {
+          ...window.location,
+          hostname: "example.com",
+        },
+        writable: true,
+        configurable: true,
+      });
+
+      const mockImg = {
+        onload: null as any,
+        onerror: null as any,
+        src: "",
+      };
+      document.createElement = vi.fn((tagName: string) => {
+        if (tagName === "img") {
+          return mockImg as any;
+        }
+        return originalCreateElement.call(document, tagName);
+      });
+
+      setTimeout(() => {
+        if (mockImg.onload) {
+          mockImg.onload();
+        }
+      }, 10);
+
+      const info = await getDappInfo();
+      expect(info.title).toBe("example.com");
+    });
+
+    it("should extract description from twitter:description meta tag", async () => {
+      const mockMeta = {
+        content: "Twitter Description",
+      } as HTMLMetaElement;
+
+      document.querySelector = vi.fn((selector: string) => {
+        if (selector === 'head > meta[property="twitter:description"]') {
+          return mockMeta;
+        }
+        return null;
+      });
+
+      const mockImg = {
+        onload: null as any,
+        onerror: null as any,
+        src: "",
+      };
+      document.createElement = vi.fn((tagName: string) => {
+        if (tagName === "img") {
+          return mockImg as any;
+        }
+        return originalCreateElement.call(document, tagName);
+      });
+
+      setTimeout(() => {
+        if (mockImg.onload) {
+          mockImg.onload();
+        }
+      }, 10);
+
+      const info = await getDappInfo();
+      expect(info.desc).toBe("Twitter Description");
+    });
+
+    it("should extract description from meta[name='description']", async () => {
+      const mockMeta = {
+        content: "Meta Description",
+      } as HTMLMetaElement;
+
+      document.querySelector = vi.fn((selector: string) => {
+        if (selector === 'head > meta[name="description"]') {
+          return mockMeta;
+        }
+        return null;
+      });
+
+      const mockImg = {
+        onload: null as any,
+        onerror: null as any,
+        src: "",
+      };
+      document.createElement = vi.fn((tagName: string) => {
+        if (tagName === "img") {
+          return mockImg as any;
+        }
+        return originalCreateElement.call(document, tagName);
+      });
+
+      setTimeout(() => {
+        if (mockImg.onload) {
+          mockImg.onload();
+        }
+      }, 10);
+
+      const info = await getDappInfo();
+      expect(info.desc).toBe("Meta Description");
+    });
+
+    it("should use document.title for description if no description meta tags", async () => {
+      document.querySelector = vi.fn().mockReturnValue(null);
+      document.title = "Page Title";
+
+      const mockImg = {
+        onload: null as any,
+        onerror: null as any,
+        src: "",
+      };
+      document.createElement = vi.fn((tagName: string) => {
+        if (tagName === "img") {
+          return mockImg as any;
+        }
+        return originalCreateElement.call(document, tagName);
+      });
+
+      setTimeout(() => {
+        if (mockImg.onload) {
+          mockImg.onload();
+        }
+      }, 10);
+
+      const info = await getDappInfo();
+      expect(info.desc).toBe("Page Title");
+    });
+
+    it("should use body innerText first line if no description available", async () => {
+      document.querySelector = vi.fn().mockReturnValue(null);
+      document.title = "";
+      // Use Object.defineProperty to set body.innerText
+      const bodyElement = document.createElement("body");
+      Object.defineProperty(bodyElement, "innerText", {
+        value: "First line\nSecond line",
+        writable: true,
+        configurable: true,
+      });
+      Object.defineProperty(document, "body", {
+        value: bodyElement,
+        writable: true,
+        configurable: true,
+      });
+
+      const mockImg = {
+        onload: null as any,
+        onerror: null as any,
+        src: "",
+      };
+      document.createElement = vi.fn((tagName: string) => {
+        if (tagName === "img") {
+          return mockImg as any;
+        }
+        return originalCreateElement.call(document, tagName);
+      });
+
+      setTimeout(() => {
+        if (mockImg.onload) {
+          mockImg.onload();
+        }
+      }, 10);
+
+      const info = await getDappInfo();
+      expect(info.desc).toBe("First line");
+    });
+
+    it("should return empty string for description if body innerText is empty", async () => {
+      document.querySelector = vi.fn().mockReturnValue(null);
+      document.title = "";
+      const bodyElement = document.createElement("body");
+      Object.defineProperty(bodyElement, "innerText", {
+        value: "",
+        writable: true,
+        configurable: true,
+      });
+      Object.defineProperty(document, "body", {
+        value: bodyElement,
+        writable: true,
+        configurable: true,
+      });
+
+      const mockImg = {
+        onload: null as any,
+        onerror: null as any,
+        src: "",
+      };
+      document.createElement = vi.fn((tagName: string) => {
+        if (tagName === "img") {
+          return mockImg as any;
+        }
+        return originalCreateElement.call(document, tagName);
+      });
+
+      setTimeout(() => {
+        if (mockImg.onload) {
+          mockImg.onload();
+        }
+      }, 10);
+
+      const info = await getDappInfo();
+      expect(info.desc).toBe("");
+    });
+
+    it("should extract icon from link[rel~='icon'] when image loads successfully", async () => {
+      document.querySelector = vi.fn((selector: string) => {
+        if (selector === 'head > link[rel~="icon"]') {
+          return { href: "https://example.com/favicon.ico" } as HTMLLinkElement;
+        }
+        return null;
+      });
+
+      const bodyElement = document.createElement("body");
+      Object.defineProperty(bodyElement, "innerText", { value: "", writable: true, configurable: true });
+      Object.defineProperty(document, "body", { value: bodyElement, writable: true, configurable: true });
+
+      document.createElement = vi.fn((tagName: string) => {
+        if (tagName === "img") {
+          const el = originalCreateElement.call(document, tagName) as HTMLImageElement;
+          let onloadFn: (() => void) | null = null;
+          Object.defineProperty(el, "onload", {
+            get: () => onloadFn,
+            set: (fn: () => void) => {
+              onloadFn = fn;
+            },
+            configurable: true,
+          });
+          Object.defineProperty(el, "src", {
+            get: () => (el as any)._src,
+            set: (url: string) => {
+              (el as any)._src = url;
+              queueMicrotask(() => {
+                if (onloadFn) onloadFn();
+              });
+            },
+            configurable: true,
+          });
+          return el;
+        }
+        return originalCreateElement.call(document, tagName);
+      });
+
+      const info = await getDappInfo();
+      expect(info.favicon).toBe("https://example.com/favicon.ico");
+    });
+
+    it("should extract icon from meta[itemprop='image'] when image loads successfully", async () => {
+      document.querySelector = vi.fn((selector: string) => {
+        if (selector === 'head > link[rel~="icon"]') return null;
+        if (selector === 'head > meta[itemprop="image"]') {
+          return { content: "https://example.com/image.png" } as HTMLMetaElement;
+        }
+        return null;
+      });
+
+      const bodyElement = document.createElement("body");
+      Object.defineProperty(bodyElement, "innerText", { value: "", writable: true, configurable: true });
+      Object.defineProperty(document, "body", { value: bodyElement, writable: true, configurable: true });
+
+      document.createElement = vi.fn((tagName: string) => {
+        if (tagName === "img") {
+          const el = originalCreateElement.call(document, tagName) as HTMLImageElement;
+          let onloadFn: (() => void) | null = null;
+          Object.defineProperty(el, "onload", {
+            get: () => onloadFn,
+            set: (fn: () => void) => { onloadFn = fn; },
+            configurable: true,
+          });
+          Object.defineProperty(el, "src", {
+            get: () => (el as any)._src,
+            set: (url: string) => {
+              (el as any)._src = url;
+              queueMicrotask(() => { if (onloadFn) onloadFn(); });
+            },
+            configurable: true,
+          });
+          return el;
+        }
+        return originalCreateElement.call(document, tagName);
+      });
+
+      const info = await getDappInfo();
+      expect(info.favicon).toBe("https://example.com/image.png");
+    });
+
+    it("should handle image load error and return empty string", async () => {
+      document.querySelector = vi.fn((selector: string) => {
+        if (selector === 'head > link[rel~="icon"]') {
+          return {
+            href: "https://example.com/invalid.ico",
+          } as HTMLLinkElement;
+        }
+        return null;
+      });
+
+      // Mock body to prevent innerText error
+      const bodyElement = document.createElement("body");
+      Object.defineProperty(bodyElement, "innerText", {
+        value: "",
+        writable: true,
+        configurable: true,
+      });
+      Object.defineProperty(document, "body", {
+        value: bodyElement,
+        writable: true,
+        configurable: true,
+      });
+
+      const mockImg = {
+        onload: null as any,
+        onerror: null as any,
+        src: "",
+      };
+      document.createElement = vi.fn((tagName: string) => {
+        if (tagName === "img") {
+          return mockImg as any;
+        }
+        return originalCreateElement.call(document, tagName);
+      });
+
+      setTimeout(() => {
+        if (mockImg.onerror) {
+          mockImg.onerror();
+        }
+      }, 10);
+
+      const info = await getDappInfo();
+      expect(info.favicon).toBe("");
+    });
+
+    it("should handle exception in imgExists", async () => {
+      document.querySelector = vi.fn((selector: string) => {
+        if (selector === 'head > link[rel~="icon"]') {
+          return {
+            href: "https://example.com/favicon.ico",
+          } as HTMLLinkElement;
+        }
+        return null;
+      });
+
+      // Mock body to prevent innerText error
+      const bodyElement = document.createElement("body");
+      Object.defineProperty(bodyElement, "innerText", {
+        value: "",
+        writable: true,
+        configurable: true,
+      });
+      Object.defineProperty(document, "body", {
+        value: bodyElement,
+        writable: true,
+        configurable: true,
+      });
+
+      const originalCreateElement = document.createElement;
+      document.createElement = vi.fn((tagName: string) => {
+        if (tagName === "img") {
+          throw new Error("Cannot create element");
+        }
+        return originalCreateElement.call(document, tagName);
+      });
+
+      // The error will be caught in imgExists and return false, not throw
+      const info = await getDappInfo();
+      expect(info.favicon).toBe("");
+    });
+  });
+});