cap-creatives-ui 8.0.280 → 8.0.321

package/app/v2Components/CommonTestAndPreview/tests/DeliverySettings/utils/parseSenderDetailsResponse.test.js

@@ -0,0 +1,576 @@
+/**
+ * Tests for parseSenderDetailsResponse
+ * Covers sender ID / delivery settings response parsing for SMS, EMAIL, WHATSAPP
+ */
+
+import { parseSenderDetailsResponse } from '../../../DeliverySettings/utils/parseSenderDetailsResponse';
+
+describe('parseSenderDetailsResponse', () => {
+  describe('when entity is missing or null', () => {
+    it('should return empty domains when response is null', () => {
+      expect(parseSenderDetailsResponse('SMS', null)).toEqual({ domains: [] });
+    });
+
+    it('should return empty domains when response is undefined', () => {
+      expect(parseSenderDetailsResponse('SMS', undefined)).toEqual({ domains: [] });
+    });
+
+    it('should return empty domains when entity is missing', () => {
+      expect(parseSenderDetailsResponse('SMS', {})).toEqual({ domains: [] });
+    });
+  });
+
+  describe('when entity is object with channel key', () => {
+    it('should parse SMS channel entity array', () => {
+      const response = {
+        entity: {
+          SMS: [
+            {
+              id: 10,
+              priority: 1,
+              domainProperties: {
+                domainName: 'SMS Domain 1',
+                id: 100,
+                contactInfo: [
+                  { type: 'gsm_sender_id', valid: true, value: 'GSM1', default: true },
+                  { type: 'cdma_sender_id', valid: true, value: 'CDMA1' },
+                ],
+                connectionProperties: {},
+              },
+            },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('SMS', response);
+      expect(result.domains).toHaveLength(1);
+      expect(result.domains[0]).toMatchObject({
+        dgmId: 10,
+        domainName: 'SMS Domain 1',
+        domainId: 100,
+        priority: 1,
+      });
+      expect(result.domains[0].gsmSenders).toHaveLength(1);
+      expect(result.domains[0].gsmSenders[0].value).toBe('GSM1');
+      expect(result.domains[0].cdmaSenders).toHaveLength(1);
+      expect(result.domains[0].cdmaSenders[0].value).toBe('CDMA1');
+    });
+
+    it('should populate SMS senders when channel argument is lowercase (normalized for branches)', () => {
+      const response = {
+        entity: {
+          SMS: [
+            {
+              id: 10,
+              priority: 1,
+              domainProperties: {
+                domainName: 'SMS Domain 1',
+                id: 100,
+                contactInfo: [
+                  { type: 'gsm_sender_id', valid: true, value: 'GSM1', default: true },
+                  { type: 'cdma_sender_id', valid: true, value: 'CDMA1' },
+                ],
+                connectionProperties: {},
+              },
+            },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('sms', response);
+      expect(result.domains).toHaveLength(1);
+      expect(result.domains[0].gsmSenders).toHaveLength(1);
+      expect(result.domains[0].gsmSenders[0].value).toBe('GSM1');
+      expect(result.domains[0].cdmaSenders).toHaveLength(1);
+    });
+
+    it('should parse EMAIL channel entity array', () => {
+      const response = {
+        entity: {
+          EMAIL: [
+            {
+              id: 20,
+              priority: 0,
+              domainProperties: {
+                domainName: 'Email Domain',
+                id: 200,
+                contactInfo: [
+                  { type: 'sender_id', valid: true, value: 'noreply@example.com' },
+                  { type: 'reply_to_id', valid: true, value: 'reply@example.com' },
+                ],
+              },
+            },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('EMAIL', response);
+      expect(result.domains).toHaveLength(1);
+      expect(result.domains[0]).toMatchObject({
+        dgmId: 20,
+        domainName: 'Email Domain',
+        domainId: 200,
+        priority: 0,
+      });
+      expect(result.domains[0].emailSenders).toHaveLength(1);
+      expect(result.domains[0].emailSenders[0].value).toBe('noreply@example.com');
+      expect(result.domains[0].emailRepliers).toHaveLength(1);
+      expect(result.domains[0].emailRepliers[0].value).toBe('reply@example.com');
+    });
+
+    it('should parse WHATSAPP channel with sourceAccountIdentifier', () => {
+      const response = {
+        entity: {
+          WHATSAPP: [
+            {
+              id: 30,
+              priority: 0,
+              domainProperties: {
+                domainName: 'WABA Domain',
+                id: 300,
+                contactInfo: [],
+                connectionProperties: {
+                  sourceAccountIdentifier: 'waba-123',
+                },
+              },
+            },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('WHATSAPP', response);
+      expect(result.domains).toHaveLength(1);
+      expect(result.domains[0].sourceAccountIdentifier).toBe('waba-123');
+      expect(result.domains[0].gsmSenders).toEqual([]);
+      expect(result.domains[0].cdmaSenders).toEqual([]);
+    });
+  });
+
+  describe('when entity is direct array', () => {
+    it('should use entity as channelSenderDetails when entity is array', () => {
+      const response = {
+        entity: [
+          {
+            id: 1,
+            priority: 0,
+            domainProperties: { domainName: 'Direct Domain', id: 1 },
+          },
+        ],
+      };
+      const result = parseSenderDetailsResponse('SMS', response);
+      expect(result.domains).toHaveLength(1);
+      expect(result.domains[0].domainName).toBe('Direct Domain');
+    });
+  });
+
+  describe('filtering and sorting', () => {
+    it('should filter contactInfo by type and valid', () => {
+      const response = {
+        entity: {
+          SMS: [
+            {
+              id: 1,
+              priority: 0,
+              domainProperties: {
+                domainName: 'D1',
+                id: 1,
+                contactInfo: [
+                  { type: 'gsm_sender_id', valid: true, value: 'A' },
+                  { type: 'gsm_sender_id', valid: false, value: 'B' },
+                  { type: 'other', valid: true, value: 'C' },
+                ],
+              },
+            },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('SMS', response);
+      expect(result.domains[0].gsmSenders).toHaveLength(1);
+      expect(result.domains[0].gsmSenders[0].value).toBe('A');
+    });
+
+    it('should sort domains by priority', () => {
+      const response = {
+        entity: {
+          SMS: [
+            { id: 1, priority: 2, domainProperties: { domainName: 'Second', id: 1 } },
+            { id: 2, priority: 0, domainProperties: { domainName: 'First', id: 2 } },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('SMS', response);
+      expect(result.domains[0].domainName).toBe('First');
+      expect(result.domains[1].domainName).toBe('Second');
+    });
+
+    it('should dedupe by domainName keeping first occurrence', () => {
+      const response = {
+        entity: {
+          SMS: [
+            { id: 1, priority: 0, domainProperties: { domainName: 'Same', id: 1 } },
+            { id: 2, priority: 1, domainProperties: { domainName: 'Same', id: 2 } },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('SMS', response);
+      expect(result.domains).toHaveLength(1);
+      expect(result.domains[0].domainId).toBe(1);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should return empty domains when channel key has no array', () => {
+      const response = { entity: { SMS: null } };
+      expect(parseSenderDetailsResponse('SMS', response)).toEqual({ domains: [] });
+    });
+
+    it('should return empty domains when channel key is missing and entity is not array', () => {
+      const response = { entity: { EMAIL: [] } };
+      expect(parseSenderDetailsResponse('SMS', response)).toEqual({ domains: [] });
+    });
+
+    it('should handle missing domainProperties with defaults', () => {
+      const response = {
+        entity: {
+          SMS: [{ id: 1, priority: 0 }],
+        },
+      };
+      const result = parseSenderDetailsResponse('SMS', response);
+      expect(result.domains).toHaveLength(1);
+      expect(result.domains[0].domainId).toBe(-1);
+      expect(result.domains[0].domainName).toBeUndefined();
+      expect(result.domains[0].gsmSenders).toEqual([]);
+      expect(result.domains[0].cdmaSenders).toEqual([]);
+    });
+
+    it('should use wabaId when sourceAccountIdentifier missing for WHATSAPP', () => {
+      const response = {
+        entity: {
+          WHATSAPP: [
+            {
+              id: 1,
+              priority: 0,
+              domainProperties: {
+                domainName: 'W',
+                id: 1,
+                connectionProperties: { wabaId: 'waba-456' },
+              },
+            },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('WHATSAPP', response);
+      expect(result.domains[0].sourceAccountIdentifier).toBe('waba-456');
+    });
+
+    it('should map hostName to domainName when domainName missing (RCS)', () => {
+      const response = {
+        entity: {
+          RCS: [
+            {
+              id: 1,
+              priority: 0,
+              domainProperties: {
+                hostName: 'rcs-host',
+                id: 42,
+                contactInfo: [
+                  { type: 'gsm_sender_id', valid: true, value: 'S1', default: true },
+                ],
+              },
+            },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('RCS', response);
+      expect(result.domains[0].domainName).toBe('rcs-host');
+      expect(result.domains[0].domainId).toBe(42);
+      expect(result.domains[0].gsmSenders[0].value).toBe('S1');
+    });
+
+    it('should unwrap result.entity when top-level entity is absent', () => {
+      const response = {
+        result: {
+          entity: {
+            SMS: [
+              {
+                id: 1,
+                priority: 0,
+                domainProperties: {
+                  domainName: 'ViaResult',
+                  id: 9,
+                  contactInfo: [{ type: 'gsm_sender_id', valid: true, value: 'G' }],
+                },
+              },
+            ],
+          },
+        },
+      };
+      const result = parseSenderDetailsResponse('SMS', response);
+      expect(result.domains[0].domainName).toBe('ViaResult');
+    });
+
+    it('should merge rcs_sender_id into gsmSenders for RCS', () => {
+      const response = {
+        entity: {
+          RCS: [
+            {
+              id: 1,
+              priority: 0,
+              domainProperties: {
+                domainName: 'RCS Domain',
+                id: 1,
+                contactInfo: [
+                  { type: 'rcs_sender_id', valid: true, value: 'RCS123', default: true },
+                ],
+              },
+            },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('RCS', response);
+      expect(result.domains[0].gsmSenders).toHaveLength(1);
+      expect(result.domains[0].gsmSenders[0].value).toBe('RCS123');
+    });
+
+    it('should unwrap data.entity when top-level entity is absent', () => {
+      const response = {
+        data: {
+          entity: {
+            SMS: [
+              {
+                id: 1,
+                priority: 0,
+                domainProperties: {
+                  domainName: 'ViaData',
+                  id: 9,
+                  contactInfo: [{ type: 'gsm_sender_id', valid: true, value: 'G' }],
+                },
+              },
+            ],
+          },
+        },
+      };
+      const result = parseSenderDetailsResponse('SMS', response);
+      expect(result.domains[0].domainName).toBe('ViaData');
+    });
+
+    it('should return empty domains when entity is explicitly null', () => {
+      expect(parseSenderDetailsResponse('SMS', { entity: null })).toEqual({ domains: [] });
+    });
+
+    it('should return empty when channel data is a non-domain object', () => {
+      expect(parseSenderDetailsResponse('SMS', { entity: { notAnArray: true } })).toEqual({ domains: [] });
+    });
+
+    it('should use userid when sourceAccountIdentifier and wabaId are missing (WHATSAPP)', () => {
+      const response = {
+        entity: {
+          WHATSAPP: [
+            {
+              id: 1,
+              priority: 0,
+              domainProperties: {
+                domainName: 'W',
+                id: 1,
+                connectionProperties: { userid: 'user-99' },
+              },
+            },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('WHATSAPP', response);
+      expect(result.domains[0].sourceAccountIdentifier).toBe('user-99');
+    });
+
+    it('should dedupe duplicate GSM values for RCS (merged contact types)', () => {
+      const response = {
+        entity: {
+          RCS: [
+            {
+              id: 1,
+              priority: 0,
+              domainProperties: {
+                domainName: 'R',
+                id: 1,
+                contactInfo: [
+                  { type: 'gsm_sender_id', valid: true, value: 'SAME', default: true },
+                  { type: 'rcs_sender_id', valid: true, value: 'SAME' },
+                ],
+              },
+            },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('RCS', response);
+      expect(result.domains[0].gsmSenders.filter((r) => r.value === 'SAME')).toHaveLength(1);
+    });
+
+    it('should return empty domains when response is not an object', () => {
+      expect(parseSenderDetailsResponse('SMS', 42)).toEqual({ domains: [] });
+      expect(parseSenderDetailsResponse('SMS', 'x')).toEqual({ domains: [] });
+    });
+
+    it('should return empty domains when entity is empty string', () => {
+      expect(parseSenderDetailsResponse('SMS', { entity: '' })).toEqual({ domains: [] });
+    });
+
+    it('should normalize hyphenated contactInfo.type to match gsm_sender_id', () => {
+      const response = {
+        entity: {
+          SMS: [
+            {
+              id: 1,
+              domainProperties: {
+                domainName: 'D',
+                id: 1,
+                contactInfo: [
+                  { type: 'gsm-sender-id', valid: true, value: 'HYPH' },
+                ],
+              },
+            },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('SMS', response);
+      expect(result.domains[0].gsmSenders[0].value).toBe('HYPH');
+    });
+
+    it('should skip whitespace-only GSM values when merging RCS contact types', () => {
+      const response = {
+        entity: {
+          RCS: [
+            {
+              id: 1,
+              domainProperties: {
+                domainName: 'R',
+                id: 1,
+                contactInfo: [
+                  { type: 'gsm_sender_id', valid: true, value: '   ' },
+                  { type: 'gsm_sender_id', valid: true, value: 'OK' },
+                ],
+              },
+            },
+          ],
+        },
+      };
+      const values = parseSenderDetailsResponse('RCS', response).domains[0].gsmSenders.map((g) => g.value);
+      expect(values).toEqual(['OK']);
+    });
+
+    it('should use default priority 0 when priority is null', () => {
+      const response = {
+        entity: {
+          SMS: [
+            {
+              id: 1,
+              priority: null,
+              domainProperties: {
+                domainName: 'P',
+                id: 9,
+                contactInfo: [],
+              },
+            },
+          ],
+        },
+      };
+      expect(parseSenderDetailsResponse('SMS', response).domains[0].priority).toBe(0);
+    });
+
+    it('should unwrap entity from raw response object when entity key is absent', () => {
+      const response = { misc: 1 };
+      expect(parseSenderDetailsResponse('SMS', response)).toEqual({ domains: [] });
+    });
+  });
+
+  describe('unwrapEntity edge cases', () => {
+    it('should return empty domains when entity key is explicitly null', () => {
+      // unwrapEntity: response.entity === null → returns null → parseSenderDetailsResponse returns { domains: [] }
+      expect(parseSenderDetailsResponse('SMS', { entity: null })).toEqual({ domains: [] });
+    });
+  });
+
+  describe('null or empty channel', () => {
+    it('should return empty domains when channel is null', () => {
+      const response = { entity: { SMS: [{ id: 1, domainProperties: { domainName: 'D', id: 10, contactInfo: [] } }] } };
+      expect(parseSenderDetailsResponse(null, response)).toEqual({ domains: [] });
+    });
+
+    it('should return empty domains when channel is empty string', () => {
+      const response = { entity: { SMS: [{ id: 1, domainProperties: { domainName: 'D', id: 10, contactInfo: [] } }] } };
+      expect(parseSenderDetailsResponse('', response)).toEqual({ domains: [] });
+    });
+  });
+
+  describe('single non-array domain object', () => {
+    it('should wrap single domain with domainProperties in an array and return one domain', () => {
+      const response = {
+        entity: {
+          SMS: {
+            id: 5,
+            domainProperties: {
+              domainName: 'SingleDomain',
+              id: 99,
+              contactInfo: [{ type: 'gsm_sender_id', valid: true, value: 'GSMSINGLE' }],
+            },
+          },
+        },
+      };
+      const result = parseSenderDetailsResponse('SMS', response);
+      expect(result.domains).toHaveLength(1);
+      expect(result.domains[0].domainName).toBe('SingleDomain');
+      expect(result.domains[0].gsmSenders[0].value).toBe('GSMSINGLE');
+    });
+
+    it('should return empty domains for single non-array domain without domainProperties', () => {
+      const response = {
+        entity: { SMS: { id: 5, someProp: 'value' } },
+      };
+      expect(parseSenderDetailsResponse('SMS', response)).toEqual({ domains: [] });
+    });
+  });
+
+  describe('deduplication by domainId when domainName is null', () => {
+    it('should deduplicate two entries sharing the same domainId when domainName is null', () => {
+      const response = {
+        entity: {
+          SMS: [
+            {
+              id: 10,
+              priority: 1,
+              domainProperties: { domainName: null, id: 42, contactInfo: [] },
+            },
+            {
+              id: 11,
+              priority: 2,
+              domainProperties: { domainName: null, id: 42, contactInfo: [] },
+            },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('SMS', response);
+      expect(result.domains).toHaveLength(1);
+      expect(result.domains[0].domainId).toBe(42);
+    });
+  });
+
+  describe('typeMatches null-type filtering', () => {
+    it('should exclude contactInfo items with null type from gsmSenders', () => {
+      const response = {
+        entity: {
+          SMS: [
+            {
+              id: 1,
+              domainProperties: {
+                domainName: 'D',
+                id: 1,
+                contactInfo: [
+                  { type: null, valid: true, value: 'EXCLUDED' },
+                  { type: 'gsm_sender_id', valid: true, value: 'INCLUDED' },
+                ],
+              },
+            },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('SMS', response);
+      expect(result.domains[0].gsmSenders).toHaveLength(1);
+      expect(result.domains[0].gsmSenders[0].value).toBe('INCLUDED');
+    });
+  });
+});