@tomo-inc/wallet-adaptor-base 0.0.19 → 0.0.21

package/src/__tests__/isMobile.test.ts

@@ -0,0 +1,187 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { isMobile, isAndroid, isSmallIOS, isLargeIOS, isIOS } from "../utils/isMobile";
+
+describe("isMobile", () => {
+  let originalUserAgent: string;
+  let originalPlatform: string;
+  let originalMaxTouchPoints: number;
+
+  beforeEach(() => {
+    originalUserAgent = navigator.userAgent;
+    originalPlatform = navigator.platform;
+    originalMaxTouchPoints = navigator.maxTouchPoints;
+  });
+
+  afterEach(() => {
+    Object.defineProperty(navigator, "userAgent", {
+      value: originalUserAgent,
+      writable: true,
+      configurable: true,
+    });
+    Object.defineProperty(navigator, "platform", {
+      value: originalPlatform,
+      writable: true,
+      configurable: true,
+    });
+    Object.defineProperty(navigator, "maxTouchPoints", {
+      value: originalMaxTouchPoints,
+      writable: true,
+      configurable: true,
+    });
+  });
+
+  describe("isAndroid", () => {
+    it("should detect Android", () => {
+      Object.defineProperty(navigator, "userAgent", {
+        value: "Mozilla/5.0 (Linux; Android 10) Mobile",
+        writable: true,
+        configurable: true,
+      });
+      expect(isAndroid()).toBe(true);
+    });
+
+    it("should return false for non-Android", () => {
+      Object.defineProperty(navigator, "userAgent", {
+        value: "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
+        writable: true,
+        configurable: true,
+      });
+      expect(isAndroid()).toBe(false);
+    });
+  });
+
+  describe("isSmallIOS", () => {
+    it("should detect iPhone", () => {
+      Object.defineProperty(navigator, "userAgent", {
+        value: "Mozilla/5.0 (iPhone; CPU iPhone OS 14_0 like Mac OS X)",
+        writable: true,
+        configurable: true,
+      });
+      expect(isSmallIOS()).toBe(true);
+    });
+
+    it("should detect iPod", () => {
+      Object.defineProperty(navigator, "userAgent", {
+        value: "Mozilla/5.0 (iPod; CPU iPhone OS 14_0 like Mac OS X)",
+        writable: true,
+        configurable: true,
+      });
+      expect(isSmallIOS()).toBe(true);
+    });
+
+    it("should return false for non-iPhone/iPod", () => {
+      Object.defineProperty(navigator, "userAgent", {
+        value: "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
+        writable: true,
+        configurable: true,
+      });
+      expect(isSmallIOS()).toBe(false);
+    });
+  });
+
+  describe("isLargeIOS", () => {
+    it("should detect iPad", () => {
+      Object.defineProperty(navigator, "userAgent", {
+        value: "Mozilla/5.0 (iPad; CPU OS 14_0 like Mac OS X)",
+        writable: true,
+        configurable: true,
+      });
+      expect(isLargeIOS()).toBe(true);
+    });
+
+    it("should detect iPad on MacIntel", () => {
+      Object.defineProperty(navigator, "userAgent", {
+        value: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)",
+        writable: true,
+        configurable: true,
+      });
+      Object.defineProperty(navigator, "platform", {
+        value: "MacIntel",
+        writable: true,
+        configurable: true,
+      });
+      Object.defineProperty(navigator, "maxTouchPoints", {
+        value: 5,
+        writable: true,
+        configurable: true,
+      });
+      expect(isLargeIOS()).toBe(true);
+    });
+
+    it("should return false for non-iPad", () => {
+      Object.defineProperty(navigator, "userAgent", {
+        value: "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
+        writable: true,
+        configurable: true,
+      });
+      expect(isLargeIOS()).toBe(false);
+    });
+  });
+
+  describe("isIOS", () => {
+    it("should return true for iPhone", () => {
+      Object.defineProperty(navigator, "userAgent", {
+        value: "Mozilla/5.0 (iPhone; CPU iPhone OS 14_0 like Mac OS X)",
+        writable: true,
+        configurable: true,
+      });
+      expect(isIOS()).toBe(true);
+    });
+
+    it("should return true for iPad", () => {
+      Object.defineProperty(navigator, "userAgent", {
+        value: "Mozilla/5.0 (iPad; CPU OS 14_0 like Mac OS X)",
+        writable: true,
+        configurable: true,
+      });
+      expect(isIOS()).toBe(true);
+    });
+
+    it("should return false for non-iOS", () => {
+      Object.defineProperty(navigator, "userAgent", {
+        value: "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
+        writable: true,
+        configurable: true,
+      });
+      expect(isIOS()).toBe(false);
+    });
+  });
+
+  describe("isMobile", () => {
+    it("should return true for Android", () => {
+      Object.defineProperty(navigator, "userAgent", {
+        value: "Mozilla/5.0 (Linux; Android 10) Mobile",
+        writable: true,
+        configurable: true,
+      });
+      expect(isMobile()).toBe(true);
+    });
+
+    it("should return true for iPhone", () => {
+      Object.defineProperty(navigator, "userAgent", {
+        value: "Mozilla/5.0 (iPhone; CPU iPhone OS 14_0 like Mac OS X)",
+        writable: true,
+        configurable: true,
+      });
+      expect(isMobile()).toBe(true);
+    });
+
+    it("should return true for iPad", () => {
+      Object.defineProperty(navigator, "userAgent", {
+        value: "Mozilla/5.0 (iPad; CPU OS 14_0 like Mac OS X)",
+        writable: true,
+        configurable: true,
+      });
+      expect(isMobile()).toBe(true);
+    });
+
+    it("should return false for desktop", () => {
+      Object.defineProperty(navigator, "userAgent", {
+        value: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+        writable: true,
+        configurable: true,
+      });
+      expect(isMobile()).toBe(false);
+    });
+  });
+});

package/src/__tests__/log.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { debugLog } from "../utils/log";
+
+describe("log", () => {
+  let originalConsoleLog: typeof console.log;
+  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    originalConsoleLog = console.log;
+    consoleLogSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    console.log = originalConsoleLog;
+    vi.restoreAllMocks();
+  });
+
+  describe("debugLog", () => {
+    it("should log when isDebug is true", () => {
+      debugLog("test message", 123, { key: "value" });
+      expect(consoleLogSpy).toHaveBeenCalledWith("test message", 123, { key: "value" });
+    });
+
+    it("should handle multiple arguments", () => {
+      debugLog("arg1", "arg2", "arg3");
+      expect(consoleLogSpy).toHaveBeenCalledWith("arg1", "arg2", "arg3");
+    });
+
+    it("should handle empty arguments", () => {
+      debugLog();
+      expect(consoleLogSpy).toHaveBeenCalledWith();
+    });
+
+    it("should handle complex objects", () => {
+      const complexObj = { nested: { deep: { value: 42 } } };
+      debugLog(complexObj);
+      expect(consoleLogSpy).toHaveBeenCalledWith(complexObj);
+    });
+  });
+});

package/src/__tests__/utils.test.ts

@@ -0,0 +1,66 @@
+import { describe, it, expect } from "vitest";
+import { uniqueConnectors, uint8arrayToHex } from "../utils/utils";
+import type { Connector } from "../type";
+
+describe("utils", () => {
+  describe("uniqueConnectors", () => {
+    it("should remove duplicate connectors by rdns", () => {
+      const connectors: Connector[] = [
+        {
+          info: { name: "Wallet1", rdns: "com.wallet1" },
+        } as Connector,
+        {
+          info: { name: "Wallet1", rdns: "com.wallet1" },
+        } as Connector,
+        {
+          info: { name: "Wallet2", rdns: "com.wallet2" },
+        } as Connector,
+      ];
+
+      const result = uniqueConnectors(connectors);
+      expect(result.length).toBe(2);
+    });
+
+    it("should remove duplicate connectors by name if rdns is missing", () => {
+      const connectors: Connector[] = [
+        {
+          info: { name: "Wallet1" },
+        } as Connector,
+        {
+          info: { name: "Wallet1" },
+        } as Connector,
+        {
+          info: { name: "Wallet2" },
+        } as Connector,
+      ];
+
+      const result = uniqueConnectors(connectors);
+      expect(result.length).toBe(2);
+    });
+
+    it("should handle empty array", () => {
+      const result = uniqueConnectors([]);
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe("uint8arrayToHex", () => {
+    it("should convert Uint8Array to hex string", () => {
+      const arr = new Uint8Array([0, 255, 16, 15]);
+      const result = uint8arrayToHex(arr);
+      expect(result).toBe("00ff100f");
+    });
+
+    it("should handle empty array", () => {
+      const arr = new Uint8Array([]);
+      const result = uint8arrayToHex(arr);
+      expect(result).toBe("");
+    });
+
+    it("should pad single digit hex values", () => {
+      const arr = new Uint8Array([0, 1, 15, 255]);
+      const result = uint8arrayToHex(arr);
+      expect(result).toBe("00010fff");
+    });
+  });
+});