@capillarytech/creatives-library 8.0.241 → 8.0.242-alpha.0

package/v2Containers/Whatsapp/tests/reducer.test.js

@@ -5,6 +5,11 @@ import {
   URL_META_TAGS_SUCCESS,
   URL_META_TAGS_FAILURE,
   URL_META_TAGS_RESET,
+  UPLOAD_WHATSAPP_ASSET_PROCESSING,
+  UPLOAD_WHATSAPP_ASSET_COMPLETED,
+  UPLOAD_WHATSAPP_ASSET_FAILED,
+  UPLOAD_WHATSAPP_ASSET_TIMEOUT,
+  CLEAR_WHATSAPP_ASSET,
 } from "../constants";
 import { mockData } from "./mockData";
 
@@ -60,4 +65,187 @@ describe("whatsapp reducer", () => {
       .set("metaTagsDetails", {});
     expect(whatsappReducer(state, action)).toEqual(expectedResult);
   });
+
+  describe("Async upload processing state management", () => {
+    const mockAsset = {
+      _id: "asset-123",
+      type: "IMAGE",
+      url: "https://example.com/image.jpg",
+    };
+
+    it.concurrent("Reducer : UPLOAD_WHATSAPP_ASSET_PROCESSING", () => {
+      const state = fromJS({
+        uploadedAssetData: {},
+        assetProcessing: {},
+        uploadAssetSuccess: false,
+        assetUploading: false,
+      });
+      const action = {
+        type: UPLOAD_WHATSAPP_ASSET_PROCESSING,
+        payload: {
+          assetId: "asset-123",
+          asset: mockAsset,
+          processingStatus: "processing",
+        },
+      };
+      const result = whatsappReducer(state, action);
+      
+      expect(result.get("uploadAssetSuccess")).toBe(false);
+      expect(result.get("assetUploading")).toBe(true);
+      expect(result.getIn(["assetProcessing", "asset-123", "status"])).toBe("processing");
+      expect(result.getIn(["assetProcessing", "asset-123", "asset"])).toEqual(fromJS(mockAsset));
+      expect(result.getIn(["assetProcessing", "asset-123", "startTime"])).toBeDefined();
+      expect(result.getIn(["assetProcessing", "asset-123", "error"])).toBe(null);
+    });
+
+    it.concurrent("Reducer : UPLOAD_WHATSAPP_ASSET_COMPLETED without templateType", () => {
+      const state = fromJS({
+        uploadedAssetData: {},
+        assetProcessing: {
+          "asset-123": {
+            status: "processing",
+            asset: mockAsset,
+          },
+        },
+        uploadAssetSuccess: false,
+        assetUploading: true,
+      });
+      const action = {
+        type: UPLOAD_WHATSAPP_ASSET_COMPLETED,
+        payload: {
+          assetId: "asset-123",
+          asset: mockAsset,
+        },
+      };
+      const result = whatsappReducer(state, action);
+      
+      expect(result.get("uploadAssetSuccess")).toBe(true);
+      expect(result.get("assetUploading")).toBe(false);
+      expect(result.get("uploadedAssetData")).toEqual(fromJS(mockAsset));
+      expect(result.getIn(["assetProcessing", "asset-123", "status"])).toBe("completed");
+      expect(result.getIn(["assetProcessing", "asset-123", "asset"])).toEqual(fromJS(mockAsset));
+      expect(result.getIn(["assetProcessing", "asset-123", "error"])).toBe(null);
+    });
+
+    it.concurrent("Reducer : UPLOAD_WHATSAPP_ASSET_COMPLETED with templateType", () => {
+      const state = fromJS({
+        uploadedAssetData: {},
+        uploadedAssetData2: {},
+        assetProcessing: {
+          "asset-123": {
+            status: "processing",
+            asset: mockAsset,
+          },
+        },
+        uploadAssetSuccess: false,
+        assetUploading: true,
+      });
+      const action = {
+        type: UPLOAD_WHATSAPP_ASSET_COMPLETED,
+        payload: {
+          assetId: "asset-123",
+          asset: mockAsset,
+        },
+        templateType: 2,
+      };
+      const result = whatsappReducer(state, action);
+      
+      expect(result.get("uploadAssetSuccess")).toBe(true);
+      expect(result.get("assetUploading")).toBe(false);
+      expect(result.get("uploadedAssetData2")).toEqual(fromJS(mockAsset));
+      expect(result.getIn(["assetProcessing", "asset-123", "status"])).toBe("completed");
+    });
+
+    it.concurrent("Reducer : UPLOAD_WHATSAPP_ASSET_FAILED", () => {
+      const state = fromJS({
+        assetProcessing: {
+          "asset-123": {
+            status: "processing",
+            asset: mockAsset,
+          },
+        },
+        uploadAssetSuccess: false,
+        assetUploading: true,
+      });
+      const action = {
+        type: UPLOAD_WHATSAPP_ASSET_FAILED,
+        payload: {
+          assetId: "asset-123",
+          error: "Processing failed",
+        },
+      };
+      const result = whatsappReducer(state, action);
+      
+      expect(result.get("uploadAssetSuccess")).toBe(false);
+      expect(result.get("assetUploading")).toBe(false);
+      expect(result.getIn(["assetProcessing", "asset-123", "status"])).toBe("failed");
+      expect(result.getIn(["assetProcessing", "asset-123", "error"])).toBe("Processing failed");
+    });
+
+    it.concurrent("Reducer : UPLOAD_WHATSAPP_ASSET_TIMEOUT", () => {
+      const state = fromJS({
+        assetProcessing: {
+          "asset-123": {
+            status: "processing",
+            asset: mockAsset,
+          },
+        },
+        uploadAssetSuccess: false,
+        assetUploading: true,
+      });
+      const action = {
+        type: UPLOAD_WHATSAPP_ASSET_TIMEOUT,
+        payload: {
+          assetId: "asset-123",
+          message: "Asset processing is taking longer than expected",
+        },
+      };
+      const result = whatsappReducer(state, action);
+      
+      expect(result.get("uploadAssetSuccess")).toBe(false);
+      expect(result.get("assetUploading")).toBe(false);
+      expect(result.getIn(["assetProcessing", "asset-123", "status"])).toBe("timeout");
+      expect(result.getIn(["assetProcessing", "asset-123", "error"])).toBe("Asset processing is taking longer than expected");
+    });
+
+    it.concurrent("Reducer : CLEAR_WHATSAPP_ASSET without templateType", () => {
+      const state = fromJS({
+        uploadedAssetData: mockAsset,
+        assetProcessing: {
+          "asset-123": {
+            status: "completed",
+            asset: mockAsset,
+          },
+        },
+      });
+      const action = {
+        type: CLEAR_WHATSAPP_ASSET,
+      };
+      const result = whatsappReducer(state, action);
+      
+      expect(result.has("uploadedAssetData")).toBe(false);
+      expect(result.get("assetProcessing")).toEqual(fromJS({}));
+    });
+
+    it.concurrent("Reducer : CLEAR_WHATSAPP_ASSET with templateType", () => {
+      const state = fromJS({
+        uploadedAssetData: {},
+        uploadedAssetData2: mockAsset,
+        assetProcessing: {
+          "asset-123": {
+            status: "completed",
+            asset: mockAsset,
+          },
+        },
+      });
+      const action = {
+        type: CLEAR_WHATSAPP_ASSET,
+        templateType: 2,
+      };
+      const result = whatsappReducer(state, action);
+      
+      expect(result.has("uploadedAssetData2")).toBe(false);
+      expect(result.get("assetProcessing")).toEqual(fromJS({}));
+    });
+  });
 });

package/v2Containers/Whatsapp/tests/saga.test.js

@@ -1,15 +1,22 @@
 import { expectSaga, testSaga } from "redux-saga-test-plan";
 import * as matchers from "redux-saga-test-plan/matchers";
-import { takeLatest } from "redux-saga/effects";
-import { getMetaTagsDetails, watchGetMetaTagsDetails,v2WhatsappSagas, sendForApprovalCreate } from "../sagas";
+import { takeLatest, call } from "redux-saga/effects";
+import { getMetaTagsDetails, watchGetMetaTagsDetails, v2WhatsappSagas, sendForApprovalCreate, uploadWhatsappAsset } from "../sagas";
 import {
   URL_META_TAGS_REQUEST,
   URL_META_TAGS_SUCCESS,
   URL_META_TAGS_FAILURE,
   TEMPLATE_CREATE_SUCCESS,
   TEMPLATE_CREATE_FAILURE,
+  UPLOAD_WHATSAPP_ASSET_REQUEST,
+  UPLOAD_WHATSAPP_ASSET_SUCCESS,
+  UPLOAD_WHATSAPP_ASSET_FAILURE,
+  UPLOAD_WHATSAPP_ASSET_PROCESSING,
+  UPLOAD_WHATSAPP_ASSET_FAILED,
 } from "../constants";
 import * as Api from "../../../services/api";
+import { pollAssetStatus } from "../../../sagas/assetPolling";
+import { createPollingConfig } from "../../../utils/asyncAssetUpload";
 import { mockData } from "./mockData";
 
 describe("v2WhatsappSagas Combined", () => {
@@ -30,13 +37,13 @@ describe("Whatsapp saga", () => {
           matchers.call.fn(Api.getMetaTags),
           {
             success: true,
-            result: [],
+            response: [],
           },
         ],
       ])
         .put({
           type: URL_META_TAGS_SUCCESS,
-          result: {},
+          data: [],
         })
         .run();
     });
@@ -107,13 +114,16 @@ describe("Whatsapp saga", () => {
           matchers.call.fn(Api.createWhatsappTemplate),
           {
             success: true,
-            result: { response: "Test data"},
+            response: "Test data",
+            status: { code: 200 },
           },
         ],
       ])
         .put({
           type: TEMPLATE_CREATE_SUCCESS,
-          result: {},
+          data: "Test data",
+          statusCode: 200,
+          errorMsg: undefined,
         })
         .run();
     });
@@ -131,6 +141,7 @@ describe("Whatsapp saga", () => {
         .put({
           type: TEMPLATE_CREATE_FAILURE,
           error: "(#192) Param components[1]['buttons'][0]['phone_number'] is not a valid phone number.",
+          errorMsg: "(#192) Param components[1]['buttons'][0]['phone_number'] is not a valid phone number.",
         })
         .run();
     });
@@ -147,7 +158,18 @@ describe("Whatsapp saga", () => {
       ])
         .put({
           type: TEMPLATE_CREATE_FAILURE,
-          error: 'Invalid params',
+          error: {
+            name: 'StatusCodeError',
+            statusCode: 500,
+            message: '500 - Invalid params',
+            error: { errorCode: '1004', errorMessage: 'Invalid params' }
+          },
+          errorMsg: {
+            name: 'StatusCodeError',
+            statusCode: 500,
+            message: '500 - Invalid params',
+            error: { errorCode: '1004', errorMessage: 'Invalid params' }
+          },
         })
         .run();
     });
@@ -172,6 +194,7 @@ describe("Whatsapp saga", () => {
         .put({
           type: TEMPLATE_CREATE_FAILURE,
           error: 'error',
+          errorMsg: 'error',
         })
         .run();
     });
@@ -195,6 +218,7 @@ describe("Whatsapp saga", () => {
         .put({
           type: TEMPLATE_CREATE_FAILURE,
           error: 500,
+          errorMsg: 500,
         })
         .run();
     });
@@ -203,6 +227,395 @@ describe("Whatsapp saga", () => {
       testSaga(sendForApprovalCreate, { callBack }).next().throw(error).next().isDone();
     });
   });
+
+  describe("uploadWhatsappAsset saga", () => {
+    const mockAsset = {
+      _id: "asset-123",
+      type: "IMAGE",
+      url: "https://example.com/image.jpg",
+    };
+
+    const mockParams = {
+      file: new File(["test"], "test.jpg", { type: "image/jpeg" }),
+      assetType: "image",
+      fileParams: {},
+      templateType: 0,
+      whatsappParams: {},
+    };
+
+    it("should handle async upload flow (202 status code)", () => {
+      const mockResponse = {
+        status: { code: 202 },
+        response: {
+          assetId: "asset-123",
+          asset: mockAsset,
+          processingStatus: "processing",
+        },
+      };
+
+      return expectSaga(uploadWhatsappAsset, mockParams)
+        .provide([
+          [matchers.call.fn(Api.uploadFile), mockResponse],
+          [
+            matchers.call.fn(pollAssetStatus),
+            undefined,
+          ],
+        ])
+        .put({
+          type: UPLOAD_WHATSAPP_ASSET_PROCESSING,
+          payload: {
+            assetId: "asset-123",
+            asset: mockAsset,
+            processingStatus: "processing",
+          },
+        })
+        .call.fn(Api.uploadFile)
+        .call.fn(pollAssetStatus)
+        .run();
+    });
+
+    it("should handle async upload flow with processingStatus in response", () => {
+      const mockResponse = {
+        status: { code: 200 },
+        response: {
+          assetId: "asset-123",
+          asset: mockAsset,
+          processingStatus: "processing",
+        },
+      };
+
+      return expectSaga(uploadWhatsappAsset, mockParams)
+        .provide([
+          [matchers.call.fn(Api.uploadFile), mockResponse],
+          [matchers.call.fn(pollAssetStatus), undefined],
+        ])
+        .put({
+          type: UPLOAD_WHATSAPP_ASSET_PROCESSING,
+          payload: {
+            assetId: "asset-123",
+            asset: mockAsset,
+            processingStatus: "processing",
+          },
+        })
+        .call.fn(Api.uploadFile)
+        .call.fn(pollAssetStatus)
+        .run();
+    });
+
+    it("should handle sync upload flow (201 status code)", () => {
+      const mockResponse = {
+        status: { code: 201 },
+        response: {
+          asset: mockAsset,
+        },
+      };
+
+      return expectSaga(uploadWhatsappAsset, mockParams)
+        .provide([
+          [matchers.call.fn(Api.uploadFile), mockResponse],
+        ])
+        .put({
+          type: UPLOAD_WHATSAPP_ASSET_SUCCESS,
+          data: mockAsset,
+          statusCode: 201,
+          templateType: 0,
+        })
+        .not.call(pollAssetStatus)
+        .run();
+    });
+
+    it("should handle sync upload flow (200 status code)", () => {
+      const mockResponse = {
+        status: { code: 200 },
+        response: {
+          asset: mockAsset,
+        },
+      };
+
+      return expectSaga(uploadWhatsappAsset, mockParams)
+        .provide([
+          [matchers.call.fn(Api.uploadFile), mockResponse],
+        ])
+        .put({
+          type: UPLOAD_WHATSAPP_ASSET_SUCCESS,
+          data: mockAsset,
+          statusCode: 200,
+          templateType: 0,
+        })
+        .not.call(pollAssetStatus)
+        .run();
+    });
+
+    it("should extract assetId from asset._id when assetId is not present", () => {
+      const mockResponse = {
+        status: { code: 202 },
+        response: {
+          asset: { ...mockAsset, _id: "asset-456" },
+          processingStatus: "processing",
+        },
+      };
+
+      return expectSaga(uploadWhatsappAsset, mockParams)
+        .provide([
+          [matchers.call.fn(Api.uploadFile), mockResponse],
+          [matchers.call.fn(pollAssetStatus), undefined],
+        ])
+        .put({
+          type: UPLOAD_WHATSAPP_ASSET_PROCESSING,
+          payload: {
+            assetId: "asset-456",
+            asset: { ...mockAsset, _id: "asset-456" },
+            processingStatus: "processing",
+          },
+        })
+        .call.fn(Api.uploadFile)
+        .call.fn(pollAssetStatus)
+        .run()
+        .then((result) => {
+          // Verify the polling config has the correct assetId
+          // Find the pollAssetStatus call by checking function name
+          const allEffects = result.allEffects || [];
+          const pollCall = allEffects.find(effect => 
+            effect && effect.CALL && effect.CALL.fn && effect.CALL.fn.name === 'pollAssetStatus'
+          );
+          expect(pollCall).toBeDefined();
+          expect(pollCall.CALL.args[0]).toMatchObject({
+            assetId: "asset-456",
+          });
+        });
+    });
+
+    it("should use assetType from params for polling", () => {
+      const videoParams = {
+        ...mockParams,
+        assetType: "video",
+      };
+      const mockResponse = {
+        status: { code: 202 },
+        response: {
+          assetId: "asset-123",
+          asset: { ...mockAsset, type: "VIDEO" },
+          processingStatus: "processing",
+        },
+      };
+
+      return expectSaga(uploadWhatsappAsset, videoParams)
+        .provide([
+          [matchers.call.fn(Api.uploadFile), mockResponse],
+          [matchers.call.fn(pollAssetStatus), undefined],
+        ])
+        .call.fn(Api.uploadFile)
+        .call.fn(pollAssetStatus)
+        .run()
+        .then((result) => {
+          const allEffects = result.allEffects || [];
+          const pollCall = allEffects.find(effect => 
+            effect && effect.CALL && effect.CALL.fn && effect.CALL.fn.name === 'pollAssetStatus'
+          );
+          expect(pollCall).toBeDefined();
+          expect(pollCall.CALL.args[0]).toMatchObject({
+            type: "video",
+          });
+        });
+    });
+
+    it("should fallback to asset.type from response when assetType not in params", () => {
+      const paramsWithoutAssetType = {
+        ...mockParams,
+        assetType: undefined,
+      };
+      const mockResponse = {
+        status: { code: 202 },
+        response: {
+          assetId: "asset-123",
+          asset: { ...mockAsset, type: "VIDEO" },
+          processingStatus: "processing",
+        },
+      };
+
+      return expectSaga(uploadWhatsappAsset, paramsWithoutAssetType)
+        .provide([
+          [matchers.call.fn(Api.uploadFile), mockResponse],
+          [matchers.call.fn(pollAssetStatus), undefined],
+        ])
+        .call.fn(Api.uploadFile)
+        .call.fn(pollAssetStatus)
+        .run()
+        .then((result) => {
+          const allEffects = result.allEffects || [];
+          const pollCall = allEffects.find(effect => 
+            effect && effect.CALL && effect.CALL.fn && effect.CALL.fn.name === 'pollAssetStatus'
+          );
+          expect(pollCall).toBeDefined();
+          expect(pollCall.CALL.args[0]).toMatchObject({
+            type: "video",
+          });
+        });
+    });
+
+    it("should default to 'image' when assetType is not available", () => {
+      const paramsWithoutAssetType = {
+        ...mockParams,
+        assetType: undefined,
+      };
+      const mockResponse = {
+        status: { code: 202 },
+        response: {
+          assetId: "asset-123",
+          asset: { ...mockAsset, type: undefined },
+          processingStatus: "processing",
+        },
+      };
+
+      return expectSaga(uploadWhatsappAsset, paramsWithoutAssetType)
+        .provide([
+          [matchers.call.fn(Api.uploadFile), mockResponse],
+          [matchers.call.fn(pollAssetStatus), undefined],
+        ])
+        .call.fn(Api.uploadFile)
+        .call.fn(pollAssetStatus)
+        .run()
+        .then((result) => {
+          const allEffects = result.allEffects || [];
+          const pollCall = allEffects.find(effect => 
+            effect && effect.CALL && effect.CALL.fn && effect.CALL.fn.name === 'pollAssetStatus'
+          );
+          expect(pollCall).toBeDefined();
+          expect(pollCall.CALL.args[0]).toMatchObject({
+            type: "image",
+          });
+        });
+    });
+
+    it("should dispatch FAILED action if assetId is missing", () => {
+      const mockResponse = {
+        status: { code: 202 },
+        response: {
+          processingStatus: "processing",
+          // No assetId or asset._id
+        },
+      };
+
+      return expectSaga(uploadWhatsappAsset, mockParams)
+        .provide([
+          [matchers.call.fn(Api.uploadFile), mockResponse],
+        ])
+        .put({
+          type: UPLOAD_WHATSAPP_ASSET_FAILED,
+          payload: {
+            assetId: undefined,
+            error: 'Asset upload initiated but no asset ID was returned from the server. Unable to track processing status.',
+          },
+          templateType: 0,
+        })
+        .not.put({ type: UPLOAD_WHATSAPP_ASSET_PROCESSING })
+        .not.call(pollAssetStatus)
+        .run();
+    });
+
+    it("should handle error during upload", () => {
+      const uploadError = new Error("Upload failed");
+
+      return expectSaga(uploadWhatsappAsset, mockParams)
+        .provide([
+          [
+            matchers.call.fn(Api.uploadFile),
+            Promise.reject(uploadError),
+          ],
+        ])
+        .put({
+          type: UPLOAD_WHATSAPP_ASSET_FAILURE,
+          error: uploadError,
+        })
+        .run();
+    });
+
+    it("should pass templateType to polling config", () => {
+      const paramsWithTemplateType = {
+        ...mockParams,
+        templateType: 2,
+      };
+      const mockResponse = {
+        status: { code: 202 },
+        response: {
+          assetId: "asset-123",
+          asset: mockAsset,
+          processingStatus: "processing",
+        },
+      };
+
+      return expectSaga(uploadWhatsappAsset, paramsWithTemplateType)
+        .provide([
+          [matchers.call.fn(Api.uploadFile), mockResponse],
+          [matchers.call.fn(pollAssetStatus), undefined],
+        ])
+        .call.fn(Api.uploadFile)
+        .call.fn(pollAssetStatus)
+        .run()
+        .then((result) => {
+          // Verify that the polling config includes templateType
+          const allEffects = result.allEffects || [];
+          const pollCall = allEffects.find(effect => 
+            effect && effect.CALL && effect.CALL.fn && effect.CALL.fn.name === 'pollAssetStatus'
+          );
+          expect(pollCall).toBeDefined();
+          const pollingConfig = pollCall.CALL.args[0];
+          expect(pollingConfig).toMatchObject({
+            onCompleted: expect.any(Function),
+          });
+          const completedAction = pollingConfig.onCompleted({ assetId: "asset-123", asset: mockAsset });
+          expect(completedAction.templateType).toBe(2);
+        });
+    });
+
+    it("should handle statusCode from result.statusCode", () => {
+      const mockResponse = {
+        statusCode: 202,
+        response: {
+          assetId: "asset-123",
+          asset: mockAsset,
+          processingStatus: "processing",
+        },
+      };
+
+      return expectSaga(uploadWhatsappAsset, mockParams)
+        .provide([
+          [matchers.call.fn(Api.uploadFile), mockResponse],
+          [matchers.call.fn(pollAssetStatus), undefined],
+        ])
+        .put({
+          type: UPLOAD_WHATSAPP_ASSET_PROCESSING,
+          payload: {
+            assetId: "asset-123",
+            asset: mockAsset,
+            processingStatus: "processing",
+          },
+        })
+        .call.fn(Api.uploadFile)
+        .call.fn(pollAssetStatus)
+        .run();
+    });
+
+    it("should handle empty response gracefully", () => {
+      const mockResponse = {
+        status: { code: 200 },
+        response: {},
+      };
+
+      return expectSaga(uploadWhatsappAsset, mockParams)
+        .provide([
+          [matchers.call.fn(Api.uploadFile), mockResponse],
+        ])
+        .put({
+          type: UPLOAD_WHATSAPP_ASSET_SUCCESS,
+          data: undefined,
+          statusCode: 200,
+          templateType: 0,
+        })
+        .run();
+    });
+  });
+
 });