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

package/utils/tests/common.test.js

@@ -1,365 +1,307 @@
-import React from 'react';
-import Bugsnag from '@bugsnag/js';
-import { FormattedMessage } from 'react-intl';
-import "@testing-library/jest-dom";
+/**
+ * Test suite for common utility functions
+ */
 import {
-  filterTags,
-  getTreeStructuredTags,
-  handleInjectedData,
-  intlKeyGenerator,
-  bytes2Size,
   getUserNameById,
+  getMergedUserList,
+  removeLinksFromHtmlContent,
   iframePreviewAdjustWidth,
-  getDecodedFileName,
-  createQueryString,
-  getMergedUserList
-} from "../common";
-import * as mockdata from "./common.mockdata";
-
-describe("getTreeStructuredTags test", () => {
-  it("test for getTreeStructuredTags when tagsList is not empty", () => {
-    expect(getTreeStructuredTags({ tagsList: mockdata.tagsList })).toEqual(mockdata.output1);
-  });
-  it("test for getTreeStructuredTags when tagsList is empty", () => {
-    expect(getTreeStructuredTags({ tagsList: [] })).toEqual([]);
-  });
+} from '../common';
+
+// Mock the Auth module
+jest.mock('@capillarytech/cap-ui-utils', () => ({
+  Auth: {
+    hasFeatureAccess: jest.fn(),
+  },
+}));
+
+describe('common Utility Functions', () => {
+  describe('getUserNameById', () => {
+    it('should return full name when user found', () => {
+      const userList = [
+        { userId: '1', firstName: 'John', lastName: 'Doe' },
+        { userId: '2', firstName: 'Jane', lastName: 'Smith' },
+      ];
+
+      const result = getUserNameById('1', userList);
+
+      expect(result).toBe('John Doe');
+    });
 
-  it("test for getTreeStructuredTags when incentive attached is BADGES", () => {
-    expect(getTreeStructuredTags({ tagsList: mockdata.badgesTags, offerDetails: mockdata.offer })).toEqual(mockdata.expectedOffer);
-  });
-  it("test for filterTags", () => {
-    expect(filterTags(mockdata.tagsToFilter, mockdata.tagsList)).toEqual([mockdata.tagsList[1]]);
-  });
-  it("test for filterTags when tagsToFilter and tagsList is empty", () => {
-    expect(filterTags([], [])).toEqual([]);
-  });
-  it("test for getTreeStructuredTags when incentive attached is offer", () => {
-    expect(getTreeStructuredTags({ tagsList: mockdata.OfferTag, offerDetails: [{ id: '12', couponName: 'mac' }] })).toEqual(mockdata.offerOutput);
-  });
-});
+    it('should return empty string when user not found', () => {
+      const userList = [
+        { userId: '1', firstName: 'John', lastName: 'Doe' },
+      ];
 
-describe("getUserNameById test", () => {
-  it("test for username is available or not", () => {
-    const data = [
-      {
-        userId: 1,
-        firstName: 'test1',
-        lastName: 'test2',
-
-      },
-      {
-        userId: 2,
-        firstName: 'test3',
-        lastName: 'test4',
-
-      },
-    ];
-    const expected = 'test1 test2';
-    expect(getUserNameById(1, data)).toEqual(expected);
-  });
-});
+      const result = getUserNameById('999', userList);
 
-describe("handleInjectedData", () => {
-  it("replaces name with intl key for top level tag", () => {
-    const data = {
-      tag1: {
-        name: "Registration Fields",
-      },
-    };
-
-    const result = handleInjectedData(data, "scope");
-    const intlKey = intlKeyGenerator("scope");
-    expect(intlKey).toEqual('scope');
-    expect(result.tag1.name).toEqual(<FormattedMessage defaultMessage="Registration Fields" id="scope.registration_fields" values={{}} />);
-  });
+      expect(result).toBe('');
+    });
 
-  it("adds tagType for Registration custom fields", () => {
-    const data = {
-      tag1: {
-        name: "Registration custom fields",
-      },
-    };
-
-    const result = handleInjectedData(data, "scope");
-    const intlKey = intlKeyGenerator();
-    expect(intlKey).toEqual('');
-    expect(result.tag1.name).toEqual(
-      <FormattedMessage defaultMessage="Registration custom fields" id="scope.registration_custom_fields_name.CustomTagMessage" values={{}} />
-    );
-  });
+    it('should handle empty user list', () => {
+      const result = getUserNameById('1', []);
 
-  it("adds tagType for Customer extended fields fields", () => {
-    const data = {
-      tag1: {
-        name: "Customer extended fields",
-      },
-    };
+      expect(result).toBe('');
+    });
 
-    const result = handleInjectedData(data, "scope");
+    it('should handle multiple users with same ID (returns last match)', () => {
+      const userList = [
+        { userId: '1', firstName: 'John', lastName: 'Doe' },
+        { userId: '1', firstName: 'Jane', lastName: 'Smith' },
+      ];
 
-    expect(result.tag1.name).toEqual(
-      <FormattedMessage defaultMessage="Customer extended fields" id="scope.customer_extended_fields_name.ExtendedTagMessage" values={{}} />
-    );
-  });
-  it("adds tagType for Customer extended fields fields", () => {
-    const data = {
-      tag1: {
-      },
-    };
+      const result = getUserNameById('1', userList);
 
-    const result = handleInjectedData(data, "scope");
+      // Should return the last match due to forEach iteration
+      expect(result).toBe('Jane Smith');
+    });
 
-    expect(result.tag1.name).toEqual(undefined);
-  });
+    it('should handle users with empty names', () => {
+      const userList = [
+        { userId: '1', firstName: '', lastName: '' },
+      ];
 
-  it("adds tagType for Customer with  extended fields fields", () => {
-    const data = {
-      tag1: {
-        name: "mahaRaja",
-        subtag1: {
-          name: "First Name",
-        },
-      },
-    };
+      const result = getUserNameById('1', userList);
 
-    const result = handleInjectedData(data, "scope");
+      expect(result).toBe(' ');
+    });
 
-    expect(result.tag1.subtag1.name).toEqual("First Name");
-  });
-  it("replaces subtag name with intl key", () => {
-    const data = {
-      tag1: {
-        subtags: {
-          subtag1: {
-            name: "First Name",
-            hasOwnProperty: jest.fn(),
-          },
-          hasOwnProperty: jest.fn(),
-        },
-      },
-    };
-
-    const result = handleInjectedData(data, "scope");
-
-    expect(result.tag1.subtags.subtag1.name).toEqual("First Name");
-  });
+    it('should handle users with only first name', () => {
+      const userList = [
+        { userId: '1', firstName: 'John', lastName: '' },
+      ];
 
-  it("replaces subtag name with intl key test", () => {
-    const data = {
-      tag1: {
-        subtags: {
-          subtag1: {
-            name: "First Name",
-            hasOwnProperty: jest.fn(),
-          },
-        },
-      },
-      hasOwnProperty: jest.fn(),
-    };
-
-    const result = handleInjectedData(data, "scope");
-
-    expect(result.tag1.subtags.subtag1.name).toEqual("First Name");
-  });
+      const result = getUserNameById('1', userList);
 
-  it("replaces subtag desc with intl key", () => {
-    const data = {
-      tag1: {
-        subtags: {
-          subtag1: {
-            desc: "Enter your first name",
-          },
-        },
-      },
-    };
-
-    const result = handleInjectedData(data, "scope");
-
-    expect(result.tag1.subtags.subtag1.desc).toEqual(
-      <FormattedMessage defaultMessage="Enter your first name" id="scope.enter_your_first_name" values={{}} />
-    );
-  });
-  it("replaces subtag name desc with intl key", () => {
-    const data = {
-      tag1: {
-        subtags: {
-          subtag1: {
-            name: "mahaRaja",
-            desc: "Enter your first name",
-          },
-        },
-      },
-    };
-
-    const result = handleInjectedData(data, "scope");
-
-    expect(result.tag1.subtags.subtag1.desc).toEqual(
-      <FormattedMessage defaultMessage="Enter your first name" id="scope.enter_your_first_name" values={{}} />
-    );
+      expect(result).toContain('John');
+    });
   });
-});
 
-describe('bytes2Size', () => {
-  it('should convert bytes to the correct size string', () => {
-    // Test cases with different byte values
-    expect(bytes2Size(0)).toBe('0 Bytes');
-    expect(bytes2Size(1023)).toBe('1023 Bytes');
-    expect(bytes2Size(1024)).toBe('1 KB');
-    expect(bytes2Size(1048576)).toBe('1 MB');
-    expect(bytes2Size(1099511627776)).toBe('1 TB');
-    expect(bytes2Size(1125899906842624)).toBe('1 PB');
-    expect(bytes2Size(1152921504606846976)).toBe('1 EB');
-    expect(bytes2Size(1180591620717411303424)).toBe('1 ZB');
-    expect(bytes2Size(Number.MAX_SAFE_INTEGER)).toBe('8 PB'); // Test with the maximum safe integer value
-  });
+  describe('getMergedUserList', () => {
+    it('should merge all user lists when isCapUser is true', () => {
+      const userList = {
+        capUsers: [
+          { userId: '1', name: 'CAP User' },
+        ],
+        otherUsers: [
+          { userId: '2', name: 'Other User' },
+        ],
+      };
 
-  it('should handle negative decimals', () => {
-    // Test with negative decimal values
-    expect(bytes2Size(1024, -1)).toBe('1 KB'); // Decimals < 0 should round to 0
-    expect(bytes2Size(1024, -2)).toBe('1 KB');
-    expect(bytes2Size(1024, -3)).toBe('1 KB');
-  });
-});
+      const result = getMergedUserList(userList, true);
 
-describe('iframeAdjustWidth', () => {
-  it("should Add the width in iframe image", () => {
-    const data = [
-      <head>
-        <meta httpEquiv="Content-Type" content="text/html; charset=utf-8">
-          <meta name="viewport" content="width=device-width">
-          </meta>
-        </meta>
-      </head>,
-
-    ];
-    expect(iframePreviewAdjustWidth(data)).toBe("<html><head></head><body>[object Object]</body></html>");
-  });
-});
+      expect(result).toHaveLength(2);
+      expect(result[0].name).toBe('CAP User');
+      expect(result[1].name).toBe('Other User');
+    });
 
-describe('getDecodedFileName function', () => {
-  it('Returns an empty string when templateName is undefined', () => {
-    expect(getDecodedFileName()).toEqual('');
-  });
+    it('should exclude capUsers when isCapUser is false', () => {
+      const userList = {
+        capUsers: [
+          { userId: '1', name: 'CAP User' },
+        ],
+        otherUsers: [
+          { userId: '2', name: 'Other User' },
+        ],
+      };
 
-  it('Returns the decoded filename from encoded filename', () => {
-    expect(getDecodedFileName('%24Test.jpeg')).toEqual('$Test.jpeg');
-    expect(getDecodedFileName('cap%24.logo.%23.jpg')).toEqual('cap$.logo.#.jpg');
-    expect(getDecodedFileName("%24L_i%40n%26e__%60AL%60L%2BI'ma_g__e%2Bco_pyAI____Copy____Copy_wek1SeS0.jpg")).toEqual("$L_i@n&e__`AL`L+I'ma_g__e+co_pyAI____Copy____Copy_wek1SeS0.jpg");
-    expect(getDecodedFileName('test.jpeg')).toEqual('test.jpeg');
-  });
+      const result = getMergedUserList(userList, false);
 
-  it('Returns the original filename when decoding fails due to URIError', () => {
-    const fileName = '@Test%ZZ.jpeg';
-    expect(getDecodedFileName(fileName)).toEqual(fileName);
-  });
+      expect(result).toHaveLength(1);
+      expect(result[0].name).toBe('Other User');
+    });
+
+    it('should handle empty user lists', () => {
+      const userList = {};
 
-  it('Returns the original filename and notifies Bugsnag for other decoding errors', () => {
-    // Mocking Bugsnag methods for testing
-    const originalLeaveBreadcrumb = Bugsnag.leaveBreadcrumb;
-    const originalNotify = Bugsnag.notify;
-    Bugsnag.leaveBreadcrumb = jest.fn();
-    Bugsnag.notify = jest.fn((error, callback) => {
-      const event = {};
-      callback(event);
-      expect(event.severity).toEqual("error");
+      const result = getMergedUserList(userList, true);
+
+      expect(result).toHaveLength(0);
     });
-    const fileName = '@Test%20ZZ.jpg';
-    const error = new Error('Some other decoding error');
-    // Mocking decodeURIComponent to throw the error
-    global.decodeURIComponent = jest.fn(() => { throw error; });
-
-    expect(getDecodedFileName(fileName)).toEqual(fileName);
-    expect(Bugsnag.notify).toHaveBeenCalled();
-    // Restoring original Bugsnag methods
-    Bugsnag.leaveBreadcrumb = originalLeaveBreadcrumb;
-    Bugsnag.notify = originalNotify;
-  });
-});
 
-describe('createQueryString', () => {
-  it('should return a query string for a valid object with multiple key-value pairs', () => {
-    const input = { name: 'John', age: 30, city: 'New York' };
-    const result = createQueryString(input);
-    expect(result).toBe('?name=John&age=30&city=New%20York');
-  });
+    it('should handle empty nested arrays', () => {
+      const userList = {
+        capUsers: [],
+        otherUsers: [],
+      };
 
-  it('should return an empty string for an empty object', () => {
-    const input = {};
-    const result = createQueryString(input);
-    expect(result).toBe('');
-  });
+      const result = getMergedUserList(userList, true);
 
-  it('should return an empty string for null or undefined input', () => {
-    expect(createQueryString(null)).toBe('');
-    expect(createQueryString(undefined)).toBe('');
-  });
+      expect(result).toHaveLength(0);
+    });
 
-  it('should return an empty string for non-object input', () => {
-    expect(createQueryString("string")).toBe('');
-    expect(createQueryString(123)).toBe('');
-    expect(createQueryString(true)).toBe('');
-  });
+    it('should handle single user list', () => {
+      const userList = {
+        users: [
+          { userId: '1', name: 'User 1' },
+          { userId: '2', name: 'User 2' },
+        ],
+      };
 
-  it('should encode special characters in keys and values', () => {
-    const input = { 'key with spaces': 'value with spaces', 'special&characters': 'value@#' };
-    const result = createQueryString(input);
-    expect(result).toBe('?key%20with%20spaces=value%20with%20spaces&special%26characters=value%40%23');
-  });
+      const result = getMergedUserList(userList, true);
 
-  it('should handle null or undefined values in query parameters', () => {
-    const input = { name: 'John', age: null, city: undefined };
-    const result = createQueryString(input);
-    expect(result).toBe('?name=John&age=null&city=undefined');
-  });
+      expect(result).toHaveLength(2);
+    });
 
-  it('should return query string for a single key-value pair', () => {
-    const input = { name: 'John' };
-    const result = createQueryString(input);
-    expect(result).toBe('?name=John');
-  });
-});
-describe('getMergedUserList', () => {
-  it('should merge user list when isCapUser is true', () => {
-    const userList = {
-      capUsers: [{ id: 1, name: 'Cap User 1' }],
-      otherUsers: [{ id: 2, name: 'Other User 1' }],
-    };
-    
-    const result = getMergedUserList(userList, true);
-
-    expect(result).toEqual([
-      { id: 1, name: 'Cap User 1' },
-      { id: 2, name: 'Other User 1' },
-    ]);
-  });
+    it('should default isCapUser to true', () => {
+      const userList = {
+        capUsers: [{ userId: '1', name: 'CAP User' }],
+        otherUsers: [{ userId: '2', name: 'Other User' }],
+      };
 
-  it('should merge user list excluding capUsers when isCapUser is false', () => {
-    const userList = {
-      capUsers: [{ id: 1, name: 'Cap User 1' }],
-      otherUsers: [{ id: 2, name: 'Other User 1' }],
-    };
-    
-    const result = getMergedUserList(userList, false);
+      const result = getMergedUserList(userList);
 
-    expect(result).toEqual([{ id: 2, name: 'Other User 1' }]);
+      expect(result).toHaveLength(2);
+    });
   });
 
-  it('should handle empty userList', () => {
-    const userList = {};
-    
-    const result = getMergedUserList(userList, true);
+  describe('removeLinksFromHtmlContent', () => {
+    it('should remove href attributes from anchor tags', () => {
+      const content = '<a href="https://example.com">Click here</a>';
+
+      const result = removeLinksFromHtmlContent(content);
+
+      expect(result).toContain('<a>');
+      expect(result).not.toContain('href="https://example.com"');
+    });
+
+    it('should preserve anchor tag content', () => {
+      const content = '<a href="https://example.com">Click here</a>';
+
+      const result = removeLinksFromHtmlContent(content);
 
-    expect(result).toEqual([]);
+      expect(result).toContain('Click here');
+    });
+
+    it('should handle multiple links', () => {
+      const content = '<a href="url1">Link 1</a><a href="url2">Link 2</a>';
+
+      const result = removeLinksFromHtmlContent(content);
+
+      expect(result).toContain('<a>');
+      expect(result).toContain('Link 1');
+      expect(result).toContain('Link 2');
+    });
+
+    it('should handle complex HTML with nested content', () => {
+      const content = '<div><p><a href="url">Link</a></p></div>';
+
+      const result = removeLinksFromHtmlContent(content);
+
+      expect(result).toContain('<a>');
+      expect(result).toContain('<p>');
+      expect(result).toContain('Link');
+    });
+
+    it('should handle content without links', () => {
+      const content = '<p>No links here</p>';
+
+      const result = removeLinksFromHtmlContent(content);
+
+      expect(result).toContain('No links here');
+      expect(result).toContain('<p>');
+    });
+
+    it('should handle anchor tags with multiple attributes', () => {
+      const content = '<a href="url" title="Title" class="link">Link</a>';
+
+      const result = removeLinksFromHtmlContent(content);
+
+      expect(result).toContain('<a>');
+      expect(result).not.toContain('href="url"');
+    });
+
+    it('should handle empty anchor tags', () => {
+      const content = '<a href="url"></a>';
+
+      const result = removeLinksFromHtmlContent(content);
+
+      expect(result).toContain('<a>');
+    });
   });
 
-  it('should handle userList with empty arrays', () => {
-    const userList = {
-      capUsers: [],
-      otherUsers: [],
-    };
-    
-    const result = getMergedUserList(userList);
+  describe('iframePreviewAdjustWidth', () => {
+    it('should add width attribute to img tags', () => {
+      const content = '<img src="image.jpg" />';
+
+      const result = iframePreviewAdjustWidth(content);
+
+      expect(result).toContain('width="310"');
+      expect(result).toContain('src="image.jpg"');
+    });
+
+    it('should set width to 310 pixels', () => {
+      const content = '<img src="image.jpg" />';
+
+      const result = iframePreviewAdjustWidth(content);
+
+      expect(result).toContain('width="310"');
+    });
+
+    it('should handle multiple img tags', () => {
+      const content = '<img src="image1.jpg" /><img src="image2.jpg" />';
+
+      const result = iframePreviewAdjustWidth(content);
+
+      const widthCount = (result.match(/width="310"/g) || []).length;
+      expect(widthCount).toBe(2);
+    });
+
+    it('should preserve existing img attributes', () => {
+      const content = '<img src="image.jpg" alt="Alt text" />';
+
+      const result = iframePreviewAdjustWidth(content);
+
+      expect(result).toContain('src="image.jpg"');
+      expect(result).toContain('alt="Alt text"');
+      expect(result).toContain('width="310"');
+    });
+
+    it('should handle img tags with other attributes', () => {
+      const content = '<img src="image.jpg" height="200" class="responsive" />';
+
+      const result = iframePreviewAdjustWidth(content);
+
+      expect(result).toContain('width="310"');
+      expect(result).toContain('height="200"');
+      expect(result).toContain('class="responsive"');
+    });
+
+    it('should handle content without img tags', () => {
+      const content = '<p>No images here</p>';
 
-    expect(result).toEqual([]);
+      const result = iframePreviewAdjustWidth(content);
+
+      expect(result).toContain('<p>No images here</p>');
+      expect(result).not.toContain('width="310"');
+    });
+
+    it('should handle complex HTML structure', () => {
+      const content = '<div><img src="image.jpg" /><p>Text</p><img src="image2.jpg" /></div>';
+
+      const result = iframePreviewAdjustWidth(content);
+
+      const widthCount = (result.match(/width="310"/g) || []).length;
+      expect(widthCount).toBe(2);
+      expect(result).toContain('<p>Text</p>');
+    });
+
+    it('should handle self-closing and non-self-closing img tags', () => {
+      const content1 = '<img src="image.jpg" />';
+      const content2 = '<img src="image.jpg">';
+
+      const result1 = iframePreviewAdjustWidth(content1);
+      const result2 = iframePreviewAdjustWidth(content2);
+
+      expect(result1).toContain('width="310"');
+      expect(result2).toContain('width="310"');
+    });
+
+    it('should handle empty content', () => {
+      const result = iframePreviewAdjustWidth('');
+      // When empty string is parsed as HTML, the DOM parser adds html/head/body tags
+      expect(result).toContain('<html>');
+      expect(result).toContain('<body>');
+    });
   });
-});
+});