@capillarytech/creatives-library 8.0.345-alpha.9 → 8.0.345

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

@@ -23,6 +23,9 @@ describe('Test Templates container', () => {
   const getUserList = jest.fn();
   const getSenderDetails = jest.fn();
   const resetTemplate = jest.fn();
+  const setArchivedMode = jest.fn();
+  const clearTemplateSelection = jest.fn();
+  const toggleTemplateSelection = jest.fn();
   let renderedComponent;
 
   beforeEach(() => {
@@ -56,6 +59,9 @@ describe('Test Templates container', () => {
           getUserList,
           getSenderDetails,
           resetTemplate,
+          setArchivedMode,
+          clearTemplateSelection,
+          toggleTemplateSelection,
         }}
         location={{
           pathname: `/${channel}`,

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

@@ -353,3 +353,181 @@ describe("test reducer - SET account actions clear templates", () => {
     expect(result.templates).toEqual([]);
   });
 });
+
+describe("test reducer - archive actions", () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should handle SET_ARCHIVE_FILTER", () => {
+    const action = { type: types.SET_ARCHIVE_FILTER, filter: 'archived' };
+    const result = reducer(initialState, action).toJS();
+    expect(result.archiveFilter).toBe('archived');
+    expect(result.templates).toEqual([]);
+    expect(result.selectedTemplateIds).toEqual([]);
+  });
+
+  it("should handle SET_ARCHIVED_MODE with isArchived true", () => {
+    const action = { type: types.SET_ARCHIVED_MODE, isArchived: true };
+    const result = reducer(initialState, action).toJS();
+    expect(result.isArchivedMode).toBe(true);
+    expect(result.archiveFilter).toBe('archived');
+    expect(result.templates).toEqual([]);
+    expect(result.selectedTemplateIds).toEqual([]);
+  });
+
+  it("should handle SET_ARCHIVED_MODE with isArchived false", () => {
+    const action = { type: types.SET_ARCHIVED_MODE, isArchived: false };
+    const result = reducer(initialState, action).toJS();
+    expect(result.isArchivedMode).toBe(false);
+    expect(result.archiveFilter).toBe('active');
+  });
+
+  it("should handle TOGGLE_TEMPLATE_SELECTION - add id", () => {
+    const action = { type: types.TOGGLE_TEMPLATE_SELECTION, id: 'id1' };
+    const result = reducer(initialState, action).toJS();
+    expect(result.selectedTemplateIds).toEqual(['id1']);
+  });
+
+  it("should handle TOGGLE_TEMPLATE_SELECTION - remove id if already selected", () => {
+    const { fromJS } = require('immutable');
+    const stateWithSelected = initialState.set('selectedTemplateIds', fromJS(['id1', 'id2']));
+    const action = { type: types.TOGGLE_TEMPLATE_SELECTION, id: 'id1' };
+    const result = reducer(stateWithSelected, action).toJS();
+    expect(result.selectedTemplateIds).toEqual(['id2']);
+  });
+
+  it("should handle TOGGLE_TEMPLATE_SELECTION - add id when selectedTemplateIds is a plain array (legacy state)", () => {
+    // Covers the Array.isArray branch of the defensive fallback
+    const stateWithPlainArray = initialState.set('selectedTemplateIds', ['id1']);
+    const action = { type: types.TOGGLE_TEMPLATE_SELECTION, id: 'id2' };
+    const result = reducer(stateWithPlainArray, action).toJS();
+    expect(result.selectedTemplateIds).toEqual(['id1', 'id2']);
+  });
+
+  it("should handle TOGGLE_TEMPLATE_SELECTION - remove id when selectedTemplateIds is a plain array (legacy state)", () => {
+    // Covers the Array.isArray branch of the defensive fallback
+    const stateWithPlainArray = initialState.set('selectedTemplateIds', ['id1', 'id2']);
+    const action = { type: types.TOGGLE_TEMPLATE_SELECTION, id: 'id1' };
+    const result = reducer(stateWithPlainArray, action).toJS();
+    expect(result.selectedTemplateIds).toEqual(['id2']);
+  });
+
+  it("should handle TOGGLE_TEMPLATE_SELECTION - add id when selectedTemplateIds is undefined (stale persisted state)", () => {
+    // Covers the final fallback to [] when rawSelected is neither Immutable nor Array
+    const stateWithUndefined = initialState.set('selectedTemplateIds', undefined);
+    const action = { type: types.TOGGLE_TEMPLATE_SELECTION, id: 'id1' };
+    const result = reducer(stateWithUndefined, action).toJS();
+    expect(result.selectedTemplateIds).toEqual(['id1']);
+  });
+
+  it("should handle SELECT_ALL_TEMPLATES", () => {
+    const action = { type: types.SELECT_ALL_TEMPLATES, ids: ['id1', 'id2', 'id3'] };
+    const result = reducer(initialState, action).toJS();
+    expect(result.selectedTemplateIds).toEqual(['id1', 'id2', 'id3']);
+  });
+
+  it("should handle CLEAR_TEMPLATE_SELECTION", () => {
+    const { fromJS } = require('immutable');
+    const stateWithSelected = initialState.set('selectedTemplateIds', fromJS(['id1', 'id2']));
+    const action = { type: types.CLEAR_TEMPLATE_SELECTION };
+    const result = reducer(stateWithSelected, action).toJS();
+    expect(result.selectedTemplateIds).toEqual([]);
+  });
+
+  it("should handle ARCHIVE_TEMPLATE_REQUEST", () => {
+    const action = { type: types.ARCHIVE_TEMPLATE_REQUEST };
+    const result = reducer(initialState, action).toJS();
+    expect(result.archiveInProgress).toBe(true);
+  });
+
+  it("should handle ARCHIVE_TEMPLATE_SUCCESS", () => {
+    const action = { type: types.ARCHIVE_TEMPLATE_SUCCESS };
+    const result = reducer(initialState, action).toJS();
+    expect(result.archiveInProgress).toBe(false);
+  });
+
+  it("should remove archived template id from selectedTemplateIds on ARCHIVE_TEMPLATE_SUCCESS", () => {
+    const { fromJS } = require('immutable');
+    const stateWithSelected = initialState.set('selectedTemplateIds', fromJS(['id1', 'id2', 'id3']));
+    const action = { type: types.ARCHIVE_TEMPLATE_SUCCESS, id: 'id2' };
+    const result = reducer(stateWithSelected, action).toJS();
+    expect(result.archiveInProgress).toBe(false);
+    expect(result.selectedTemplateIds).toEqual(['id1', 'id3']);
+  });
+
+  it("should handle ARCHIVE_TEMPLATE_FAILURE", () => {
+    const action = { type: types.ARCHIVE_TEMPLATE_FAILURE };
+    const result = reducer(initialState, action).toJS();
+    expect(result.archiveInProgress).toBe(false);
+  });
+
+  it("should handle UNARCHIVE_TEMPLATE_REQUEST", () => {
+    const action = { type: types.UNARCHIVE_TEMPLATE_REQUEST };
+    const result = reducer(initialState, action).toJS();
+    expect(result.unarchiveInProgress).toBe(true);
+  });
+
+  it("should handle UNARCHIVE_TEMPLATE_SUCCESS", () => {
+    const action = { type: types.UNARCHIVE_TEMPLATE_SUCCESS };
+    const result = reducer(initialState, action).toJS();
+    expect(result.unarchiveInProgress).toBe(false);
+  });
+
+  it("should remove unarchived template id from selectedTemplateIds on UNARCHIVE_TEMPLATE_SUCCESS", () => {
+    const { fromJS } = require('immutable');
+    const stateWithSelected = initialState.set('selectedTemplateIds', fromJS(['id1', 'id2', 'id3']));
+    const action = { type: types.UNARCHIVE_TEMPLATE_SUCCESS, id: 'id1' };
+    const result = reducer(stateWithSelected, action).toJS();
+    expect(result.unarchiveInProgress).toBe(false);
+    expect(result.selectedTemplateIds).toEqual(['id2', 'id3']);
+  });
+
+  it("should handle UNARCHIVE_TEMPLATE_FAILURE", () => {
+    const action = { type: types.UNARCHIVE_TEMPLATE_FAILURE };
+    const result = reducer(initialState, action).toJS();
+    expect(result.unarchiveInProgress).toBe(false);
+  });
+
+  it("should handle BULK_ARCHIVE_REQUEST", () => {
+    const action = { type: types.BULK_ARCHIVE_REQUEST };
+    const result = reducer(initialState, action).toJS();
+    expect(result.bulkArchiveInProgress).toBe(true);
+  });
+
+  it("should handle BULK_ARCHIVE_SUCCESS", () => {
+    const { fromJS } = require('immutable');
+    const stateWithSelected = initialState.set('selectedTemplateIds', fromJS(['id1']));
+    const action = { type: types.BULK_ARCHIVE_SUCCESS };
+    const result = reducer(stateWithSelected, action).toJS();
+    expect(result.bulkArchiveInProgress).toBe(false);
+    expect(result.selectedTemplateIds).toEqual([]);
+  });
+
+  it("should handle BULK_ARCHIVE_FAILURE", () => {
+    const action = { type: types.BULK_ARCHIVE_FAILURE };
+    const result = reducer(initialState, action).toJS();
+    expect(result.bulkArchiveInProgress).toBe(false);
+  });
+
+  it("should handle BULK_UNARCHIVE_REQUEST", () => {
+    const action = { type: types.BULK_UNARCHIVE_REQUEST };
+    const result = reducer(initialState, action).toJS();
+    expect(result.bulkUnarchiveInProgress).toBe(true);
+  });
+
+  it("should handle BULK_UNARCHIVE_SUCCESS", () => {
+    const { fromJS } = require('immutable');
+    const stateWithSelected = initialState.set('selectedTemplateIds', fromJS(['id1']));
+    const action = { type: types.BULK_UNARCHIVE_SUCCESS };
+    const result = reducer(stateWithSelected, action).toJS();
+    expect(result.bulkUnarchiveInProgress).toBe(false);
+    expect(result.selectedTemplateIds).toEqual([]);
+  });
+
+  it("should handle BULK_UNARCHIVE_FAILURE", () => {
+    const action = { type: types.BULK_UNARCHIVE_FAILURE };
+    const result = reducer(initialState, action).toJS();
+    expect(result.bulkUnarchiveInProgress).toBe(false);
+  });
+});

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

@@ -1,10 +1,10 @@
 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,
@@ -28,13 +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 { 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", () => {
@@ -839,4 +856,293 @@ describe('getAllTemplates wechat channel', () => {
     );
     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);
+  });
+});

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

@@ -1,5 +1,6 @@
 import { fromJS } from "immutable";
 import { makeSelectTemplatesResponse } from "../selectors";
+import { selectArchiveFilter, selectSelectedTemplateIds } from "../selectors";
 
 describe("Template selectors", () => {
   const mockState = fromJS({
@@ -15,3 +16,34 @@ describe("Template selectors", () => {
     });
   });
 });
+
+describe("selectArchiveFilter selector", () => {
+  it("should return archiveFilter from state", () => {
+    const state = fromJS({
+      templates: { archiveFilter: 'archived' },
+    });
+    const result = selectArchiveFilter().resultFunc(state.get('templates').toJS());
+    expect(result).toBe('archived');
+  });
+
+  it("should default to 'active' when archiveFilter is not set", () => {
+    const result = selectArchiveFilter().resultFunc({});
+    expect(result).toBe('active');
+  });
+});
+
+describe("selectSelectedTemplateIds selector", () => {
+  it("should return selectedTemplateIds from state", () => {
+    const ids = ['id1', 'id2'];
+    const state = fromJS({
+      templates: { selectedTemplateIds: ids },
+    });
+    const result = selectSelectedTemplateIds().resultFunc(state.get('templates').toJS());
+    expect(result).toEqual(ids);
+  });
+
+  it("should default to [] when selectedTemplateIds is not set", () => {
+    const result = selectSelectedTemplateIds().resultFunc({});
+    expect(result).toEqual([]);
+  });
+});