@capillarytech/creatives-library 8.0.316 → 8.0.317-alpha.0

package/v2Components/SmsFallback/tests/smsFallbackUtils.test.js

@@ -0,0 +1,261 @@
+import {
+  buildFallbackDataFromTemplate,
+  mapFallbackValueToEditTemplateData,
+  getBaseFromSmsTraiFormData,
+  getSmsFallbackCardDisplayContent,
+  resolveContentFromTraiBase,
+  filterSmsTemplatesByCategory,
+  buildFallbackDataFromCreativesPayload,
+} from '../smsFallbackUtils';
+import { SMS_CATEGORY_FILTERS } from '../constants';
+
+describe('smsFallbackUtils', () => {
+  describe('buildFallbackDataFromTemplate', () => {
+    it('maps template versions.base and header sender list', () => {
+      const template = {
+        _id: 'tid',
+        name: 'My SMS',
+        versions: {
+          base: {
+            'sms-editor': 'Hello {{1}}',
+            header: ['S1', 'S2'],
+            'unicode-validity': false,
+          },
+        },
+      };
+      expect(buildFallbackDataFromTemplate(template)).toEqual({
+        smsTemplateId: 'tid',
+        templateName: 'My SMS',
+        content: 'Hello {{1}}',
+        templateContent: 'Hello {{1}}',
+        senderId: 'S1',
+        registeredSenderIds: ['S1', 'S2'],
+        unicodeValidity: false,
+      });
+    });
+
+    it('falls back to senderId when header is missing', () => {
+      const template = {
+        _id: '',
+        name: '',
+        versions: { base: { 'sms-editor': 'x', senderId: 'SID' } },
+      };
+      expect(buildFallbackDataFromTemplate(template).senderId).toBe('SID');
+      expect(buildFallbackDataFromTemplate(template).registeredSenderIds).toEqual([]);
+    });
+
+    it('defaults unicodeValidity to true when not a boolean', () => {
+      const template = {
+        versions: { base: { 'sms-editor': '' } },
+      };
+      expect(buildFallbackDataFromTemplate(template).unicodeValidity).toBe(true);
+    });
+  });
+
+  describe('getSmsFallbackCardDisplayContent', () => {
+    it('returns raw template when rcsSmsFallbackVarMapped is empty', () => {
+      expect(
+        getSmsFallbackCardDisplayContent({
+          templateContent: 'A {#var#} B',
+          rcsSmsFallbackVarMapped: {},
+        }),
+      ).toBe('A {#var#} B');
+    });
+
+    it('substitutes slot values like preview when var map is set', () => {
+      expect(
+        getSmsFallbackCardDisplayContent({
+          templateContent: 'Hi {{name}}',
+          rcsSmsFallbackVarMapped: { '{{name}}_1': 'Pat' },
+        }),
+      ).toBe('Hi Pat');
+    });
+
+    it('shows raw {#var#} in card when slots saved empty (DLT, no labels)', () => {
+      expect(
+        getSmsFallbackCardDisplayContent({
+          templateContent: 'Balance {#var#}',
+          rcsSmsFallbackVarMapped: { '{#var#}_1': '' },
+        }),
+      ).toBe('Balance {#var#}');
+    });
+  });
+
+  describe('mapFallbackValueToEditTemplateData', () => {
+    it('returns null when source is missing', () => {
+      expect(mapFallbackValueToEditTemplateData(null)).toBeNull();
+      expect(mapFallbackValueToEditTemplateData(undefined)).toBeNull();
+    });
+
+    it('maps content, optional header and unicode flag', () => {
+      const source = {
+        smsTemplateId: 'id1',
+        templateName: 'N',
+        templateContent: 'body',
+        registeredSenderIds: ['h1'],
+        unicodeValidity: false,
+      };
+      expect(mapFallbackValueToEditTemplateData(source)).toEqual({
+        _id: 'id1',
+        name: 'N',
+        versions: {
+          base: {
+            'sms-editor': 'body',
+            header: ['h1'],
+            'unicode-validity': false,
+          },
+        },
+      });
+    });
+
+    it('uses content when templateContent is empty', () => {
+      const source = {
+        smsTemplateId: 'x',
+        templateName: 'y',
+        content: 'from-content',
+      };
+      expect(mapFallbackValueToEditTemplateData(source).versions.base['sms-editor']).toBe('from-content');
+    });
+
+    it('omits header when registeredSenderIds is empty', () => {
+      const source = {
+        smsTemplateId: 'x',
+        templateName: 'y',
+        templateContent: 't',
+        registeredSenderIds: [],
+      };
+      expect(mapFallbackValueToEditTemplateData(source).versions.base.header).toBeUndefined();
+    });
+
+    it('omits unicode-validity when value is not a boolean', () => {
+      const source = {
+        smsTemplateId: 'x',
+        templateName: 'y',
+        templateContent: 't',
+        unicodeValidity: 'yes',
+      };
+      expect(mapFallbackValueToEditTemplateData(source).versions.base['unicode-validity']).toBeUndefined();
+    });
+  });
+
+  describe('getBaseFromSmsTraiFormData', () => {
+    it('reads versions.base', () => {
+      const fd = { versions: { base: { 'sms-editor': 'a' } } };
+      expect(getBaseFromSmsTraiFormData(fd)).toEqual({ base: { 'sms-editor': 'a' } });
+    });
+
+    it('falls back to value.base', () => {
+      const fd = { value: { base: { 'sms-editor': 'b' } } };
+      expect(getBaseFromSmsTraiFormData(fd)).toEqual({ base: { 'sms-editor': 'b' } });
+    });
+
+    it('uses empty base when neither path exists', () => {
+      expect(getBaseFromSmsTraiFormData({})).toEqual({ base: {} });
+    });
+
+    it('normalizes null versions.base to empty object', () => {
+      expect(getBaseFromSmsTraiFormData({ versions: { base: null } })).toEqual({ base: {} });
+    });
+  });
+
+  describe('resolveContentFromTraiBase', () => {
+    it('returns sms-editor string', () => {
+      expect(resolveContentFromTraiBase({ 'sms-editor': 'z' })).toBe('z');
+    });
+
+    it('returns empty string when missing', () => {
+      expect(resolveContentFromTraiBase({})).toBe('');
+    });
+  });
+
+  describe('filterSmsTemplatesByCategory', () => {
+    const templates = [
+      { versions: { base: { type: 'Promo' } } },
+      { versions: { base: { type: 'Explicit' } } },
+    ];
+
+    it('returns empty array for non-array input', () => {
+      expect(filterSmsTemplatesByCategory(null, SMS_CATEGORY_FILTERS.PROMOTIONAL)).toEqual([]);
+    });
+
+    it('returns all templates for ALL or missing filter', () => {
+      expect(filterSmsTemplatesByCategory(templates, SMS_CATEGORY_FILTERS.ALL)).toEqual(templates);
+      expect(filterSmsTemplatesByCategory(templates, null)).toEqual(templates);
+    });
+
+    it('filters by lowercase type substring', () => {
+      const filtered = filterSmsTemplatesByCategory(templates, SMS_CATEGORY_FILTERS.PROMOTIONAL);
+      expect(filtered).toHaveLength(1);
+      expect(filtered[0].versions.base.type).toBe('Promo');
+    });
+
+    it('treats missing type as empty string for filtering', () => {
+      const mixed = [{}, { versions: { base: {} } }];
+      expect(filterSmsTemplatesByCategory(mixed, SMS_CATEGORY_FILTERS.PROMOTIONAL)).toEqual([]);
+    });
+  });
+
+  describe('buildFallbackDataFromCreativesPayload', () => {
+    it('returns null for missing or non-SMS channel', () => {
+      expect(buildFallbackDataFromCreativesPayload(null)).toBeNull();
+      expect(buildFallbackDataFromCreativesPayload({ channel: 'RCS' })).toBeNull();
+    });
+
+    it('maps SMS payload with messageBody and templateConfigs', () => {
+      const creativesData = {
+        channel: 'SMS',
+        messageBody: 'Hello',
+        templateConfigs: {
+          templateId: 99,
+          templateName: 'T',
+          template: 'Template str',
+          registeredSenderIds: ['R1'],
+        },
+      };
+      expect(buildFallbackDataFromCreativesPayload(creativesData)).toEqual({
+        smsTemplateId: '99',
+        templateName: 'T',
+        content: 'Hello',
+        templateContent: 'Template str',
+        senderId: 'R1',
+        registeredSenderIds: ['R1'],
+        unicodeValidity: true,
+      });
+    });
+
+    it('uses template string as body when messageBody is not a string', () => {
+      const creativesData = {
+        channel: 'SMS',
+        messageBody: null,
+        templateConfigs: {
+          template: 'only-template',
+        },
+      };
+      const out = buildFallbackDataFromCreativesPayload(creativesData);
+      expect(out.content).toBe('only-template');
+      expect(out.templateContent).toBe('only-template');
+    });
+
+    it('stringifies templateId and templateName when present', () => {
+      const creativesData = {
+        channel: 'SMS',
+        messageBody: 'm',
+        templateConfigs: { templateId: 0, templateName: null },
+      };
+      const out = buildFallbackDataFromCreativesPayload(creativesData);
+      expect(out.smsTemplateId).toBe('0');
+      expect(out.templateName).toBe('');
+    });
+
+    it('uses empty templateConfigs when null', () => {
+      const creativesData = {
+        channel: 'SMS',
+        messageBody: 'only-body',
+        templateConfigs: null,
+      };
+      const out = buildFallbackDataFromCreativesPayload(creativesData);
+      expect(out.templateContent).toBe('only-body');
+      expect(out.content).toBe('only-body');
+    });
+  });
+});

package/v2Components/SmsFallback/tests/useLocalTemplateList.test.js

@@ -0,0 +1,422 @@
+import { renderHook, act } from '@testing-library/react-hooks';
+import { waitFor } from '@testing-library/react';
+import { useLocalTemplateList } from '../useLocalTemplateList';
+
+const makeDeferred = () => {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+};
+
+describe('useLocalTemplateList', () => {
+  it('drops stale response when a newer reset starts', async () => {
+    const first = makeDeferred();
+    const second = makeDeferred();
+    const fetchTemplates = jest
+      .fn()
+      .mockImplementationOnce(() => first.promise)
+      .mockImplementationOnce(() => second.promise);
+
+    const { result } = renderHook(() =>
+      useLocalTemplateList({ fetchTemplates, perPage: 2 })
+    );
+
+    act(() => {
+      result.current.reset('old-search');
+    });
+
+    act(() => {
+      result.current.reset('new-search');
+    });
+
+    await act(async () => {
+      second.resolve({
+        templates: [{ _id: 'new-1' }],
+        totalCount: 1,
+      });
+      await Promise.resolve();
+    });
+
+    expect(result.current.templates).toEqual([{ _id: 'new-1' }]);
+    expect(result.current.totalCount).toBe(1);
+
+    await act(async () => {
+      first.resolve({
+        templates: [{ _id: 'old-1' }],
+        totalCount: 1,
+      });
+      await Promise.resolve();
+    });
+
+    // Older response should not overwrite latest state.
+    expect(result.current.templates).toEqual([{ _id: 'new-1' }]);
+    expect(result.current.search).toBe('new-search');
+  });
+
+  it('keeps existing templates when loadMore fails', async () => {
+    const fetchTemplates = jest.fn(({ page }) => {
+      if (page === 1) {
+        return Promise.resolve({
+          templates: [{ _id: 't1' }, { _id: 't2' }],
+          totalCount: 4,
+        });
+      }
+      return Promise.reject(new Error('load-more-failed'));
+    });
+
+    const { result } = renderHook(() =>
+      useLocalTemplateList({ fetchTemplates, perPage: 2 })
+    );
+
+    act(() => {
+      result.current.reset('');
+    });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+      expect(result.current.templates).toHaveLength(2);
+      expect(result.current.page).toBe(1);
+    });
+
+    act(() => {
+      result.current.loadMore();
+    });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    // Non-reset failure should not wipe already loaded data.
+    expect(result.current.templates).toEqual([{ _id: 't1' }, { _id: 't2' }]);
+    expect(result.current.totalCount).toBe(4);
+    expect(result.current.page).toBe(1);
+  });
+
+  it('clears list on reset failure', async () => {
+    const fetchTemplates = jest
+      .fn()
+      .mockResolvedValueOnce({
+        templates: [{ _id: 'seed-1' }, { _id: 'seed-2' }],
+        totalCount: 2,
+      })
+      .mockRejectedValueOnce(new Error('reset-failed'));
+
+    const { result } = renderHook(() =>
+      useLocalTemplateList({ fetchTemplates, perPage: 2 })
+    );
+
+    act(() => {
+      result.current.reset('');
+    });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+      expect(result.current.templates).toHaveLength(2);
+    });
+
+    act(() => {
+      result.current.reset('fresh-search');
+    });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.templates).toEqual([]);
+    expect(result.current.totalCount).toBe(0);
+    expect(result.current.page).toBe(1);
+    expect(result.current.search).toBe('fresh-search');
+  });
+
+  it('keeps previous totalCount when loadMore returns zero totalCount', async () => {
+    const fetchTemplates = jest.fn(({ page }) => {
+      if (page === 1) {
+        return Promise.resolve({
+          templates: [{ _id: 't1' }],
+          totalCount: 10,
+        });
+      }
+      return Promise.resolve({
+        templates: [{ _id: 't2' }],
+        totalCount: 0,
+      });
+    });
+
+    const { result } = renderHook(() =>
+      useLocalTemplateList({ fetchTemplates, perPage: 1 })
+    );
+
+    act(() => {
+      result.current.reset('');
+    });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+      expect(result.current.templates).toHaveLength(1);
+      expect(result.current.totalCount).toBe(10);
+    });
+
+    act(() => {
+      result.current.loadMore();
+    });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.templates.map((t) => t._id)).toEqual(['t1', 't2']);
+    expect(result.current.totalCount).toBe(10);
+  });
+
+  it('ignores rejection from a superseded fetch (stale generation)', async () => {
+    const slowFirst = makeDeferred();
+    const fetchTemplates = jest
+      .fn()
+      .mockImplementationOnce(() => slowFirst.promise)
+      .mockImplementationOnce(() =>
+        Promise.resolve({ templates: [{ _id: 'from-second' }], totalCount: 1 }),
+      );
+
+    const { result } = renderHook(() =>
+      useLocalTemplateList({ fetchTemplates, perPage: 25 })
+    );
+
+    act(() => {
+      result.current.reset('first-search');
+    });
+    act(() => {
+      result.current.reset('second-search');
+    });
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+      expect(result.current.templates).toEqual([{ _id: 'from-second' }]);
+    });
+
+    await act(async () => {
+      slowFirst.reject(new Error('stale'));
+      await Promise.resolve();
+    });
+
+    expect(result.current.templates).toEqual([{ _id: 'from-second' }]);
+    expect(result.current.search).toBe('second-search');
+  });
+
+  it('does not leave loading stuck when stale resolve completes after newer fetch (finally gen check)', async () => {
+    const d1 = makeDeferred();
+    const fetchTemplates = jest
+      .fn()
+      .mockImplementationOnce(() => d1.promise)
+      .mockResolvedValueOnce({ templates: [{ _id: 'new' }], totalCount: 1 });
+
+    const { result } = renderHook(() =>
+      useLocalTemplateList({ fetchTemplates, perPage: 2 }),
+    );
+
+    act(() => {
+      result.current.reset('a');
+    });
+    act(() => {
+      result.current.reset('b');
+    });
+
+    await act(async () => {
+      d1.resolve({ templates: [{ _id: 'old' }], totalCount: 1 });
+      await Promise.resolve();
+    });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+      expect(result.current.templates).toEqual([{ _id: 'new' }]);
+    });
+  });
+
+  it('coerces setSearch non-string values to empty search term', () => {
+    const fetchTemplates = jest.fn().mockResolvedValue({ templates: [], totalCount: 0 });
+    const { result } = renderHook(() =>
+      useLocalTemplateList({ fetchTemplates, perPage: 25 }),
+    );
+
+    act(() => {
+      result.current.setSearch(null);
+    });
+    expect(result.current.search).toBe('');
+
+    act(() => {
+      result.current.setSearch(123);
+    });
+    expect(result.current.search).toBe('');
+  });
+
+  it('does not call fetch when loadMore runs but canLoadMore is false', async () => {
+    const fetchTemplates = jest.fn().mockResolvedValue({
+      templates: [{ _id: 'only' }],
+      totalCount: 1,
+    });
+
+    const { result } = renderHook(() =>
+      useLocalTemplateList({ fetchTemplates, perPage: 1 }),
+    );
+
+    act(() => {
+      result.current.reset('');
+    });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+      expect(result.current.canLoadMore).toBe(false);
+    });
+
+    const callsAfterFirst = fetchTemplates.mock.calls.length;
+
+    act(() => {
+      result.current.loadMore();
+    });
+
+    expect(fetchTemplates.mock.calls.length).toBe(callsAfterFirst);
+  });
+
+  it('passes explicit search term from reset() through to fetchTemplates', async () => {
+    const fetchTemplates = jest.fn().mockResolvedValue({
+      templates: [{ _id: 'r1' }],
+      totalCount: 5,
+    });
+
+    const { result } = renderHook(() =>
+      useLocalTemplateList({ fetchTemplates, perPage: 25 }),
+    );
+
+    act(() => {
+      result.current.reset('explicit-search');
+    });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(fetchTemplates).toHaveBeenCalledWith(
+      expect.objectContaining({ search: 'explicit-search', page: 1, reset: true }),
+    );
+    expect(result.current.search).toBe('explicit-search');
+  });
+
+  it('stores a positive totalCount returned by the API', async () => {
+    const fetchTemplates = jest.fn().mockResolvedValue({
+      templates: [{ _id: 'a' }, { _id: 'b' }],
+      totalCount: 42,
+    });
+
+    const { result } = renderHook(() =>
+      useLocalTemplateList({ fetchTemplates, perPage: 25 }),
+    );
+
+    act(() => {
+      result.current.reset('');
+    });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.totalCount).toBe(42);
+    expect(result.current.templates).toHaveLength(2);
+  });
+
+  it('canLoadMore is false while a fetch is in progress even when more items exist', async () => {
+    let resolveFirst;
+    const fetchTemplates = jest.fn(
+      () => new Promise((res) => { resolveFirst = res; }),
+    );
+
+    const { result } = renderHook(() =>
+      useLocalTemplateList({ fetchTemplates, perPage: 2 }),
+    );
+
+    act(() => {
+      result.current.reset('');
+    });
+
+    // Loading is true → canLoadMore must be false regardless of hasMoreByTotal
+    expect(result.current.loading).toBe(true);
+    expect(result.current.canLoadMore).toBe(false);
+
+    await act(async () => {
+      resolveFirst({ templates: [{ _id: 'x' }, { _id: 'y' }], totalCount: 10 });
+      await Promise.resolve();
+    });
+
+    expect(result.current.loading).toBe(false);
+    expect(result.current.canLoadMore).toBe(true);
+  });
+
+  it('canLoadMore is false when templates is empty (hasMoreByFullPage requires length > 0)', async () => {
+    const fetchTemplates = jest.fn().mockResolvedValue({
+      templates: [],
+      totalCount: 0,
+    });
+
+    const { result } = renderHook(() =>
+      useLocalTemplateList({ fetchTemplates, perPage: 0 }),
+    );
+
+    act(() => {
+      result.current.reset('');
+    });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    // templates.length === 0 means hasMoreByFullPage is false even if lastFetchFullPage would be true
+    expect(result.current.canLoadMore).toBe(false);
+  });
+
+  it('allows loadMore when totalCount is unknown but first page is full (hasMoreByFullPage)', async () => {
+    const fetchTemplates = jest.fn(({ page }) => {
+      if (page === 1) {
+        return Promise.resolve({
+          templates: [{ _id: 'a' }, { _id: 'b' }],
+          totalCount: 0,
+        });
+      }
+      return Promise.resolve({
+        templates: [{ _id: 'c' }],
+        totalCount: 0,
+      });
+    });
+
+    const { result } = renderHook(() =>
+      useLocalTemplateList({ fetchTemplates, perPage: 2 }),
+    );
+
+    act(() => {
+      result.current.reset('');
+    });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+      expect(result.current.canLoadMore).toBe(true);
+    });
+
+    act(() => {
+      result.current.loadMore();
+    });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.templates.map((t) => t._id)).toEqual(['a', 'b', 'c']);
+    expect(fetchTemplates).toHaveBeenCalledWith(
+      expect.objectContaining({ page: 2, reset: false }),
+    );
+  });
+});