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

package/utils/tests/commonUtil.test.js

@@ -1,525 +1,222 @@
-import {
-  validateLiquidTemplateContent,
-  validateMobilePushContent,
-  validateInAppContent,
-  getChannelData
-} from "../commonUtils";
-
-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();
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  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("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();
+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([]);
   });
+});
 
-  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();
+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);
   });
 
-  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 return the original template if history is empty', () => {
+    const template = {
+      versions: {
+        history: [],
+      },
+    };
+    expect(addBaseToTemplate(template)).toEqual(template);
   });
 
-  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' },
+  it('should return the original template if history is undefined', () => {
+    const template = {
+      versions: {},
     };
-    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();
+    expect(addBaseToTemplate(template)).toEqual(template);
   });
-});
 
-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(() => {
-    jest.clearAllMocks();
+  it('should return the original template if versions is undefined', () => {
+    const template = {};
+    expect(addBaseToTemplate(template)).toEqual(template);
   });
 
-  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 handle null input gracefully', () => {
+    expect(addBaseToTemplate(null)).toBeNull();
   });
 
-  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 handle undefined input gracefully', () => {
+    expect(addBaseToTemplate(undefined)).toBeUndefined();
   });
 
-  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 not modify the original template object', () => {
+    const template = {
+      versions: {
+        history: ['v1', 'v2', 'v3'],
+      },
+    };
+    const originalTemplateCopy = JSON.parse(JSON.stringify(template));
+    addBaseToTemplate(template);
+    expect(template).toEqual(originalTemplateCopy);
   });
+});
 
-  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('isEmbeddedEditOrPreview', () => {
+  beforeEach(() => {
+    get.mockClear();
   });
 
-  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('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("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");
+  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 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();
+  it('should return false when query type is not embedded', () => {
+    const queryType = FULL;
+    const creativesMode = PREVIEW;
+    expect(isEmbeddedEditOrPreview(queryType, creativesMode)).toBe(false);
   });
 
-  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 return false when creatives mode is not edit or preview', () => {
+    const queryType = EMBEDDED;
+    const creativesMode = CREATE;
+    expect(isEmbeddedEditOrPreview(queryType, creativesMode)).toBe(false);
   });
+});
 
-  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,
+describe('transformCustomFieldsData', () => {
+  it('should transform registration custom fields correctly', () => {
+    const input = {
+      1: {
+        name: 'age_group',
+        label: 'Age Group',
+        scope: 'loyalty_registration',
       },
-    );
-    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,
+      2: {
+        name: 'gender',
+        label: 'Gender',
+        scope: 'loyalty_registration',
       },
-    );
-    expect(onError).toHaveBeenCalled();
-  });
+    };
 
-  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,
+    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',
+          },
+        },
       },
-    );
-    expect(onError).toHaveBeenCalled();
-  });
+    };
 
-  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();
+    expect(transformCustomFieldsData(input)).toEqual(expected);
   });
 
-  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,
+  it('should transform organization custom fields correctly', () => {
+    const input = {
+      1: {
+        name: 'org_phone',
+        label: 'Phone',
+        scope: 'org_custom_field',
       },
-    );
-    expect(onError).toHaveBeenCalled();
-  });
-
-  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,
+      2: {
+        name: 'store_location',
+        label: 'Location',
+        scope: 'store_custom_fields',
       },
-    );
-    expect(onError).toHaveBeenCalled();
-  });
+    };
 
-  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,
+    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',
+          },
+        },
       },
-    );
-    expect(onError).toHaveBeenCalled();
-  });
-});
-
-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("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("");
+    expect(transformCustomFieldsData(input)).toEqual(expected);
   });
 
-  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('should handle empty input correctly', () => {
+    expect(transformCustomFieldsData({})).toEqual({});
   });
 
-  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('should handle fields with missing properties', () => {
+    const input = {
+      1: {
+        scope: 'loyalty_registration',
+      },
+    };
 
-  it("returns JSON string for unknown channel", () => {
-    const formData = { foo: "bar" };
-    expect(getChannelData("unknown", formData)).toBe(JSON.stringify(formData));
-  });
+    const expected = {
+      'Registration custom fields': {
+        name: 'Registration custom fields',
+        subtags: {
+          'custom_field.undefined': {
+            name: undefined,
+            desc: undefined,
+          },
+        },
+      },
+    };
 
-  it("returns JSON string for null formData", () => {
-    expect(getChannelData("SMS", null)).toBe("undefined undefined");
+    expect(transformCustomFieldsData(input)).toEqual(expected);
   });
 
-  it("returns JSON string for undefined formData", () => {
-    expect(getChannelData("SMS", undefined)).toBe("undefined undefined");
-  });
+  it('should ignore fields with invalid scope', () => {
+    const input = {
+      1: {
+        name: 'test',
+        label: 'Test',
+        scope: 'invalid_scope',
+      },
+    };
 
-  it("handles missing base/en gracefully for EMAIL", () => {
-    expect(getChannelData("email", {})).toBe("");
-    expect(getChannelData("email", { base: {} })).toBe("");
-    expect(getChannelData("email", { base: { en: null } })).toBe("");
+    expect(transformCustomFieldsData(input)).toEqual({});
   });
 });