@capillarytech/creatives-library 8.0.114 → 8.0.116

package/utils/tests/commonUtil.test.js

@@ -1,222 +1,658 @@
-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,
+  extractContent,addBaseToTemplate
+} from "../commonUtils";
+import { SMS_TRAI_VAR } from '../../v2Containers/SmsTrai/Edit/constants';
+import { ANDROID, IOS } from '../../v2Containers/CreativesContainer/constants';
 
-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();
+
+  beforeEach(() => {
+    jest.clearAllMocks();
   });
 
-  it('should return the original template if history is empty', () => {
-    const template = {
-      versions: {
-        history: [],
-      },
-    };
-    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 history is undefined', () => {
-    const template = {
-      versions: {},
-    };
-    expect(addBaseToTemplate(template)).toEqual(template);
+  it("when onError is not provided, it should not throw an error", async () => {
+    const getLiquidTags = jest.fn((content, cb) =>
+      cb({ errors: [], data: [] })
+    );
+    await validateLiquidTemplateContent("", {
+      getLiquidTags,
+      formatMessage,
+      messages,
+      tagLookupMap,
+      eventContextTags
+    });
+    expect(onError).not.toHaveBeenCalled();
+    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({ askAiraResponse: { errors: [{ message: "API error" }], data: [] }, isError: true })
+    );
+    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({ askAiraResponse: { errors: [], data: [{ name: "baz" }] }, isError: false })
+    );
+    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({ askAiraResponse: { errors: [], data: [{ name: "foo" }, { name: "bar" }] }, isError: false })
+    );
+    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({ askAiraResponse: { errors: [], data: [] }, isError: false }));
+    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("addBaseToTemplate - subject property logic", () => {
+    it("should use template.versions.base.subject if it exists", () => {
+      const template = {
+        versions: {
+          base: { subject: "base-subject" },
+          history: [{ subject: "history-subject" }],
+        },
+      };
+      const result = addBaseToTemplate(template);
+      expect(result.versions.base.subject).toBe("base-subject");
+    });
+
+    it("should use history[0].subject if template.versions.base.subject does not exist", () => {
+      const template = {
+        versions: {
+          history: [{ subject: "history-subject" }],
+        },
+      };
+      const result = addBaseToTemplate(template);
+      expect(result.versions.base.subject).toBe("history-subject");
+    });
+
+    it("should set subject as undefined if neither exists", () => {
+      const template = {
+        versions: {
+          history: [{}],
+        },
+      };
+      const result = addBaseToTemplate(template);
+      expect(result.versions.base.subject).toBeUndefined();
+    });
+
+    it("should return the original template if history is empty", () => {
+      const template = {
+        versions: {
+          history: [],
+        },
+      };
+      expect(addBaseToTemplate(template)).toEqual(template);
+    });
   });
 });
 
-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({ askAiraResponse: { errors: [], data: [] }, isError: false })
+    );
+    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({ askAiraResponse: { errors: [], data: [] }, isError: false })
+    );
+    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({ askAiraResponse: { errors: [], data: [] }, isError: false })
+    );
+    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({ askAiraResponse: { errors: [], data: [] }, isError: false })
+    );
+    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({ askAiraResponse: { errors: [], data: [] }, isError: false })
+    );
+    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");
+  });
+
+  it("calls onError for null formData", async () => {
+    const getLiquidTags = jest.fn((content, cb) => cb({ askAiraResponse: { errors: [], data: [] }, isError: false }));
+    await validateMobilePushContent(
+      null,
+      {
+        getLiquidTags,
+        formatMessage,
+        messages,
+        onError,
+        onSuccess,
+        tagLookupMap,
+        eventContextTags,
+        currentTab: 1,
       },
-    };
+    );
+    expect(onError).toHaveBeenCalled();
+  });
 
-    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 undefined formData", async () => {
+    const getLiquidTags = jest.fn((content, cb) => cb({ askAiraResponse: { errors: [], data: [] }, isError: false }));
+    await validateMobilePushContent(
+      undefined,
+      {
+        getLiquidTags,
+        formatMessage,
+        messages,
+        onError,
+        onSuccess,
+        tagLookupMap,
+        eventContextTags,
+        currentTab: 1,
       },
-    };
+    );
+    expect(onError).toHaveBeenCalled();
+  });
 
-    expect(transformCustomFieldsData(input)).toEqual(expected);
+  it("calls onError for empty string formData", async () => {
+    const getLiquidTags = jest.fn((content, cb) => cb({ askAiraResponse: { errors: [], data: [] }, isError: false }));
+    await validateMobilePushContent(
+      '',
+      {
+        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 array formData", async () => {
+    const getLiquidTags = jest.fn((content, cb) => cb({ askAiraResponse: { errors: [], data: [] }, isError: false }));
+    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 both android and ios missing", async () => {
+    const getLiquidTags = jest.fn((content, cb) => cb({ askAiraResponse: { errors: [], data: [] }, isError: false }));
+    await validateMobilePushContent(
+      [{}, {}],
+      {
+        getLiquidTags,
+        formatMessage,
+        messages,
+        onError,
+        onSuccess,
+        tagLookupMap,
+        eventContextTags,
       },
-    };
+    );
+    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 null", async () => {
+    const getLiquidTags = jest.fn((content, cb) => cb({ askAiraResponse: { errors: [], data: [] }, isError: false }));
+    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({ askAiraResponse: { errors: [], data: [] }, isError: false }));
+    await validateMobilePushContent(
+      [{ android: '' }, { ios: '' }],
+      {
+        getLiquidTags,
+        formatMessage,
+        messages,
+        onError,
+        onSuccess,
+        tagLookupMap,
+        eventContextTags,
+      },
+    );
+    expect(onError).toHaveBeenCalled();
   });
 
-  it('should handle empty input correctly', () => {
-    expect(transformCustomFieldsData({})).toEqual({});
+  it("calls onError for non-object types in formData", async () => {
+    const getLiquidTags = jest.fn((content, cb) => cb({ askAiraResponse: { errors: [], data: [] }, isError: false }));
+    await validateMobilePushContent(
+      [123, 456],
+      {
+        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 string types in formData", async () => {
+    const getLiquidTags = jest.fn((content, cb) => cb({ askAiraResponse: { errors: [], data: [] }, isError: false }));
+    await validateMobilePushContent(
+      ['', ''],
+      {
+        getLiquidTags,
+        formatMessage,
+        messages,
+        onError,
+        onSuccess,
+        tagLookupMap,
+        eventContextTags,
       },
+    );
+    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({ askAiraResponse: { errors: [], data: [] }, isError: false })
+    );
+    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({ askAiraResponse: { errors: [], data: [] }, isError: false })
+    );
+    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,
+      singleTab: ANDROID,
+    });
+    expect(onSuccess).toHaveBeenCalled();
+  });
+  it("calls onSuccess for valid ios content", async () => {
 
-    const expected = {
-      'Registration custom fields': {
-        name: 'Registration custom fields',
-        subtags: {
-          'custom_field.undefined': {
-            name: undefined,
-            desc: undefined,
-          },
-        },
-      },
+    const getLiquidTags = jest.fn((content, cb) =>
+      cb({ askAiraResponse: { errors: [], data: [] }, isError: false })
+    );
+    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,
+      singleTab: IOS,
+    });
+    expect(onSuccess).toHaveBeenCalled();
+  });
+});
 
-    expect(transformCustomFieldsData(input)).toEqual(expected);
+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('should ignore fields with invalid scope', () => {
-    const input = {
-      1: {
-        name: 'test',
-        label: 'Test',
-        scope: 'invalid_scope',
-      },
-    };
+  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");
+  });
 
-    expect(transformCustomFieldsData(input)).toEqual({});
+  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");
+  });
+
+  it("handles missing base/en gracefully for EMAIL", () => {
+    expect(getChannelData("email", {})).toBe("");
+    expect(getChannelData("email", { base: {} })).toBe("");
+    expect(getChannelData("email", { base: { en: null } })).toBe("");
+  });
+  it("returns empty string for SMS_TRAI_VAR channel with missing fields", () => {
+    expect(getChannelData(SMS_TRAI_VAR, {})).toBe("");
+    expect(getChannelData(SMS_TRAI_VAR, { versions: {} })).toBe("");
+    expect(getChannelData(SMS_TRAI_VAR, { versions: { base: { "updated-sms-editor": [] } } })).toBe("");
+  });
+});
+
+describe("extractContent", () => {
+  it("returns empty string for null or undefined", () => {
+    expect(extractContent(null)).toBe("");
+    expect(extractContent(undefined)).toBe("");
+  });
+  it("returns empty string for empty object", () => {
+    expect(extractContent({})).toBe("");
+  });
+  it("returns only title if only title is present", () => {
+    expect(extractContent({ title: "Title" })).toBe("Title");
+  });
+  it("returns only message if only message is present", () => {
+    expect(extractContent({ message: "Message" })).toBe("Message");
+  });
+  it("returns only ctas text if only ctas with text is present", () => {
+    expect(extractContent({ ctas: [{ text: "CTA1" }, { text: "CTA2" }] })).toBe("CTA1 CTA2");
+  });
+  it("returns only ctas actionLink if only ctas with actionLink is present", () => {
+    expect(extractContent({ ctas: [{ actionLink: "/link1" }, { actionLink: "/link2" }] })).toBe("/link1 /link2");
+  });
+  it("returns ctas text if both text and actionLink are present (text preferred)", () => {
+    expect(extractContent({ ctas: [{ text: "CTA1", actionLink: "/link1" }, { text: "CTA2", actionLink: "/link2" }] })).toBe("CTA1 CTA2");
+  });
+  it("returns actionLink if text is missing", () => {
+    expect(extractContent({ ctas: [{ actionLink: "/link1" }, { text: null, actionLink: "/link2" }] })).toBe("/link1 /link2");
+  });
+  it("returns empty string for ctas with neither text nor actionLink", () => {
+    expect(extractContent({ ctas: [{}, { text: null }] })).toBe("");
+  });
+  it("returns all fields joined if all present", () => {
+    expect(extractContent({ title: "T", message: "M", ctas: [{ text: "C1" }, { actionLink: "C2" }] })).toBe("T M C1 C2");
+  });
+  it("handles ctas as empty array", () => {
+    expect(extractContent({ title: "T", message: "M", ctas: [] })).toBe("T M");
+  });
+  it("handles ctas as undefined", () => {
+    expect(extractContent({ title: "T", message: "M" })).toBe("T M");
   });
 });