@frak-labs/core-sdk 0.1.0-beta.b0bd1f8a → 0.1.0-beta.b77c23c7

package/src/clients/DebugInfo.test.ts

@@ -0,0 +1,418 @@
+/**
+ * Tests for DebugInfoGatherer class
+ * Tests debug information gathering and formatting for error reporting
+ */
+
+import { FrakRpcError, RpcErrorCodes } from "@frak-labs/frame-connector";
+import {
+    afterEach,
+    beforeEach,
+    describe,
+    expect,
+    it,
+    vi,
+} from "../../tests/vitest-fixtures";
+import type { FrakWalletSdkConfig } from "../types";
+import { DebugInfoGatherer } from "./DebugInfo";
+
+describe("DebugInfoGatherer", () => {
+    let mockConfig: FrakWalletSdkConfig;
+    let mockIframe: HTMLIFrameElement;
+    let consoleWarnSpy: ReturnType<typeof vi.spyOn>;
+
+    beforeEach(() => {
+        // Create mock config
+        mockConfig = {
+            metadata: {
+                name: "Test App",
+            },
+        };
+
+        // Create mock iframe
+        mockIframe = document.createElement("iframe");
+        mockIframe.src = "https://wallet.frak.id";
+        mockIframe.setAttribute("loading", "lazy");
+        document.body.appendChild(mockIframe);
+
+        // Mock iframe contentDocument
+        Object.defineProperty(mockIframe, "contentDocument", {
+            value: {
+                readyState: "complete",
+            },
+            writable: true,
+        });
+
+        // Mock iframe contentWindow
+        Object.defineProperty(mockIframe, "contentWindow", {
+            value: {},
+            writable: true,
+        });
+
+        // Spy on console.warn
+        consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    });
+
+    afterEach(() => {
+        consoleWarnSpy.mockRestore();
+        document.body.removeChild(mockIframe);
+        vi.clearAllMocks();
+    });
+
+    describe("constructor", () => {
+        it("should create instance with config and iframe", () => {
+            const gatherer = new DebugInfoGatherer(mockConfig, mockIframe);
+
+            expect(gatherer).toBeInstanceOf(DebugInfoGatherer);
+        });
+
+        it("should create instance without config and iframe", () => {
+            const gatherer = new DebugInfoGatherer();
+
+            expect(gatherer).toBeInstanceOf(DebugInfoGatherer);
+        });
+
+        it("should initialize with null lastRequest and lastResponse", () => {
+            const gatherer = new DebugInfoGatherer(mockConfig, mockIframe);
+
+            // Access private properties through formatDebugInfo output
+            const debugInfo = gatherer.formatDebugInfo("test error");
+            expect(debugInfo).toContain("No Frak request logged");
+            expect(debugInfo).toContain("No Frak response logged");
+        });
+    });
+
+    describe("static empty()", () => {
+        it("should create empty instance", () => {
+            const gatherer = DebugInfoGatherer.empty();
+
+            expect(gatherer).toBeInstanceOf(DebugInfoGatherer);
+        });
+
+        it("should create instance without config or iframe", () => {
+            const gatherer = DebugInfoGatherer.empty();
+            const debugInfo = gatherer.formatDebugInfo("test error");
+
+            expect(debugInfo).toContain("no-config");
+            expect(debugInfo).toContain("not-iframe");
+        });
+    });
+
+    describe("setLastRequest", () => {
+        it("should set last request with timestamp", () => {
+            const gatherer = new DebugInfoGatherer(mockConfig, mockIframe);
+            const mockMessage = {
+                id: 1,
+                method: "test_method",
+                params: [],
+            } as any;
+
+            gatherer.setLastRequest(mockMessage);
+
+            const debugInfo = gatherer.formatDebugInfo("test error");
+            expect(debugInfo).toContain("Last Request:");
+            expect(debugInfo).not.toContain("No Frak request logged");
+        });
+    });
+
+    describe("setLastResponse", () => {
+        it("should set last response with timestamp", () => {
+            const gatherer = new DebugInfoGatherer(mockConfig, mockIframe);
+            const mockMessage = {
+                id: 1,
+                method: "test_method",
+            } as any;
+            const mockResponse = {
+                id: 1,
+                result: "success",
+            } as any;
+
+            gatherer.setLastResponse(mockMessage, mockResponse);
+
+            const debugInfo = gatherer.formatDebugInfo("test error");
+            expect(debugInfo).toContain("Last Response:");
+            expect(debugInfo).not.toContain("No Frak response logged");
+        });
+    });
+
+    describe("updateSetupStatus", () => {
+        it("should update setup status to true", () => {
+            const gatherer = new DebugInfoGatherer(mockConfig, mockIframe);
+
+            gatherer.updateSetupStatus(true);
+
+            const debugInfo = gatherer.formatDebugInfo("test error");
+            expect(debugInfo).toContain("Client Status: setup");
+        });
+
+        it("should update setup status to false", () => {
+            const gatherer = new DebugInfoGatherer(mockConfig, mockIframe);
+
+            gatherer.updateSetupStatus(false);
+
+            const debugInfo = gatherer.formatDebugInfo("test error");
+            expect(debugInfo).toContain("Client Status: not-setup");
+        });
+    });
+
+    describe("formatDebugInfo", () => {
+        it("should format debug info with all fields", () => {
+            const gatherer = new DebugInfoGatherer(mockConfig, mockIframe);
+
+            const debugInfo = gatherer.formatDebugInfo("test error");
+
+            expect(debugInfo).toContain("Debug Information:");
+            expect(debugInfo).toContain("Timestamp:");
+            expect(debugInfo).toContain("URL:");
+            expect(debugInfo).toContain("Config:");
+            expect(debugInfo).toContain("Navigator Info:");
+            expect(debugInfo).toContain("IFrame Status:");
+            expect(debugInfo).toContain("Last Request:");
+            expect(debugInfo).toContain("Last Response:");
+            expect(debugInfo).toContain("Client Status:");
+            expect(debugInfo).toContain("Error:");
+        });
+
+        it("should format FrakRpcError correctly", () => {
+            const gatherer = new DebugInfoGatherer(mockConfig, mockIframe);
+            const error = new FrakRpcError(
+                RpcErrorCodes.walletNotConnected,
+                "Wallet not connected"
+            );
+
+            const debugInfo = gatherer.formatDebugInfo(error);
+
+            expect(debugInfo).toContain(
+                `FrakRpcError: ${RpcErrorCodes.walletNotConnected} 'Wallet not connected'`
+            );
+        });
+
+        it("should format regular Error correctly", () => {
+            const gatherer = new DebugInfoGatherer(mockConfig, mockIframe);
+            const error = new Error("Network timeout");
+
+            const debugInfo = gatherer.formatDebugInfo(error);
+
+            expect(debugInfo).toContain("Network timeout");
+        });
+
+        it("should format string error correctly", () => {
+            const gatherer = new DebugInfoGatherer(mockConfig, mockIframe);
+
+            const debugInfo = gatherer.formatDebugInfo("String error message");
+
+            expect(debugInfo).toContain("String error message");
+        });
+
+        it("should format unknown error as 'Unknown'", () => {
+            const gatherer = new DebugInfoGatherer(mockConfig, mockIframe);
+
+            const debugInfo = gatherer.formatDebugInfo(null);
+
+            expect(debugInfo).toContain("Error: Unknown");
+        });
+
+        it("should include encoded URL", () => {
+            const gatherer = new DebugInfoGatherer(mockConfig, mockIframe);
+
+            const debugInfo = gatherer.formatDebugInfo("test error");
+
+            // URL should be base64 encoded
+            expect(debugInfo).toContain("URL:");
+            const urlMatch = debugInfo.match(/URL: (.+)/);
+            expect(urlMatch).toBeTruthy();
+            if (urlMatch) {
+                // Should be base64 encoded (alphanumeric + =)
+                expect(urlMatch[1]).toMatch(/^[A-Za-z0-9+/=]+$/);
+            }
+        });
+
+        it("should include encoded config when config is provided", () => {
+            const gatherer = new DebugInfoGatherer(mockConfig, mockIframe);
+
+            const debugInfo = gatherer.formatDebugInfo("test error");
+
+            expect(debugInfo).toContain("Config:");
+            expect(debugInfo).not.toContain("no-config");
+        });
+
+        it("should show 'no-config' when config is not provided", () => {
+            const gatherer = new DebugInfoGatherer(undefined, mockIframe);
+
+            const debugInfo = gatherer.formatDebugInfo("test error");
+
+            expect(debugInfo).toContain("Config: no-config");
+        });
+
+        it("should include iframe status when iframe is provided", () => {
+            const gatherer = new DebugInfoGatherer(mockConfig, mockIframe);
+
+            const debugInfo = gatherer.formatDebugInfo("test error");
+
+            expect(debugInfo).toContain("IFrame Status:");
+            expect(debugInfo).not.toContain("not-iframe");
+        });
+
+        it("should show 'not-iframe' when iframe is not provided", () => {
+            const gatherer = new DebugInfoGatherer(mockConfig, undefined);
+
+            const debugInfo = gatherer.formatDebugInfo("test error");
+
+            expect(debugInfo).toContain("IFrame Status: not-iframe");
+        });
+
+        it("should include navigator info", () => {
+            const gatherer = new DebugInfoGatherer(mockConfig, mockIframe);
+
+            const debugInfo = gatherer.formatDebugInfo("test error");
+
+            expect(debugInfo).toContain("Navigator Info:");
+            expect(debugInfo).not.toContain("no-navigator");
+        });
+
+        it("should handle iframe without contentDocument", () => {
+            const iframeWithoutDoc = document.createElement("iframe");
+            Object.defineProperty(iframeWithoutDoc, "contentDocument", {
+                value: null,
+                writable: true,
+            });
+            Object.defineProperty(iframeWithoutDoc, "contentWindow", {
+                value: {},
+                writable: true,
+            });
+
+            const gatherer = new DebugInfoGatherer(
+                mockConfig,
+                iframeWithoutDoc
+            );
+
+            const debugInfo = gatherer.formatDebugInfo("test error");
+
+            expect(debugInfo).toContain("IFrame Status:");
+        });
+
+        it("should handle iframe with incomplete readyState", () => {
+            const iframeIncomplete = document.createElement("iframe");
+            Object.defineProperty(iframeIncomplete, "contentDocument", {
+                value: {
+                    readyState: "loading",
+                },
+                writable: true,
+            });
+            Object.defineProperty(iframeIncomplete, "contentWindow", {
+                value: {},
+                writable: true,
+            });
+
+            const gatherer = new DebugInfoGatherer(
+                mockConfig,
+                iframeIncomplete
+            );
+
+            const debugInfo = gatherer.formatDebugInfo("test error");
+
+            expect(debugInfo).toContain("IFrame Status:");
+        });
+
+        it("should include last request when set", () => {
+            const gatherer = new DebugInfoGatherer(mockConfig, mockIframe);
+            const mockMessage = {
+                id: 1,
+                method: "test_method",
+                params: [],
+            } as any;
+
+            gatherer.setLastRequest(mockMessage);
+            const debugInfo = gatherer.formatDebugInfo("test error");
+
+            expect(debugInfo).toContain("Last Request:");
+            expect(debugInfo).not.toContain("No Frak request logged");
+        });
+
+        it("should include last response when set", () => {
+            const gatherer = new DebugInfoGatherer(mockConfig, mockIframe);
+            const mockMessage = {
+                id: 1,
+                method: "test_method",
+            } as any;
+            const mockResponse = {
+                id: 1,
+                result: "success",
+            } as any;
+
+            gatherer.setLastResponse(mockMessage, mockResponse);
+            const debugInfo = gatherer.formatDebugInfo("test error");
+
+            expect(debugInfo).toContain("Last Response:");
+            expect(debugInfo).not.toContain("No Frak response logged");
+        });
+
+        it("should show 'No Frak request logged' when no request is set", () => {
+            const gatherer = new DebugInfoGatherer(mockConfig, mockIframe);
+
+            const debugInfo = gatherer.formatDebugInfo("test error");
+
+            expect(debugInfo).toContain("No Frak request logged");
+        });
+
+        it("should show 'No Frak response logged' when no response is set", () => {
+            const gatherer = new DebugInfoGatherer(mockConfig, mockIframe);
+
+            const debugInfo = gatherer.formatDebugInfo("test error");
+
+            expect(debugInfo).toContain("No Frak response logged");
+        });
+    });
+
+    describe("base64 encoding error handling", () => {
+        it("should handle encoding errors gracefully", () => {
+            const gatherer = new DebugInfoGatherer(mockConfig, mockIframe);
+
+            // Create a circular reference that can't be JSON stringified
+            const circularObj: any = { prop: "value" };
+            circularObj.self = circularObj;
+
+            // Mock base64Encode to throw an error
+            // We can't directly test the private method, but we can test
+            // that formatDebugInfo doesn't throw when encoding fails
+            // by checking that it still produces output
+
+            const debugInfo = gatherer.formatDebugInfo("test error");
+
+            // Should still produce debug info even if encoding fails
+            expect(debugInfo).toContain("Debug Information:");
+        });
+    });
+
+    describe("integration", () => {
+        it("should format complete debug info with all data set", () => {
+            const gatherer = new DebugInfoGatherer(mockConfig, mockIframe);
+            const mockRequest = {
+                id: 1,
+                method: "frak_sendInteraction",
+                params: [],
+            } as any;
+            const mockResponse = {
+                id: 1,
+                result: { delegationId: "123" },
+            } as any;
+            const error = new FrakRpcError(
+                RpcErrorCodes.serverError,
+                "Server error"
+            );
+
+            gatherer.setLastRequest(mockRequest);
+            gatherer.setLastResponse(mockRequest, mockResponse);
+            gatherer.updateSetupStatus(true);
+
+            const debugInfo = gatherer.formatDebugInfo(error);
+
+            expect(debugInfo).toContain("Debug Information:");
+            expect(debugInfo).toContain("Client Status: setup");
+            expect(debugInfo).toContain(
+                `FrakRpcError: ${RpcErrorCodes.serverError} 'Server error'`
+            );
+            expect(debugInfo).not.toContain("No Frak request logged");
+            expect(debugInfo).not.toContain("No Frak response logged");
+        });
+    });
+});

package/src/constants/interactionTypes.test.ts

@@ -0,0 +1,128 @@
+/**
+ * Tests for interactionTypes constants
+ * Tests interaction type definitions and type utilities
+ */
+
+import { describe, expect, it } from "vitest";
+import { interactionTypes } from "./interactionTypes";
+
+describe("interactionTypes", () => {
+    describe("structure", () => {
+        it("should have all expected categories", () => {
+            expect(interactionTypes).toHaveProperty("press");
+            expect(interactionTypes).toHaveProperty("dapp");
+            expect(interactionTypes).toHaveProperty("webshop");
+            expect(interactionTypes).toHaveProperty("referral");
+            expect(interactionTypes).toHaveProperty("purchase");
+            expect(interactionTypes).toHaveProperty("retail");
+        });
+
+        it("should have press interactions", () => {
+            expect(interactionTypes.press).toEqual({
+                openArticle: "0xc0a24ffb",
+                readArticle: "0xd5bd0fbe",
+            });
+        });
+
+        it("should have dapp interactions", () => {
+            expect(interactionTypes.dapp).toEqual({
+                proofVerifiableStorageUpdate: "0x2ab2aeef",
+                callableVerifiableStorageUpdate: "0xa07da986",
+            });
+        });
+
+        it("should have webshop interactions", () => {
+            expect(interactionTypes.webshop).toEqual({
+                open: "0xb311798f",
+            });
+        });
+
+        it("should have referral interactions", () => {
+            expect(interactionTypes.referral).toEqual({
+                referred: "0x010cc3b9",
+                createLink: "0xb2c0f17c",
+            });
+        });
+
+        it("should have purchase interactions", () => {
+            expect(interactionTypes.purchase).toEqual({
+                started: "0xd87e90c3",
+                completed: "0x8403aeb4",
+                unsafeCompleted: "0x4d5b14e0",
+            });
+        });
+
+        it("should have retail interactions", () => {
+            expect(interactionTypes.retail).toEqual({
+                customerMeeting: "0x74489004",
+            });
+        });
+    });
+
+    describe("interaction values", () => {
+        it("should have all interaction values as hex strings", () => {
+            Object.values(interactionTypes).forEach((category) => {
+                Object.values(category).forEach((value) => {
+                    expect(value).toMatch(/^0x[a-f0-9]{8}$/);
+                });
+            });
+        });
+
+        it("should have unique interaction values across all categories", () => {
+            const allValues = Object.values(interactionTypes).flatMap(
+                (category) => Object.values(category)
+            );
+            const uniqueValues = new Set(allValues);
+            expect(allValues.length).toBe(uniqueValues.size);
+        });
+    });
+
+    describe("specific interactions", () => {
+        it("should have correct press.openArticle value", () => {
+            expect(interactionTypes.press.openArticle).toBe("0xc0a24ffb");
+        });
+
+        it("should have correct press.readArticle value", () => {
+            expect(interactionTypes.press.readArticle).toBe("0xd5bd0fbe");
+        });
+
+        it("should have correct webshop.open value", () => {
+            expect(interactionTypes.webshop.open).toBe("0xb311798f");
+        });
+
+        it("should have correct referral.referred value", () => {
+            expect(interactionTypes.referral.referred).toBe("0x010cc3b9");
+        });
+
+        it("should have correct purchase.completed value", () => {
+            expect(interactionTypes.purchase.completed).toBe("0x8403aeb4");
+        });
+
+        it("should have correct purchase.unsafeCompleted value", () => {
+            expect(interactionTypes.purchase.unsafeCompleted).toBe(
+                "0x4d5b14e0"
+            );
+        });
+
+        it("should have correct retail.customerMeeting value", () => {
+            expect(interactionTypes.retail.customerMeeting).toBe("0x74489004");
+        });
+    });
+
+    describe("type safety", () => {
+        it("should be readonly (as const)", () => {
+            // TypeScript ensures this is readonly, but we can verify structure
+            expect(Object.isFrozen(interactionTypes)).toBe(false);
+            // The values should be consistent
+            expect(typeof interactionTypes.press.openArticle).toBe("string");
+        });
+
+        it("should have consistent structure across categories", () => {
+            Object.values(interactionTypes).forEach((category) => {
+                expect(typeof category).toBe("object");
+                expect(category).not.toBeNull();
+                expect(Array.isArray(category)).toBe(false);
+            });
+        });
+    });
+});

package/src/constants/productTypes.test.ts

@@ -0,0 +1,130 @@
+/**
+ * Tests for productTypes constants
+ * Tests product type definitions and bitmask calculations
+ */
+
+import { describe, expect, it } from "vitest";
+import { productTypes, productTypesMask } from "./productTypes";
+
+describe("productTypes", () => {
+    describe("structure", () => {
+        it("should have all expected product types", () => {
+            expect(productTypes).toHaveProperty("dapp");
+            expect(productTypes).toHaveProperty("press");
+            expect(productTypes).toHaveProperty("webshop");
+            expect(productTypes).toHaveProperty("retail");
+            expect(productTypes).toHaveProperty("referral");
+            expect(productTypes).toHaveProperty("purchase");
+        });
+
+        it("should have correct numeric values", () => {
+            expect(productTypes.dapp).toBe(1);
+            expect(productTypes.press).toBe(2);
+            expect(productTypes.webshop).toBe(3);
+            expect(productTypes.retail).toBe(4);
+            expect(productTypes.referral).toBe(30);
+            expect(productTypes.purchase).toBe(31);
+        });
+    });
+
+    describe("productTypesMask", () => {
+        it("should have masks for all product types", () => {
+            expect(productTypesMask).toHaveProperty("dapp");
+            expect(productTypesMask).toHaveProperty("press");
+            expect(productTypesMask).toHaveProperty("webshop");
+            expect(productTypesMask).toHaveProperty("retail");
+            expect(productTypesMask).toHaveProperty("referral");
+            expect(productTypesMask).toHaveProperty("purchase");
+        });
+
+        it("should calculate correct bitmask for dapp (value 1)", () => {
+            expect(productTypesMask.dapp).toBe(BigInt(1) << BigInt(1));
+            expect(productTypesMask.dapp).toBe(BigInt(2));
+        });
+
+        it("should calculate correct bitmask for press (value 2)", () => {
+            expect(productTypesMask.press).toBe(BigInt(1) << BigInt(2));
+            expect(productTypesMask.press).toBe(BigInt(4));
+        });
+
+        it("should calculate correct bitmask for webshop (value 3)", () => {
+            expect(productTypesMask.webshop).toBe(BigInt(1) << BigInt(3));
+            expect(productTypesMask.webshop).toBe(BigInt(8));
+        });
+
+        it("should calculate correct bitmask for retail (value 4)", () => {
+            expect(productTypesMask.retail).toBe(BigInt(1) << BigInt(4));
+            expect(productTypesMask.retail).toBe(BigInt(16));
+        });
+
+        it("should calculate correct bitmask for referral (value 30)", () => {
+            expect(productTypesMask.referral).toBe(BigInt(1) << BigInt(30));
+            expect(productTypesMask.referral).toBe(BigInt(1073741824));
+        });
+
+        it("should calculate correct bitmask for purchase (value 31)", () => {
+            expect(productTypesMask.purchase).toBe(BigInt(1) << BigInt(31));
+            expect(productTypesMask.purchase).toBe(BigInt(2147483648));
+        });
+
+        it("should have all masks as BigInt values", () => {
+            Object.values(productTypesMask).forEach((mask) => {
+                expect(typeof mask).toBe("bigint");
+            });
+        });
+
+        it("should have unique mask values", () => {
+            const maskValues = Object.values(productTypesMask);
+            const uniqueValues = new Set(maskValues);
+            expect(maskValues.length).toBe(uniqueValues.size);
+        });
+    });
+
+    describe("bitmask calculation", () => {
+        it("should correctly calculate bitmask from product type value", () => {
+            // Verify the formula: 1 << value
+            expect(productTypesMask.dapp).toBe(
+                BigInt(1) << BigInt(productTypes.dapp)
+            );
+            expect(productTypesMask.press).toBe(
+                BigInt(1) << BigInt(productTypes.press)
+            );
+            expect(productTypesMask.webshop).toBe(
+                BigInt(1) << BigInt(productTypes.webshop)
+            );
+            expect(productTypesMask.retail).toBe(
+                BigInt(1) << BigInt(productTypes.retail)
+            );
+            expect(productTypesMask.referral).toBe(
+                BigInt(1) << BigInt(productTypes.referral)
+            );
+            expect(productTypesMask.purchase).toBe(
+                BigInt(1) << BigInt(productTypes.purchase)
+            );
+        });
+
+        it("should have masks that are powers of 2", () => {
+            Object.values(productTypesMask).forEach((mask) => {
+                // A power of 2 has exactly one bit set
+                // Check: mask & (mask - 1n) should be 0n
+                const isPowerOfTwo = mask > 0n && (mask & (mask - 1n)) === 0n;
+                expect(isPowerOfTwo).toBe(true);
+            });
+        });
+    });
+
+    describe("type safety", () => {
+        it("should have consistent structure", () => {
+            const productKeys = Object.keys(productTypes);
+            const maskKeys = Object.keys(productTypesMask);
+            expect(productKeys.sort()).toEqual(maskKeys.sort());
+        });
+
+        it("should have numeric values for product types", () => {
+            Object.values(productTypes).forEach((value) => {
+                expect(typeof value).toBe("number");
+                expect(Number.isInteger(value)).toBe(true);
+            });
+        });
+    });
+});