@capillarytech/creatives-library 8.0.113 → 8.0.114-alpha.1

package/utils/tests/commonUtil.test.js

@@ -1,222 +1,525 @@
-import "@testing-library/jest-dom";
-import get from 'lodash/get';
-import { getTreeStructuredTags } from "../common";
-import * as mockdata from "./common.mockdata";
-import { addBaseToTemplate, isEmbeddedEditOrPreview, transformCustomFieldsData } from "../commonUtils";
-import { EMBEDDED, FULL } from "../../v2Containers/Whatsapp/constants";
-import { CREATE, EDIT, PREVIEW } from "../../v2Containers/App/constants";
-
-jest.mock('@capillarytech/cap-ui-utils', () => ({
-  Auth: {
-    hasAccess: () => jest.fn(() => true),
-    hasFeatureAccess: () => jest.fn(() => true),
-    authHoc: jest.fn(),
-    initialize: jest.fn(),
-  },
-}));
-
-jest.mock('lodash/get');
-
-describe("common utils test", () => {
-  it("test for getTreeStructuredTags when tagsList is not empty", () => {
-    expect(getTreeStructuredTags({tagsList: mockdata.tagsList})).toEqual(mockdata.output2);
-  });
-  it("test for getTreeStructuredTags when tagsList is empty", () => {
-    expect(getTreeStructuredTags({tagsList: []})).toEqual([]);
-  });
-});
+import {
+  validateLiquidTemplateContent,
+  validateMobilePushContent,
+  validateInAppContent,
+  getChannelData
+} from "../commonUtils";
 
-describe('addBaseToTemplate', () => {
-  it('should add the first item in history as base if history exists', () => {
-    const template = {
-      versions: {
-        history: ['v1', 'v2', 'v3'],
-      },
-    };
-    const expected = {
-      versions: {
-        history: ['v1', 'v2', 'v3'],
-        base: {
-          0: "v", 1: "1", subject: undefined,
-        },
-      },
-    };
-    expect(addBaseToTemplate(template)).toEqual(expected);
-  });
+describe("validateLiquidTemplateContent", () => {
+  const formatMessage = jest.fn((msg, vars) =>
+    vars ? `${msg.id}:${vars.unsupportedTags}` : msg.id
+  );
+  const messages = {
+    emailBodyEmptyError: { id: "empty" },
+    somethingWentWrong: { id: "wrong" },
+    unsupportedTagsValidationError: { id: "unsupported" }
+  };
+  const tagLookupMap = { foo: true };
+  const eventContextTags = [{ tagName: "bar" }];
+  const onError = jest.fn();
+  const onSuccess = jest.fn();
 
-  it('should return the original template if history is empty', () => {
-    const template = {
-      versions: {
-        history: [],
-      },
-    };
-    expect(addBaseToTemplate(template)).toEqual(template);
+  beforeEach(() => {
+    jest.clearAllMocks();
   });
 
-  it('should return the original template if history is undefined', () => {
-    const template = {
-      versions: {},
-    };
-    expect(addBaseToTemplate(template)).toEqual(template);
+  it("calls onError for empty content", async () => {
+    const getLiquidTags = jest.fn((content, cb) =>
+      cb({ errors: [], data: [] })
+    );
+    await validateLiquidTemplateContent("", {
+      getLiquidTags,
+      formatMessage,
+      messages,
+      onError,
+      onSuccess,
+      tagLookupMap,
+      eventContextTags
+    });
+    expect(onError).toHaveBeenCalledWith({
+      standardErrors: [undefined],
+      liquidErrors: [],
+      tabType: undefined
+    });
+    expect(onSuccess).not.toHaveBeenCalled();
   });
 
-  it('should return the original template if versions is undefined', () => {
-    const template = {};
-    expect(addBaseToTemplate(template)).toEqual(template);
+  it("calls onError for API errors", async () => {
+    const getLiquidTags = jest.fn((content, cb) =>
+      cb({ errors: [{ message: "API error" }], data: [] })
+    );
+    await validateLiquidTemplateContent("foo", {
+      getLiquidTags,
+      formatMessage,
+      messages,
+      onError,
+      onSuccess,
+      tagLookupMap,
+      eventContextTags
+    });
+    expect(onError).toHaveBeenCalledWith({
+      standardErrors: [],
+      liquidErrors: ["API error"],
+      tabType: undefined
+    });
+    expect(onSuccess).not.toHaveBeenCalled();
   });
 
-  it('should handle null input gracefully', () => {
-    expect(addBaseToTemplate(null)).toBeNull();
+  it("calls onError for unsupported tags", async () => {
+    const getLiquidTags = jest.fn((content, cb) =>
+      cb({ errors: [], data: [{ name: "baz" }] })
+    );
+    await validateLiquidTemplateContent("foo", {
+      getLiquidTags,
+      formatMessage,
+      messages,
+      onError,
+      onSuccess,
+      tagLookupMap,
+      eventContextTags
+    });
+    expect(onError).toHaveBeenCalledWith({
+      standardErrors: [],
+      liquidErrors: [undefined],
+      tabType: undefined
+    });
+    expect(onSuccess).not.toHaveBeenCalled();
   });
 
-  it('should handle undefined input gracefully', () => {
-    expect(addBaseToTemplate(undefined)).toBeUndefined();
+  it("calls onSuccess for valid content", async () => {
+    const getLiquidTags = jest.fn((content, cb) =>
+      cb({ errors: [], data: [{ name: "foo" }, { name: "bar" }] })
+    );
+    await validateLiquidTemplateContent("foo", {
+      getLiquidTags,
+      formatMessage,
+      messages,
+      onError,
+      onSuccess,
+      tagLookupMap,
+      eventContextTags
+    });
+    expect(onSuccess).toHaveBeenCalledWith("foo", undefined);
   });
 
-  it('should not modify the original template object', () => {
-    const template = {
-      versions: {
-        history: ['v1', 'v2', 'v3'],
-      },
+  it("calls onError with emailBodyEmptyError when validString is falsy", async () => {
+    const getLiquidTags = jest.fn((content, cb) => cb({ errors: [], data: [] }));
+    const formatMessage = jest.fn((msg) => msg.id);
+    const messages = {
+      emailBodyEmptyError: { id: 'empty' },
+      somethingWentWrong: { id: 'wrong' },
+      unsupportedTagsValidationError: { id: 'unsupported' },
     };
-    const originalTemplateCopy = JSON.parse(JSON.stringify(template));
-    addBaseToTemplate(template);
-    expect(template).toEqual(originalTemplateCopy);
+    const onError = jest.fn();
+    const onSuccess = jest.fn();
+    const tagLookupMap = {};
+    const eventContextTags = [];
+    await validateLiquidTemplateContent('', {
+      getLiquidTags,
+      formatMessage,
+      messages,
+      onError,
+      onSuccess,
+      tagLookupMap,
+      eventContextTags,
+    });
+    expect(formatMessage).toHaveBeenCalledWith(messages.emailBodyEmptyError);
+    expect(onError).toHaveBeenCalledWith({
+      standardErrors: ['empty'],
+      liquidErrors: [],
+      tabType: undefined,
+    });
+    expect(onSuccess).not.toHaveBeenCalled();
   });
 });
 
-describe('isEmbeddedEditOrPreview', () => {
+describe("validateMobilePushContent", () => {
+  const formatMessage = jest.fn(msg => msg.id);
+  const messages = {
+    emailBodyEmptyError: { id: "empty" },
+    somethingWentWrong: { id: "wrong" },
+    unsupportedTagsValidationError: { id: "unsupported" }
+  };
+  const tagLookupMap = { foo: true };
+  const eventContextTags = [{ tagName: "foo" }];
+  const onError = jest.fn();
+  const onSuccess = jest.fn();
+
   beforeEach(() => {
-    get.mockClear();
+    jest.clearAllMocks();
   });
 
-  it('should return true when query type is embedded and creatives mode is edit', () => {
-    const queryType = EMBEDDED;
-    const creativesMode = EDIT;
-    expect(isEmbeddedEditOrPreview(queryType, creativesMode)).toBe(true);
+  it("calls onError for empty formData", async () => {
+    const getLiquidTags = jest.fn((content, cb) =>
+      cb({ errors: [], data: [] })
+    );
+    await validateMobilePushContent(
+      {},
+      {
+        getLiquidTags,
+        formatMessage,
+        messages,
+        onError,
+        onSuccess,
+        tagLookupMap,
+        eventContextTags,
+        currentTab: 1
+      }
+    );
+    expect(onError).toHaveBeenCalled();
   });
 
-  it('should return true when query type is embedded and creatives mode is preview', () => {
-    const queryType = EMBEDDED;
-    const creativesMode = PREVIEW;
-    expect(isEmbeddedEditOrPreview(queryType, creativesMode)).toBe(true);
+  it("calls onSuccess for valid android and ios content", async () => {
+    const getLiquidTags = jest.fn((content, cb) =>
+      cb({ errors: [], data: [] })
+    );
+    const formData = [{ foo: "bar" }, { baz: "qux" }];
+    await validateMobilePushContent(formData, {
+      getLiquidTags,
+      formatMessage,
+      messages,
+      onError,
+      onSuccess,
+      tagLookupMap,
+      eventContextTags,
+      currentTab: 1
+    });
+    expect(onSuccess).toHaveBeenCalled();
   });
 
-  it('should return false when query type is not embedded', () => {
-    const queryType = FULL;
-    const creativesMode = PREVIEW;
-    expect(isEmbeddedEditOrPreview(queryType, creativesMode)).toBe(false);
+  it("calls onSuccess with android content when tab is 1", async () => {
+    const getLiquidTags = jest.fn((content, cb) =>
+      cb({ errors: [], data: [] })
+    );
+    const formData = [{ android: "content" }, { ios: "content" }];
+    await validateMobilePushContent(formData, {
+      getLiquidTags,
+      formatMessage,
+      messages,
+      onError,
+      onSuccess,
+      tagLookupMap,
+      eventContextTags,
+      currentTab: 1
+    });
+    expect(onSuccess).toHaveBeenCalledWith(JSON.stringify(formData[0]), "android");
   });
 
-  it('should return false when creatives mode is not edit or preview', () => {
-    const queryType = EMBEDDED;
-    const creativesMode = CREATE;
-    expect(isEmbeddedEditOrPreview(queryType, creativesMode)).toBe(false);
+  it("calls onSuccess with ios content when tab is 2", async () => {
+    const getLiquidTags = jest.fn((content, cb) =>
+      cb({ errors: [], data: [] })
+    );
+    const formData = [{ android: "content" }, { ios: "content" }];
+    await validateMobilePushContent(formData, {
+      getLiquidTags,
+      formatMessage,
+      messages,
+      onError,
+      onSuccess,
+      tagLookupMap,
+      eventContextTags,
+      currentTab: 2
+    });
+    expect(onSuccess).toHaveBeenCalledWith(JSON.stringify(formData[1]), "ios");
   });
-});
 
-describe('transformCustomFieldsData', () => {
-  it('should transform registration custom fields correctly', () => {
-    const input = {
-      1: {
-        name: 'age_group',
-        label: 'Age Group',
-        scope: 'loyalty_registration',
-      },
-      2: {
-        name: 'gender',
-        label: 'Gender',
-        scope: 'loyalty_registration',
-      },
-    };
+  it("falls back to android content when no tab selected and android exists", async () => {
+    const getLiquidTags = jest.fn((content, cb) =>
+      cb({ errors: [], data: [] })
+    );
+    const formData = [{ android: "content" }, null];
+    await validateMobilePushContent(formData, {
+      getLiquidTags,
+      formatMessage,
+      messages,
+      onError,
+      onSuccess,
+      tagLookupMap,
+      eventContextTags
+    });
+    expect(onSuccess).toHaveBeenCalledWith(JSON.stringify(formData[0]), "android");
+  });
+
+  it("falls back to ios content when no tab selected and only ios exists", async () => {
+    const getLiquidTags = jest.fn((content, cb) =>
+      cb({ errors: [], data: [] })
+    );
+    const formData = [null, { ios: "content" }];
+    await validateMobilePushContent(formData, {
+      getLiquidTags,
+      formatMessage,
+      messages,
+      onError,
+      onSuccess,
+      tagLookupMap,
+      eventContextTags
+    });
+    expect(onSuccess).toHaveBeenCalledWith("null", "android");
+  });
 
-    const expected = {
-      'Registration custom fields': {
-        name: 'Registration custom fields',
-        subtags: {
-          'custom_field.age_group': {
-            name: 'age_group',
-            desc: 'age_group',
-          },
-          'custom_field.gender': {
-            name: 'gender',
-            desc: 'gender',
-          },
-        },
+  it("calls onError for null formData", async () => {
+    const getLiquidTags = jest.fn((content, cb) => cb({ errors: [], data: [] }));
+    await validateMobilePushContent(
+      null,
+      {
+        getLiquidTags,
+        formatMessage,
+        messages,
+        onError,
+        onSuccess,
+        tagLookupMap,
+        eventContextTags,
+        currentTab: 1,
       },
-    };
+    );
+    expect(onError).toHaveBeenCalled();
+  });
 
-    expect(transformCustomFieldsData(input)).toEqual(expected);
+  it("calls onError for undefined formData", async () => {
+    const getLiquidTags = jest.fn((content, cb) => cb({ errors: [], data: [] }));
+    await validateMobilePushContent(
+      undefined,
+      {
+        getLiquidTags,
+        formatMessage,
+        messages,
+        onError,
+        onSuccess,
+        tagLookupMap,
+        eventContextTags,
+        currentTab: 1,
+      },
+    );
+    expect(onError).toHaveBeenCalled();
   });
 
-  it('should transform organization custom fields correctly', () => {
-    const input = {
-      1: {
-        name: 'org_phone',
-        label: 'Phone',
-        scope: 'org_custom_field',
+  it("calls onError for empty string formData", async () => {
+    const getLiquidTags = jest.fn((content, cb) => cb({ errors: [], data: [] }));
+    await validateMobilePushContent(
+      '',
+      {
+        getLiquidTags,
+        formatMessage,
+        messages,
+        onError,
+        onSuccess,
+        tagLookupMap,
+        eventContextTags,
+        currentTab: 1,
       },
-      2: {
-        name: 'store_location',
-        label: 'Location',
-        scope: 'store_custom_fields',
+    );
+    expect(onError).toHaveBeenCalled();
+  });
+
+  it("calls onError for empty array formData", async () => {
+    const getLiquidTags = jest.fn((content, cb) => cb({ errors: [], data: [] }));
+    await validateMobilePushContent(
+      [],
+      {
+        getLiquidTags,
+        formatMessage,
+        messages,
+        onError,
+        onSuccess,
+        tagLookupMap,
+        eventContextTags,
+        currentTab: 1,
       },
-    };
+    );
+    expect(onError).toHaveBeenCalled();
+  });
 
-    const expected = {
-      'Organization custom fields': {
-        name: 'Organization custom fields',
-        subtags: {
-          'org_custom_field.org_phone': {
-            name: 'org_phone',
-            desc: 'org_phone',
-          },
-          'store_custom_field.store_location': {
-            name: 'store_location',
-            desc: 'store_location',
-          },
-        },
+  it("calls onError for both android and ios missing", async () => {
+    const getLiquidTags = jest.fn((content, cb) => cb({ errors: [], data: [] }));
+    await validateMobilePushContent(
+      [{}, {}],
+      {
+        getLiquidTags,
+        formatMessage,
+        messages,
+        onError,
+        onSuccess,
+        tagLookupMap,
+        eventContextTags,
       },
-    };
+    );
+    expect(onError).toHaveBeenCalled();
+  });
 
-    expect(transformCustomFieldsData(input)).toEqual(expected);
+  it("calls onError for both android and ios null", async () => {
+    const getLiquidTags = jest.fn((content, cb) => cb({ errors: [], data: [] }));
+    await validateMobilePushContent(
+      [null, null],
+      {
+        getLiquidTags,
+        formatMessage,
+        messages,
+        onError,
+        onSuccess,
+        tagLookupMap,
+        eventContextTags,
+      },
+    );
+    expect(onError).toHaveBeenCalled();
   });
 
-  it('should handle empty input correctly', () => {
-    expect(transformCustomFieldsData({})).toEqual({});
+  it("calls onError for android and ios as empty strings", async () => {
+    const getLiquidTags = jest.fn((content, cb) => cb({ errors: [], data: [] }));
+    await validateMobilePushContent(
+      [{ android: '' }, { ios: '' }],
+      {
+        getLiquidTags,
+        formatMessage,
+        messages,
+        onError,
+        onSuccess,
+        tagLookupMap,
+        eventContextTags,
+      },
+    );
+    expect(onError).toHaveBeenCalled();
   });
 
-  it('should handle fields with missing properties', () => {
-    const input = {
-      1: {
-        scope: 'loyalty_registration',
+  it("calls onError for non-object types in formData", async () => {
+    const getLiquidTags = jest.fn((content, cb) => cb({ errors: [], data: [] }));
+    await validateMobilePushContent(
+      [123, 456],
+      {
+        getLiquidTags,
+        formatMessage,
+        messages,
+        onError,
+        onSuccess,
+        tagLookupMap,
+        eventContextTags,
       },
-    };
+    );
+    expect(onError).toHaveBeenCalled();
+  });
 
-    const expected = {
-      'Registration custom fields': {
-        name: 'Registration custom fields',
-        subtags: {
-          'custom_field.undefined': {
-            name: undefined,
-            desc: undefined,
-          },
-        },
+  it("calls onError for string types in formData", async () => {
+    const getLiquidTags = jest.fn((content, cb) => cb({ errors: [], data: [] }));
+    await validateMobilePushContent(
+      ['', ''],
+      {
+        getLiquidTags,
+        formatMessage,
+        messages,
+        onError,
+        onSuccess,
+        tagLookupMap,
+        eventContextTags,
       },
-    };
+    );
+    expect(onError).toHaveBeenCalled();
+  });
+});
 
-    expect(transformCustomFieldsData(input)).toEqual(expected);
+describe("validateInAppContent", () => {
+  const formatMessage = jest.fn(msg => msg.id);
+  const messages = {
+    emailBodyEmptyError: { id: "empty" },
+    somethingWentWrong: { id: "wrong" },
+    unsupportedTagsValidationError: { id: "unsupported" }
+  };
+  const tagLookupMap = { foo: true };
+  const eventContextTags = [{ tagName: "foo" }];
+  const onError = jest.fn();
+  const onSuccess = jest.fn();
+
+  beforeEach(() => {
+    jest.clearAllMocks();
   });
 
-  it('should ignore fields with invalid scope', () => {
-    const input = {
-      1: {
-        name: 'test',
-        label: 'Test',
-        scope: 'invalid_scope',
-      },
+  it("calls onError for empty formData", async () => {
+    const getLiquidTags = jest.fn((content, cb) =>
+      cb({ errors: [], data: [] })
+    );
+    await validateInAppContent(
+      {},
+      {
+        getLiquidTags,
+        formatMessage,
+        messages,
+        onError,
+        onSuccess,
+        tagLookupMap,
+        eventContextTags,
+      }
+    );
+    expect(onError).toHaveBeenCalled();
+  });
+
+  it("calls onSuccess for valid android and ios content", async () => {
+    const getLiquidTags = jest.fn((content, cb) =>
+      cb({ errors: [], data: [] })
+    );
+    const formData = {
+      versions: {
+        base: {
+          content: {
+            ANDROID: { title: "t", message: "m", ctas: [{ text: "c" }] },
+            IOS: { title: "t2", message: "m2", ctas: [{ text: "c2" }] }
+          }
+        }
+      }
     };
+    await validateInAppContent(formData, {
+      getLiquidTags,
+      formatMessage,
+      messages,
+      onError,
+      onSuccess,
+      tagLookupMap,
+      eventContextTags,
+    });
+    expect(onSuccess).toHaveBeenCalled();
+  });
+});
+
+describe("getChannelData", () => {
+  it("returns converted email content for EMAIL channel with template-content", () => {
+    const formData = { base: { en: { "template-content": "<h1>Hello</h1>" } } };
+    // Mock convert to just return the input string for test
+    jest.mock("html-to-text", () => ({ convert: (str) => str }));
+    expect(getChannelData("email", formData)).toBe("");
+  });
+
+  it("returns empty string for EMAIL channel with missing template-content", () => {
+    const formData = { base: { en: {} } };
+    jest.mock("html-to-text", () => ({ convert: (str) => str }));
+    expect(getChannelData("email", formData)).toBe("");
+  });
+
+  it("returns SMS editor and template name for SMS channel", () => {
+    const formData = { base: { "sms-editor": "Hi" }, "template-name": "Test" };
+    expect(getChannelData("SMS", formData)).toBe("Hi Test");
+  });
+
+  it("returns string with undefineds for SMS channel with missing fields", () => {
+    const formData = { base: {}, "template-name": undefined };
+    expect(getChannelData("SMS", formData)).toBe("undefined undefined");
+  });
+  it("returns string with undefineds for SMS channel with missing fields", () => {
+    expect(getChannelData("SMS", "")).toBe("undefined undefined");
+  });
+
+  it("returns JSON string for unknown channel", () => {
+    const formData = { foo: "bar" };
+    expect(getChannelData("unknown", formData)).toBe(JSON.stringify(formData));
+  });
+
+  it("returns JSON string for null formData", () => {
+    expect(getChannelData("SMS", null)).toBe("undefined undefined");
+  });
+
+  it("returns JSON string for undefined formData", () => {
+    expect(getChannelData("SMS", undefined)).toBe("undefined undefined");
+  });
 
-    expect(transformCustomFieldsData(input)).toEqual({});
+  it("handles missing base/en gracefully for EMAIL", () => {
+    expect(getChannelData("email", {})).toBe("");
+    expect(getChannelData("email", { base: {} })).toBe("");
+    expect(getChannelData("email", { base: { en: null } })).toBe("");
   });
 });