@applicaster/zapp-react-native-utils 15.0.0-rc.94 → 15.0.0-rc.96

package/appDataUtils/__tests__/urlScheme.test.ts

@@ -0,0 +1,678 @@
+import { getAppUrlScheme } from "../urlScheme";
+
+// Mock dependencies
+jest.mock("@applicaster/zapp-react-native-redux/AppStore", () => ({
+  appStore: {
+    get: jest.fn(),
+  },
+}));
+
+jest.mock("../../reactUtils", () => ({
+  isWeb: jest.fn(),
+}));
+
+jest.mock("../../stringUtils", () => ({
+  isString: jest.fn((value) => typeof value === "string"),
+}));
+
+import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
+import { isWeb } from "../../reactUtils";
+import { isString } from "../../stringUtils";
+
+describe("appDataUtils - urlScheme", () => {
+  const mockAppStoreGet = appStore.get as jest.MockedFunction<
+    typeof appStore.get
+  >;
+
+  const mockIsWeb = isWeb as jest.MockedFunction<typeof isWeb>;
+  const mockIsString = isString as jest.MockedFunction<typeof isString>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Default mocks
+    mockIsWeb.mockReturnValue(false);
+    mockIsString.mockImplementation((value) => typeof value === "string");
+  });
+
+  describe("getAppUrlScheme", () => {
+    describe("web platform", () => {
+      it("should return 'self' when running on web", () => {
+        mockIsWeb.mockReturnValue(true);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "myapp",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("self");
+        expect(mockAppStoreGet).toHaveBeenCalledWith("appData");
+      });
+
+      it("should return 'self' on web even when urlScheme is missing", () => {
+        mockIsWeb.mockReturnValue(true);
+        mockAppStoreGet.mockReturnValue({});
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("self");
+      });
+
+      it("should return 'self' on web even when appData is null", () => {
+        mockIsWeb.mockReturnValue(true);
+        mockAppStoreGet.mockReturnValue(null);
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("self");
+      });
+    });
+
+    describe("native platform - basic functionality", () => {
+      it("should return first URL scheme from urlScheme string", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "myapp",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("myapp");
+      });
+
+      it("should return first scheme from comma-separated list", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "myapp,secondapp,thirdapp",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("myapp");
+      });
+
+      it("should handle URL scheme with spaces after comma", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "myapp, secondapp, thirdapp",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("myapp");
+      });
+
+      it("should return undefined when urlScheme is missing", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          appName: "My App",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBeUndefined();
+      });
+
+      it("should return undefined when urlScheme is null", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: null,
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBeUndefined();
+      });
+
+      it("should return undefined when urlScheme is undefined", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: undefined,
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBeUndefined();
+      });
+    });
+
+    describe("native platform - string cleaning", () => {
+      it("should remove square brackets from urlScheme", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "[myapp]",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("myapp");
+      });
+
+      it("should remove single quotes from urlScheme", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "'myapp'",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("myapp");
+      });
+
+      it("should remove brackets and quotes from urlScheme", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "['myapp']",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("myapp");
+      });
+
+      it("should remove multiple brackets and quotes", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "[['myapp']]",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("myapp");
+      });
+
+      it("should clean comma-separated list with brackets", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "['myapp','secondapp']",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("myapp");
+      });
+
+      it("should return null when cleaned string is empty", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "[]",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBeNull();
+      });
+
+      it("should return null when urlScheme contains only quotes and brackets", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "['']",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBeNull();
+      });
+
+      it("should preserve hyphens in URL scheme", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "my-app-scheme",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("my-app-scheme");
+      });
+
+      it("should preserve dots in URL scheme", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "com.example.app",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("com.example.app");
+      });
+
+      it("should preserve colons in URL scheme", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "myapp://",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("myapp://");
+      });
+    });
+
+    describe("native platform - type validation", () => {
+      it("should return null when urlScheme is not a string (number)", () => {
+        mockIsWeb.mockReturnValue(false);
+        mockIsString.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: 12345,
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBeNull();
+      });
+
+      it("should return null when urlScheme is not a string (boolean)", () => {
+        mockIsWeb.mockReturnValue(false);
+        mockIsString.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: true,
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBeNull();
+      });
+
+      it("should return null when urlScheme is not a string (object)", () => {
+        mockIsWeb.mockReturnValue(false);
+        mockIsString.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: { scheme: "myapp" },
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBeNull();
+      });
+
+      it("should return null when urlScheme is not a string (array)", () => {
+        mockIsWeb.mockReturnValue(false);
+        mockIsString.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: ["myapp", "secondapp"],
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBeNull();
+      });
+    });
+
+    describe("native platform - empty string handling", () => {
+      it("should return undefined when urlScheme is empty string", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "",
+        });
+
+        const result = getAppUrlScheme();
+
+        // Empty string is falsy, function returns undefined (no return statement)
+        expect(result).toBeUndefined();
+      });
+
+      it("should return whitespace when urlScheme is only whitespace", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "   ",
+        });
+
+        const result = getAppUrlScheme();
+
+        // Whitespace is preserved by getCleanString, then split by comma
+        // urlSchemes[0] returns "   " which is truthy, so || null doesn't trigger
+        expect(result).toBe("   ");
+      });
+
+      it("should handle empty string after cleaning", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "''",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBeNull();
+      });
+    });
+
+    describe("native platform - comma-separated schemes", () => {
+      it("should return first scheme when multiple schemes present", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "scheme1,scheme2,scheme3",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("scheme1");
+      });
+
+      it("should handle two schemes", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "primary,fallback",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("primary");
+      });
+
+      it("should return null when first scheme is empty", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: ",secondapp",
+        });
+
+        const result = getAppUrlScheme();
+
+        // Empty string is falsy, so || null returns null
+        expect(result).toBeNull();
+      });
+
+      it("should handle scheme with trailing comma", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "myapp,",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("myapp");
+      });
+
+      it("should handle complex comma-separated list with brackets", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "['app1','app2','app3']",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("app1");
+      });
+    });
+
+    describe("native platform - appStore edge cases", () => {
+      it("should handle when appStore.get returns null", () => {
+        mockIsWeb.mockReturnValue(false);
+        mockAppStoreGet.mockReturnValue(null);
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBeUndefined();
+      });
+
+      it("should handle when appStore.get returns undefined", () => {
+        mockIsWeb.mockReturnValue(false);
+        mockAppStoreGet.mockReturnValue(undefined);
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBeUndefined();
+      });
+
+      it("should handle when appData is empty object", () => {
+        mockIsWeb.mockReturnValue(false);
+        mockAppStoreGet.mockReturnValue({});
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBeUndefined();
+      });
+
+      it("should only access urlScheme property from appData", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "myapp",
+          appName: "My Application",
+          version: "1.0.0",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("myapp");
+        expect(mockAppStoreGet).toHaveBeenCalledWith("appData");
+        expect(mockAppStoreGet).toHaveBeenCalledTimes(1);
+      });
+    });
+
+    describe("native platform - special characters", () => {
+      it("should handle URL scheme with numbers", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "myapp123",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("myapp123");
+      });
+
+      it("should handle URL scheme with uppercase letters", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "MyApp",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("MyApp");
+      });
+
+      it("should handle URL scheme with underscores", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "my_app_scheme",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("my_app_scheme");
+      });
+
+      it("should handle complex URL scheme format", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "com.example.myapp://deep/link",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("com.example.myapp://deep/link");
+      });
+
+      it("should preserve plus signs in URL scheme", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "myapp+custom",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("myapp+custom");
+      });
+    });
+
+    describe("native platform - integration scenarios", () => {
+      it("should handle real-world iOS URL scheme", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "['myiosapp']",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("myiosapp");
+      });
+
+      it("should handle real-world Android URL scheme", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "myandroidapp",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("myandroidapp");
+      });
+
+      it("should handle multi-platform URL scheme configuration", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "['myapp', 'myapp-dev', 'myapp-staging']",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("myapp");
+      });
+
+      it("should handle URL scheme with protocol separator", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "myapp://",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("myapp://");
+      });
+    });
+
+    describe("native platform - null/undefined return values", () => {
+      it("should return null when only brackets remain after cleaning", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "[[]]",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBeNull();
+      });
+
+      it("should return null when cleaned result is zero-length", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "''",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBeNull();
+      });
+
+      it("should return null for array-like string with no content", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "['', '']",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBeNull();
+      });
+    });
+
+    describe("isWeb dependency", () => {
+      it("should call isWeb to check platform", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "myapp",
+        });
+
+        getAppUrlScheme();
+
+        expect(mockIsWeb).toHaveBeenCalledTimes(1);
+        expect(mockIsWeb).toHaveBeenCalledWith();
+      });
+
+      it("should prioritize web check before appStore access", () => {
+        mockIsWeb.mockReturnValue(true);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "myapp",
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBe("self");
+        expect(mockIsWeb).toHaveBeenCalled();
+        expect(mockAppStoreGet).toHaveBeenCalled();
+      });
+    });
+
+    describe("isString dependency", () => {
+      it("should call isString to validate urlScheme type", () => {
+        mockIsWeb.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: "myapp",
+        });
+
+        getAppUrlScheme();
+
+        expect(mockIsString).toHaveBeenCalledWith("myapp");
+      });
+
+      it("should handle isString returning false", () => {
+        mockIsWeb.mockReturnValue(false);
+        mockIsString.mockReturnValue(false);
+
+        mockAppStoreGet.mockReturnValue({
+          urlScheme: 123,
+        });
+
+        const result = getAppUrlScheme();
+
+        expect(result).toBeNull();
+        expect(mockIsString).toHaveBeenCalledWith(123);
+      });
+    });
+  });
+});