@capillarytech/creatives-library 8.0.145 → 8.0.147-beta.5

package/utils/tests/transformerUtils.test.js

@@ -11,7 +11,10 @@ import {
   MOBILE_PUSH,
   WHATSAPP,
   PUSH,
-  ZALO
+  ZALO,
+  RCS,
+  LINE,
+  VIBER,
 } from "../../v2Containers/CreativesContainer/constants";
 
 describe("transformerUtils", () => {
@@ -819,6 +822,366 @@ describe("transformerUtils", () => {
     });
   });
 
+  describe("RCS payload transformation", () => {
+    it("should transform RCS data with all options", () => {
+      const mockData = {
+        channel: RCS,
+        messageBody: "test rcs message",
+        accountId: "rcs-account-123",
+        accountName: "RCS Official Account",
+        templateConfigs: {
+          id: "template-789",
+          name: "notification_template",
+          template: "https://example.com/rcs-template",
+          varMapped: {
+            customer: "Mike Johnson",
+            notification: "Important Update",
+            urgency: "HIGH"
+          }
+        }
+      };
+
+      const options = {
+        loyaltyMetaData: {
+          actionId: "action-123",
+          ouId: 456,
+          clientName: "TestClient",
+          module: "TestModule",
+          transformedMessageDetails: {
+            rcsDeliverySettings: {
+              sendDate: "2023-01-01",
+              priority: "URGENT"
+            }
+          }
+        }
+      };
+
+      const result = transformChannelPayload(mockData, options);
+
+      // Check base payload
+      expect(result.centralCommsPayload.sourceEntityId).toEqual("action-123");
+      expect(result.centralCommsPayload.ouId).toEqual(456);
+      expect(result.centralCommsPayload.clientName).toEqual("TestClient");
+      expect(result.centralCommsPayload.module).toEqual("TestModule");
+      // Check RCS-specific content
+      expect(result.centralCommsPayload.rcsMessageContent.messageBody).toEqual(
+        "test rcs message"
+      );
+      expect(result.centralCommsPayload.rcsMessageContent.accountId).toEqual(
+        "rcs-account-123"
+      );
+      expect(result.centralCommsPayload.rcsMessageContent.accountName).toEqual(
+        "RCS Official Account"
+      );
+      // Check template configs
+      expect(
+        result.centralCommsPayload.rcsMessageContent.templateConfigs.id
+      ).toEqual("template-789");
+      expect(
+        result.centralCommsPayload.rcsMessageContent.templateConfigs.name
+      ).toEqual("notification_template");
+      expect(
+        result.centralCommsPayload.rcsMessageContent.templateConfigs.template
+      ).toEqual("https://example.com/rcs-template");
+      expect(
+        result.centralCommsPayload.rcsMessageContent.templateConfigs.varMapped
+      ).toEqual({
+        customer: "Mike Johnson",
+        notification: "Important Update",
+        urgency: "HIGH"
+      });
+      // Check delivery settings
+      expect(result.centralCommsPayload.rcsDeliverySettings).toEqual({
+        sendDate: "2023-01-01",
+        priority: "URGENT"
+      });
+    });
+
+    it("should handle missing template configs", () => {
+      const mockData = {
+        channel: RCS,
+        messageBody: "test rcs message"
+      };
+
+      const result = transformChannelPayload(mockData);
+
+      expect(
+        result.centralCommsPayload.rcsMessageContent.templateConfigs
+      ).toEqual({});
+    });
+
+    it("should handle undefined rcsDeliverySettings", () => {
+      const mockData = {
+        channel: RCS,
+        messageBody: "test rcs message"
+      };
+
+      const options = {
+        loyaltyMetaData: {
+          transformedMessageDetails: {}
+        }
+      };
+
+      const result = transformChannelPayload(mockData, options);
+
+      expect(result.centralCommsPayload.rcsDeliverySettings).toEqual({});
+    });
+
+    it("should initialize default values when fields are missing", () => {
+      const mockData = {
+        channel: RCS
+      };
+
+      const result = transformChannelPayload(mockData);
+
+      expect(result.centralCommsPayload.rcsMessageContent.messageBody).toEqual(
+        ""
+      );
+      expect(result.centralCommsPayload.rcsMessageContent.accountId).toEqual(
+        ""
+      );
+      expect(result.centralCommsPayload.rcsMessageContent.accountName).toEqual(
+        ""
+      );
+    });
+  });
+
+  describe("LINE payload transformation", () => {
+    it("should transform LINE data correctly with minimal data", () => {
+      const mockData = {
+        channel: LINE,
+        messageBody: "test line message"
+      };
+
+      const result = transformChannelPayload(mockData);
+
+      expect(result.centralCommsPayload).toBeDefined();
+      expect(result.centralCommsPayload.channel).toEqual(LINE);
+      expect(result.centralCommsPayload.lineMessageContent.messageBody).toEqual(
+        "test line message"
+      );
+      expect(result.centralCommsPayload.clientName).toEqual("VENENO");
+    });
+
+    it("should transform LINE data with all options", () => {
+      const mockData = {
+        channel: LINE,
+        messageBody: "test line message",
+        accountId: 12345,
+        accountDetails: "LINE Official Account Details"
+      };
+
+      const options = {
+        loyaltyMetaData: {
+          actionId: "action-123",
+          ouId: 456,
+          clientName: "TestClient",
+          module: "TestModule",
+          transformedMessageDetails: {
+            lineDeliverySettings: {
+              sendDate: "2023-01-01",
+              priority: "NORMAL"
+            }
+          }
+        }
+      };
+
+      const result = transformChannelPayload(mockData, options);
+
+      // Check base payload
+      expect(result.centralCommsPayload.sourceEntityId).toEqual("action-123");
+      expect(result.centralCommsPayload.ouId).toEqual(456);
+      expect(result.centralCommsPayload.clientName).toEqual("TestClient");
+      expect(result.centralCommsPayload.module).toEqual("TestModule");
+
+      // Check LINE-specific content
+      expect(result.centralCommsPayload.lineMessageContent.messageBody).toEqual(
+        "test line message"
+      );
+      expect(result.centralCommsPayload.lineMessageContent.accountId).toEqual(12345);
+      expect(result.centralCommsPayload.lineMessageContent.accountDetails).toEqual(
+        "LINE Official Account Details"
+      );
+
+      // Check delivery settings
+      expect(result.centralCommsPayload.lineDeliverySettings).toEqual({
+        sendDate: "2023-01-01",
+        priority: "NORMAL"
+      });
+    });
+
+    it("should handle undefined lineDeliverySettings", () => {
+      const mockData = {
+        channel: LINE,
+        messageBody: "test line message"
+      };
+
+      const options = {
+        loyaltyMetaData: {
+          transformedMessageDetails: {}
+        }
+      };
+
+      const result = transformChannelPayload(mockData, options);
+
+      expect(result.centralCommsPayload.lineDeliverySettings).toEqual({});
+    });
+
+    it("should initialize default values when fields are missing", () => {
+      const mockData = {
+        channel: LINE
+      };
+
+      const result = transformChannelPayload(mockData);
+
+      expect(result.centralCommsPayload.lineMessageContent.messageBody).toEqual(
+        ""
+      );
+      expect(result.centralCommsPayload.lineMessageContent.accountId).toEqual(0);
+      expect(result.centralCommsPayload.lineMessageContent.accountDetails).toEqual(
+        ""
+      );
+    });
+
+    it("should preserve all original LINE data properties", () => {
+      const mockData = {
+        channel: LINE,
+        messageBody: "test line message",
+        accountId: 12345,
+        accountDetails: "LINE Official Account Details",
+        customField1: "custom value 1",
+        customField2: "custom value 2"
+      };
+
+      const result = transformChannelPayload(mockData);
+
+      expect(result.centralCommsPayload.lineMessageContent.customField1).toEqual(
+        "custom value 1"
+      );
+      expect(result.centralCommsPayload.lineMessageContent.customField2).toEqual(
+        "custom value 2"
+      );
+    });
+  });
+
+  describe("VIBER payload transformation", () => {
+    it("should transform VIBER data correctly with minimal data", () => {
+      const mockData = {
+        channel: VIBER,
+        messageBody: "test viber message"
+      };
+
+      const result = transformChannelPayload(mockData);
+
+      expect(result.centralCommsPayload).toBeDefined();
+      expect(result.centralCommsPayload.channel).toEqual(VIBER);
+      expect(result.centralCommsPayload.viberMessageContent.messageBody).toEqual(
+        "test viber message"
+      );
+      expect(result.centralCommsPayload.clientName).toEqual("VENENO");
+    });
+
+    it("should transform VIBER data with all options", () => {
+      const mockData = {
+        channel: VIBER,
+        messageBody: "test viber message",
+        accountId: 67890,
+        accountDetails: "VIBER Official Account Details"
+      };
+
+      const options = {
+        loyaltyMetaData: {
+          actionId: "action-123",
+          ouId: 456,
+          clientName: "TestClient",
+          module: "TestModule",
+          transformedMessageDetails: {
+            viberDeliverySettings: {
+              sendDate: "2023-01-01",
+              priority: "HIGH"
+            }
+          }
+        }
+      };
+
+      const result = transformChannelPayload(mockData, options);
+
+      // Check base payload
+      expect(result.centralCommsPayload.sourceEntityId).toEqual("action-123");
+      expect(result.centralCommsPayload.ouId).toEqual(456);
+      expect(result.centralCommsPayload.clientName).toEqual("TestClient");
+      expect(result.centralCommsPayload.module).toEqual("TestModule");
+
+      // Check VIBER-specific content
+      expect(result.centralCommsPayload.viberMessageContent.messageBody).toEqual(
+        "test viber message"
+      );
+      expect(result.centralCommsPayload.viberMessageContent.accountId).toEqual(67890);
+      expect(result.centralCommsPayload.viberMessageContent.accountDetails).toEqual(
+        "VIBER Official Account Details"
+      );
+
+      // Check delivery settings
+      expect(result.centralCommsPayload.viberDeliverySettings).toEqual({
+        sendDate: "2023-01-01",
+        priority: "HIGH"
+      });
+    });
+
+    it("should handle undefined viberDeliverySettings", () => {
+      const mockData = {
+        channel: VIBER,
+        messageBody: "test viber message"
+      };
+
+      const options = {
+        loyaltyMetaData: {
+          transformedMessageDetails: {}
+        }
+      };
+
+      const result = transformChannelPayload(mockData, options);
+
+      expect(result.centralCommsPayload.viberDeliverySettings).toEqual({});
+    });
+
+    it("should initialize default values when fields are missing", () => {
+      const mockData = {
+        channel: VIBER
+      };
+
+      const result = transformChannelPayload(mockData);
+
+      expect(result.centralCommsPayload.viberMessageContent.messageBody).toEqual(
+        ""
+      );
+      expect(result.centralCommsPayload.viberMessageContent.accountId).toEqual(0);
+      expect(result.centralCommsPayload.viberMessageContent.accountDetails).toEqual(
+        ""
+      );
+    });
+
+    it("should preserve all original VIBER data properties", () => {
+      const mockData = {
+        channel: VIBER,
+        messageBody: "test viber message",
+        accountId: 67890,
+        accountDetails: "VIBER Official Account Details",
+        customField1: "custom value 1",
+        customField2: "custom value 2"
+      };
+
+      const result = transformChannelPayload(mockData);
+
+      expect(result.centralCommsPayload.viberMessageContent.customField1).toEqual(
+        "custom value 1"
+      );
+      expect(result.centralCommsPayload.viberMessageContent.customField2).toEqual(
+        "custom value 2"
+      );
+    });
+  });
+
   describe("getTemplateDiffState", () => {
     it("should return false for unsupported channel", () => {
       const result = getTemplateDiffState("UNSUPPORTED_CHANNEL", {}, {});
@@ -2124,4 +2487,501 @@ describe("transformerUtils", () => {
       ).toBe(true);
     });
   });
+
+  describe("LINE template diff checking", () => {
+    it("should detect changes in message content", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          lineMessageContent: {
+            messageBody: "old line message",
+            accountId: "same-account",
+            accountDetails: "same-details",
+          },
+        },
+      };
+
+      const newData = {
+        messageBody: "new line message",
+        accountId: "same-account",
+        accountDetails: "same-details",
+      };
+
+      const result = getTemplateDiffState(LINE, oldData, newData);
+
+      expect(result).toBe(true);
+    });
+
+    it("should detect changes in accountId", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          lineMessageContent: {
+            messageBody: "same line message",
+            accountId: "old-account-123",
+            accountDetails: "same-details",
+          },
+        },
+      };
+
+      const newData = {
+        messageBody: "same line message",
+        accountId: "new-account-123",
+        accountDetails: "same-details",
+      };
+
+      const result = getTemplateDiffState(LINE, oldData, newData);
+
+      expect(result).toBe(true);
+    });
+
+    it("should detect changes in accountDetails", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          lineMessageContent: {
+            messageBody: "same line message",
+            accountId: "same-account",
+            accountDetails: "old-account-details",
+          },
+        },
+      };
+
+      const newData = {
+        messageBody: "same line message",
+        accountId: "same-account",
+        accountDetails: "new-account-details",
+      };
+
+      const result = getTemplateDiffState(LINE, oldData, newData);
+
+      expect(result).toBe(true);
+    });
+
+    it("should return false when LINE content is the same", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          lineMessageContent: {
+            messageBody: "same line message",
+            accountId: "same-account",
+            accountDetails: "same-details",
+          },
+        },
+      };
+
+      const newData = {
+        messageBody: "same line message",
+        accountId: "same-account",
+        accountDetails: "same-details",
+      };
+
+      const result = getTemplateDiffState(LINE, oldData, newData);
+
+      expect(result).toBe(false);
+    });
+
+    it("should detect actual changes despite type differences", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          lineMessageContent: {
+            messageBody: "same message",
+            accountId: 12345,
+            accountDetails: "same details",
+          },
+        },
+      };
+
+      const newData = {
+        messageBody: "same message",
+        accountId: "12346",
+        accountDetails: "same details",
+      };
+
+      // Should return true because "12345" !== "12346"
+      const result = getTemplateDiffState(LINE, oldData, newData);
+
+      expect(result).toBe(true);
+    });
+
+    it("should handle undefined/null values gracefully", () => {
+      // Both values undefined
+      expect(
+        getTemplateDiffState(
+          LINE,
+          { transformedMessageDetails: { lineMessageContent: {} } },
+          {}
+        )
+      ).toBe(false);
+
+      // Old value undefined, new value defined
+      expect(
+        getTemplateDiffState(
+          LINE,
+          { transformedMessageDetails: { lineMessageContent: {} } },
+          { messageBody: "new message" }
+        )
+      ).toBe(true);
+
+      // Old value defined, new value undefined
+      expect(
+        getTemplateDiffState(
+          LINE,
+          {
+            transformedMessageDetails: {
+              lineMessageContent: { messageBody: "old message" }
+            }
+          },
+          {}
+        )
+      ).toBe(true);
+    });
+  });
+
+  describe("VIBER template diff checking", () => {
+    it("should detect changes in message content", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          viberMessageContent: {
+            messageBody: "old viber message",
+            accountId: "same-account",
+            accountDetails: "same-details",
+          },
+        },
+      };
+
+      const newData = {
+        messageBody: "new viber message",
+        accountId: "same-account",
+        accountDetails: "same-details",
+      };
+
+      const result = getTemplateDiffState(VIBER, oldData, newData);
+
+      expect(result).toBe(true);
+    });
+
+    it("should detect changes in accountId", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          viberMessageContent: {
+            messageBody: "same viber message",
+            accountId: "old-account-123",
+            accountDetails: "same-details",
+          },
+        },
+      };
+
+      const newData = {
+        messageBody: "same viber message",
+        accountId: "new-account-123",
+        accountDetails: "same-details",
+      };
+
+      const result = getTemplateDiffState(VIBER, oldData, newData);
+
+      expect(result).toBe(true);
+    });
+
+    it("should detect changes in accountDetails", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          viberMessageContent: {
+            messageBody: "same viber message",
+            accountId: "same-account",
+            accountDetails: "old-account-details",
+          },
+        },
+      };
+
+      const newData = {
+        messageBody: "same viber message",
+        accountId: "same-account",
+        accountDetails: "new-account-details",
+      };
+
+      const result = getTemplateDiffState(VIBER, oldData, newData);
+
+      expect(result).toBe(true);
+    });
+
+    it("should return false when VIBER content is the same", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          viberMessageContent: {
+            messageBody: "same viber message",
+            accountId: "same-account",
+            accountDetails: "same-details",
+          },
+        },
+      };
+
+      const newData = {
+        messageBody: "same viber message",
+        accountId: "same-account",
+        accountDetails: "same-details",
+      };
+
+      const result = getTemplateDiffState(VIBER, oldData, newData);
+
+      expect(result).toBe(false);
+    });
+
+    it("should detect actual changes despite type differences", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          viberMessageContent: {
+            messageBody: "same message",
+            accountId: 67890,
+            accountDetails: "same details",
+          },
+        },
+      };
+
+      const newData = {
+        messageBody: "same message",
+        accountId: "67891",
+        accountDetails: "same details",
+      };
+
+      // Should return true because "67890" !== "67891"
+      const result = getTemplateDiffState(VIBER, oldData, newData);
+
+      expect(result).toBe(true);
+    });
+
+    it("should handle undefined/null values gracefully", () => {
+      // Both values undefined
+      expect(
+        getTemplateDiffState(
+          VIBER,
+          { transformedMessageDetails: { viberMessageContent: {} } },
+          {}
+        )
+      ).toBe(false);
+
+      // Old value undefined, new value defined
+      expect(
+        getTemplateDiffState(
+          VIBER,
+          { transformedMessageDetails: { viberMessageContent: {} } },
+          { messageBody: "new message" }
+        )
+      ).toBe(true);
+
+      // Old value defined, new value undefined
+      expect(
+        getTemplateDiffState(
+          VIBER,
+          {
+            transformedMessageDetails: {
+              viberMessageContent: { messageBody: "old message" }
+            }
+          },
+          {}
+        )
+      ).toBe(true);
+    });
+  });
+
+  describe("RCS template diff checking", () => {
+    it("should detect changes in accountId", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          rcsMessageContent: {
+            accountId: "old-account-123",
+            accountName: "same-account-name",
+            templateConfigs: {
+              id: "same-template-123",
+              name: "same_template_name",
+              template: "same_template_content",
+              varMapped: { customer: "John" },
+            },
+          },
+        },
+      };
+
+      const newData = {
+        accountId: "new-account-123",
+        accountName: "same-account-name",
+        templateConfigs: {
+          id: "same-template-123",
+          name: "same_template_name",
+          template: "same_template_content",
+          varMapped: { customer: "John" },
+        },
+      };
+
+      const result = getTemplateDiffState(RCS, oldData, newData);
+
+      expect(result).toBe(true);
+    });
+
+    it("should detect changes in accountName", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          rcsMessageContent: {
+            accountId: "same-account",
+            accountName: "old-account-name",
+            templateConfigs: {
+              id: "same-template-123",
+              name: "same_template_name",
+              template: "same_template_content",
+              varMapped: { customer: "John" },
+            },
+          },
+        },
+      };
+
+      const newData = {
+        accountId: "same-account",
+        accountName: "new-account-name",
+        templateConfigs: {
+          id: "same-template-123",
+          name: "same_template_name",
+          template: "same_template_content",
+          varMapped: { customer: "John" },
+        },
+      };
+
+      const result = getTemplateDiffState(RCS, oldData, newData);
+
+      expect(result).toBe(true);
+    });
+
+    it("should detect changes in template configs structure", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          rcsMessageContent: {
+            accountId: "same-account",
+            accountName: "same-account-name",
+            templateConfigs: {
+              id: "same-template-123",
+              name: "same_template_name",
+              // Missing template and varMapped properties
+            },
+          },
+        },
+      };
+
+      const newData = {
+        accountId: "same-account",
+        accountName: "same-account-name",
+        templateConfigs: {
+          id: "same-template-123",
+          name: "same_template_name",
+          template: "same_template_content",
+          varMapped: { customer: "John" },
+        },
+      };
+
+      const result = getTemplateDiffState(RCS, oldData, newData);
+
+      expect(result).toBe(true);
+    });
+
+    it("should detect changes in account details", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          rcsMessageContent: {
+            accountId: "old-account-123",
+            accountName: "old-account-name",
+            templateConfigs: {
+              id: "same-template-123",
+              name: "same_template_name",
+              template: "same_template_content",
+              varMapped: { customer: "John" },
+            },
+          },
+        },
+      };
+
+      const newData = {
+        accountId: "new-account-123",
+        accountName: "new-account-name",
+        templateConfigs: {
+          id: "same-template-123",
+          name: "same_template_name",
+          template: "same_template_content",
+          varMapped: { customer: "John" },
+        },
+      };
+
+      const result = getTemplateDiffState("RCS", oldData, newData);
+
+      expect(result).toBe(true);
+    });
+
+    it("should return false when RCS content is the same", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          rcsMessageContent: {
+            accountId: "same-account",
+            accountName: "same-account-name",
+            templateConfigs: {
+              id: "same-template-123",
+              name: "same_template_name",
+              template: "same_template_content",
+              varMapped: { customer: "John" },
+            },
+          },
+        },
+      };
+
+      const newData = {
+        accountId: "same-account",
+        accountName: "same-account-name",
+        templateConfigs: {
+          id: "same-template-123",
+          name: "same_template_name",
+          template: "same_template_content",
+          varMapped: { customer: "John" },
+        },
+      };
+
+      const result = getTemplateDiffState(RCS, oldData, newData);
+
+      expect(result).toBe(false);
+    });
+
+    it("should handle missing transformedMessageDetails with default values", () => {
+      const oldData = {
+        // Missing transformedMessageDetails completely
+      };
+
+      const newData = {
+        accountId: "new-account",
+        accountName: "new-account-name",
+        templateConfigs: {
+          id: "template-123",
+          name: "template_name",
+        },
+      };
+
+      // This should trigger default value assignments in destructuring
+      const result = getTemplateDiffState(RCS, oldData, newData);
+
+      // Should return true because oldData has no rcsMessageContent
+      expect(result).toBe(true);
+    });
+
+    it("should handle empty newData with default values", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          rcsMessageContent: {
+            accountId: "old-account",
+            accountName: "old-account-name",
+            templateConfigs: {
+              id: "template-123",
+              name: "template_name",
+            },
+          },
+        },
+      };
+
+      const newData = null;
+
+      // This should trigger default value assignments in destructuring for newData
+      const result = getTemplateDiffState(RCS, oldData, newData);
+
+      // Should return true because newData is null
+      expect(result).toBe(true);
+    });
+  });
 });