@capillarytech/creatives-library 8.0.293 → 8.0.295

package/v2Components/CommonTestAndPreview/tests/reducer.test.js

@@ -35,13 +35,6 @@ import {
   GET_PREFILLED_VALUES_FAILURE,
   CLEAR_PREFILLED_VALUES,
   CLEAR_PREVIEW_ERRORS,
-  GET_SENDER_DETAILS_REQUESTED,
-  GET_SENDER_DETAILS_SUCCESS,
-  GET_SENDER_DETAILS_FAILURE,
-  GET_WECRM_ACCOUNTS_REQUESTED,
-  GET_WECRM_ACCOUNTS_SUCCESS,
-  GET_WECRM_ACCOUNTS_FAILURE,
-  CHANNELS,
 } from '../constants';
 
 describe('previewAndTestReducer', () => {
@@ -87,15 +80,6 @@ describe('previewAndTestReducer', () => {
       isFetchingPrefilledValues: false,
       fetchPrefilledValuesError: null,
       fetchPrefilledValuesErrors: [],
-      senderDetailsByChannel: fromJS({
-        [CHANNELS.SMS]: [],
-        [CHANNELS.EMAIL]: [],
-        [CHANNELS.WHATSAPP]: [],
-      }),
-      wecrmAccounts: fromJS([]),
-      isLoadingSenderDetails: false,
-      fetchSenderDetailsError: null,
-      fetchWeCrmAccountsError: null,
     });
   });
 
@@ -789,108 +773,6 @@ describe('previewAndTestReducer', () => {
     });
   });
 
-  describe('GET_SENDER_DETAILS_REQUESTED', () => {
-    it('should set isLoadingSenderDetails to true and clear fetchSenderDetailsError', () => {
-      const action = {
-        type: GET_SENDER_DETAILS_REQUESTED,
-        payload: { channel: CHANNELS.SMS, orgUnitId: 123 },
-      };
-      const result = previewAndTestReducer(initialState, action);
-
-      expect(result.get('isLoadingSenderDetails')).toBe(true);
-      expect(result.get('fetchSenderDetailsError')).toBeNull();
-    });
-  });
-
-  describe('GET_SENDER_DETAILS_SUCCESS', () => {
-    it('should store domains for channel and set loading to false', () => {
-      const domains = [
-        { domainId: 1, domainName: 'Domain 1', gsmSenders: [] },
-      ];
-      const action = {
-        type: GET_SENDER_DETAILS_SUCCESS,
-        payload: { channel: CHANNELS.SMS, domains },
-      };
-      const result = previewAndTestReducer(initialState, action);
-
-      expect(result.getIn(['senderDetailsByChannel', CHANNELS.SMS])).toEqual(fromJS(domains));
-      expect(result.get('isLoadingSenderDetails')).toBe(false);
-      expect(result.get('fetchSenderDetailsError')).toBeNull();
-    });
-
-    it('should return state unchanged when channel is missing', () => {
-      const action = {
-        type: GET_SENDER_DETAILS_SUCCESS,
-        payload: { domains: [] },
-      };
-      const result = previewAndTestReducer(initialState, action);
-
-      expect(result).toEqual(initialState);
-    });
-  });
-
-  describe('GET_SENDER_DETAILS_FAILURE', () => {
-    it('should set loading to false and store error', () => {
-      const action = {
-        type: GET_SENDER_DETAILS_FAILURE,
-        payload: { channel: CHANNELS.EMAIL, error: 'Failed to fetch' },
-      };
-      const result = previewAndTestReducer(initialState, action);
-
-      expect(result.get('isLoadingSenderDetails')).toBe(false);
-      expect(result.get('fetchSenderDetailsError')).toBe('Failed to fetch');
-    });
-  });
-
-  describe('GET_WECRM_ACCOUNTS_REQUESTED', () => {
-    it('should clear fetchWeCrmAccountsError', () => {
-      const stateWithError = initialState.set('fetchWeCrmAccountsError', 'Error');
-      const action = {
-        type: GET_WECRM_ACCOUNTS_REQUESTED,
-        payload: { sourceName: 'WHATSAPP' },
-      };
-      const result = previewAndTestReducer(stateWithError, action);
-
-      expect(result.get('fetchWeCrmAccountsError')).toBeNull();
-    });
-  });
-
-  describe('GET_WECRM_ACCOUNTS_SUCCESS', () => {
-    it('should store wecrm accounts and clear error', () => {
-      const accounts = [{ name: 'Account 1', sourceAccountIdentifier: 'acc-1' }];
-      const action = {
-        type: GET_WECRM_ACCOUNTS_SUCCESS,
-        payload: { accounts },
-      };
-      const result = previewAndTestReducer(initialState, action);
-
-      expect(result.get('wecrmAccounts')).toEqual(fromJS(accounts));
-      expect(result.get('fetchWeCrmAccountsError')).toBeNull();
-    });
-
-    it('should handle empty accounts', () => {
-      const action = {
-        type: GET_WECRM_ACCOUNTS_SUCCESS,
-        payload: { accounts: [] },
-      };
-      const result = previewAndTestReducer(initialState, action);
-
-      expect(result.get('wecrmAccounts')).toEqual(fromJS([]));
-    });
-  });
-
-  describe('GET_WECRM_ACCOUNTS_FAILURE', () => {
-    it('should store fetchWeCrmAccountsError', () => {
-      const action = {
-        type: GET_WECRM_ACCOUNTS_FAILURE,
-        payload: { error: 'WeCRM fetch failed' },
-      };
-      const result = previewAndTestReducer(initialState, action);
-
-      expect(result.get('fetchWeCrmAccountsError')).toBe('WeCRM fetch failed');
-    });
-  });
-
   describe('CLEAR_PREVIEW_ERRORS', () => {
     it('should clear all preview-related errors', () => {
       const stateWithErrors = initialState

package/v2Components/CommonTestAndPreview/tests/sagas.test.js

@@ -25,17 +25,9 @@ import {
   watchFetchTestGroups,
   watchCreateMessageMeta,
   watchGetPrefilledValues,
-  getSenderDetailsSaga,
-  getWeCrmAccountsSaga,
-  watchGetSenderDetails,
-  watchGetWeCrmAccounts,
   commonTestAndPreviewSaga,
 } from '../sagas';
 import * as Api from '../../../services/api';
-jest.mock('../DeliverySettings/utils/parseSenderDetailsResponse', () => ({
-  parseSenderDetailsResponse: jest.fn((channel, response) => ({ domains: response?.entity?.[channel] || [] })),
-}));
-import { parseSenderDetailsResponse } from '../DeliverySettings/utils/parseSenderDetailsResponse';
 import {
   SEARCH_CUSTOMERS_SUCCESS,
   SEARCH_CUSTOMERS_FAILURE,
@@ -53,10 +45,6 @@ import {
   CREATE_MESSAGE_META_FAILURE,
   GET_PREFILLED_VALUES_SUCCESS,
   GET_PREFILLED_VALUES_FAILURE,
-  GET_SENDER_DETAILS_SUCCESS,
-  GET_SENDER_DETAILS_FAILURE,
-  GET_WECRM_ACCOUNTS_SUCCESS,
-  GET_WECRM_ACCOUNTS_FAILURE,
 } from '../constants';
 
 describe('CommonTestAndPreview Sagas', () => {
@@ -1706,137 +1694,6 @@ describe('CommonTestAndPreview Sagas', () => {
       );
       expect(generator.next().done).toBe(true);
     });
-
-    it('should watch for GET_SENDER_DETAILS_REQUESTED', () => {
-      const generator = watchGetSenderDetails();
-      expect(generator.next().value).toEqual(
-        takeLatest('app/CommonTestAndPreview/GET_SENDER_DETAILS_REQUESTED', getSenderDetailsSaga)
-      );
-      expect(generator.next().done).toBe(true);
-    });
-
-    it('should watch for GET_WECRM_ACCOUNTS_REQUESTED', () => {
-      const generator = watchGetWeCrmAccounts();
-      expect(generator.next().value).toEqual(
-        takeLatest('app/CommonTestAndPreview/GET_WECRM_ACCOUNTS_REQUESTED', getWeCrmAccountsSaga)
-      );
-      expect(generator.next().done).toBe(true);
-    });
-  });
-
-  describe('getSenderDetailsSaga', () => {
-    it('should fetch sender details and put SUCCESS with parsed domains', () => {
-      const action = { payload: { channel: 'SMS', orgUnitId: 100 } };
-      const apiResponse = { entity: { SMS: [{ id: 1, domainProperties: {} }] } };
-      parseSenderDetailsResponse.mockReturnValue({ domains: [{ domainId: 1 }] });
-
-      const generator = getSenderDetailsSaga(action);
-
-      expect(generator.next().value).toEqual(call(Api.getSenderDetails, 'SMS', 100));
-      expect(generator.next(apiResponse).value).toEqual(
-        put({ type: GET_SENDER_DETAILS_SUCCESS, payload: { channel: 'SMS', domains: [{ domainId: 1 }] } })
-      );
-      expect(generator.next().done).toBe(true);
-    });
-
-    it('should use orgUnitId -1 when not provided', () => {
-      const action = { payload: { channel: 'EMAIL' } };
-      const apiResponse = { entity: { EMAIL: [] } };
-      parseSenderDetailsResponse.mockReturnValue({ domains: [] });
-
-      const generator = getSenderDetailsSaga(action);
-
-      expect(generator.next().value).toEqual(call(Api.getSenderDetails, 'EMAIL', -1));
-      generator.next(apiResponse);
-      expect(generator.next().done).toBe(true);
-    });
-
-    it('should return early when channel is missing', () => {
-      const action = { payload: {} };
-      const generator = getSenderDetailsSaga(action);
-      expect(generator.next().done).toBe(true);
-    });
-
-    it('should put FAILURE when response has errors', () => {
-      const action = { payload: { channel: 'SMS' } };
-      const apiResponse = { errors: [{ message: 'Forbidden' }] };
-
-      const generator = getSenderDetailsSaga(action);
-      generator.next();
-      expect(generator.next(apiResponse).value).toEqual(
-        put({
-          type: GET_SENDER_DETAILS_FAILURE,
-          payload: { channel: 'SMS', error: [{ message: 'Forbidden' }] },
-        })
-      );
-      expect(generator.next().done).toBe(true);
-    });
-
-    it('should put FAILURE on throw', () => {
-      const action = { payload: { channel: 'WHATSAPP' } };
-      const generator = getSenderDetailsSaga(action);
-      generator.next();
-      const err = generator.throw(new Error('Network error'));
-      expect(err.value).toEqual(
-        put({
-          type: GET_SENDER_DETAILS_FAILURE,
-          payload: { channel: 'WHATSAPP', error: 'Network error' },
-        })
-      );
-      expect(generator.next().done).toBe(true);
-    });
-  });
-
-  describe('getWeCrmAccountsSaga', () => {
-    it('should fetch wecrm accounts and put SUCCESS with list from response', () => {
-      const action = { payload: { sourceName: 'WHATSAPP' } };
-      const apiResult = { response: [{ name: 'WABA1', sourceAccountIdentifier: 'waba-1' }] };
-
-      const generator = getWeCrmAccountsSaga(action);
-
-      expect(generator.next().value).toEqual(call(Api.fetchWeCrmAccounts, 'WHATSAPP'));
-      expect(generator.next(apiResult).value).toEqual(
-        put({ type: GET_WECRM_ACCOUNTS_SUCCESS, payload: { accounts: [{ name: 'WABA1', sourceAccountIdentifier: 'waba-1' }] } })
-      );
-      expect(generator.next().done).toBe(true);
-    });
-
-    it('should use WHATSAPP when sourceName not provided', () => {
-      const action = { payload: {} };
-      const generator = getWeCrmAccountsSaga(action);
-      expect(generator.next().value).toEqual(call(Api.fetchWeCrmAccounts, 'WHATSAPP'));
-    });
-
-    it('should use entity when response not present', () => {
-      const action = { payload: {} };
-      const apiResult = { entity: [{ name: 'Acc1' }] };
-
-      const generator = getWeCrmAccountsSaga(action);
-      generator.next();
-      expect(generator.next(apiResult).value).toEqual(
-        put({ type: GET_WECRM_ACCOUNTS_SUCCESS, payload: { accounts: [{ name: 'Acc1' }] } })
-      );
-    });
-
-    it('should put empty array when result has no list', () => {
-      const action = { payload: {} };
-      const generator = getWeCrmAccountsSaga(action);
-      generator.next();
-      expect(generator.next({}).value).toEqual(
-        put({ type: GET_WECRM_ACCOUNTS_SUCCESS, payload: { accounts: [] } })
-      );
-    });
-
-    it('should put FAILURE on throw', () => {
-      const action = { payload: {} };
-      const generator = getWeCrmAccountsSaga(action);
-      generator.next();
-      const err = generator.throw(new Error('API failed'));
-      expect(err.value).toEqual(
-        put({ type: GET_WECRM_ACCOUNTS_FAILURE, payload: { error: 'API failed' } })
-      );
-      expect(generator.next().done).toBe(true);
-    });
   });
 
   describe('commonTestAndPreviewSaga', () => {
@@ -1853,8 +1710,6 @@ describe('CommonTestAndPreview Sagas', () => {
           watchFetchTestGroups(),
           watchCreateMessageMeta(),
           watchGetPrefilledValues(),
-          watchGetSenderDetails(),
-          watchGetWeCrmAccounts(),
         ])
       );
 

package/v2Components/CommonTestAndPreview/tests/selectors.test.js

@@ -32,12 +32,6 @@ import {
   makeSelectUpdatePreviewErrors,
   makeSelectFetchPrefilledValuesError,
   makeSelectFetchPrefilledValuesErrors,
-  makeSelectSenderDetailsForChannel,
-  makeSelectSenderDetailsByChannel,
-  makeSelectWeCrmAccounts,
-  makeSelectIsLoadingSenderDetails,
-  makeSelectFetchSenderDetailsError,
-  makeSelectFetchWeCrmAccountsError,
 } from '../selectors';
 
 describe('CommonTestAndPreview Selectors', () => {
@@ -107,19 +101,6 @@ describe('CommonTestAndPreview Selectors', () => {
       fetchPrefilledValuesErrors: [
         { code: 7078, message: 'User profile not found' },
       ],
-      senderDetailsByChannel: {
-        SMS: [
-          { domainId: 1, domainName: 'SMS Domain', gsmSenders: [{ value: 'sender1' }] },
-        ],
-        EMAIL: [],
-        WHATSAPP: [],
-      },
-      wecrmAccounts: [
-        { name: 'WeCRM Account 1', sourceAccountIdentifier: 'waba-1' },
-      ],
-      isLoadingSenderDetails: false,
-      fetchSenderDetailsError: null,
-      fetchWeCrmAccountsError: null,
     },
   });
 
@@ -569,133 +550,6 @@ describe('CommonTestAndPreview Selectors', () => {
     });
   });
 
-  describe('makeSelectSenderDetailsForChannel', () => {
-    it('should select sender details for given channel as JS array', () => {
-      const selector = makeSelectSenderDetailsForChannel('SMS');
-      const result = selector(mockState);
-
-      expect(result).toBeDefined();
-      expect(Array.isArray(result)).toBe(true);
-      expect(result.length).toBe(1);
-      expect(result[0].domainName).toBe('SMS Domain');
-    });
-
-    it('should return empty array for channel with no data', () => {
-      const selector = makeSelectSenderDetailsForChannel('EMAIL');
-      const result = selector(mockState);
-
-      expect(result).toEqual([]);
-    });
-
-    it('should return empty array when substate or byChannel missing', () => {
-      const emptyState = fromJS({});
-      const selector = makeSelectSenderDetailsForChannel('SMS');
-      const result = selector(emptyState);
-
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe('makeSelectSenderDetailsByChannel', () => {
-    it('should select senderDetailsByChannel and convert to JS object', () => {
-      const selector = makeSelectSenderDetailsByChannel();
-      const result = selector(mockState);
-
-      expect(result).toBeDefined();
-      expect(result.SMS).toBeDefined();
-      expect(Array.isArray(result.SMS)).toBe(true);
-      expect(result.SMS[0].domainName).toBe('SMS Domain');
-      expect(result.EMAIL).toEqual([]);
-      expect(result.WHATSAPP).toEqual([]);
-    });
-
-    it('should return empty object when domain is missing', () => {
-      const emptyState = fromJS({});
-      const selector = makeSelectSenderDetailsByChannel();
-      const result = selector(emptyState);
-
-      expect(result).toEqual({});
-    });
-  });
-
-  describe('makeSelectWeCrmAccounts', () => {
-    it('should select wecrmAccounts and convert to JS array', () => {
-      const selector = makeSelectWeCrmAccounts();
-      const result = selector(mockState);
-
-      expect(result).toBeDefined();
-      expect(Array.isArray(result)).toBe(true);
-      expect(result.length).toBe(1);
-      expect(result[0].name).toBe('WeCRM Account 1');
-      expect(result[0].sourceAccountIdentifier).toBe('waba-1');
-    });
-
-    it('should return empty array when wecrmAccounts is missing', () => {
-      const emptyState = fromJS({ commonTestAndPreview: {} });
-      const selector = makeSelectWeCrmAccounts();
-      const result = selector(emptyState);
-
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe('makeSelectIsLoadingSenderDetails', () => {
-    it('should select isLoadingSenderDetails flag', () => {
-      const selector = makeSelectIsLoadingSenderDetails();
-      const result = selector(mockState);
-
-      expect(result).toBe(false);
-    });
-
-    it('should return true when loading', () => {
-      const loadingState = fromJS({
-        commonTestAndPreview: { isLoadingSenderDetails: true },
-      });
-      const selector = makeSelectIsLoadingSenderDetails();
-      const result = selector(loadingState);
-
-      expect(result).toBe(true);
-    });
-  });
-
-  describe('makeSelectFetchSenderDetailsError', () => {
-    it('should select fetchSenderDetailsError from state', () => {
-      const selector = makeSelectFetchSenderDetailsError();
-      const result = selector(mockState);
-
-      expect(result).toBeNull();
-    });
-
-    it('should return error when present', () => {
-      const errorState = fromJS({
-        commonTestAndPreview: { fetchSenderDetailsError: 'Sender fetch failed' },
-      });
-      const selector = makeSelectFetchSenderDetailsError();
-      const result = selector(errorState);
-
-      expect(result).toBe('Sender fetch failed');
-    });
-  });
-
-  describe('makeSelectFetchWeCrmAccountsError', () => {
-    it('should select fetchWeCrmAccountsError from state', () => {
-      const selector = makeSelectFetchWeCrmAccountsError();
-      const result = selector(mockState);
-
-      expect(result).toBeNull();
-    });
-
-    it('should return error when present', () => {
-      const errorState = fromJS({
-        commonTestAndPreview: { fetchWeCrmAccountsError: 'WeCRM fetch failed' },
-      });
-      const selector = makeSelectFetchWeCrmAccountsError();
-      const result = selector(errorState);
-
-      expect(result).toBe('WeCRM fetch failed');
-    });
-  });
-
   describe('Edge Cases', () => {
     it('should handle undefined state gracefully', () => {
       const selector = makeSelectCustomers();

package/v2Components/FormBuilder/index.js

@@ -1331,7 +1331,7 @@ class FormBuilder extends React.Component { // eslint-disable-line react/prefer-
   }
   onSubmitWrapper = (args) => {
     const {singleTab = null} = args || {};
-    if (this.liquidFlow()) {
+    if (this.liquidFlow() && !this.props?.isFullMode) {
       // For MPUSH, we need to validate both Android and iOS content separately
       if (this.props.channel === MOBILE_PUSH || this.props?.schema?.channel?.toUpperCase() === MOBILE_PUSH) {
         this.validateFormBuilderMPush(this.state.formData, singleTab);

package/v2Components/HtmlEditor/HTMLEditor.js

@@ -294,6 +294,7 @@ const HTMLEditor = forwardRef(({
     enableSanitization: true,
     securityLevel: 'standard',
     apiValidationErrors, // Pass API validation errors to merge with client-side validation
+    isFullMode, // Skip liquid validation in standalone/full mode
   }, formatSanitizerMessage, formatValidatorMessage);
 
   // Expose validation and content state via ref

package/v2Components/HtmlEditor/__tests__/HTMLEditor.test.js

@@ -1375,6 +1375,7 @@ describe('HTMLEditor', () => {
           debounceMs: 500,
           enableSanitization: true,
           securityLevel: 'standard',
+          isFullMode: true,
         },
         expect.any(Function),
         expect.any(Function)

package/v2Components/HtmlEditor/hooks/__tests__/useValidation.test.js

@@ -155,7 +155,7 @@ describe('useValidation', () => {
         await Promise.resolve();
       });
 
-      expect(validateHTML).toHaveBeenCalledWith('<p>Test</p>', 'email', null);
+      expect(validateHTML).toHaveBeenCalledWith('<p>Test</p>', 'email', null, { skipLiquidValidation: false });
     });
 
     it('updates validation when content changes', async () => {
@@ -472,7 +472,7 @@ describe('useValidation', () => {
         await Promise.resolve();
       });
 
-      expect(validateHTML).toHaveBeenCalledWith('<p>Test</p>', 'inapp', null);
+      expect(validateHTML).toHaveBeenCalledWith('<p>Test</p>', 'inapp', null, { skipLiquidValidation: false });
     });
 
     it('defaults to email variant', async () => {
@@ -487,7 +487,7 @@ describe('useValidation', () => {
         await Promise.resolve();
       });
 
-      expect(validateHTML).toHaveBeenCalledWith('<p>Test</p>', 'email', null);
+      expect(validateHTML).toHaveBeenCalledWith('<p>Test</p>', 'email', null, { skipLiquidValidation: false });
     });
   });
 
@@ -922,4 +922,133 @@ describe('useValidation', () => {
       });
     });
   });
+
+  describe('isFullMode - skip liquid validation', () => {
+    it('passes skipLiquidValidation: true to validateHTML when isFullMode is true', async () => {
+      const { validateHTML } = require('../../utils/htmlValidator');
+
+      render(<TestComponent content="<p>Test</p>" options={{ isFullMode: true }} />);
+
+      await act(async () => {
+        jest.advanceTimersByTime(500);
+        await Promise.resolve();
+        await Promise.resolve();
+        await Promise.resolve();
+      });
+
+      expect(validateHTML).toHaveBeenCalledWith('<p>Test</p>', 'email', null, { skipLiquidValidation: true });
+    });
+
+    it('excludes API liquid errors from getAllIssues when isFullMode is true', async () => {
+      let validationState;
+      const onStateChange = (state) => { validationState = state; };
+
+      const apiValidationErrors = {
+        liquidErrors: ['Unsupported tag: points_balance'],
+        standardErrors: [],
+      };
+
+      render(
+        <TestComponent
+          content="<p>Test</p>"
+          options={{ apiValidationErrors, isFullMode: true }}
+          onStateChange={onStateChange}
+        />
+      );
+
+      await act(async () => {
+        jest.advanceTimersByTime(500);
+        await Promise.resolve();
+        await Promise.resolve();
+        await Promise.resolve();
+      });
+
+      await waitFor(() => {
+        expect(validationState).toBeDefined();
+      });
+
+      const issues = validationState.getAllIssues();
+      const liquidIssues = issues.filter((i) => i.source === 'liquid-validator');
+      expect(liquidIssues).toHaveLength(0);
+    });
+
+    it('returns isClean true when only liquid errors exist and isFullMode is true', () => {
+      const apiValidationErrors = {
+        liquidErrors: ['Unsupported tag: points_balance'],
+        standardErrors: [],
+      };
+
+      render(
+        <TestComponent
+          content=""
+          options={{ apiValidationErrors, isFullMode: true }}
+        />
+      );
+
+      // Before validation runs, isClean should be true because liquid errors are ignored in full mode
+      expect(screen.getByTestId('is-clean')).toHaveTextContent('true');
+    });
+
+    it('does not treat liquid errors as blocking when isFullMode is true', async () => {
+      let validationState;
+      const onStateChange = (state) => { validationState = state; };
+
+      const apiValidationErrors = {
+        liquidErrors: ['Unsupported tag: points_balance'],
+        standardErrors: [],
+      };
+
+      render(
+        <TestComponent
+          content="<p>Valid</p>"
+          options={{ apiValidationErrors, isFullMode: true }}
+          onStateChange={onStateChange}
+        />
+      );
+
+      await act(async () => {
+        jest.advanceTimersByTime(500);
+        await Promise.resolve();
+        await Promise.resolve();
+        await Promise.resolve();
+      });
+
+      await waitFor(() => {
+        expect(validationState).toBeDefined();
+      });
+
+      expect(validationState.hasBlockingErrors).toBe(false);
+    });
+
+    it('still treats standard API errors as blocking when isFullMode is true', async () => {
+      let validationState;
+      const onStateChange = (state) => { validationState = state; };
+
+      const apiValidationErrors = {
+        liquidErrors: ['Liquid error'],
+        standardErrors: ['Standard error'],
+      };
+
+      render(
+        <TestComponent
+          content="<p>Valid</p>"
+          options={{ apiValidationErrors, isFullMode: true }}
+          onStateChange={onStateChange}
+        />
+      );
+
+      await act(async () => {
+        jest.advanceTimersByTime(500);
+        await Promise.resolve();
+        await Promise.resolve();
+        await Promise.resolve();
+      });
+
+      await waitFor(() => {
+        expect(validationState).toBeDefined();
+      });
+
+      expect(validationState.hasBlockingErrors).toBe(true);
+    });
+  });
 });