@capillarytech/blaze-ui 5.23.3-beta.3 → 5.23.3-beta.4

package/CapCondition/tests/ConditionDate.test.js

@@ -1,1982 +0,0 @@
-var _excluded = ["options", "value", "onChange", "placeholder"],
-  _excluded2 = ["value", "onChange", "placeholder", "suffix"],
-  _excluded3 = ["children"],
-  _excluded4 = ["value", "onChange", "placeholder", "disabledDate"],
-  _excluded5 = ["children", "spinning", "tip"];
-function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
-function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
-import '@testing-library/jest-dom';
-import { fireEvent, render, screen } from '@testing-library/react';
-import React from 'react';
-import { IntlProvider } from 'react-intl';
-import ConditionDate from "../ConditionDate";
-import { IS_BEFORE_DAYS, IS_AFTER_DAYS, IS_INBETWEEN_DATES, ENTRY_TRIGGER_EVENT_ATTRIBUTE, THE_VALUE, ENTRY_TRIGGER, WAIT_TILL_EVENT, USER_EVENT, WAIT_TILL_EVENT_TYPE, MINUS_TIME, PLUS_TIME, REQUEST, IS_EXACT_DATE } from "../constants";
-
-// Mock the helper function
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-jest.mock("../helper", () => ({
-  getEventContextComponent: jest.fn(() => /*#__PURE__*/_jsx("div", {
-    "data-testid": "event-context-component",
-    children: "Event Context Component"
-  }))
-}));
-
-// Mock the components
-jest.mock("../../CapSelect", () => {
-  return function MockCapSelect(_ref) {
-    var {
-        options,
-        value,
-        onChange: _onChange
-      } = _ref,
-      props = _objectWithoutPropertiesLoose(_ref, _excluded);
-    return /*#__PURE__*/_jsx("select", _extends({
-      "data-testid": "cap-select",
-      value: value || '',
-      onChange: e => _onChange && _onChange(e.target.value)
-    }, props, {
-      children: options == null ? void 0 : options.map(option => /*#__PURE__*/_jsx("option", {
-        value: option.value,
-        children: option.label
-      }, option.key || option.value))
-    }));
-  };
-});
-jest.mock("../../CapInput", () => {
-  return function MockCapInput(_ref2) {
-    var {
-        value,
-        onChange,
-        placeholder,
-        suffix
-      } = _ref2,
-      props = _objectWithoutPropertiesLoose(_ref2, _excluded2);
-    return /*#__PURE__*/_jsxs("div", {
-      children: [/*#__PURE__*/_jsx("input", _extends({
-        "data-testid": "cap-input",
-        value: value || '',
-        onChange: onChange,
-        placeholder: placeholder
-      }, props)), suffix && /*#__PURE__*/_jsx("span", {
-        "data-testid": "input-suffix",
-        children: suffix
-      })]
-    });
-  };
-});
-jest.mock("../../CapLabel", () => {
-  return function MockCapLabel(_ref3) {
-    var {
-        children
-      } = _ref3,
-      props = _objectWithoutPropertiesLoose(_ref3, _excluded3);
-    return /*#__PURE__*/_jsx("label", _extends({
-      "data-testid": "cap-label"
-    }, props, {
-      children: children
-    }));
-  };
-});
-jest.mock("../../CapDatePicker", () => {
-  return function MockCapDatePicker(_ref4) {
-    var {
-        value,
-        onChange: _onChange2,
-        placeholder
-      } = _ref4,
-      props = _objectWithoutPropertiesLoose(_ref4, _excluded4);
-    var moment = require('moment');
-    return /*#__PURE__*/_jsx("input", _extends({
-      "data-testid": "cap-date-picker",
-      type: "date",
-      value: value ? moment(value).format('YYYY-MM-DD') : '',
-      onChange: e => _onChange2 && _onChange2(moment(e.target.value).toDate()),
-      placeholder: placeholder
-    }, props));
-  };
-});
-jest.mock("../../CapSpin", () => {
-  return function MockCapSpin(_ref5) {
-    var {
-        children,
-        spinning,
-        tip
-      } = _ref5,
-      _props = _objectWithoutPropertiesLoose(_ref5, _excluded5);
-    if (spinning) {
-      return /*#__PURE__*/_jsx("div", {
-        "data-testid": "cap-spin",
-        "data-spinning": "true",
-        "data-tip": tip,
-        children: children
-      });
-    }
-    return /*#__PURE__*/_jsx("div", {
-      "data-testid": "cap-spin",
-      "data-spinning": "false",
-      children: children
-    });
-  };
-});
-var renderComponent = function renderComponent(props) {
-  if (props === void 0) {
-    props = {};
-  }
-  var defaultProps = {
-    conditionExpressionOptions: {
-      IS_EXACT_DATE: {
-        text: 'On'
-      },
-      IS_BEFORE_DATE: {
-        text: 'Before'
-      },
-      IS_AFTER_DATE: {
-        text: 'After'
-      },
-      IS_BEFORE_DAYS: {
-        text: 'X Days Before'
-      },
-      IS_AFTER_DAYS: {
-        text: 'X Days After'
-      },
-      IS_INBETWEEN_DATES: {
-        text: 'Between'
-      }
-    },
-    conditionExpression: {
-      operator: null,
-      operand: null,
-      dateTypeValues: {}
-    },
-    setConditionExpression: jest.fn(),
-    onMsg: 'On',
-    beforeMsg: 'Before',
-    afterMsg: 'After',
-    xDaysBeforeMsg: 'X Days Before',
-    xDaysAfterMsg: 'X Days After',
-    betweenMsg: 'Between',
-    andMsg: 'And',
-    specificDateLabel: 'specific date',
-    eventDateAttributeLabel: 'Event date attribute',
-    entryTriggerLabel: 'Entry trigger',
-    waitTillEventLabel: 'Wait till event',
-    andLabel: 'and',
-    beforeLabel: 'before',
-    afterLabel: 'after',
-    daysSuffix: 'days',
-    loadingTip: 'Loading...',
-    specificDateToolTip: 'Select a specific date',
-    shouldRemoveOperator: false,
-    removeOperatorsList: [],
-    eventContextDataOptions: [],
-    useEntryTriggerEventAttribute: false,
-    eventContextSelectionValue: THE_VALUE,
-    setEventContextSelectionValue: jest.fn(),
-    eventContextData: {},
-    setEventContextData: jest.fn(),
-    getEngagementBlocksBeforeWaitTill: jest.fn(),
-    availableEngagementBlocks: {},
-    getProfilesDetailsByBlockData: jest.fn(),
-    getGrammarDataBasedOnEvent: jest.fn(),
-    dateEventGrammar: {},
-    eventContextUniqueId: null,
-    events: [],
-    getEventNameByType: jest.fn((events, eventType) => "Event: " + eventType)
-  };
-  return render(/*#__PURE__*/_jsx(IntlProvider, {
-    locale: "en-US",
-    messages: {},
-    children: /*#__PURE__*/_jsx(ConditionDate, _extends({}, defaultProps, props))
-  }));
-};
-describe('ConditionDate Component', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-  describe('Component Rendering', () => {
-    it('should render the component with default props', () => {
-      renderComponent();
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-      expect(screen.getByTestId('cap-select')).toBeInTheDocument();
-    });
-    it('should render with loading state when dateEventGrammar is loading', () => {
-      renderComponent({
-        dateEventGrammar: {
-          getGrammarStatus: REQUEST
-        }
-      });
-      var spinElement = screen.getByTestId('cap-spin');
-      expect(spinElement).toHaveAttribute('data-spinning', 'true');
-      expect(spinElement).toHaveAttribute('data-tip', 'Loading...');
-    });
-    it('should render without loading state when dateEventGrammar is not loading', () => {
-      renderComponent({
-        dateEventGrammar: {
-          getGrammarStatus: 'SUCCESS'
-        }
-      });
-      var spinElement = screen.getByTestId('cap-spin');
-      expect(spinElement).toHaveAttribute('data-spinning', 'false');
-    });
-  });
-  describe('useEffect Hooks', () => {
-    it('should call getEngagementBlocksBeforeWaitTill on mount', () => {
-      var getEngagementBlocksBeforeWaitTill = jest.fn();
-      renderComponent({
-        getEngagementBlocksBeforeWaitTill
-      });
-      expect(getEngagementBlocksBeforeWaitTill).toHaveBeenCalledTimes(1);
-    });
-    it('should process availableEngagementBlocks and set blocksDropdownData', () => {
-      var availableEngagementBlocks = {
-        block1: {
-          blockType: ENTRY_TRIGGER,
-          blockData: {
-            triggerType: USER_EVENT,
-            userEventTrigger: {
-              eventType: 'testEvent',
-              eventCategory: 'testCategory'
-            }
-          }
-        },
-        block2: {
-          blockType: WAIT_TILL_EVENT,
-          name: 'Test Wait Block',
-          blockData: {
-            waitType: WAIT_TILL_EVENT_TYPE
-          }
-        }
-      };
-      renderComponent({
-        availableEngagementBlocks
-      });
-
-      // The component should process the blocks and set dropdown data
-      // We can verify this by checking if the event context component is rendered
-      // when useEntryTriggerEventAttribute is true
-    });
-    it('should set operator to first dropdown value when no operator is provided', () => {
-      var setConditionExpression = jest.fn();
-      renderComponent({
-        conditionExpression: {
-          operator: null,
-          operand: null,
-          dateTypeValues: {}
-        },
-        setConditionExpression
-      });
-
-      // The component should set the operator to the first available option
-      expect(setConditionExpression).toHaveBeenCalled();
-    });
-    it('should handle eventContextUniqueId and set selected block', () => {
-      var availableEngagementBlocks = {
-        block1: {
-          blockType: ENTRY_TRIGGER,
-          blockData: {
-            triggerType: USER_EVENT,
-            userEventTrigger: {
-              eventType: 'testEvent',
-              eventCategory: 'testCategory'
-            }
-          }
-        }
-      };
-      var getProfilesDetailsByBlockData = jest.fn();
-      renderComponent({
-        eventContextUniqueId: 'block1_test',
-        availableEngagementBlocks,
-        getProfilesDetailsByBlockData
-      });
-      expect(getProfilesDetailsByBlockData).toHaveBeenCalled();
-    });
-    it('should update eventContextSelectionValue based on operator changes', () => {
-      var setEventContextSelectionValue = jest.fn();
-      renderComponent({
-        conditionExpression: {
-          operator: IS_BEFORE_DAYS,
-          operand: null,
-          dateTypeValues: {}
-        },
-        eventContextSelectionValue: THE_VALUE,
-        setEventContextSelectionValue
-      });
-      expect(setEventContextSelectionValue).toHaveBeenCalledWith(ENTRY_TRIGGER_EVENT_ATTRIBUTE);
-    });
-    it('should call getGrammarDataBasedOnEvent when conditions are met', () => {
-      var getGrammarDataBasedOnEvent = jest.fn();
-      var selectedBlock = {
-        blockData: {
-          userEventTrigger: {
-            eventType: 'testEvent'
-          }
-        }
-      };
-      renderComponent({
-        dateEventGrammar: {
-          someData: 'test'
-        },
-        eventContextSelectionValue: ENTRY_TRIGGER_EVENT_ATTRIBUTE,
-        selectedBlock,
-        getGrammarDataBasedOnEvent
-      });
-
-      // Test that the component renders without errors
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-  });
-  describe('Operator Changes', () => {
-    it('should handle IS_BEFORE_DAYS operator change', () => {
-      var setConditionExpression = jest.fn();
-      renderComponent({
-        setConditionExpression
-      });
-      var select = screen.getByTestId('cap-select');
-      fireEvent.change(select, {
-        target: {
-          value: IS_BEFORE_DAYS
-        }
-      });
-      expect(setConditionExpression).toHaveBeenCalledWith(expect.objectContaining({
-        operator: IS_BEFORE_DAYS,
-        operand: null,
-        dateTypeValues: expect.objectContaining({
-          daysKey: MINUS_TIME
-        })
-      }));
-    });
-    it('should handle IS_AFTER_DAYS operator change', () => {
-      var setConditionExpression = jest.fn();
-      renderComponent({
-        setConditionExpression
-      });
-      var select = screen.getByTestId('cap-select');
-      fireEvent.change(select, {
-        target: {
-          value: IS_AFTER_DAYS
-        }
-      });
-      expect(setConditionExpression).toHaveBeenCalledWith(expect.objectContaining({
-        operator: IS_AFTER_DAYS,
-        operand: null,
-        dateTypeValues: expect.objectContaining({
-          daysKey: PLUS_TIME
-        })
-      }));
-    });
-    it('should handle IS_INBETWEEN_DATES operator change', () => {
-      var setConditionExpression = jest.fn();
-      renderComponent({
-        setConditionExpression
-      });
-      var select = screen.getByTestId('cap-select');
-      fireEvent.change(select, {
-        target: {
-          value: IS_INBETWEEN_DATES
-        }
-      });
-      expect(setConditionExpression).toHaveBeenCalledWith(expect.objectContaining({
-        operator: IS_INBETWEEN_DATES,
-        operand: null,
-        dateTypeValues: expect.objectContaining({
-          daysKey: null
-        })
-      }));
-    });
-    it('should handle other operator changes', () => {
-      var setConditionExpression = jest.fn();
-      renderComponent({
-        setConditionExpression
-      });
-      var select = screen.getByTestId('cap-select');
-      fireEvent.change(select, {
-        target: {
-          value: 'IS_EXACT_DATE'
-        }
-      });
-      expect(setConditionExpression).toHaveBeenCalledWith(expect.objectContaining({
-        operator: 'IS_EXACT_DATE',
-        operand: null,
-        dateTypeValues: expect.objectContaining({
-          daysKey: null
-        })
-      }));
-    });
-  });
-  describe('Operand Changes', () => {
-    it('should handle operand change with valid value', () => {
-      var setConditionExpression = jest.fn();
-      renderComponent({
-        conditionExpression: {
-          operator: IS_BEFORE_DAYS,
-          operand: null,
-          dateTypeValues: {}
-        },
-        setConditionExpression
-      });
-      var input = screen.getByTestId('cap-input');
-      fireEvent.change(input, {
-        target: {
-          value: '5'
-        }
-      });
-      expect(setConditionExpression).toHaveBeenCalledWith(expect.objectContaining({
-        operand: '5'
-      }));
-    });
-    it('should handle operand change with empty value', () => {
-      var setConditionExpression = jest.fn();
-      renderComponent({
-        conditionExpression: {
-          operator: IS_BEFORE_DAYS,
-          operand: '5',
-          dateTypeValues: {}
-        },
-        setConditionExpression
-      });
-      var input = screen.getByTestId('cap-input');
-      fireEvent.change(input, {
-        target: {
-          value: ''
-        }
-      });
-      expect(setConditionExpression).toHaveBeenCalledWith(expect.objectContaining({
-        operand: null
-      }));
-    });
-  });
-  describe('Event Context Selection', () => {
-    it('should handle event context selection change', () => {
-      var setEventContextSelectionValue = jest.fn();
-      renderComponent({
-        useEntryTriggerEventAttribute: true,
-        conditionExpression: {
-          operator: IS_EXACT_DATE,
-          operand: null,
-          dateTypeValues: {}
-        },
-        setEventContextSelectionValue
-      });
-
-      // Test that the component renders without errors
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should render event context component when useEntryTriggerEventAttribute is true', () => {
-      renderComponent({
-        useEntryTriggerEventAttribute: true,
-        conditionExpression: {
-          operator: IS_EXACT_DATE,
-          operand: null,
-          dateTypeValues: {}
-        }
-      });
-
-      // Test that the component renders without errors
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should not render event context component when useEntryTriggerEventAttribute is false', () => {
-      renderComponent({
-        useEntryTriggerEventAttribute: false
-      });
-      expect(screen.queryByTestId('event-context-component')).not.toBeInTheDocument();
-    });
-  });
-  describe('Block Selection', () => {
-    it('should handle block selection change', () => {
-      var _handleBlockSelectionChange = jest.fn();
-      var setEventContextData = jest.fn();
-      var getProfilesDetailsByBlockData = jest.fn();
-      var availableEngagementBlocks = {
-        block1: {
-          blockType: ENTRY_TRIGGER,
-          blockData: {
-            triggerType: USER_EVENT,
-            userEventTrigger: {
-              eventType: 'testEvent',
-              eventCategory: 'testCategory'
-            }
-          }
-        }
-      };
-      renderComponent({
-        useEntryTriggerEventAttribute: true,
-        conditionExpression: {
-          operator: IS_EXACT_DATE,
-          operand: null,
-          dateTypeValues: {}
-        },
-        availableEngagementBlocks,
-        setEventContextData,
-        getProfilesDetailsByBlockData
-      });
-
-      // Test that the component renders without errors
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-  });
-  describe('Date Picker Interactions', () => {
-    it('should render date picker when event context is not selected', () => {
-      renderComponent({
-        conditionExpression: {
-          operator: IS_EXACT_DATE,
-          operand: null,
-          dateTypeValues: {}
-        },
-        eventContextSelectionValue: THE_VALUE
-      });
-      expect(screen.getByTestId('cap-date-picker')).toBeInTheDocument();
-    });
-    it('should not render date picker when event context is selected', () => {
-      renderComponent({
-        conditionExpression: {
-          operator: IS_EXACT_DATE,
-          operand: null,
-          dateTypeValues: {}
-        },
-        eventContextSelectionValue: ENTRY_TRIGGER_EVENT_ATTRIBUTE
-      });
-      expect(screen.queryByTestId('cap-date-picker')).not.toBeInTheDocument();
-    });
-    it('should handle date picker change', () => {
-      var setConditionExpression = jest.fn();
-      var dateTypeValues = {
-        specificDateTimeStamp: null
-      };
-      renderComponent({
-        conditionExpression: {
-          operator: IS_EXACT_DATE,
-          operand: null,
-          dateTypeValues
-        },
-        eventContextSelectionValue: THE_VALUE,
-        setConditionExpression
-      });
-      var datePicker = screen.getByTestId('cap-date-picker');
-      var testDate = new Date('2023-01-01');
-      fireEvent.change(datePicker, {
-        target: {
-          value: '2023-01-01'
-        }
-      });
-      expect(setConditionExpression).toHaveBeenCalledWith(expect.objectContaining({
-        dateTypeValues: expect.objectContaining({
-          specificDateTimeStamp: testDate
-        })
-      }));
-    });
-    it('should render second date picker for between operator', () => {
-      var setConditionExpression = jest.fn();
-      var dateTypeValues = {
-        specificDateTimeStamp: new Date('2023-01-01'),
-        specificDateTimeStamp2: null
-      };
-      renderComponent({
-        conditionExpression: {
-          operator: IS_INBETWEEN_DATES,
-          operand: null,
-          dateTypeValues
-        },
-        eventContextSelectionValue: THE_VALUE,
-        setConditionExpression
-      });
-      var datePickers = screen.getAllByTestId('cap-date-picker');
-      expect(datePickers).toHaveLength(2);
-
-      // Should render AND label
-      expect(screen.getByText('and')).toBeInTheDocument();
-    });
-    it('should handle second date picker change for between operator', () => {
-      var setConditionExpression = jest.fn();
-      var dateTypeValues = {
-        specificDateTimeStamp: new Date('2023-01-01'),
-        specificDateTimeStamp2: null
-      };
-      renderComponent({
-        conditionExpression: {
-          operator: IS_INBETWEEN_DATES,
-          operand: null,
-          dateTypeValues
-        },
-        eventContextSelectionValue: THE_VALUE,
-        setConditionExpression
-      });
-      var datePickers = screen.getAllByTestId('cap-date-picker');
-      var secondDatePicker = datePickers[1];
-      var testDate = new Date('2023-01-15');
-      fireEvent.change(secondDatePicker, {
-        target: {
-          value: '2023-01-15'
-        }
-      });
-      expect(setConditionExpression).toHaveBeenCalledWith(expect.objectContaining({
-        dateTypeValues: expect.objectContaining({
-          specificDateTimeStamp2: testDate
-        })
-      }));
-    });
-  });
-  describe('Input Elements Rendering', () => {
-    it('should render input elements for days operators', () => {
-      renderComponent({
-        conditionExpression: {
-          operator: IS_BEFORE_DAYS,
-          operand: '5',
-          dateTypeValues: {}
-        },
-        eventContextSelectionValue: THE_VALUE
-      });
-      expect(screen.getByTestId('cap-input')).toBeInTheDocument();
-      expect(screen.getByText('before')).toBeInTheDocument();
-      expect(screen.getByTestId('input-suffix')).toBeInTheDocument();
-      expect(screen.getByTestId('input-suffix')).toHaveTextContent('days');
-    });
-    it('should render input elements for after days operator', () => {
-      renderComponent({
-        conditionExpression: {
-          operator: IS_AFTER_DAYS,
-          operand: '10',
-          dateTypeValues: {}
-        },
-        eventContextSelectionValue: THE_VALUE
-      });
-      expect(screen.getByTestId('cap-input')).toBeInTheDocument();
-      expect(screen.getByText('after')).toBeInTheDocument();
-      expect(screen.getByTestId('input-suffix')).toBeInTheDocument();
-      expect(screen.getByTestId('input-suffix')).toHaveTextContent('days');
-    });
-    it('should not render input elements for between operator', () => {
-      renderComponent({
-        conditionExpression: {
-          operator: IS_INBETWEEN_DATES,
-          operand: null,
-          dateTypeValues: {}
-        },
-        eventContextSelectionValue: THE_VALUE
-      });
-      expect(screen.queryByTestId('cap-input')).not.toBeInTheDocument();
-    });
-  });
-  describe('Dropdown Options', () => {
-    it('should create dropdown options from operandsMapping', () => {
-      renderComponent();
-      var select = screen.getByTestId('cap-select');
-      expect(select).toBeInTheDocument();
-    });
-    it('should handle custom conditionExpressionOptions', () => {
-      var customOptions = {
-        IS_EXACT_DATE: {
-          text: 'Custom On'
-        },
-        IS_BEFORE_DATE: {
-          text: 'Custom Before'
-        },
-        IS_AFTER_DATE: {
-          text: 'Custom After'
-        },
-        IS_BEFORE_DAYS: {
-          text: 'Custom X Days Before'
-        },
-        IS_AFTER_DAYS: {
-          text: 'Custom X Days After'
-        },
-        IS_INBETWEEN_DATES: {
-          text: 'Custom Between'
-        }
-      };
-      renderComponent({
-        conditionExpressionOptions: customOptions
-      });
-      var select = screen.getByTestId('cap-select');
-      expect(select).toBeInTheDocument();
-    });
-  });
-  describe('Edge Cases', () => {
-    it('should handle null conditionExpression', () => {
-      renderComponent({
-        conditionExpression: null
-      });
-
-      // Component should handle null gracefully by providing defaults
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle undefined conditionExpression', () => {
-      renderComponent({
-        conditionExpression: undefined
-      });
-
-      // Component should handle undefined gracefully by providing defaults
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle empty availableEngagementBlocks', () => {
-      renderComponent({
-        availableEngagementBlocks: {}
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle null availableEngagementBlocks', () => {
-      expect(() => {
-        renderComponent({
-          availableEngagementBlocks: null
-        });
-      }).toThrow();
-    });
-    it('should handle undefined availableEngagementBlocks', () => {
-      renderComponent({
-        availableEngagementBlocks: undefined
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle empty dateTypeValues', () => {
-      renderComponent({
-        conditionExpression: {
-          operator: IS_EXACT_DATE,
-          operand: null,
-          dateTypeValues: {}
-        }
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle null dateTypeValues', () => {
-      renderComponent({
-        conditionExpression: {
-          operator: IS_EXACT_DATE,
-          operand: null,
-          dateTypeValues: null
-        }
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle undefined dateTypeValues', () => {
-      renderComponent({
-        conditionExpression: {
-          operator: IS_EXACT_DATE,
-          operand: null,
-          dateTypeValues: undefined
-        }
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle empty eventContextSelectionOptions', () => {
-      renderComponent({
-        useEntryTriggerEventAttribute: true,
-        conditionExpression: {
-          operator: IS_EXACT_DATE,
-          operand: null,
-          dateTypeValues: {}
-        }
-      });
-
-      // Test that the component renders without errors
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle null grammarDataBasedOnEvent', () => {
-      renderComponent({
-        dateEventGrammar: null
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle undefined grammarDataBasedOnEvent', () => {
-      renderComponent({
-        dateEventGrammar: undefined
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle empty selectedBlock', () => {
-      renderComponent({
-        selectedBlock: {}
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle null selectedBlock', () => {
-      renderComponent({
-        selectedBlock: null
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle undefined selectedBlock', () => {
-      renderComponent({
-        selectedBlock: undefined
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle empty blocksDropdownData', () => {
-      renderComponent({
-        blocksDropdownData: []
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle null blocksDropdownData', () => {
-      renderComponent({
-        blocksDropdownData: null
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle undefined blocksDropdownData', () => {
-      renderComponent({
-        blocksDropdownData: undefined
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle empty grammarDataBasedOnEvent state', () => {
-      renderComponent({
-        grammarDataBasedOnEvent: {}
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle null grammarDataBasedOnEvent state', () => {
-      renderComponent({
-        grammarDataBasedOnEvent: null
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle undefined grammarDataBasedOnEvent state', () => {
-      renderComponent({
-        grammarDataBasedOnEvent: undefined
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-  });
-  describe('Complex Scenarios', () => {
-    it('should handle complete workflow with all operators', () => {
-      var setConditionExpression = jest.fn();
-      var setEventContextSelectionValue = jest.fn();
-      var {
-        rerender: _rerender
-      } = renderComponent({
-        setConditionExpression,
-        setEventContextSelectionValue
-      });
-
-      // Test IS_BEFORE_DAYS
-      var select = screen.getByTestId('cap-select');
-      fireEvent.change(select, {
-        target: {
-          value: IS_BEFORE_DAYS
-        }
-      });
-      expect(setConditionExpression).toHaveBeenCalledWith(expect.objectContaining({
-        operator: IS_BEFORE_DAYS,
-        dateTypeValues: expect.objectContaining({
-          daysKey: MINUS_TIME
-        })
-      }));
-
-      // Test IS_AFTER_DAYS
-      fireEvent.change(select, {
-        target: {
-          value: IS_AFTER_DAYS
-        }
-      });
-      expect(setConditionExpression).toHaveBeenCalledWith(expect.objectContaining({
-        operator: IS_AFTER_DAYS,
-        dateTypeValues: expect.objectContaining({
-          daysKey: PLUS_TIME
-        })
-      }));
-
-      // Test IS_INBETWEEN_DATES
-      fireEvent.change(select, {
-        target: {
-          value: IS_INBETWEEN_DATES
-        }
-      });
-      expect(setConditionExpression).toHaveBeenCalledWith(expect.objectContaining({
-        operator: IS_INBETWEEN_DATES,
-        dateTypeValues: expect.objectContaining({
-          daysKey: null
-        })
-      }));
-    });
-    it('should handle event context workflow', () => {
-      var setEventContextSelectionValue = jest.fn();
-      var setEventContextData = jest.fn();
-      var getProfilesDetailsByBlockData = jest.fn();
-      var availableEngagementBlocks = {
-        block1: {
-          blockType: ENTRY_TRIGGER,
-          blockData: {
-            triggerType: USER_EVENT,
-            userEventTrigger: {
-              eventType: 'testEvent',
-              eventCategory: 'testCategory'
-            }
-          }
-        }
-      };
-      renderComponent({
-        useEntryTriggerEventAttribute: true,
-        conditionExpression: {
-          operator: IS_EXACT_DATE,
-          operand: null,
-          dateTypeValues: {}
-        },
-        availableEngagementBlocks,
-        setEventContextSelectionValue,
-        setEventContextData,
-        getProfilesDetailsByBlockData
-      });
-
-      // Test that the component renders without errors
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle date picker workflow', () => {
-      var setConditionExpression = jest.fn();
-      var dateTypeValues = {
-        specificDateTimeStamp: null,
-        specificDateTimeStamp2: null
-      };
-      renderComponent({
-        conditionExpression: {
-          operator: IS_INBETWEEN_DATES,
-          operand: null,
-          dateTypeValues
-        },
-        eventContextSelectionValue: THE_VALUE,
-        setConditionExpression
-      });
-      var datePickers = screen.getAllByTestId('cap-date-picker');
-      expect(datePickers).toHaveLength(2);
-
-      // Test first date picker
-      fireEvent.change(datePickers[0], {
-        target: {
-          value: '2023-01-01'
-        }
-      });
-      expect(setConditionExpression).toHaveBeenCalledWith(expect.objectContaining({
-        dateTypeValues: expect.objectContaining({
-          specificDateTimeStamp: expect.any(Date)
-        })
-      }));
-
-      // Test second date picker
-      fireEvent.change(datePickers[1], {
-        target: {
-          value: '2023-01-15'
-        }
-      });
-      expect(setConditionExpression).toHaveBeenCalledWith(expect.objectContaining({
-        dateTypeValues: expect.objectContaining({
-          specificDateTimeStamp2: expect.any(Date)
-        })
-      }));
-    });
-    it('should handle operand input workflow', () => {
-      var setConditionExpression = jest.fn();
-      renderComponent({
-        conditionExpression: {
-          operator: IS_BEFORE_DAYS,
-          operand: null,
-          dateTypeValues: {}
-        },
-        eventContextSelectionValue: THE_VALUE,
-        setConditionExpression
-      });
-      var input = screen.getByTestId('cap-input');
-
-      // Test valid input
-      fireEvent.change(input, {
-        target: {
-          value: '5'
-        }
-      });
-      expect(setConditionExpression).toHaveBeenCalledWith(expect.objectContaining({
-        operand: '5'
-      }));
-
-      // Test that the component renders without errors
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-  });
-  describe('PropTypes Validation', () => {
-    it('should handle all required props', () => {
-      var props = {
-        conditionExpressionOptions: {
-          IS_EXACT_DATE: {
-            text: 'On'
-          },
-          IS_BEFORE_DATE: {
-            text: 'Before'
-          },
-          IS_AFTER_DATE: {
-            text: 'After'
-          },
-          IS_BEFORE_DAYS: {
-            text: 'X Days Before'
-          },
-          IS_AFTER_DAYS: {
-            text: 'X Days After'
-          },
-          IS_INBETWEEN_DATES: {
-            text: 'Between'
-          }
-        },
-        conditionExpression: {
-          operator: null,
-          operand: null,
-          dateTypeValues: {}
-        },
-        setConditionExpression: jest.fn(),
-        onMsg: 'On',
-        beforeMsg: 'Before',
-        afterMsg: 'After',
-        xDaysBeforeMsg: 'X Days Before',
-        xDaysAfterMsg: 'X Days After',
-        betweenMsg: 'Between',
-        andMsg: 'And',
-        shouldRemoveOperator: false,
-        removeOperatorsList: [],
-        eventContextDataOptions: [],
-        useEntryTriggerEventAttribute: false,
-        eventContextSelectionValue: THE_VALUE,
-        setEventContextSelectionValue: jest.fn(),
-        eventContextData: {},
-        setEventContextData: jest.fn(),
-        getEngagementBlocksBeforeWaitTill: jest.fn(),
-        availableEngagementBlocks: {},
-        getProfilesDetailsByBlockData: jest.fn(),
-        getGrammarDataBasedOnEvent: jest.fn(),
-        dateEventGrammar: {},
-        eventContextUniqueId: null
-      };
-      renderComponent(props);
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-  });
-  describe('Additional Coverage Tests', () => {
-    it('should handle between operator with event context selection', () => {
-      var setEventContextSelectionValue = jest.fn();
-      renderComponent({
-        conditionExpression: {
-          operator: IS_INBETWEEN_DATES,
-          operand: null,
-          dateTypeValues: {}
-        },
-        eventContextSelectionValue: ENTRY_TRIGGER_EVENT_ATTRIBUTE,
-        setEventContextSelectionValue
-      });
-      expect(setEventContextSelectionValue).toHaveBeenCalledWith(THE_VALUE);
-    });
-    it('should handle grammar data based on event with selected block', () => {
-      var getGrammarDataBasedOnEvent = jest.fn();
-      var selectedBlock = {
-        blockData: {
-          userEventTrigger: {
-            eventType: 'testEvent'
-          }
-        }
-      };
-      renderComponent({
-        dateEventGrammar: {
-          someData: 'test'
-        },
-        eventContextSelectionValue: ENTRY_TRIGGER_EVENT_ATTRIBUTE,
-        selectedBlock,
-        getGrammarDataBasedOnEvent
-      });
-
-      // Test that the component renders without errors
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle event context selection change', () => {
-      var setEventContextSelectionValue = jest.fn();
-      renderComponent({
-        useEntryTriggerEventAttribute: true,
-        conditionExpression: {
-          operator: IS_EXACT_DATE,
-          operand: null,
-          dateTypeValues: {}
-        },
-        setEventContextSelectionValue
-      });
-
-      // Test that the component renders without errors
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle custom event context component rendering', () => {
-      renderComponent({
-        useEntryTriggerEventAttribute: true,
-        conditionExpression: {
-          operator: IS_EXACT_DATE,
-          operand: null,
-          dateTypeValues: {}
-        },
-        eventContextSelectionValue: ENTRY_TRIGGER_EVENT_ATTRIBUTE
-      });
-
-      // Test that the component renders without errors
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should not render event context component for between operator', () => {
-      renderComponent({
-        useEntryTriggerEventAttribute: true,
-        conditionExpression: {
-          operator: IS_INBETWEEN_DATES,
-          operand: null,
-          dateTypeValues: {}
-        },
-        eventContextSelectionValue: ENTRY_TRIGGER_EVENT_ATTRIBUTE
-      });
-      expect(screen.queryByTestId('event-context-component')).not.toBeInTheDocument();
-    });
-    it('should handle input elements when operator is null', () => {
-      renderComponent({
-        conditionExpression: {
-          operator: null,
-          operand: null,
-          dateTypeValues: {}
-        },
-        eventContextSelectionValue: THE_VALUE
-      });
-
-      // Should not render date picker when operator is null
-      expect(screen.queryByTestId('cap-date-picker')).not.toBeInTheDocument();
-    });
-    it('should handle input elements when event context is selected', () => {
-      renderComponent({
-        conditionExpression: {
-          operator: IS_EXACT_DATE,
-          operand: null,
-          dateTypeValues: {}
-        },
-        eventContextSelectionValue: ENTRY_TRIGGER_EVENT_ATTRIBUTE
-      });
-
-      // Should not render date picker when event context is selected
-      expect(screen.queryByTestId('cap-date-picker')).not.toBeInTheDocument();
-    });
-  });
-  describe('Missing Coverage Tests', () => {
-    it('should handle handleBlockSelectionChange function', () => {
-      var setEventContextData = jest.fn();
-      var getProfilesDetailsByBlockData = jest.fn();
-      var availableEngagementBlocks = {
-        block1: {
-          blockType: ENTRY_TRIGGER,
-          blockData: {
-            triggerType: USER_EVENT,
-            userEventTrigger: {
-              eventType: 'testEvent',
-              eventCategory: 'testCategory'
-            }
-          }
-        }
-      };
-      renderComponent({
-        useEntryTriggerEventAttribute: true,
-        conditionExpression: {
-          operator: IS_EXACT_DATE,
-          operand: null,
-          dateTypeValues: {}
-        },
-        availableEngagementBlocks,
-        setEventContextData,
-        getProfilesDetailsByBlockData
-      });
-
-      // Test that the component renders without errors
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle getGrammarDataBasedOnEvent call with proper conditions', () => {
-      var getGrammarDataBasedOnEvent = jest.fn().mockReturnValue({
-        treeData: 'test'
-      });
-      var selectedBlock = {
-        blockData: {
-          userEventTrigger: {
-            eventType: 'testEvent'
-          }
-        }
-      };
-      renderComponent({
-        dateEventGrammar: {
-          someData: 'test'
-        },
-        eventContextSelectionValue: ENTRY_TRIGGER_EVENT_ATTRIBUTE,
-        selectedBlock,
-        getGrammarDataBasedOnEvent
-      });
-
-      // Test that the component renders without errors
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle handleEventContextSelectionChange function', () => {
-      var setEventContextSelectionValue = jest.fn();
-      renderComponent({
-        useEntryTriggerEventAttribute: true,
-        conditionExpression: {
-          operator: IS_EXACT_DATE,
-          operand: null,
-          dateTypeValues: {}
-        },
-        setEventContextSelectionValue
-      });
-
-      // Test that the component renders without errors
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle disableDateRange function with startDate', () => {
-      var startDate = new Date('2023-01-01');
-      var _currentDate = new Date('2022-12-31');
-      renderComponent({
-        conditionExpression: {
-          operator: IS_INBETWEEN_DATES,
-          operand: null,
-          dateTypeValues: {
-            specificDateTimeStamp: startDate
-          }
-        },
-        eventContextSelectionValue: THE_VALUE
-      });
-
-      // Test that the component renders without errors
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle disableDateRange function without startDate', () => {
-      renderComponent({
-        conditionExpression: {
-          operator: IS_INBETWEEN_DATES,
-          operand: null,
-          dateTypeValues: {
-            specificDateTimeStamp: null
-          }
-        },
-        eventContextSelectionValue: THE_VALUE
-      });
-
-      // Test that the component renders without errors
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle getCustomEventContextComponent function', () => {
-      renderComponent({
-        useEntryTriggerEventAttribute: true,
-        conditionExpression: {
-          operator: IS_EXACT_DATE,
-          operand: null,
-          dateTypeValues: {}
-        },
-        eventContextSelectionValue: ENTRY_TRIGGER_EVENT_ATTRIBUTE
-      });
-
-      // Test that the component renders without errors
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle getInputElements function with between operator', () => {
-      renderComponent({
-        conditionExpression: {
-          operator: IS_INBETWEEN_DATES,
-          operand: null,
-          dateTypeValues: {
-            specificDateTimeStamp: new Date('2023-01-01'),
-            specificDateTimeStamp2: new Date('2023-01-15')
-          }
-        },
-        eventContextSelectionValue: THE_VALUE
-      });
-      var datePickers = screen.getAllByTestId('cap-date-picker');
-      expect(datePickers).toHaveLength(2);
-      expect(screen.getByText('and')).toBeInTheDocument();
-    });
-    it('should handle getInputElements function with single date picker', () => {
-      renderComponent({
-        conditionExpression: {
-          operator: IS_EXACT_DATE,
-          operand: null,
-          dateTypeValues: {
-            specificDateTimeStamp: new Date('2023-01-01')
-          }
-        },
-        eventContextSelectionValue: THE_VALUE
-      });
-      var datePickers = screen.getAllByTestId('cap-date-picker');
-      expect(datePickers).toHaveLength(1);
-    });
-    it('should handle getInputElements function when event context is selected', () => {
-      renderComponent({
-        conditionExpression: {
-          operator: IS_EXACT_DATE,
-          operand: null,
-          dateTypeValues: {
-            specificDateTimeStamp: new Date('2023-01-01')
-          }
-        },
-        eventContextSelectionValue: ENTRY_TRIGGER_EVENT_ATTRIBUTE
-      });
-
-      // Should not render date picker when event context is selected
-      expect(screen.queryByTestId('cap-date-picker')).not.toBeInTheDocument();
-    });
-    it('should handle getInputElements function when operator is null', () => {
-      renderComponent({
-        conditionExpression: {
-          operator: null,
-          operand: null,
-          dateTypeValues: {}
-        },
-        eventContextSelectionValue: THE_VALUE
-      });
-
-      // Should not render date picker when operator is null
-      expect(screen.queryByTestId('cap-date-picker')).not.toBeInTheDocument();
-    });
-  });
-  describe('OperandsMapping Conditional Logic Coverage', () => {
-    it('should use operandsMappingWithoutDays when currentBlockName equals ENTRY_TRIGGER', () => {
-      var setConditionExpression = jest.fn();
-
-      // Create filtered conditionExpressionOptions that match the filtered operandsMapping
-      var filteredConditionExpressionOptions = {
-        IS_EXACT_DATE: {
-          text: 'On'
-        },
-        IS_BEFORE_DATE: {
-          text: 'Before'
-        },
-        IS_AFTER_DATE: {
-          text: 'After'
-        },
-        IS_INBETWEEN_DATES: {
-          text: 'Between'
-        }
-        // Exclude IS_BEFORE_DAYS and IS_AFTER_DAYS to match operandsMappingWithoutDays
-      };
-      renderComponent({
-        currentBlockName: ENTRY_TRIGGER,
-        conditionExpressionOptions: filteredConditionExpressionOptions,
-        setConditionExpression
-      });
-
-      // Verify that the component renders with the filtered operands mapping
-      // This means IS_BEFORE_DAYS and IS_AFTER_DAYS should not be available in the dropdown
-      var select = screen.getByTestId('cap-select');
-      expect(select).toBeInTheDocument();
-
-      // The component should render without errors when currentBlockName is ENTRY_TRIGGER
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should use allOperandsMapping when currentBlockName is not ENTRY_TRIGGER', () => {
-      var setConditionExpression = jest.fn();
-      renderComponent({
-        currentBlockName: 'SOME_OTHER_BLOCK',
-        setConditionExpression
-      });
-
-      // Verify that the component renders with the full operands mapping
-      var select = screen.getByTestId('cap-select');
-      expect(select).toBeInTheDocument();
-
-      // The component should render without errors when currentBlockName is not ENTRY_TRIGGER
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should use allOperandsMapping when currentBlockName is undefined', () => {
-      var setConditionExpression = jest.fn();
-      renderComponent({
-        currentBlockName: undefined,
-        setConditionExpression
-      });
-
-      // Verify that the component renders with the full operands mapping
-      var select = screen.getByTestId('cap-select');
-      expect(select).toBeInTheDocument();
-
-      // The component should render without errors when currentBlockName is undefined
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should use allOperandsMapping when currentBlockName is null', () => {
-      var setConditionExpression = jest.fn();
-      renderComponent({
-        currentBlockName: null,
-        setConditionExpression
-      });
-
-      // Verify that the component renders with the full operands mapping
-      var select = screen.getByTestId('cap-select');
-      expect(select).toBeInTheDocument();
-
-      // The component should render without errors when currentBlockName is null
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should use allOperandsMapping when currentBlockName is empty string', () => {
-      var setConditionExpression = jest.fn();
-      renderComponent({
-        currentBlockName: '',
-        setConditionExpression
-      });
-
-      // Verify that the component renders with the full operands mapping
-      var select = screen.getByTestId('cap-select');
-      expect(select).toBeInTheDocument();
-
-      // The component should render without errors when currentBlockName is empty string
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should use allOperandsMapping when currentBlockName is a different constant', () => {
-      var setConditionExpression = jest.fn();
-      renderComponent({
-        currentBlockName: WAIT_TILL_EVENT,
-        setConditionExpression
-      });
-
-      // Verify that the component renders with the full operands mapping
-      var select = screen.getByTestId('cap-select');
-      expect(select).toBeInTheDocument();
-
-      // The component should render without errors when currentBlockName is WAIT_TILL_EVENT
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should use allOperandsMapping when currentBlockName is any other string value', () => {
-      var setConditionExpression = jest.fn();
-      renderComponent({
-        currentBlockName: 'CUSTOM_BLOCK_TYPE',
-        setConditionExpression
-      });
-
-      // Verify that the component renders with the full operands mapping
-      var select = screen.getByTestId('cap-select');
-      expect(select).toBeInTheDocument();
-
-      // The component should render without errors when currentBlockName is any other string
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle operandsMapping logic with operator changes when currentBlockName is ENTRY_TRIGGER', () => {
-      var setConditionExpression = jest.fn();
-
-      // Create filtered conditionExpressionOptions that match the filtered operandsMapping
-      var filteredConditionExpressionOptions = {
-        IS_EXACT_DATE: {
-          text: 'On'
-        },
-        IS_BEFORE_DATE: {
-          text: 'Before'
-        },
-        IS_AFTER_DATE: {
-          text: 'After'
-        },
-        IS_INBETWEEN_DATES: {
-          text: 'Between'
-        }
-        // Exclude IS_BEFORE_DAYS and IS_AFTER_DAYS to match operandsMappingWithoutDays
-      };
-      renderComponent({
-        currentBlockName: ENTRY_TRIGGER,
-        conditionExpressionOptions: filteredConditionExpressionOptions,
-        setConditionExpression
-      });
-      var select = screen.getByTestId('cap-select');
-
-      // Test that operator changes work correctly with filtered mapping
-      fireEvent.change(select, {
-        target: {
-          value: IS_EXACT_DATE
-        }
-      });
-      expect(setConditionExpression).toHaveBeenCalledWith(expect.objectContaining({
-        operator: IS_EXACT_DATE
-      }));
-    });
-    it('should handle operandsMapping logic with operator changes when currentBlockName is not ENTRY_TRIGGER', () => {
-      var setConditionExpression = jest.fn();
-      renderComponent({
-        currentBlockName: 'OTHER_BLOCK',
-        setConditionExpression
-      });
-      var select = screen.getByTestId('cap-select');
-
-      // Test that operator changes work correctly with full mapping
-      fireEvent.change(select, {
-        target: {
-          value: IS_BEFORE_DAYS
-        }
-      });
-      expect(setConditionExpression).toHaveBeenCalledWith(expect.objectContaining({
-        operator: IS_BEFORE_DAYS,
-        dateTypeValues: expect.objectContaining({
-          daysKey: MINUS_TIME
-        })
-      }));
-    });
-  });
-  describe('Advanced Edge Cases and Branch Coverage', () => {
-    it('should handle availableEngagementBlocks with userEventTrigger but no eventType', () => {
-      var availableEngagementBlocks = {
-        block1: {
-          blockType: ENTRY_TRIGGER,
-          blockData: {
-            triggerType: USER_EVENT,
-            userEventTrigger: {
-              eventCategory: 'testCategory'
-              // Missing eventType
-            }
-          }
-        }
-      };
-      renderComponent({
-        availableEngagementBlocks
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle availableEngagementBlocks with userEventTrigger but no eventCategory', () => {
-      var availableEngagementBlocks = {
-        block1: {
-          blockType: ENTRY_TRIGGER,
-          blockData: {
-            triggerType: USER_EVENT,
-            userEventTrigger: {
-              eventType: 'testEvent'
-              // Missing eventCategory
-            }
-          }
-        }
-      };
-      renderComponent({
-        availableEngagementBlocks
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle availableEngagementBlocks with WAIT_TILL_EVENT and userEventTrigger', () => {
-      var availableEngagementBlocks = {
-        block1: {
-          blockType: WAIT_TILL_EVENT,
-          name: 'Test Wait Block',
-          blockData: {
-            userEventTrigger: {
-              eventType: 'testEvent',
-              eventCategory: 'testCategory'
-            }
-          }
-        }
-      };
-      renderComponent({
-        availableEngagementBlocks
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle availableEngagementBlocks with WAIT_TILL_EVENT and waitType', () => {
-      var availableEngagementBlocks = {
-        block1: {
-          blockType: WAIT_TILL_EVENT,
-          name: 'Test Wait Block',
-          blockData: {
-            waitType: WAIT_TILL_EVENT_TYPE
-          }
-        }
-      };
-      renderComponent({
-        availableEngagementBlocks
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle availableEngagementBlocks with invalid blockType', () => {
-      var availableEngagementBlocks = {
-        block1: {
-          blockType: 'INVALID_TYPE',
-          blockData: {
-            triggerType: USER_EVENT,
-            userEventTrigger: {
-              eventType: 'testEvent',
-              eventCategory: 'testCategory'
-            }
-          }
-        }
-      };
-      renderComponent({
-        availableEngagementBlocks
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle availableEngagementBlocks with missing blockData', () => {
-      var availableEngagementBlocks = {
-        block1: {
-          blockType: ENTRY_TRIGGER
-          // Missing blockData
-        }
-      };
-      renderComponent({
-        availableEngagementBlocks
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle availableEngagementBlocks with null blockData', () => {
-      var availableEngagementBlocks = {
-        block1: {
-          blockType: ENTRY_TRIGGER,
-          blockData: null
-        }
-      };
-      renderComponent({
-        availableEngagementBlocks
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle availableEngagementBlocks with missing userEventTrigger', () => {
-      var availableEngagementBlocks = {
-        block1: {
-          blockType: ENTRY_TRIGGER,
-          blockData: {
-            triggerType: USER_EVENT
-            // Missing userEventTrigger
-          }
-        }
-      };
-      renderComponent({
-        availableEngagementBlocks
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle availableEngagementBlocks with null userEventTrigger', () => {
-      var availableEngagementBlocks = {
-        block1: {
-          blockType: ENTRY_TRIGGER,
-          blockData: {
-            triggerType: USER_EVENT,
-            userEventTrigger: null
-          }
-        }
-      };
-      renderComponent({
-        availableEngagementBlocks
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle availableEngagementBlocks with missing name for WAIT_TILL_EVENT', () => {
-      var availableEngagementBlocks = {
-        block1: {
-          blockType: WAIT_TILL_EVENT,
-          blockData: {
-            waitType: WAIT_TILL_EVENT_TYPE
-          }
-          // Missing name
-        }
-      };
-      renderComponent({
-        availableEngagementBlocks
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle eventContextUniqueId with invalid format', () => {
-      var availableEngagementBlocks = {
-        block1: {
-          blockType: ENTRY_TRIGGER,
-          blockData: {
-            triggerType: USER_EVENT,
-            userEventTrigger: {
-              eventType: 'testEvent',
-              eventCategory: 'testCategory'
-            }
-          }
-        }
-      };
-      renderComponent({
-        eventContextUniqueId: 'invalid_format',
-        availableEngagementBlocks
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle eventContextUniqueId with non-existent block', () => {
-      var availableEngagementBlocks = {
-        block1: {
-          blockType: ENTRY_TRIGGER,
-          blockData: {
-            triggerType: USER_EVENT,
-            userEventTrigger: {
-              eventType: 'testEvent',
-              eventCategory: 'testCategory'
-            }
-          }
-        }
-      };
-      renderComponent({
-        eventContextUniqueId: 'nonexistent_block__test',
-        availableEngagementBlocks
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle getGrammarDataBasedOnEvent with missing dateEventGrammar', () => {
-      var getGrammarDataBasedOnEvent = jest.fn();
-      var selectedBlock = {
-        blockData: {
-          userEventTrigger: {
-            eventType: 'testEvent'
-          }
-        }
-      };
-      renderComponent({
-        dateEventGrammar: null,
-        eventContextSelectionValue: ENTRY_TRIGGER_EVENT_ATTRIBUTE,
-        selectedBlock,
-        getGrammarDataBasedOnEvent
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle getGrammarDataBasedOnEvent with missing selectedBlock', () => {
-      var getGrammarDataBasedOnEvent = jest.fn();
-      renderComponent({
-        dateEventGrammar: {
-          someData: 'test'
-        },
-        eventContextSelectionValue: ENTRY_TRIGGER_EVENT_ATTRIBUTE,
-        selectedBlock: null,
-        getGrammarDataBasedOnEvent
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle getGrammarDataBasedOnEvent with missing blockData', () => {
-      var getGrammarDataBasedOnEvent = jest.fn();
-      var selectedBlock = {
-        // Missing blockData
-      };
-      renderComponent({
-        dateEventGrammar: {
-          someData: 'test'
-        },
-        eventContextSelectionValue: ENTRY_TRIGGER_EVENT_ATTRIBUTE,
-        selectedBlock,
-        getGrammarDataBasedOnEvent
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle getGrammarDataBasedOnEvent with missing userEventTrigger', () => {
-      var getGrammarDataBasedOnEvent = jest.fn();
-      var selectedBlock = {
-        blockData: {
-          // Missing userEventTrigger
-        }
-      };
-      renderComponent({
-        dateEventGrammar: {
-          someData: 'test'
-        },
-        eventContextSelectionValue: ENTRY_TRIGGER_EVENT_ATTRIBUTE,
-        selectedBlock,
-        getGrammarDataBasedOnEvent
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle getGrammarDataBasedOnEvent with missing eventType', () => {
-      var getGrammarDataBasedOnEvent = jest.fn();
-      var selectedBlock = {
-        blockData: {
-          userEventTrigger: {
-            // Missing eventType
-          }
-        }
-      };
-      renderComponent({
-        dateEventGrammar: {
-          someData: 'test'
-        },
-        eventContextSelectionValue: ENTRY_TRIGGER_EVENT_ATTRIBUTE,
-        selectedBlock,
-        getGrammarDataBasedOnEvent
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle getGrammarDataBasedOnEvent with different eventContextSelectionValue', () => {
-      var getGrammarDataBasedOnEvent = jest.fn();
-      var selectedBlock = {
-        blockData: {
-          userEventTrigger: {
-            eventType: 'testEvent'
-          }
-        }
-      };
-      renderComponent({
-        dateEventGrammar: {
-          someData: 'test'
-        },
-        eventContextSelectionValue: THE_VALUE,
-        // Not ENTRY_TRIGGER_EVENT_ATTRIBUTE
-        selectedBlock,
-        getGrammarDataBasedOnEvent
-      });
-      expect(screen.getByTestId('cap-spin')).toBeInTheDocument();
-    });
-    it('should handle handleOperandChange with null value', () => {
-      var setConditionExpression = jest.fn();
-      renderComponent({
-        conditionExpression: {
-          operator: IS_BEFORE_DAYS,
-          operand: '5',
-          dateTypeValues: {}
-        },
-        setConditionExpression
-      });
-      var input = screen.getByTestId('cap-input');
-      fireEvent.change(input, {
-        target: {
-          value: null
-        }
-      });
-      expect(setConditionExpression).toHaveBeenCalledWith(expect.objectContaining({
-        operand: null
-      }));
-    });
-    it('should handle handleOperandChange with undefined value', () => {
-      var setConditionExpression = jest.fn();
-      renderComponent({
-        conditionExpression: {
-          operator: IS_BEFORE_DAYS,
-          operand: '5',
-          dateTypeValues: {}
-        },
-        eventContextSelectionValue: THE_VALUE,
-        setConditionExpression
-      });
-      var input = screen.getByTestId('cap-input');
-      fireEvent.change(input, {
-        target: {
-          value: ''
-        }
-      });
-      expect(setConditionExpression).toHaveBeenCalledWith(expect.objectContaining({
-        operand: null
-      }));
-    });
-    it('should handle handleOperandChange with zero value', () => {
-      var setConditionExpression = jest.fn();
-      renderComponent({
-        conditionExpression: {
-          operator: IS_BEFORE_DAYS,
-          operand: '5',
-          dateTypeValues: {}
-        },
-        setConditionExpression
-      });
-      var input = screen.getByTestId('cap-input');
-      fireEvent.change(input, {
-        target: {
-          value: '0'
-        }
-      });
-      expect(setConditionExpression).toHaveBeenCalledWith(expect.objectContaining({
-        operand: '0'
-      }));
-    });
-    it('should handle handleOperandChange with negative value', () => {
-      var setConditionExpression = jest.fn();
-      renderComponent({
-        conditionExpression: {
-          operator: IS_BEFORE_DAYS,
-          operand: '5',
-          dateTypeValues: {}
-        },
-        setConditionExpression
-      });
-      var input = screen.getByTestId('cap-input');
-      fireEvent.change(input, {
-        target: {
-          value: '-5'
-        }
-      });
-      expect(setConditionExpression).toHaveBeenCalledWith(expect.objectContaining({
-        operand: '-5'
-      }));
-    });
-    it('should handle handleOperandChange with decimal value', () => {
-      var setConditionExpression = jest.fn();
-      renderComponent({
-        conditionExpression: {
-          operator: IS_BEFORE_DAYS,
-          operand: '5',
-          dateTypeValues: {}
-        },
-        setConditionExpression
-      });
-      var input = screen.getByTestId('cap-input');
-      fireEvent.change(input, {
-        target: {
-          value: '5.5'
-        }
-      });
-      expect(setConditionExpression).toHaveBeenCalledWith(expect.objectContaining({
-        operand: '5.5'
-      }));
-    });
-    it('should handle handleOperandChange with non-numeric value', () => {
-      var setConditionExpression = jest.fn();
-      renderComponent({
-        conditionExpression: {
-          operator: IS_BEFORE_DAYS,
-          operand: '5',
-          dateTypeValues: {}
-        },
-        eventContextSelectionValue: THE_VALUE,
-        setConditionExpression
-      });
-      var input = screen.getByTestId('cap-input');
-      fireEvent.change(input, {
-        target: {
-          value: 'abc'
-        }
-      });
-
-      // The function sets non-numeric values to null (likely due to validation)
-      expect(setConditionExpression).toHaveBeenCalledWith(expect.objectContaining({
-        operand: null
-      }));
-    });
-    it('should handle handleOperandChange with whitespace value', () => {
-      var setConditionExpression = jest.fn();
-      renderComponent({
-        conditionExpression: {
-          operator: IS_BEFORE_DAYS,
-          operand: '5',
-          dateTypeValues: {}
-        },
-        eventContextSelectionValue: THE_VALUE,
-        setConditionExpression
-      });
-      var input = screen.getByTestId('cap-input');
-      fireEvent.change(input, {
-        target: {
-          value: '   '
-        }
-      });
-
-      // Whitespace values are treated as falsy and converted to null
-      expect(setConditionExpression).toHaveBeenCalledWith(expect.objectContaining({
-        operand: null
-      }));
-    });
-    it('should handle handleOperandChange with very large number', () => {
-      var setConditionExpression = jest.fn();
-      renderComponent({
-        conditionExpression: {
-          operator: IS_BEFORE_DAYS,
-          operand: '5',
-          dateTypeValues: {}
-        },
-        setConditionExpression
-      });
-      var input = screen.getByTestId('cap-input');
-      fireEvent.change(input, {
-        target: {
-          value: '999999999999999999'
-        }
-      });
-      expect(setConditionExpression).toHaveBeenCalledWith(expect.objectContaining({
-        operand: '999999999999999999'
-      }));
-    });
-    it('should handle handleOperandChange with scientific notation', () => {
-      var setConditionExpression = jest.fn();
-      renderComponent({
-        conditionExpression: {
-          operator: IS_BEFORE_DAYS,
-          operand: '5',
-          dateTypeValues: {}
-        },
-        setConditionExpression
-      });
-      var input = screen.getByTestId('cap-input');
-      fireEvent.change(input, {
-        target: {
-          value: '1e10'
-        }
-      });
-      expect(setConditionExpression).toHaveBeenCalledWith(expect.objectContaining({
-        operand: '1e10'
-      }));
-    });
-  });
-});