fix(tests): suppress Cypress DOM snapshots during search loop to prevent OOM

cy.reload() only frees browser-side DOM memory, but Cypress stores
serialized DOM snapshots in Node.js memory for each command (~1-5 MB
each). With ~40 commands per search iteration * 15+ iterations, this
accumulates ~600 MB+ of snapshots, causing OOM (exit 137) in CI.

Adds a _quietSearch flag that suppresses Cypress command logging
(and thus DOM snapshot creation) during findIncidentWithAlert's
search loop. Key operations use { log: false } via _qLog() helper.
Outer cy.log() calls are preserved for CI visibility.

CI run: https://prow.ci.openshift.org/view/gs/test-platform-results/pr-logs/pull/openshift_monitoring-plugin/860/pull-ci-openshift-monitoring-plugin-main-e2e-incidents/2041404831268081664
Classifications: TEST_BUG (confidence: high)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: DavidRajnoha

web/cypress/views/incidents-page.ts

@@ -7,6 +7,12 @@ import { DataTestIDs } from '../../src/components/data-test';
 let _findIncidentSearchStart: number | null = null;
 const _FIND_INCIDENT_HARD_TIMEOUT_MS = 35 * 60 * 1000; // 35 minutes
 
+// When true, search methods suppress Cypress command logging to prevent
+// DOM snapshot accumulation that causes OOM (exit 137) in CI containers.
+// Toggled by findIncidentWithAlert during its retry loop.
+let _quietSearch = false;
+const _qLog = (): { log: false } | Record<string, never> => _quietSearch ? { log: false } : {};
+
 export const incidentsPage = {
 
     // Centralized element selectors - all selectors defined in one place
@@ -60,22 +66,22 @@ export const incidentsPage = {
       incidentsChartBars: () => cy.byTestID(DataTestIDs.IncidentsChart.ChartBars),
       incidentsChartBar: (groupId: string) => cy.byTestID(`${DataTestIDs.IncidentsChart.ChartBar}-${groupId}`),
       incidentsChartBarsVisiblePaths: () => {
-        return cy.get('body').then($body => {
+        return cy.get('body', _qLog()).then($body => {
           // There is a delay between the element being rendered and the paths being visible.
           // The case when no paths are visible is valid, so we can not use should or conditional testing semantics.
-          cy.wait(500);
+          cy.wait(500, _qLog());
           // We need to use the $body as both cases when the element is there or not are valid.
           const exists = $body.find('g[role="presentation"][data-test*="incidents-chart-bar-"]').length > 0;
           if (exists) {
-            return cy.get('g[role="presentation"][data-test*="incidents-chart-bar-"]')
+            return cy.get('g[role="presentation"][data-test*="incidents-chart-bar-"]', _qLog())
               .find('path[role="presentation"]')
               .filter((index, element) => {
                 const fillOpacity = Cypress.$(element).css('fill-opacity') || Cypress.$(element).attr('fill-opacity');
                 return parseFloat(fillOpacity || '0') > 0;
               });
           } else {
-            cy.log('Chart bars were not found. Test continues.');
-            return cy.wrap([]);
+            if (!_quietSearch) cy.log('Chart bars were not found. Test continues.');
+            return cy.wrap([], _qLog());
           }
         });
       },
@@ -320,35 +326,35 @@ export const incidentsPage = {
    * @returns Promise that resolves when the incidents table is visible
    */
   selectIncidentByBarIndex: (index = 0) => {
-    cy.log(`incidentsPage.selectIncidentByBarIndex: ${index} (clicking visible path elements)`);
-    
+    if (!_quietSearch) cy.log(`incidentsPage.selectIncidentByBarIndex: ${index} (clicking visible path elements)`);
+
     return incidentsPage.elements.incidentsChartBarsVisiblePaths()
       .should('have.length.greaterThan', index)
       .then(($paths) => {
         if (index >= $paths.length) {
           throw new Error(`Index ${index} exceeds available paths (${$paths.length})`);
         }
-        
-        return cy.wrap($paths.eq(index))
-          .click({ force: true });
+
+        return cy.wrap($paths.eq(index), _qLog())
+          .click({ force: true, ..._qLog() });
       })
       .then(() => {
-        cy.wait(2000);
+        cy.wait(2000, _qLog());
         return incidentsPage.elements.incidentsTable()
           .scrollIntoView()
           .should('exist');
       });
   },
 
   deselectIncidentByBar: () => {
-    cy.log('incidentsPage.deselectIncidentByBar');
+    if (!_quietSearch) cy.log('incidentsPage.deselectIncidentByBar');
     return incidentsPage.elements.incidentsChartBarsVisiblePaths()
       .then(($paths) => {
         if ($paths.length === 0) {
           throw new Error('No paths found in incidents chart');
         }
-        return cy.wrap($paths.eq(0))
-          .click({ force: true });
+        return cy.wrap($paths.eq(0), _qLog())
+          .click({ force: true, ..._qLog() });
       })
       .then(() => {
         return incidentsPage.elements.incidentsTable()
@@ -403,9 +409,9 @@ export const incidentsPage = {
   },
 
   expandRow: (rowIndex = 0) => {
-    cy.log('incidentsPage.expandRow');
+    if (!_quietSearch) cy.log('incidentsPage.expandRow');
     incidentsPage.elements.incidentsTableExpandButton(rowIndex)
-          .click({ force: true });
+          .click({ force: true, ..._qLog() });
   },
 
   waitForTooltip: () => {
@@ -555,15 +561,13 @@ export const incidentsPage = {
   },
 
   prepareIncidentsPageForSearch: () => {
-    cy.log('incidentsPage.prepareIncidentsPageForSearch: Setting up page...');
-    // Force a hard page reload to release DOM memory from previous search iterations.
-    // Without this, repeated searches within waitUntil accumulate Cypress command
-    // snapshots and browser DOM nodes, causing OOM (exit 137) in CI containers.
+    if (!_quietSearch) cy.log('incidentsPage.prepareIncidentsPageForSearch: Setting up page...');
+    // Force a hard page reload to release browser DOM memory from previous search iterations.
     cy.reload({ log: false });
     incidentsPage.goTo();
     incidentsPage.setDays(incidentsPage.SEARCH_CONFIG.DEFAULT_DAYS);
     incidentsPage.elements.incidentsChartContainer().should('be.visible');
-    cy.wait(incidentsPage.SEARCH_CONFIG.CHART_LOAD_WAIT);
+    cy.wait(incidentsPage.SEARCH_CONFIG.CHART_LOAD_WAIT, _qLog());
   },
 
   /**
@@ -577,10 +581,9 @@ export const incidentsPage = {
     return incidentsPage.elements.incidentsTable().invoke('text').then((text) => {
       if (String(text).includes(alertName)) {
         cy.log(`Found alert "${alertName}" in incident ${incidentIndex + 1} table content`);
-        cy.log(text);
-        return cy.wrap(true);
+        return cy.wrap(true, _qLog());
       }
-      return cy.wrap(false);
+      return cy.wrap(false, _qLog());
     });
   },
 
@@ -596,18 +599,18 @@ export const incidentsPage = {
    */
   checkComponentInIncident: (alertName: string, incidentIndex: number, totalRows: number, currentRowIndex: number = 0): Cypress.Chainable<boolean> => {
     if (currentRowIndex >= totalRows) {
-      cy.log(`Checked all ${totalRows} rows in incident ${incidentIndex + 1}, alert not found`);
-      return cy.wrap(false);
+      if (!_quietSearch) cy.log(`Checked all ${totalRows} rows in incident ${incidentIndex + 1}, alert not found`);
+      return cy.wrap(false, _qLog());
     }
-    
-    cy.log(`Expanding and checking row ${currentRowIndex} in incident ${incidentIndex + 1}`);
+
+    if (!_quietSearch) cy.log(`Expanding and checking row ${currentRowIndex} in incident ${incidentIndex + 1}`);
     incidentsPage.expandRow(currentRowIndex);
-    
+
     return incidentsPage.checkComponentRowInIncidentTableForAlert(alertName, incidentIndex)
       .then((found) => {
         if (found) {
           cy.log(`Found alert "${alertName}" in expanded row ${currentRowIndex} of incident ${incidentIndex + 1}`);
-          return cy.wrap(true);
+          return cy.wrap(true, _qLog());
         }
         return incidentsPage.checkComponentInIncident(alertName, incidentIndex, totalRows, currentRowIndex + 1);
       });
@@ -622,24 +625,24 @@ export const incidentsPage = {
    * @returns Promise resolving to true if alert is found anywhere in the incident
    */
   searchAllComponentsInIncident: (alertName: string, incidentIndex: number): Cypress.Chainable<boolean> => {
-    cy.log(`incidentsPage.searchAllRowsInIncident: Checking all rows in incident ${incidentIndex + 1} for alert "${alertName}"`);
-    
+    if (!_quietSearch) cy.log(`incidentsPage.searchAllRowsInIncident: Checking all rows in incident ${incidentIndex + 1} for alert "${alertName}"`);
+
     return incidentsPage.checkComponentRowInIncidentTableForAlert(alertName, incidentIndex)
       .then((foundInMain) => {
         if (foundInMain) {
-          return cy.wrap(true);
+          return cy.wrap(true, _qLog());
         }
-        
+
         return incidentsPage.elements.incidentsTable()
           .find('tbody[data-test*="incidents-table-row-"]')
           .then(($rows) => {
             const totalRows = $rows.length;
             if (totalRows === 0) {
-              cy.log(`No rows found in incident ${incidentIndex + 1}`);
-              return cy.wrap(false);
+              if (!_quietSearch) cy.log(`No rows found in incident ${incidentIndex + 1}`);
+              return cy.wrap(false, _qLog());
             }
-            
-            cy.log(`Found ${totalRows} incident rows to check in incident ${incidentIndex + 1}`);
+
+            if (!_quietSearch) cy.log(`Found ${totalRows} incident rows to check in incident ${incidentIndex + 1}`);
             return incidentsPage.checkComponentInIncident(alertName, incidentIndex, totalRows);
           });
       });
@@ -654,10 +657,10 @@ export const incidentsPage = {
    * @returns Promise resolving to true if alert is found in the incident
    */
   searchForAlertInIncident: (alertName: string, incidentIndex: number): Cypress.Chainable<boolean> => {
-    cy.log(`incidentsPage.searchForAlertInIncident: Checking incident ${incidentIndex + 1} for alert "${alertName}"`);
-    
+    if (!_quietSearch) cy.log(`incidentsPage.searchForAlertInIncident: Checking incident ${incidentIndex + 1} for alert "${alertName}"`);
+
     return cy
-      .wrap(null)
+      .wrap(null, _qLog())
       .then(() => {
         incidentsPage.selectIncidentByBarIndex(incidentIndex);
         return null;
@@ -674,25 +677,21 @@ export const incidentsPage = {
    * @returns Promise resolving to true if alert is found in any incident
    */
   traverseAllIncidentsBars: (alertName: string, totalIncidents: number): Cypress.Chainable<boolean> => {
-    cy.log(`incidentsPage.searchAllIncidents: Searching ${totalIncidents} incidents for alert "${alertName}"`);
-    
+    if (!_quietSearch) cy.log(`incidentsPage.searchAllIncidents: Searching ${totalIncidents} incidents for alert "${alertName}"`);
+
     const searchNextIncidentBar = (currentIndex: number): Cypress.Chainable<boolean> => {
       if (currentIndex >= totalIncidents) {
-        cy.log(`Checked all ${totalIncidents} incidents, alert "${alertName}" not found`);
-        return cy.wrap(false);
+        if (!_quietSearch) cy.log(`Checked all ${totalIncidents} incidents, alert "${alertName}" not found`);
+        return cy.wrap(false, _qLog());
       }
 
       return incidentsPage.searchForAlertInIncident(alertName, currentIndex)
         .then((found) => {
           if (found) {
-            return cy.wrap(true);
+            return cy.wrap(true, _qLog());
           }
           incidentsPage.deselectIncidentByBar();
-          // Wait for the incident to be deselected
-          // Quick workaround, could be improved by waiting for the number of paths to change, but it
-          // does not has to if 1 initially. The check for the alert table non existance is already implemented,
-          // but there seems to be a short delay between the alert table closing and new bars rendering.
-          cy.wait(500)
+          cy.wait(500, _qLog());
           return searchNextIncidentBar(currentIndex + 1);
         });
     };
@@ -716,28 +715,35 @@ export const incidentsPage = {
     const elapsed = Date.now() - _findIncidentSearchStart;
     if (elapsed > _FIND_INCIDENT_HARD_TIMEOUT_MS) {
       _findIncidentSearchStart = null;
+      _quietSearch = false;
       throw new Error(
         `findIncidentWithAlert: hard timeout after ${Math.round(elapsed / 60000)} minutes searching for "${alertName}"`
       );
     }
 
     cy.log(`incidentsPage.findIncidentWithAlert: Starting search for alert "${alertName}"`);
 
+    // Enable quiet mode to suppress Cypress DOM snapshots during the search.
+    // Each snapshot stores a serialized copy of the DOM (~1-5 MB). Without this,
+    // ~40 snapshots per search iteration * 15+ iterations = OOM in CI containers.
+    _quietSearch = true;
+
     incidentsPage.prepareIncidentsPageForSearch();
 
     return incidentsPage.elements.incidentsChartBarsVisiblePaths()
       .then(($paths) => {
         const totalPaths = $paths.length;
         if (totalPaths === 0) {
           cy.log('No visible incident bar paths found in chart');
-          return cy.wrap(false);
+          return cy.wrap(false, { log: false });
         }
 
         return incidentsPage.traverseAllIncidentsBars(alertName, totalPaths);
       })
       .then((found: boolean) => {
+        _quietSearch = false;
         if (found) {
-          _findIncidentSearchStart = null; // Reset on success
+          _findIncidentSearchStart = null;
         }
         return found;
       });