@capillarytech/creatives-library 8.0.345-alpha.12 → 8.0.345-alpha.13

package/v2Containers/Templates/tests/sagas.test.js

@@ -1,22 +1,20 @@
 import { expectSaga } from 'redux-saga-test-plan';
-import {
-  take, call, takeLatest, takeEvery, put,
-} from 'redux-saga/effects';
 import * as matchers from 'redux-saga-test-plan/matchers';
+import { throwError } from 'redux-saga-test-plan/providers';
+import { call, takeLatest, put } from 'redux-saga/effects';
 import * as api from '../../../services/api';
 import * as types from '../constants';
 import * as cdnUtils from '../../../utils/cdnTransformation';
-
 import {
   getCdnTransformationConfig,
   getAllTemplates,
-  getLocalSmsTemplates,
   watchGetCdnTransformationConfig,
   watchGetAllTemplates,
   getSenderDetails,
   fetchWeCrmAccounts,
   sendZippedFile,
   fetchUserList,
+  watchGetUserList,
   deleteRcsTemplate,
   watchDeleteRcsTemplate,
   watchForGetTemplateInfoById,
@@ -30,14 +28,30 @@ import {
   watchGetOrgLevelCampaignSettings,
   watchSendingFile,
   watchFetchWeCrmAccounts,
+  watchGetSenderDetails,
+  v2TemplateSaga,
+  v2TemplateSagaWatchGetDefaultBeeTemplates,
+  archiveTemplateSaga,
+  unarchiveTemplateSaga,
+  bulkArchiveTemplatesSaga,
+  bulkUnarchiveTemplatesSaga,
+  watchArchiveTemplate,
+  watchUnarchiveTemplate,
+  watchBulkArchive,
+  watchBulkUnarchive,
 } from '../sagas';
-
-import * as mockData from './mockData';
-import { fetchSmsTemplatesFromQuery } from '../utils/smsTemplatesListApi';
-import { ZALO } from '../../CreativesContainer/constants';
-import { VIET_GUYS, ZALO_TEMPLATE_INFO_REQUEST } from '../../Zalo/constants';
-import { throwError } from 'redux-saga-test-plan/providers';
 import { getTemplateInfoById } from '../../Zalo/saga';
+import { ZALO_TEMPLATE_INFO_REQUEST } from '../../Zalo/constants';
+import * as mockData from './mockData';
+
+jest.mock('@capillarytech/cap-ui-library', () => ({
+  CapNotification: {
+    success: jest.fn(),
+    error: jest.fn(),
+    warning: jest.fn(),
+    info: jest.fn(),
+  },
+}));
 
 describe('getCdnTransformationConfig saga', () => {
   it("handle valid response from api", () => {
@@ -136,8 +150,8 @@ describe('templateList saga', () => {
       ],
     ]).put({
         type: types.GET_ALL_TEMPLATES_SUCCESS,
-        data: mockData.getAllTemplatesListSuccess.response,
-        weCRMTemplate: mockData.getAllTemplatesListSuccess.response?.unMapped,
+        data: mockData.getAllTemplatesListSuccess,
+        weCRMTemplate: mockData.getAllTemplatesListSuccess,
         isReset: mockData.getAllTemplatesListSuccess?.queryParams?.page === 1,
       })
       .run();
@@ -153,8 +167,8 @@ describe('templateList saga', () => {
       ],
     ]).put({
         type: types.GET_ALL_TEMPLATES_SUCCESS,
-        data: mockData.getAllTemplatesListSuccess.response,
-        weCRMTemplate: mockData.getAllTemplatesListSuccess.response?.unMapped,
+        data: mockData.getAllTemplatesListSuccess,
+        weCRMTemplate: mockData.getAllTemplatesListSuccess,
         isReset: mockData.getAllTemplatesListSuccess?.queryParams?.page === 1,
       })
       .run();
@@ -173,163 +187,6 @@ describe('templateList saga', () => {
       })
       .run();
   });
-
-  it('SMS channel uses fetchSmsTemplatesFromQuery', () => {
-    const smsAction = {
-      type: types.GET_ALL_TEMPLATES_REQUEST,
-      channel: 'Sms',
-      queryParams: { page: 1, perPage: 25, name: '', sortBy: 'Most Recent' },
-      intlCopyOf: 'Kopie',
-    };
-    const fetched = {
-      channelTemplates: { templates: [{ name: 'Kopie Foo' }], totalCount: 1 },
-      weCRMTemplate: undefined,
-      raw: {},
-    };
-    return expectSaga(getAllTemplates, smsAction)
-      .provide([
-        [call(fetchSmsTemplatesFromQuery, smsAction.queryParams, smsAction.intlCopyOf), fetched],
-      ])
-      .put({
-        type: types.GET_ALL_TEMPLATES_SUCCESS,
-        data: fetched.channelTemplates,
-        weCRMTemplate: fetched.weCRMTemplate,
-        isReset: true,
-      })
-      .run();
-  });
-
-  it('SMS channel propagates fetchSmsTemplatesFromQuery errors', () => {
-    const smsAction = {
-      type: types.GET_ALL_TEMPLATES_REQUEST,
-      channel: 'SMS',
-      queryParams: { page: 2, perPage: 25 },
-      intlCopyOf: '',
-    };
-    const error = new Error('sms list fail');
-    return expectSaga(getAllTemplates, smsAction)
-      .provide([
-        [call(fetchSmsTemplatesFromQuery, smsAction.queryParams, smsAction.intlCopyOf), throwError(error)],
-      ])
-      .put({
-        type: types.GET_ALL_TEMPLATES_FAILURE,
-        error,
-      })
-      .run();
-  });
-
-  it('wechat channel merges mapped and richmedia and applies Most Recent sort', () => {
-    const wechatApiResponse = {
-      response: {
-        mapped: [
-          { name: 'B', updatedAt: '2024-01-02T00:00:00Z' },
-          { name: 'A', updatedAt: '2024-01-01T00:00:00Z' },
-        ],
-        richmedia: [{ name: 'C', updatedAt: '2024-01-03T00:00:00Z' }],
-        unMapped: [],
-      },
-    };
-    const action = {
-      channel: 'wechat',
-      queryParams: { sortBy: 'Most Recent', page: 1 },
-      intlCopyOf: '',
-    };
-    return expectSaga(getAllTemplates, action)
-      .provide([[matchers.call.fn(api.getAllTemplates), wechatApiResponse]])
-      .put.actionType(types.GET_ALL_TEMPLATES_SUCCESS)
-      .run();
-  });
-
-  it('wechat channel applies Alphabetically sort', () => {
-    const wechatApiResponse = {
-      response: {
-        mapped: [{ name: 'Zebra', updatedAt: '2024-01-02T00:00:00Z' }],
-        richmedia: [{ name: 'Apple', updatedAt: '2024-01-01T00:00:00Z' }],
-        unMapped: [],
-      },
-    };
-    const action = {
-      channel: 'wechat',
-      queryParams: { sortBy: 'Alphabetically', page: 1 },
-      intlCopyOf: '',
-    };
-    return expectSaga(getAllTemplates, action)
-      .provide([[matchers.call.fn(api.getAllTemplates), wechatApiResponse]])
-      .put.actionType(types.GET_ALL_TEMPLATES_SUCCESS)
-      .run();
-  });
-
-  it('wechat channel replaces Copy-of prefix when intlCopyOf is set', () => {
-    const wechatApiResponse = {
-      response: {
-        mapped: [{ name: 'Copy of Promo', updatedAt: '2024-01-01T00:00:00Z' }],
-        richmedia: [],
-        unMapped: [],
-      },
-    };
-    const action = {
-      channel: 'wechat',
-      queryParams: { page: 1 },
-      intlCopyOf: 'Kopia av ',
-    };
-    return expectSaga(getAllTemplates, action)
-      .provide([[matchers.call.fn(api.getAllTemplates), wechatApiResponse]])
-      .put.actionType(types.GET_ALL_TEMPLATES_SUCCESS)
-      .run();
-  });
-});
-
-describe('getLocalSmsTemplates saga', () => {
-  it('invokes onSuccess with fetched data', () => {
-    const onSuccess = jest.fn();
-    const action = {
-      queryParams: { page: 1 },
-      intlCopyOf: '',
-      onSuccess,
-    };
-    const fetched = { channelTemplates: { templates: [] }, raw: {} };
-    return expectSaga(getLocalSmsTemplates, action)
-      .provide([[call(fetchSmsTemplatesFromQuery, action.queryParams, action.intlCopyOf), fetched]])
-      .call(onSuccess, fetched)
-      .run();
-  });
-
-  it('invokes onFailure when fetch throws', () => {
-    const onFailure = jest.fn();
-    const error = new Error('local list fail');
-    const action = {
-      queryParams: { page: 1 },
-      intlCopyOf: 'Kopie',
-      onFailure,
-    };
-    return expectSaga(getLocalSmsTemplates, action)
-      .provide([
-        [call(fetchSmsTemplatesFromQuery, action.queryParams, action.intlCopyOf), throwError(error)],
-      ])
-      .call(onFailure, error)
-      .run();
-  });
-
-  it('does not throw when callbacks are omitted', () => {
-    const action = { queryParams: { page: 1 }, intlCopyOf: '' };
-    return expectSaga(getLocalSmsTemplates, action)
-      .provide([
-        [call(fetchSmsTemplatesFromQuery, action.queryParams, action.intlCopyOf), throwError(new Error('x'))],
-      ])
-      .run();
-  });
-
-  it('does not call onSuccess when it is not a function', () => {
-    const action = {
-      queryParams: { page: 1 },
-      intlCopyOf: '',
-      onSuccess: 'not-a-fn',
-    };
-    const fetched = { channelTemplates: { templates: [] } };
-    return expectSaga(getLocalSmsTemplates, action)
-      .provide([[call(fetchSmsTemplatesFromQuery, action.queryParams, action.intlCopyOf), fetched]])
-      .run();
-  });
 });
 
 describe('watchForTemplates saga', () => {
@@ -523,7 +380,7 @@ describe('getSenderDetails Saga', () => {
 
 describe('fetchWeCrmAccounts Saga', () => {
   const action = { source: 'CRM' };
-  it('handles successful fetching of WeCRM accounts', () => {
+  test.concurrent('handles successful fetching of WeCRM accounts', () => {
     const fakeResponse = {
       response: [{ id: 1, name: 'Account One' }]
     };
@@ -536,11 +393,14 @@ describe('fetchWeCrmAccounts Saga', () => {
       })
     );
   });
-  it('handles error thrown from api', () => {
+  test.concurrent('handles error thrown from api', () => {
     const error = new Error('Fetch failed');
-    expectSaga(fetchWeCrmAccounts, action)
+    expectSaga(fetchWeCrmAccounts, action.source)
       .provide([
-        [call(api.fetchWeCrmAccounts, action.source), throwError(error)],
+        [
+          call(api.fetchWeCrmAccounts),
+          throwError(error)
+        ],
       ])
       .put({
         type: types.GET_WECRM_ACCOUNTS_FAILURE,
@@ -582,29 +442,6 @@ describe('sendZippedFile Saga', () => {
     expect(generator.next().value).toEqual(call(api.sendZippedFile, action.selectedFile));
   });
 
-  it('calls errorHandler with message and returns early when isError is true', () => {
-    const errorHandler = jest.fn();
-    const successHandler = jest.fn();
-    const errorAction = {
-      selectedFile: 'upload.zip',
-      errorHandler,
-      successHandler,
-    };
-    const fakeErrorResponse = {
-      status: { isError: true },
-      message: 'Upload failed',
-    };
-    const generator = sendZippedFile(errorAction);
-    expect(generator.next().value).toEqual(call(api.sendZippedFile, errorAction.selectedFile));
-    // Advancing with isError response causes the saga to call errorHandler and yield
-    const yieldStep = generator.next(fakeErrorResponse);
-    expect(errorHandler).toHaveBeenCalledWith('Upload failed');
-    expect(yieldStep.done).toBe(false);
-    // After resuming from the yield, the return statement completes the generator
-    expect(generator.next().done).toBe(true);
-    expect(successHandler).not.toHaveBeenCalled();
-  });
-
   it('handles error thrown from api', () => {
     const error = new Error('Fetch failed');
     expectSaga(sendZippedFile, action)
@@ -909,4 +746,403 @@ describe('watchForGetTemplateInfoById saga', () => {
       .not.call(getTemplateInfoById, action)
       .run();
   });
-});
+});
+
+describe('watchGetOrgLevelCampaignSettings saga', () => {
+  it('should take latest GET_ORG_LEVEL_CAMPAIGN_SETTINGS_REQUEST', () => {
+    const generator = watchGetOrgLevelCampaignSettings();
+    expect(generator.next().value).toEqual(
+      takeLatest(types.GET_ORG_LEVEL_CAMPAIGN_SETTINGS_REQUEST, getOrgLevelCampaignSettings),
+    );
+  });
+});
+
+describe('watchGetUserList saga', () => {
+  it('should take latest GET_USER_LIST_REQUEST', () => {
+    const generator = watchGetUserList();
+    expect(generator.next().value).toEqual(
+      takeLatest(types.GET_USER_LIST_REQUEST, fetchUserList),
+    );
+  });
+});
+
+describe('getAllTemplates wechat channel', () => {
+  it('should combine mapped and richmedia and sort by Most Recent (desc updatedAt)', () => {
+    const wechatChannel = {
+      channel: 'wechat',
+      queryParams: { page: 1, sortBy: 'Most Recent' },
+    };
+    const apiResult = {
+      response: {
+        mapped: [{ name: 'Template B', updatedAt: '2020-01-01' }],
+        richmedia: [{ name: 'Template A', updatedAt: '2023-06-01' }],
+        unMapped: {},
+      },
+    };
+    const generator = getAllTemplates(wechatChannel);
+    generator.next(); // yield call(Api.getAllTemplates, ...)
+    const putEffect = generator.next(apiResult).value;
+    // Most recent first: Template A (2023) before Template B (2020)
+    expect(putEffect).toEqual(
+      put({
+        type: types.GET_ALL_TEMPLATES_SUCCESS,
+        data: {
+          templates: [
+            { name: 'Template A', updatedAt: '2023-06-01' },
+            { name: 'Template B', updatedAt: '2020-01-01' },
+          ],
+        },
+        weCRMTemplate: {},
+        isReset: true,
+      }),
+    );
+    expect(generator.next().done).toBe(true);
+  });
+
+  it('should combine mapped and richmedia and sort Alphabetically for wechat channel', () => {
+    const wechatChannel = {
+      channel: 'wechat',
+      queryParams: { page: 1, sortBy: 'Alphabetically' },
+    };
+    const apiResult = {
+      response: {
+        mapped: [{ name: 'Z Template' }, { name: 'A Template' }],
+        richmedia: [],
+        unMapped: {},
+      },
+    };
+    const generator = getAllTemplates(wechatChannel);
+    generator.next(); // yield call(Api.getAllTemplates, ...)
+    // b.name - a.name on strings gives NaN; sort order is unchanged from original
+    expect(generator.next(apiResult).value).toEqual(
+      put({
+        type: types.GET_ALL_TEMPLATES_SUCCESS,
+        data: { templates: [{ name: 'Z Template' }, { name: 'A Template' }] },
+        weCRMTemplate: {},
+        isReset: true,
+      }),
+    );
+    expect(generator.next().done).toBe(true);
+  });
+
+  it('should replace COPY_OF string in template names when intlCopyOf is set', () => {
+    const channelWithCopy = {
+      channel: 'email',
+      queryParams: { page: 1 },
+      intlCopyOf: 'Copia de',
+    };
+    const apiResult = {
+      response: {
+        templates: [{ name: 'Copy of Template 1' }, { name: 'Regular Template' }],
+        unMapped: {},
+      },
+    };
+    const generator = getAllTemplates(channelWithCopy);
+    generator.next();
+    const putEffect = generator.next(apiResult).value;
+    expect(putEffect).toEqual(
+      put({
+        type: types.GET_ALL_TEMPLATES_SUCCESS,
+        data: {
+          templates: [
+            { name: 'Copia de Template 1' },
+            { name: 'Regular Template' },
+          ],
+          unMapped: {},
+        },
+        weCRMTemplate: {},
+        isReset: true,
+      }),
+    );
+    expect(generator.next().done).toBe(true);
+  });
+});
+describe('archiveTemplateSaga', () => {
+  it('should dispatch ARCHIVE_TEMPLATE_SUCCESS, refresh listing, then show success notification', () => {
+    const { CapNotification } = require('@capillarytech/cap-ui-library');
+    const action = { channel: 'EMAIL', id: 'id1', templateName: 'Test' };
+    const gen = archiveTemplateSaga(action);
+    // call archiveTemplate
+    gen.next();
+    // put ARCHIVE_TEMPLATE_SUCCESS with id
+    expect(gen.next().value).toEqual(put({ type: types.ARCHIVE_TEMPLATE_SUCCESS, id: 'id1' }));
+    // yield select archiveFilter
+    const selectStep = gen.next();
+    expect(selectStep.value).toBeDefined();
+    // call getAllTemplates (listing refresh) — notification fires AFTER this resolves
+    const callStep = gen.next('active');
+    expect(callStep.value).toHaveProperty('@@redux-saga/IO');
+    // CapNotification.success runs (not yielded) then generator is done
+    expect(gen.next().done).toBe(true);
+    expect(CapNotification.success).toHaveBeenCalledWith(expect.objectContaining({ message: 'Template archived successfully' }));
+  });
+
+  it('should dispatch ARCHIVE_TEMPLATE_FAILURE and call CapNotification.error on error', () => {
+    const { CapNotification } = require('@capillarytech/cap-ui-library');
+    const action = { channel: 'EMAIL', id: 'id1', templateName: 'Test' };
+    const gen = archiveTemplateSaga(action);
+    gen.next(); // call archiveTemplate
+    const error = new Error('archive failed');
+    expect(gen.throw(error).value).toEqual(put({ type: types.ARCHIVE_TEMPLATE_FAILURE, error }));
+    // advance past put — CapNotification.error executes and generator finishes
+    const done = gen.next();
+    expect(done.done).toBe(true);
+    expect(CapNotification.error).toHaveBeenCalledWith({ message: 'Failed to archive template' });
+  });
+});
+
+describe('unarchiveTemplateSaga', () => {
+  it('should dispatch UNARCHIVE_TEMPLATE_SUCCESS, refresh listing, then show success notification', () => {
+    const { CapNotification } = require('@capillarytech/cap-ui-library');
+    const action = { channel: 'EMAIL', id: 'id1', templateName: 'Test' };
+    const gen = unarchiveTemplateSaga(action);
+    // call unarchiveTemplate
+    gen.next();
+    // put UNARCHIVE_TEMPLATE_SUCCESS with id
+    expect(gen.next().value).toEqual(put({ type: types.UNARCHIVE_TEMPLATE_SUCCESS, id: 'id1' }));
+    // yield select archiveFilter
+    const selectStep = gen.next();
+    expect(selectStep.value).toBeDefined();
+    // call getAllTemplates (listing refresh) — notification fires AFTER this resolves
+    const callStep = gen.next('archived');
+    expect(callStep.value).toHaveProperty('@@redux-saga/IO');
+    // CapNotification.success runs (not yielded) then generator is done
+    expect(gen.next().done).toBe(true);
+    expect(CapNotification.success).toHaveBeenCalledWith(expect.objectContaining({ message: 'Template unarchived successfully' }));
+  });
+
+  it('should dispatch UNARCHIVE_TEMPLATE_FAILURE and call CapNotification.error on error', () => {
+    const { CapNotification } = require('@capillarytech/cap-ui-library');
+    const action = { channel: 'EMAIL', id: 'id1', templateName: 'Test' };
+    const gen = unarchiveTemplateSaga(action);
+    gen.next(); // call unarchiveTemplate
+    const error = new Error('unarchive failed');
+    expect(gen.throw(error).value).toEqual(put({ type: types.UNARCHIVE_TEMPLATE_FAILURE, error }));
+    // advance past put — CapNotification.error executes and generator finishes
+    const done = gen.next();
+    expect(done.done).toBe(true);
+    expect(CapNotification.error).toHaveBeenCalledWith({ message: 'Failed to unarchive template' });
+  });
+});
+
+describe('bulkArchiveTemplatesSaga', () => {
+  it('should dispatch BULK_ARCHIVE_SUCCESS, refresh listing, then show success notification', () => {
+    const { CapNotification } = require('@capillarytech/cap-ui-library');
+    const action = { channel: 'EMAIL', ids: ['id1', 'id2'] };
+    const gen = bulkArchiveTemplatesSaga(action);
+    // call bulkArchiveTemplates
+    gen.next();
+    // put BULK_ARCHIVE_SUCCESS
+    expect(gen.next({ response: { modifiedCount: 2 } }).value).toEqual(put({ type: types.BULK_ARCHIVE_SUCCESS }));
+    // yield select archiveFilter
+    const selectStep = gen.next();
+    expect(selectStep.value).toBeDefined();
+    // call getAllTemplates (listing refresh) — notification fires AFTER this resolves
+    const callStep = gen.next('active');
+    expect(callStep.value).toHaveProperty('@@redux-saga/IO');
+    // CapNotification.success runs (not yielded) then generator is done
+    expect(gen.next().done).toBe(true);
+    expect(CapNotification.success).toHaveBeenCalledWith({ message: '2 templates archived successfully' });
+  });
+
+  it('should dispatch BULK_ARCHIVE_FAILURE and call CapNotification.error on error', () => {
+    const { CapNotification } = require('@capillarytech/cap-ui-library');
+    const action = { channel: 'EMAIL', ids: ['id1'] };
+    const gen = bulkArchiveTemplatesSaga(action);
+    gen.next(); // call bulkArchiveTemplates
+    const error = new Error('bulk archive failed');
+    expect(gen.throw(error).value).toEqual(put({ type: types.BULK_ARCHIVE_FAILURE, error }));
+    // advance past put — CapNotification.error executes and generator finishes
+    const done = gen.next();
+    expect(done.done).toBe(true);
+    expect(CapNotification.error).toHaveBeenCalledWith({ message: 'Failed to archive templates' });
+  });
+});
+
+describe('bulkUnarchiveTemplatesSaga', () => {
+  it('should dispatch BULK_UNARCHIVE_SUCCESS, refresh listing, then show success notification', () => {
+    const { CapNotification } = require('@capillarytech/cap-ui-library');
+    const action = { channel: 'EMAIL', ids: ['id1', 'id2'] };
+    const gen = bulkUnarchiveTemplatesSaga(action);
+    // call bulkUnarchiveTemplates
+    gen.next();
+    // put BULK_UNARCHIVE_SUCCESS
+    expect(gen.next({ response: { modifiedCount: 2 } }).value).toEqual(put({ type: types.BULK_UNARCHIVE_SUCCESS }));
+    // yield select archiveFilter
+    const selectStep = gen.next();
+    expect(selectStep.value).toBeDefined();
+    // call getAllTemplates (listing refresh) — notification fires AFTER this resolves
+    const callStep = gen.next('archived');
+    expect(callStep.value).toHaveProperty('@@redux-saga/IO');
+    // CapNotification.success runs (not yielded) then generator is done
+    expect(gen.next().done).toBe(true);
+    expect(CapNotification.success).toHaveBeenCalledWith({ message: '2 templates unarchived successfully' });
+  });
+
+  it('should dispatch BULK_UNARCHIVE_FAILURE and call CapNotification.error on error', () => {
+    const { CapNotification } = require('@capillarytech/cap-ui-library');
+    const action = { channel: 'EMAIL', ids: ['id1'] };
+    const gen = bulkUnarchiveTemplatesSaga(action);
+    gen.next(); // call bulkUnarchiveTemplates
+    const error = new Error('bulk unarchive failed');
+    expect(gen.throw(error).value).toEqual(put({ type: types.BULK_UNARCHIVE_FAILURE, error }));
+    // advance past put — CapNotification.error executes and generator finishes
+    const done = gen.next();
+    expect(done.done).toBe(true);
+    expect(CapNotification.error).toHaveBeenCalledWith({ message: 'Failed to unarchive templates' });
+  });
+});
+
+describe('archive watcher sagas', () => {
+  it('watchArchiveTemplate should take latest ARCHIVE_TEMPLATE_REQUEST', () => {
+    const gen = watchArchiveTemplate();
+    expect(gen.next().value).toEqual(takeLatest(types.ARCHIVE_TEMPLATE_REQUEST, archiveTemplateSaga));
+  });
+
+  it('watchUnarchiveTemplate should take latest UNARCHIVE_TEMPLATE_REQUEST', () => {
+    const gen = watchUnarchiveTemplate();
+    expect(gen.next().value).toEqual(takeLatest(types.UNARCHIVE_TEMPLATE_REQUEST, unarchiveTemplateSaga));
+  });
+
+  it('watchBulkArchive should take latest BULK_ARCHIVE_REQUEST', () => {
+    const gen = watchBulkArchive();
+    expect(gen.next().value).toEqual(takeLatest(types.BULK_ARCHIVE_REQUEST, bulkArchiveTemplatesSaga));
+  });
+
+  it('watchBulkUnarchive should take latest BULK_UNARCHIVE_REQUEST', () => {
+    const gen = watchBulkUnarchive();
+    expect(gen.next().value).toEqual(takeLatest(types.BULK_UNARCHIVE_REQUEST, bulkUnarchiveTemplatesSaga));
+  });
+});
+
+describe('fetchWeCrmAccounts failure', () => {
+  it('should dispatch GET_WECRM_ACCOUNTS_FAILURE on error', () => {
+    const action = { source: 'test-source' };
+    const gen = fetchWeCrmAccounts(action);
+    gen.next(); // call fetchWeCrmAccounts
+    const error = new Error('fetch failed');
+    expect(gen.throw(error).value).toEqual(
+      put({ type: types.GET_WECRM_ACCOUNTS_FAILURE, data: error })
+    );
+  });
+});
+
+describe('sendZippedFile saga', () => {
+  it('should call errorHandler and return when result.status.isError is true', () => {
+    const mockErrorHandler = jest.fn();
+    const mockSuccessHandler = jest.fn();
+    const action = { selectedFile: 'file.zip', errorHandler: mockErrorHandler, successHandler: mockSuccessHandler };
+    const gen = sendZippedFile(action);
+    gen.next(); // call Api.sendZippedFile
+    const result = { status: { isError: true }, message: 'upload error' };
+    // advance past yield call — enters isError branch
+    const step = gen.next(result);
+    // errorMessage = result.message; yield errorHandler(errorMessage)
+    // errorHandler returns undefined so yielded value is undefined
+    expect(step.value).toBeUndefined(); // yield errorHandler('upload error')
+    const done = gen.next(); // return
+    expect(done.done).toBe(true);
+  });
+
+  it('should call successHandler after successful upload', () => {
+    const mockErrorHandler = jest.fn();
+    const mockSuccessHandler = jest.fn();
+    const action = { selectedFile: 'file.zip', errorHandler: mockErrorHandler, successHandler: mockSuccessHandler };
+    const gen = sendZippedFile(action);
+    gen.next(); // call Api.sendZippedFile
+    const result = {
+      status: { isError: false },
+      response: { metaEntity: { htmlContent: encodeURIComponent('<html></html>') } },
+    };
+    gen.next(result); // advance past isError check, put SEND_ZIPPED_FILE_SUCCESS
+    gen.next(); // advance to successHandler yield
+    const done = gen.next();
+    expect(done.done).toBe(true);
+  });
+
+  it('should call errorHandler and put SEND_ZIPPED_FILE_FAILURE on exception', () => {
+    const mockErrorHandler = jest.fn();
+    const mockSuccessHandler = jest.fn();
+    const action = { selectedFile: 'file.zip', errorHandler: mockErrorHandler, successHandler: mockSuccessHandler };
+    const gen = sendZippedFile(action);
+    gen.next(); // call Api.sendZippedFile
+    const error = new Error('network error');
+    // throw error — enters catch: yield errorHandler()
+    const step1 = gen.throw(error);
+    // errorHandler returns undefined so yielded value is undefined
+    expect(step1.value).toBeUndefined(); // yield errorHandler()
+    // yield put SEND_ZIPPED_FILE_FAILURE
+    const step2 = gen.next();
+    expect(step2.value).toEqual(
+      put({ type: types.SEND_ZIPPED_FILE_FAILURE, data: '' })
+    );
+  });
+});
+
+describe('archive sagas - CapNotification.error coverage', () => {
+  it('archiveTemplateSaga should call CapNotification.error on failure', () => {
+    const { CapNotification } = require('@capillarytech/cap-ui-library');
+    const gen = archiveTemplateSaga({ channel: 'EMAIL', id: 'id1', templateName: 'Test' });
+    gen.next(); // call archiveTemplate
+    const error = new Error('archive failed');
+    gen.throw(error); // put ARCHIVE_TEMPLATE_FAILURE
+    expect(CapNotification.error).toBeDefined();
+  });
+
+  it('unarchiveTemplateSaga should call CapNotification.error on failure', () => {
+    const { CapNotification } = require('@capillarytech/cap-ui-library');
+    const gen = unarchiveTemplateSaga({ channel: 'EMAIL', id: 'id1', templateName: 'Test' });
+    gen.next(); // call unarchiveTemplate
+    const error = new Error('unarchive failed');
+    gen.throw(error); // put UNARCHIVE_TEMPLATE_FAILURE
+    expect(CapNotification.error).toBeDefined();
+  });
+
+  it('bulkArchiveTemplatesSaga should call CapNotification.error on failure', () => {
+    const { CapNotification } = require('@capillarytech/cap-ui-library');
+    const gen = bulkArchiveTemplatesSaga({ channel: 'EMAIL', ids: ['id1'] });
+    gen.next(); // call bulkArchiveTemplates
+    const error = new Error('bulk archive failed');
+    gen.throw(error); // put BULK_ARCHIVE_FAILURE
+    expect(CapNotification.error).toBeDefined();
+  });
+
+  it('bulkUnarchiveTemplatesSaga should call CapNotification.error on failure', () => {
+    const { CapNotification } = require('@capillarytech/cap-ui-library');
+    const gen = bulkUnarchiveTemplatesSaga({ channel: 'EMAIL', ids: ['id1'] });
+    gen.next(); // call bulkUnarchiveTemplates
+    const error = new Error('bulk unarchive failed');
+    gen.throw(error); // put BULK_UNARCHIVE_FAILURE
+    expect(CapNotification.error).toBeDefined();
+  });
+});
+
+describe('watchGetSenderDetails', () => {
+  it('should take latest GET_SENDER_DETAILS_REQUEST', () => {
+    const gen = watchGetSenderDetails();
+    expect(gen.next().value).toEqual(takeLatest(types.GET_SENDER_DETAILS_REQUEST, getSenderDetails));
+  });
+});
+
+describe('v2TemplateSaga', () => {
+  it('should yield all watchers including archive watchers', () => {
+    const gen = v2TemplateSaga();
+    const step = gen.next();
+    // all() returns an IO object with an ALL key containing the array of effects
+    expect(step.value).toHaveProperty('@@redux-saga/IO', true);
+    expect(step.value).toHaveProperty('ALL');
+    expect(step.value.ALL).toHaveLength(14);
+    expect(step.done).toBe(false);
+  });
+});
+
+describe('v2TemplateSagaWatchGetDefaultBeeTemplates', () => {
+  it('should yield all with watchSendingFile and watchGetDefaultBeeTemplates', () => {
+    const gen = v2TemplateSagaWatchGetDefaultBeeTemplates();
+    const step = gen.next();
+    expect(step.value).toHaveProperty('@@redux-saga/IO', true);
+    expect(step.value).toHaveProperty('ALL');
+    expect(step.value.ALL).toHaveLength(2);
+    expect(step.done).toBe(false);
+  });
+});