@capillarytech/creatives-library 8.0.329 → 8.0.330

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

@@ -1,261 +0,0 @@
-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

@@ -1,422 +0,0 @@
-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 }),
-    );
-  });
-});