@capillarytech/creatives-library 8.0.85 → 8.0.87-alpha.0

package/containers/Email/test/saga.test.js

@@ -1,5 +1,5 @@
 import { expectSaga } from 'redux-saga-test-plan';
-import { call } from 'redux-saga/effects';
+import { call, put } from 'redux-saga/effects';
 import { throwError } from 'redux-saga-test-plan/providers';
 import * as Api from '../../../services/api';
 import * as types from '../constants';
@@ -10,79 +10,472 @@ describe('Email Template Sagas', () => {
   jest.setTimeout(1000);
 
   describe('createTemplate Saga', () => {
-    const template = { name: 'New Template' };
+    const template = { name: 'Test Template', content: 'Test Content' };
 
-    it('handles creating a template successfully', () => {
-      const fakeResponse = {
-        response: { id: 1, name: 'New Template' },
+    it('should handle successful template creation', () => {
+      const generator = sagas.createTemplate(template);
+      const response = {
+        response: { id: 1, name: 'Test Template' },
         status: { code: 200 },
       };
 
-      return expectSaga(sagas.createTemplate, template)
-        .provide([
-          [call(Api.createEmailTemplate, template), fakeResponse],
-        ])
-        .put({
+      expect(generator.next().value)
+        .toEqual(call(Api.createEmailTemplate, template));
+
+      expect(generator.next(response).value)
+        .toEqual(put({
           type: types.CREATE_TEMPLATE_SUCCESS,
-          data: fakeResponse.response,
-          statusCode: 200,
+          data: response.response,
+          statusCode: response.status.code,
           errorMsg: undefined,
-        })
-        .run();
+        }));
+
+      expect(generator.next().done).toBeTruthy();
     });
 
-    it('handles failure when creating a template', () => {
-      const error = new Error('Failed to create template');
+    it('should handle server error with status code 500', () => {
+      const generator = sagas.createTemplate(template);
+      const response = {
+        message: 'Internal Server Error',
+        status: { code: 500 },
+      };
 
-      return expectSaga(sagas.createTemplate, template)
-        .provide([
-          [call(Api.createEmailTemplate, template), throwError(error)],
-        ])
-        .put({
+      expect(generator.next().value)
+        .toEqual(call(Api.createEmailTemplate, template));
+
+      expect(generator.next(response).value)
+        .toEqual(put({
+          type: types.CREATE_TEMPLATE_SUCCESS,
+          data: undefined,
+          statusCode: 500,
+          errorMsg: 'Internal Server Error',
+        }));
+
+      expect(generator.next().done).toBeTruthy();
+    });
+
+    it('should handle API error response with message', () => {
+      const generator = sagas.createTemplate(template);
+      const response = {
+        message: 'Validation Error',
+        status: { code: 400 },
+      };
+
+      expect(generator.next().value)
+        .toEqual(call(Api.createEmailTemplate, template));
+
+      expect(generator.next(response).value)
+        .toEqual(put({
+          type: types.CREATE_TEMPLATE_SUCCESS,
+          data: undefined,
+          statusCode: 400,
+          errorMsg: 'Validation Error',
+        }));
+
+      expect(generator.next().done).toBeTruthy();
+    });
+
+    it('should handle API call exception', () => {
+      const generator = sagas.createTemplate(template);
+      const error = new Error('Network Error');
+
+      expect(generator.next().value)
+        .toEqual(call(Api.createEmailTemplate, template));
+
+      expect(generator.throw(error).value)
+        .toEqual(put({
           type: types.CREATE_TEMPLATE_FAILURE,
           error,
           errorMsg: undefined,
-        })
-        .run();
+        }));
+
+      expect(generator.next().done).toBeTruthy();
+    });
+
+    it('should set empty string statusCode when status is null', () => {
+      const generator = sagas.createTemplate(template);
+      const response = {
+        response: { id: 1, name: 'Test Template' },
+        status: null,
+        message: 'Success',
+      };
+
+      expect(generator.next().value)
+        .toEqual(call(Api.createEmailTemplate, template));
+
+      expect(generator.next(response).value)
+        .toEqual(put({
+          type: types.CREATE_TEMPLATE_SUCCESS,
+          data: response.response,
+          statusCode: "",
+          errorMsg: response.message,
+        }));
+
+      expect(generator.next().done).toBeTruthy();
+    });
+
+    it('should set empty string statusCode when status is undefined', () => {
+      const generator = sagas.createTemplate(template);
+      const response = {
+        response: { id: 1, name: 'Test Template' },
+        message: 'Success',
+      };
+
+      expect(generator.next().value)
+        .toEqual(call(Api.createEmailTemplate, template));
+
+      expect(generator.next(response).value)
+        .toEqual(put({
+          type: types.CREATE_TEMPLATE_SUCCESS,
+          data: response.response,
+          statusCode: "",
+          errorMsg: response.message,
+        }));
+
+      expect(generator.next().done).toBeTruthy();
+    });
+
+    it('should set empty string statusCode when status.code is null', () => {
+      const generator = sagas.createTemplate(template);
+      const response = {
+        response: { id: 1, name: 'Test Template' },
+        status: { code: null },
+        message: 'Success',
+      };
+
+      expect(generator.next().value)
+        .toEqual(call(Api.createEmailTemplate, template));
+
+      expect(generator.next(response).value)
+        .toEqual(put({
+          type: types.CREATE_TEMPLATE_SUCCESS,
+          data: response.response,
+          statusCode: null,
+          errorMsg: response.message,
+        }));
+
+      expect(generator.next().done).toBeTruthy();
+    });
+
+    it('should set empty string statusCode when status.code is undefined', () => {
+      const generator = sagas.createTemplate(template);
+      const response = {
+        response: { id: 1, name: 'Test Template' },
+        status: { code: undefined },
+        message: 'Success',
+      };
+
+      expect(generator.next().value)
+        .toEqual(call(Api.createEmailTemplate, template));
+
+      expect(generator.next(response).value)
+        .toEqual(put({
+          type: types.CREATE_TEMPLATE_SUCCESS,
+          data: response.response,
+          statusCode: undefined,
+          errorMsg: response.message,
+        }));
+
+      expect(generator.next().done).toBeTruthy();
+    });
+
+    it('should set empty string statusCode when status is an empty object', () => {
+      const generator = sagas.createTemplate(template);
+      const response = {
+        response: { id: 1, name: 'Test Template' },
+        status: {},
+        message: 'Success',
+      };
+
+      expect(generator.next().value)
+        .toEqual(call(Api.createEmailTemplate, template));
+
+      expect(generator.next(response).value)
+        .toEqual(put({
+          type: types.CREATE_TEMPLATE_SUCCESS,
+          data: response.response,
+          statusCode: undefined,
+          errorMsg: response.message,
+        }));
+
+      expect(generator.next().done).toBeTruthy();
     });
   });
 
-  describe('duplicateTemplate Saga', () => {
-    const id = 1;
+  describe('duplicateTemplate saga', () => {
+    const templateId = 123;
     const channel = 'email';
 
-    it('handles duplicating a template successfully', () => {
-      const fakeResponse = {
-        response: { id: 2, name: 'Duplicated Template' },
+    it('should handle successful template duplication with complete response', () => {
+      const generator = sagas.duplicateTemplate(templateId, channel);
+      const response = {
+        response: { id: 456, name: 'Duplicated Template' },
         status: { code: 200 },
+        message: 'Template duplicated successfully',
       };
 
-      return expectSaga(sagas.duplicateTemplate, id, channel)
-        .provide([
-          [call(Api.duplicateTemplate, id, channel), fakeResponse],
-        ])
-        .put({
+      expect(generator.next().value)
+        .toEqual(call(Api.duplicateTemplate, templateId, channel));
+
+      expect(generator.next(response).value)
+        .toEqual(put({
           type: types.DUPLICATE_TEMPLATE_SUCCESS,
-          data: fakeResponse.response,
+          data: response.response,
+          statusCode: response.status.code,
+          errorMsg: response.message,
+        }));
+
+      expect(generator.next().done).toBeTruthy();
+    });
+
+    it('should handle response with missing status object', () => {
+      const generator = sagas.duplicateTemplate(templateId, channel);
+      const response = {
+        response: { id: 456, name: 'Duplicated Template' },
+        message: 'Success without status',
+      };
+
+      expect(generator.next().value)
+        .toEqual(call(Api.duplicateTemplate, templateId, channel));
+
+      expect(generator.next(response).value)
+        .toEqual(put({
+          type: types.DUPLICATE_TEMPLATE_SUCCESS,
+          data: response.response,
+          statusCode: '',
+          errorMsg: response.message,
+        }));
+
+      expect(generator.next().done).toBeTruthy();
+    });
+
+    it('should handle response with empty status object', () => {
+      const generator = sagas.duplicateTemplate(templateId, channel);
+      const response = {
+        response: { id: 456, name: 'Duplicated Template' },
+        status: {},
+        message: 'Success with empty status',
+      };
+
+      expect(generator.next().value)
+        .toEqual(call(Api.duplicateTemplate, templateId, channel));
+
+      expect(generator.next(response).value)
+        .toEqual(put({
+          type: types.DUPLICATE_TEMPLATE_SUCCESS,
+          data: response.response,
+          statusCode: undefined,
+          errorMsg: response.message,
+        }));
+
+      expect(generator.next().done).toBeTruthy();
+    });
+
+    it('should handle response with null status', () => {
+      const generator = sagas.duplicateTemplate(templateId, channel);
+      const response = {
+        response: { id: 456, name: 'Duplicated Template' },
+        status: null,
+        message: 'Success with null status',
+      };
+
+      expect(generator.next().value)
+        .toEqual(call(Api.duplicateTemplate, templateId, channel));
+
+      expect(generator.next(response).value)
+        .toEqual(put({
+          type: types.DUPLICATE_TEMPLATE_SUCCESS,
+          data: response.response,
+          statusCode: '',
+          errorMsg: response.message,
+        }));
+
+      expect(generator.next().done).toBeTruthy();
+    });
+
+    it('should handle response with undefined status code', () => {
+      const generator = sagas.duplicateTemplate(templateId, channel);
+      const response = {
+        response: { id: 456, name: 'Duplicated Template' },
+        status: { code: undefined },
+        message: 'Success with undefined status code',
+      };
+
+      expect(generator.next().value)
+        .toEqual(call(Api.duplicateTemplate, templateId, channel));
+
+      expect(generator.next(response).value)
+        .toEqual(put({
+          type: types.DUPLICATE_TEMPLATE_SUCCESS,
+          data: response.response,
+          statusCode: undefined,
+          errorMsg: response.message,
+        }));
+
+      expect(generator.next().done).toBeTruthy();
+    });
+
+    it('should handle response with missing response data', () => {
+      const generator = sagas.duplicateTemplate(templateId, channel);
+      const response = {
+        status: { code: 200 },
+        message: 'Success but no response data',
+      };
+
+      expect(generator.next().value)
+        .toEqual(call(Api.duplicateTemplate, templateId, channel));
+
+      expect(generator.next(response).value)
+        .toEqual(put({
+          type: types.DUPLICATE_TEMPLATE_SUCCESS,
+          data: undefined,
+          statusCode: response.status.code,
+          errorMsg: response.message,
+        }));
+
+      expect(generator.next().done).toBeTruthy();
+    });
+
+    it('should handle error response', () => {
+      const generator = sagas.duplicateTemplate(templateId, channel);
+      const error = new Error('Duplication failed');
+
+      expect(generator.next().value)
+        .toEqual(call(Api.duplicateTemplate, templateId, channel));
+
+      expect(generator.throw(error).value)
+        .toEqual(put({
+          type: types.DUPLICATE_TEMPLATE_FAILURE,
+          error,
+          errorMsg: undefined,
+        }));
+
+      expect(generator.next().done).toBeTruthy();
+    });
+
+    it('should set errorMsg when status code is 500', () => {
+      const generator = sagas.duplicateTemplate(templateId, channel);
+      const response = {
+        response: { id: 456 },
+        status: { code: 500 },
+        message: 'Internal Server Error',
+      };
+
+      expect(generator.next().value)
+        .toEqual(call(Api.duplicateTemplate, templateId, channel));
+
+      expect(generator.next(response).value)
+        .toEqual(put({
+          type: types.DUPLICATE_TEMPLATE_SUCCESS,
+          data: response.response,
+          statusCode: 500,
+          errorMsg: 'Internal Server Error',
+        }));
+
+      expect(generator.next().done).toBeTruthy();
+    });
+
+    it('should set errorMsg when both message exists and status code is 500', () => {
+      const generator = sagas.duplicateTemplate(templateId, channel);
+      const response = {
+        response: null,
+        status: { code: 500 },
+        message: 'Custom Error Message',
+      };
+
+      expect(generator.next().value)
+        .toEqual(call(Api.duplicateTemplate, templateId, channel));
+
+      expect(generator.next(response).value)
+        .toEqual(put({
+          type: types.DUPLICATE_TEMPLATE_SUCCESS,
+          data: null,
+          statusCode: 500,
+          errorMsg: 'Custom Error Message',
+        }));
+
+      expect(generator.next().done).toBeTruthy();
+    });
+
+    it('should set errorMsg when message exists but status code is not 500', () => {
+      const generator = sagas.duplicateTemplate(templateId, channel);
+      const response = {
+        response: { id: 456 },
+        status: { code: 400 },
+        message: 'Bad Request Error',
+      };
+
+      expect(generator.next().value)
+        .toEqual(call(Api.duplicateTemplate, templateId, channel));
+
+      expect(generator.next(response).value)
+        .toEqual(put({
+          type: types.DUPLICATE_TEMPLATE_SUCCESS,
+          data: response.response,
+          statusCode: 400,
+          errorMsg: 'Bad Request Error',
+        }));
+
+      expect(generator.next().done).toBeTruthy();
+    });
+
+    it('should handle case when status code is 500 but no message exists', () => {
+      const generator = sagas.duplicateTemplate(templateId, channel);
+      const response = {
+        response: { id: 456 },
+        status: { code: 500 },
+      };
+
+      expect(generator.next().value)
+        .toEqual(call(Api.duplicateTemplate, templateId, channel));
+
+      expect(generator.next(response).value)
+        .toEqual(put({
+          type: types.DUPLICATE_TEMPLATE_SUCCESS,
+          data: response.response,
+          statusCode: 500,
+          errorMsg: undefined,
+        }));
+
+      expect(generator.next().done).toBeTruthy();
+    });
+
+    it('should not set errorMsg when no message and status code is not 500', () => {
+      const generator = sagas.duplicateTemplate(templateId, channel);
+      const response = {
+        response: { id: 456 },
+        status: { code: 200 },
+      };
+
+      expect(generator.next().value)
+        .toEqual(call(Api.duplicateTemplate, templateId, channel));
+
+      expect(generator.next(response).value)
+        .toEqual(put({
+          type: types.DUPLICATE_TEMPLATE_SUCCESS,
+          data: response.response,
           statusCode: 200,
           errorMsg: undefined,
-        })
-        .run();
+        }));
+
+      expect(generator.next().done).toBeTruthy();
     });
 
-    it('handles failure when duplicating a template', () => {
-      const error = new Error('Failed to duplicate template');
+    it('should handle case when accessing status.code throws error', () => {
+      const generator = sagas.duplicateTemplate(templateId, channel);
+      const error = new TypeError("Cannot read property 'code' of undefined");
 
-      return expectSaga(sagas.duplicateTemplate, id, channel)
-        .provide([
-          [call(Api.duplicateTemplate, id, channel), throwError(error)],
-        ])
-        .put({
+      expect(generator.next().value)
+        .toEqual(call(Api.duplicateTemplate, templateId, channel));
+
+      expect(generator.throw(error).value)
+        .toEqual(put({
           type: types.DUPLICATE_TEMPLATE_FAILURE,
           error,
           errorMsg: undefined,
-        })
-        .run();
+        }));
+
+      expect(generator.next().done).toBeTruthy();
     });
   });
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@capillarytech/creatives-library",
   "author": "meharaj",
-  "version": "8.0.85",
+  "version": "8.0.87-alpha.0",
   "description": "Capillary creatives ui",
   "main": "./index.js",
   "module": "./index.es.js",

package/v2Containers/MobilePush/Edit/index.js

@@ -525,10 +525,10 @@ export class Edit extends React.Component { // eslint-disable-line react/prefer-
           return actionLink;
         }).filter((actionLink) => actionLink);
         // Check if base URL already has query parameters
-        const baseUrl = obj.versions.base.ANDROID.cta.actionLink;
+        const baseUrl = obj?.versions?.base?.ANDROID?.cta?.actionLink;
         if (params.length) {
           // Only append parameters if the URL doesn't already have them
-          if (baseUrl.indexOf('?') === -1) {
+          if (baseUrl?.indexOf('?') === -1) {
             obj.versions.base.ANDROID.cta.actionLink = `${baseUrl}?${params.join('&')}`;
           } else {
             // URL already has parameters, don't append them again
@@ -604,10 +604,10 @@ export class Edit extends React.Component { // eslint-disable-line react/prefer-
           return actionLink;
         }).filter((actionLink) => actionLink);
         // Check if base URL already has query parameters
-        const baseUrl = obj.versions.base.IOS.cta.actionLink;
+        const baseUrl = obj?.versions?.base?.IOS?.cta?.actionLink;
         if (params.length) {
           // Only append parameters if the URL doesn't already have them
-          if (baseUrl.indexOf('?') === -1) {
+          if (baseUrl?.indexOf('?') === -1) {
             obj.versions.base.IOS.cta.actionLink = `${baseUrl}?${params.join('&')}`;
           } else {
             // URL already has parameters, don't append them again
@@ -775,12 +775,12 @@ export class Edit extends React.Component { // eslint-disable-line react/prefer-
           const originalUrl = android['cta-deeplink-secondary-cta-0-select'];
           
           // Check if URL contains custom parameters that need extraction
-          if (originalUrl.includes('custom_param=')) {
+          if (originalUrl?.includes('custom_param=')) {
             const link = originalUrl.split('?')[0];
             const params = originalUrl.split('?')[1] && originalUrl.split('?')[1].split('&');
             
             // Only process and extract custom parameters
-            const customParams = params?.filter(param => param.startsWith('custom_param='));
+            const customParams = params?.filter(param => param?.startsWith('custom_param='));
             
             if (customParams?.length) {
               android['cta-deeplink-secondary-cta-0-select'] = link;
@@ -792,25 +792,25 @@ export class Edit extends React.Component { // eslint-disable-line react/prefer-
           // If no custom parameters, keep original URL intact
           // android['cta-deeplink-secondary-cta-0-select'] remains unchanged
         }
-        if (androidData.expandableDetails && androidData.expandableDetails.ctas && androidData.expandableDetails.ctas.length > 1) {
+        if (androidData?.expandableDetails && androidData?.expandableDetails?.ctas && androidData?.expandableDetails?.ctas?.length > 1) {
           android['add-sec-cta-2'] = true;
-          android['cta-deeplink-secondary-cta-1'] = androidData.expandableDetails.ctas[1].type === "DEEP_LINK" ? "Deeplink" : "External Link";
-          if (androidData.expandableDetails.ctas[1].type === "DEEP_LINK") {
-            android['cta-deeplink-secondary-cta-1-select'] = androidData.expandableDetails.ctas[1].actionLink;
+          android['cta-deeplink-secondary-cta-1'] = androidData?.expandableDetails?.ctas[1]?.type === "DEEP_LINK" ? "Deeplink" : "External Link";
+          if (androidData?.expandableDetails?.ctas[1]?.type === "DEEP_LINK") {
+            android['cta-deeplink-secondary-cta-1-select'] = androidData?.expandableDetails?.ctas[1]?.actionLink;
           } else {
-            android['cta-deeplink-secondary-cta-1-text'] = androidData.expandableDetails.ctas[1].actionLink;
+            android['cta-deeplink-secondary-cta-1-text'] = androidData?.expandableDetails?.ctas[1]?.actionLink;
           }
-          android['secondary-cta-1-label'] = androidData.expandableDetails.ctas[1].actionText;
-          if (androidData.expandableDetails.ctas[1].type === "DEEP_LINK" && android['cta-deeplink-secondary-cta-1-select']) {
+          android['secondary-cta-1-label'] = androidData?.expandableDetails?.ctas[1]?.actionText;
+          if (androidData?.expandableDetails?.ctas[1]?.type === "DEEP_LINK" && android['cta-deeplink-secondary-cta-1-select']) {
             const originalUrl = android['cta-deeplink-secondary-cta-1-select'];
             
             // Check if URL contains custom parameters that need extraction
-            if (originalUrl.includes('custom_param=')) {
+            if (originalUrl?.includes('custom_param=')) {
               const link = originalUrl.split('?')[0];
               const params = originalUrl.split('?')[1] && originalUrl.split('?')[1].split('&');
               
               // Only process and extract custom parameters
-              const customParams = params?.filter(param => param.startsWith('custom_param='));
+              const customParams = params?.filter(param => param?.startsWith('custom_param='));
               
               if (customParams?.length) {
                 android['cta-deeplink-secondary-cta-1-select'] = link;
@@ -822,9 +822,6 @@ export class Edit extends React.Component { // eslint-disable-line react/prefer-
             // If no custom parameters, keep original URL intact
             // android['cta-deeplink-secondary-cta-1-select'] remains unchanged
           }
-          if (androidData.expandableDetails && androidData.expandableDetails.ctas?.[1]?.type === "DEEP_LINK") {
-            android['cta-deeplink-secondary-cta-1-select'] = androidData.expandableDetails.ctas[1].actionLink;
-          }
         }
       }
     }
@@ -864,12 +861,12 @@ export class Edit extends React.Component { // eslint-disable-line react/prefer-
           const originalUrl = ios['cta-deeplink-secondary-cta-1-select2'];
           
           // Check if URL contains custom parameters that need extraction
-          if (originalUrl.includes('custom_param=')) {
+          if (originalUrl?.includes('custom_param=')) {
             const link = originalUrl.split('?')[0];
             const params = originalUrl.split('?')[1] && originalUrl.split('?')[1].split('&');
             
             // Only process and extract custom parameters
-            const customParams = params?.filter(param => param.startsWith('custom_param='));
+            const customParams = params?.filter(param => param?.startsWith('custom_param='));
             
             if (customParams?.length) {
               ios['cta-deeplink-secondary-cta-1-select2'] = link;

package/v2Containers/Zalo/index.js

@@ -407,12 +407,6 @@ export const Zalo = (props) => {
                 name,
               })}
             </CapLabel>
-            <CapLabel className="variable-field-length">
-              {formatMessage(messages.charactersCount, {
-                variableLength: value.length,
-                maxLength,
-              })}
-            </CapLabel>
           </CapRow>
         </>
       );