@capillarytech/creatives-library 8.0.136-alpha.4 → 8.0.136-beta.3

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

@@ -0,0 +1,671 @@
+import { expectSaga } from 'redux-saga-test-plan';
+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';
+import * as sagas from '../sagas';
+
+describe('Email Template Sagas', () => {
+  // Increase timeout to prevent timeout warnings
+  jest.setTimeout(1000);
+
+  describe('createTemplate Saga', () => {
+    const template = { name: 'Test Template', content: 'Test Content' };
+
+    it.concurrent('should handle successful template creation', () => {
+      const generator = sagas.createTemplate(template);
+      const response = {
+        response: { id: 1, name: 'Test Template' },
+        status: { code: 200 },
+      };
+
+      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: response.status.code,
+          errorMsg: undefined,
+        }));
+
+      expect(generator.next().done).toBeTruthy();
+    });
+
+    it.concurrent('should handle server error with status code 500', () => {
+      const generator = sagas.createTemplate(template);
+      const response = {
+        message: 'Internal Server Error',
+        status: { code: 500 },
+      };
+
+      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.concurrent('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.concurrent('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,
+        }));
+
+      expect(generator.next().done).toBeTruthy();
+    });
+
+    it.concurrent('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.concurrent('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.concurrent('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.concurrent('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.concurrent('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 templateId = 123;
+    const channel = 'email';
+
+    it.concurrent('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',
+      };
+
+      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: response.status.code,
+          errorMsg: response.message,
+        }));
+
+      expect(generator.next().done).toBeTruthy();
+    });
+
+    it.concurrent('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.concurrent('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.concurrent('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.concurrent('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.concurrent('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.concurrent('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.concurrent('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.concurrent('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.concurrent('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.concurrent('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.concurrent('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,
+        }));
+
+      expect(generator.next().done).toBeTruthy();
+    });
+
+    it.concurrent('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");
+
+      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();
+    });
+  });
+
+  describe('getTemplateDetails Saga', () => {
+    const id = '123';
+
+    it.concurrent('handles fetching template details successfully', () => {
+      const fakeResponse = {
+        response: { id: 123, name: 'Detailed Template' },
+      };
+
+      return expectSaga(sagas.getTemplateDetails, id)
+        .provide([
+          [call(Api.getTemplateDetails, id), fakeResponse],
+        ])
+        .put({
+          type: types.GET_TEMPLATE_DETAILS_SUCCESS,
+          data: fakeResponse.response,
+        })
+        .run();
+    });
+
+    it.concurrent('handles failure in fetching template details', () => {
+      const error = new Error('Fetch failed');
+
+      return expectSaga(sagas.getTemplateDetails, id)
+        .provide([
+          [call(Api.getTemplateDetails, id), throwError(error)],
+        ])
+        .put({
+          type: types.GET_TEMPLATE_DETAILS_FAILURE,
+          error,
+        })
+        .run();
+    });
+  });
+
+  describe('getAllAssets Saga', () => {
+    const mockAssets = [{ id: 1, url: 'http://example.com/asset.jpg' }];
+    const mockError = new Error('Fetch failed');
+    const assetType = 'image';
+    const queryParams = { page: 1 };
+
+    it.concurrent('handles fetching all assets successfully', () => {
+      const result = {
+        response: { data: { data: mockAssets } },
+      };
+      return expectSaga(sagas.getAllAssets, { assetType, queryParams })
+        .provide([
+          [call(Api.getAllAssets, { assetType, queryParams }), result],
+        ])
+        .put({
+          type: types.GET_ALL_ASSETS_SUCCESS,
+          data: { data: { data: mockAssets } }, // Match the exact nested structure
+          isReset: true,
+        })
+        .run(500);
+    });
+
+    it.concurrent('handles failure in fetching all assets', () => expectSaga(sagas.getAllAssets, { assetType, queryParams })
+      .provide([
+        [call(Api.getAllAssets, { assetType, queryParams }), throwError(mockError)],
+      ])
+      .put({
+        type: types.GET_ALL_ASSETS_FAILURE,
+        error: mockError,
+      })
+      .run(500));
+  });
+
+  describe('getCmsSetting Saga', () => {
+    const params = {
+      cmsType: 'email', projectId: '123', cmsMode: 'edit', langId: 'en', isEdmSupport: true,
+    };
+
+    it.concurrent('handles fetching CMS settings successfully', () => {
+      const fakeResponse = {
+        data: {
+          response: {
+            cmsDetails: { id: 1, name: 'CMS Config' },
+          },
+        },
+      };
+
+      return expectSaga(sagas.getCmsSetting, params)
+        .provide([
+          [call(Api.getCmsTemplateSettings, params.cmsType, params.projectId, params.cmsMode, params.langId, params.isEdmSupport), fakeResponse],
+        ])
+        .put({
+          type: types.GET_CMS_EDITOR_DETAILS_SUCCESS,
+          settings: fakeResponse.data.response.cmsDetails,
+        })
+        .run();
+    });
+
+    it.concurrent('handles failure in fetching CMS settings', () => {
+      const error = new Error('Fetch failed');
+
+      return expectSaga(sagas.getCmsSetting, params)
+        .provide([
+          [call(Api.getCmsTemplateSettings, params.cmsType, params.projectId, params.cmsMode, params.langId, params.isEdmSupport), throwError(error)],
+        ])
+        .put({
+          type: types.GET_CMS_EDITOR_DETAILS_FAILURE,
+          error,
+        })
+        .run();
+    });
+  });
+
+  describe('getCmsData Saga', () => {
+    const params = { cmsType: 'email', projectId: '123', langId: 'en' };
+
+    it.concurrent('handles fetching CMS data successfully', () => {
+      const fakeResponse = {
+        data: {
+          response: {
+            data: { id: 1, content: 'Content here' },
+            langId: 'en',
+          },
+        },
+      };
+
+      return expectSaga(sagas.getCmsData, params)
+        .provide([
+          [call(Api.getCmsTemplateData, params.cmsType, params.projectId, params.langId), fakeResponse],
+        ])
+        .put({
+          type: types.GET_CMS_EDITOR_DATA_SUCCESS,
+          data: fakeResponse.data.response.data,
+          langId: fakeResponse.data.response.langId,
+        })
+        .run();
+    });
+
+    it.concurrent('handles failure in fetching CMS data', () => {
+      const error = new Error('Fetch failed');
+
+      return expectSaga(sagas.getCmsData, params)
+        .provide([
+          [call(Api.getCmsTemplateData, params.cmsType, params.projectId, params.langId), throwError(error)],
+        ])
+        .put({
+          type: types.GET_CMS_EDITOR_DATA_FAILURE,
+          error,
+        })
+        .run();
+    });
+  });
+
+  describe('uploadAsset Saga', () => {
+    const file = new Blob();
+    const assetType = 'image';
+    const fileParams = { param1: 'value1' };
+
+    it.concurrent('handles successful asset upload', () => {
+      const fakeResponse = {
+        response: { asset: { id: 1, url: 'http://example.com/asset.jpg' } },
+        status: { code: '200' },
+      };
+
+      return expectSaga(sagas.uploadAsset, file, assetType, fileParams)
+        .provide([
+          [call(Api.uploadFile, file, assetType, fileParams), fakeResponse],
+        ])
+        .put({
+          type: types.UPLOAD_ASSET_SUCCESS,
+          data: fakeResponse.response.asset,
+          statusCode: '200',
+        })
+        .run();
+    });
+
+    it.concurrent('handles failure in asset upload', () => {
+      const error = new Error('Failed to upload asset');
+
+      return expectSaga(sagas.uploadAsset, file, assetType, fileParams)
+        .provide([
+          [call(Api.uploadFile, file, assetType, fileParams), throwError(error)],
+        ])
+        .put({
+          type: types.UPLOAD_ASSET_FAILURE,
+          error,
+        })
+        .run();
+    });
+  });
+
+  describe('Combined emailSaga', () => {
+    it.concurrent('should initialize all email-related watcher sagas without error', () => expectSaga(sagas.emailSaga)
+      .run());
+  });
+});

package/containers/LanguageProvider/actions.js

@@ -0,0 +1,17 @@
+/*
+ *
+ * LanguageProvider actions
+ *
+ */
+
+import {
+  CHANGE_LOCALE,
+} from './constants';
+
+export function changeLocale(languageLocale) {
+  
+  return {
+    type: CHANGE_LOCALE,
+    locale: languageLocale,
+  };
+}

package/containers/LanguageProvider/constants.js

@@ -0,0 +1,8 @@
+/*
+ *
+ * LanguageProvider constants
+ *
+ */
+
+export const CHANGE_LOCALE = 'app/LanguageToggle/CHANGE_LOCALE';
+export const DEFAULT_LOCALE = 'en';