@capillarytech/creatives-library 8.0.125-alpha.6 → 8.0.126

package/v2Containers/MobilePushNew/tests/utils.test.js

@@ -1,322 +0,0 @@
-import {
-  validateLink,
-  validateExternalLink,
-  validateDeepLink,
-} from "../utils";
-import { isUrl } from "../../Line/Container/Wrapper/utils";
-
-// Mock the isUrl utility function
-jest.mock("../../Line/Container/Wrapper/utils", () => ({
-  isUrl: jest.fn(),
-}));
-
-describe("utils.js", () => {
-  const mockFormatMessage = jest.fn();
-  const mockMessages = {
-    invalidUrl: {
-      id: "invalidUrl",
-      defaultMessage: "Invalid URL format",
-    },
-  };
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    mockFormatMessage.mockImplementation((msg) => msg.defaultMessage);
-  });
-
-  describe("validateLink", () => {
-    describe("Valid scenarios", () => {
-      it("should return null for valid URL", () => {
-        isUrl.mockReturnValue(true);
-
-        const result = validateLink("https://example.com", mockFormatMessage, mockMessages);
-
-        expect(result).toBeNull();
-        expect(isUrl).toHaveBeenCalledWith("https://example.com");
-        expect(mockFormatMessage).not.toHaveBeenCalled();
-      });
-
-      it("should return null for valid URL with whitespace", () => {
-        isUrl.mockReturnValue(true);
-
-        const result = validateLink("  https://example.com  ", mockFormatMessage, mockMessages);
-
-        expect(result).toBeNull();
-        expect(isUrl).toHaveBeenCalledWith("https://example.com");
-        expect(mockFormatMessage).not.toHaveBeenCalled();
-      });
-
-      it("should return null for empty URL", () => {
-        const result = validateLink("", mockFormatMessage, mockMessages);
-
-        expect(result).toBeNull();
-        expect(isUrl).not.toHaveBeenCalled();
-        expect(mockFormatMessage).not.toHaveBeenCalled();
-      });
-
-      it("should return null for null URL", () => {
-        const result = validateLink(null, mockFormatMessage, mockMessages);
-
-        expect(result).toBeNull();
-        expect(isUrl).not.toHaveBeenCalled();
-        expect(mockFormatMessage).not.toHaveBeenCalled();
-      });
-
-      it("should return null for undefined URL", () => {
-        const result = validateLink(undefined, mockFormatMessage, mockMessages);
-
-        expect(result).toBeNull();
-        expect(isUrl).not.toHaveBeenCalled();
-        expect(mockFormatMessage).not.toHaveBeenCalled();
-      });
-
-      it("should return null for whitespace-only URL", () => {
-        const result = validateLink("   ", mockFormatMessage, mockMessages);
-
-        expect(result).toBeNull();
-        expect(isUrl).not.toHaveBeenCalled();
-        expect(mockFormatMessage).not.toHaveBeenCalled();
-      });
-
-      it("should return null for tab and newline whitespace", () => {
-        const result = validateLink("\t\n\r", mockFormatMessage, mockMessages);
-
-        expect(result).toBeNull();
-        expect(isUrl).not.toHaveBeenCalled();
-        expect(mockFormatMessage).not.toHaveBeenCalled();
-      });
-    });
-
-    describe("Invalid scenarios", () => {
-      it("should return error message for invalid URL", () => {
-        isUrl.mockReturnValue(false);
-
-        const result = validateLink("invalid-url", mockFormatMessage, mockMessages);
-
-        expect(result).toBe("Invalid URL format");
-        expect(isUrl).toHaveBeenCalledWith("invalid-url");
-        expect(mockFormatMessage).toHaveBeenCalledWith(mockMessages.invalidUrl);
-      });
-
-      it("should return error message for invalid URL with whitespace", () => {
-        isUrl.mockReturnValue(false);
-
-        const result = validateLink("  invalid-url  ", mockFormatMessage, mockMessages);
-
-        expect(result).toBe("Invalid URL format");
-        expect(isUrl).toHaveBeenCalledWith("invalid-url");
-        expect(mockFormatMessage).toHaveBeenCalledWith(mockMessages.invalidUrl);
-      });
-
-      it("should return error message for malformed URL", () => {
-        isUrl.mockReturnValue(false);
-
-        const result = validateLink("htp://malformed", mockFormatMessage, mockMessages);
-
-        expect(result).toBe("Invalid URL format");
-        expect(isUrl).toHaveBeenCalledWith("htp://malformed");
-        expect(mockFormatMessage).toHaveBeenCalledWith(mockMessages.invalidUrl);
-      });
-
-      it("should return error message for URL without protocol", () => {
-        isUrl.mockReturnValue(false);
-
-        const result = validateLink("example.com", mockFormatMessage, mockMessages);
-
-        expect(result).toBe("Invalid URL format");
-        expect(isUrl).toHaveBeenCalledWith("example.com");
-        expect(mockFormatMessage).toHaveBeenCalledWith(mockMessages.invalidUrl);
-      });
-
-      it("should handle special characters in invalid URL", () => {
-        isUrl.mockReturnValue(false);
-
-        const result = validateLink("http://ex@mple.com", mockFormatMessage, mockMessages);
-
-        expect(result).toBe("Invalid URL format");
-        expect(isUrl).toHaveBeenCalledWith("http://ex@mple.com");
-        expect(mockFormatMessage).toHaveBeenCalledWith(mockMessages.invalidUrl);
-      });
-    });
-
-    describe("Edge cases", () => {
-      it("should handle custom formatMessage function", () => {
-        const customFormatMessage = jest.fn().mockReturnValue("Custom error message");
-        isUrl.mockReturnValue(false);
-
-        const result = validateLink("invalid", customFormatMessage, mockMessages);
-
-        expect(result).toBe("Custom error message");
-        expect(customFormatMessage).toHaveBeenCalledWith(mockMessages.invalidUrl);
-      });
-
-      it("should handle different message object structure", () => {
-        const customMessages = {
-          invalidUrl: {
-            id: "custom.invalidUrl",
-            defaultMessage: "Custom invalid URL message",
-          },
-        };
-        isUrl.mockReturnValue(false);
-
-        const result = validateLink("invalid", mockFormatMessage, customMessages);
-
-        expect(result).toBe("Custom invalid URL message");
-        expect(mockFormatMessage).toHaveBeenCalledWith(customMessages.invalidUrl);
-      });
-
-      it("should trim very long whitespace strings", () => {
-        const longWhitespace = " ".repeat(100);
-
-        const result = validateLink(longWhitespace, mockFormatMessage, mockMessages);
-
-        expect(result).toBeNull();
-        expect(isUrl).not.toHaveBeenCalled();
-      });
-    });
-  });
-
-  describe("validateExternalLink", () => {
-    it("should call validateLink with correct parameters for valid URL", () => {
-      isUrl.mockReturnValue(true);
-
-      const result = validateExternalLink("https://external.com", mockFormatMessage, mockMessages);
-
-      expect(result).toBeNull();
-      expect(isUrl).toHaveBeenCalledWith("https://external.com");
-    });
-
-    it("should call validateLink with correct parameters for invalid URL", () => {
-      isUrl.mockReturnValue(false);
-
-      const result = validateExternalLink("invalid-external", mockFormatMessage, mockMessages);
-
-      expect(result).toBe("Invalid URL format");
-      expect(isUrl).toHaveBeenCalledWith("invalid-external");
-      expect(mockFormatMessage).toHaveBeenCalledWith(mockMessages.invalidUrl);
-    });
-
-    it("should handle empty external link", () => {
-      const result = validateExternalLink("", mockFormatMessage, mockMessages);
-
-      expect(result).toBeNull();
-      expect(isUrl).not.toHaveBeenCalled();
-    });
-
-    it("should handle null external link", () => {
-      const result = validateExternalLink(null, mockFormatMessage, mockMessages);
-
-      expect(result).toBeNull();
-      expect(isUrl).not.toHaveBeenCalled();
-    });
-
-    it("should trim whitespace in external link", () => {
-      isUrl.mockReturnValue(true);
-
-      const result = validateExternalLink("  https://external.com  ", mockFormatMessage, mockMessages);
-
-      expect(result).toBeNull();
-      expect(isUrl).toHaveBeenCalledWith("https://external.com");
-    });
-  });
-
-  describe("validateDeepLink", () => {
-    it("should call validateLink with correct parameters for valid deep link", () => {
-      isUrl.mockReturnValue(true);
-
-      const result = validateDeepLink("myapp://deeplink", mockFormatMessage, mockMessages);
-
-      expect(result).toBeNull();
-      expect(isUrl).toHaveBeenCalledWith("myapp://deeplink");
-    });
-
-    it("should call validateLink with correct parameters for invalid deep link", () => {
-      isUrl.mockReturnValue(false);
-
-      const result = validateDeepLink("invalid-deeplink", mockFormatMessage, mockMessages);
-
-      expect(result).toBe("Invalid URL format");
-      expect(isUrl).toHaveBeenCalledWith("invalid-deeplink");
-      expect(mockFormatMessage).toHaveBeenCalledWith(mockMessages.invalidUrl);
-    });
-
-    it("should handle empty deep link", () => {
-      const result = validateDeepLink("", mockFormatMessage, mockMessages);
-
-      expect(result).toBeNull();
-      expect(isUrl).not.toHaveBeenCalled();
-    });
-
-    it("should handle undefined deep link", () => {
-      const result = validateDeepLink(undefined, mockFormatMessage, mockMessages);
-
-      expect(result).toBeNull();
-      expect(isUrl).not.toHaveBeenCalled();
-    });
-
-    it("should trim whitespace in deep link", () => {
-      isUrl.mockReturnValue(true);
-
-      const result = validateDeepLink("  myapp://deeplink  ", mockFormatMessage, mockMessages);
-
-      expect(result).toBeNull();
-      expect(isUrl).toHaveBeenCalledWith("myapp://deeplink");
-    });
-
-    it("should handle custom scheme deep links", () => {
-      isUrl.mockReturnValue(true);
-
-      const result = validateDeepLink("customscheme://action/path", mockFormatMessage, mockMessages);
-
-      expect(result).toBeNull();
-      expect(isUrl).toHaveBeenCalledWith("customscheme://action/path");
-    });
-  });
-
-  describe("Function independence", () => {
-    it("should ensure validateExternalLink and validateDeepLink are independent", () => {
-      isUrl.mockReturnValue(true);
-
-      validateExternalLink("https://external.com", mockFormatMessage, mockMessages);
-      validateDeepLink("myapp://deeplink", mockFormatMessage, mockMessages);
-
-      expect(isUrl).toHaveBeenCalledTimes(2);
-      expect(isUrl).toHaveBeenNthCalledWith(1, "https://external.com");
-      expect(isUrl).toHaveBeenNthCalledWith(2, "myapp://deeplink");
-    });
-
-    it("should handle mixed valid and invalid calls", () => {
-      isUrl.mockReturnValueOnce(true).mockReturnValueOnce(false);
-
-      const result1 = validateExternalLink("https://valid.com", mockFormatMessage, mockMessages);
-      const result2 = validateDeepLink("invalid", mockFormatMessage, mockMessages);
-
-      expect(result1).toBeNull();
-      expect(result2).toBe("Invalid URL format");
-      expect(mockFormatMessage).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe("Error handling", () => {
-    it("should handle isUrl throwing an error", () => {
-      isUrl.mockImplementation(() => {
-        throw new Error("isUrl error");
-      });
-
-      expect(() => {
-        validateLink("https://example.com", mockFormatMessage, mockMessages);
-      }).toThrow("isUrl error");
-    });
-
-    it("should handle formatMessage throwing an error", () => {
-      isUrl.mockReturnValue(false);
-      mockFormatMessage.mockImplementation(() => {
-        throw new Error("formatMessage error");
-      });
-
-      expect(() => {
-        validateLink("invalid", mockFormatMessage, mockMessages);
-      }).toThrow("formatMessage error");
-    });
-  });
-});

package/v2Containers/MobilePushNew/utils.js

@@ -1,33 +0,0 @@
-import { isUrl } from "../Line/Container/Wrapper/utils";
-
-/**
- * Common link validation function using isUrl utility
- * @param {string} url - The URL to validate
- * @param {Function} formatMessage - Function to format error messages
- * @param {Object} messages - Messages object containing invalidUrl message
- * @returns {string|null} - Error message if invalid, null if valid
- */
-export const validateLink = (url, formatMessage, messages) => {
-  if (!url || url.trim() === "") {
-    return null; // Empty URL is valid (optional field)
-  }
-  return isUrl(url.trim()) ? null : formatMessage(messages.invalidUrl);
-};
-
-/**
- * Validate external link specifically
- * @param {string} url - The external URL to validate
- * @param {Function} formatMessage - Function to format error messages
- * @param {Object} messages - Messages object containing invalidUrl message
- * @returns {string|null} - Error message if invalid, null if valid
- */
-export const validateExternalLink = (url, formatMessage, messages) => validateLink(url, formatMessage, messages);
-
-/**
- * Validate deep link specifically
- * @param {string} linkValue - The deep link to validate
- * @param {Function} formatMessage - Function to format error messages
- * @param {Object} messages - Messages object containing invalidUrl message
- * @returns {string|null} - Error message if invalid, null if valid
- */
-export const validateDeepLink = (linkValue, formatMessage, messages) => validateLink(linkValue, formatMessage, messages);