Merge pull request #857 from DavidRajnoha/test/incident-coo-1.4.0-features

OBSINTA-993: Tests for incident detection coo 1.4.0 changes

Author: openshift-merge-bot[bot]

web/cypress/e2e/incidents/regression/02.reg_ui_tooltip_boundary_times.cy.ts

@@ -0,0 +1,165 @@
+/*
+Regression test for mixed severity interval boundary times (Section 2.3.3).
+
+Test 1 (OU-1205): Verifies tooltip End times at severity interval boundaries
+are rounded to 5-minute precision. Without rounding, consecutive interval end
+times can land on non-5-minute values (e.g., "10:58" instead of "11:00").
+
+Test 2 (OU-1221, XFAIL): Verifies Start times shown in incident tooltips match
+alert tooltips and alerts table, and that consecutive segment boundaries align
+with no 5-minute gap between End of one segment and Start of the next.
+*/
+
+import { incidentsPage } from '../../../views/incidents-page';
+
+const MCP = {
+  namespace: Cypress.env('COO_NAMESPACE'),
+  packageName: 'cluster-observability-operator',
+  operatorName: 'Cluster Observability Operator',
+  config: {
+    kind: 'UIPlugin',
+    name: 'monitoring',
+  },
+};
+
+const MP = {
+  namespace: 'openshift-monitoring',
+  operatorName: 'Cluster Monitoring Operator',
+};
+
+describe('Regression: Mixed Severity Interval Boundary Times', { tags: ['@incidents', '@xfail'] }, () => {
+
+  before(() => {
+    cy.beforeBlockCOO(MCP, MP, { dashboards: false, troubleshootingPanel: false });
+  });
+
+  beforeEach(() => {
+    cy.mockIncidentFixture('incident-scenarios/21-multi-severity-boundary-times.yaml');
+  });
+
+  const extractTime = (tooltipText: string, field: 'Start' | 'End'): string => {
+    const afterField = tooltipText.split(field)[1] || '';
+    const match = afterField.match(/(\d{1,2}:\d{2}(\s*[AP]M)?)/);
+    return match ? match[1].trim() : '';
+  };
+
+  it('1. Tooltip End times at severity boundaries show 5-minute rounded values', () => {
+    const verifyEndTimeRounded = (label: string) => {
+      incidentsPage.elements.tooltip()
+        .invoke('text')
+        .then((text) => {
+          cy.log(`${label} tooltip: "${text}"`);
+
+          if (text.match(/End.*---/)) {
+            cy.log(`${label}: Firing, End shows --- (skipped)`);
+            return;
+          }
+
+          const endPart = text.split('End')[1];
+          expect(endPart, `${label}: should contain End time`).to.exist;
+
+          const timeMatch = endPart.match(/(\d{1,2}):(\d{2})/);
+          expect(timeMatch, `${label}: End time should be parseable`).to.not.be.null;
+
+          const minutes = parseInt(timeMatch[2], 10);
+          const remainder = minutes % 5;
+          expect(remainder, `${label}: End minutes (${minutes}) should be divisible by 5, remainder=${remainder}`).to.equal(0);
+          cy.log(`${label}: End ${timeMatch[1]}:${timeMatch[2]} - minutes divisible by 5`);
+        });
+    };
+
+    cy.log('1.1 Verify multi-severity incident loaded');
+    incidentsPage.clearAllFilters();
+    incidentsPage.setDays('1 day');
+    incidentsPage.elements.incidentsChartContainer().should('be.visible');
+    incidentsPage.elements.incidentsChartBarsGroups().should('have.length', 1);
+
+    cy.log('1.2 Verify bar has multiple severity segments');
+    incidentsPage.getIncidentBarVisibleSegments(0).then((segments) => {
+      expect(segments.length, 'Multi-severity bar should have at least 2 visible segments')
+        .to.be.greaterThan(1);
+      cy.log(`Found ${segments.length} visible severity segments`);
+    });
+
+    cy.log('1.3 Check first segment end time (Info -> Warning boundary)');
+    incidentsPage.hoverOverIncidentBarSegment(0, 0);
+    verifyEndTimeRounded('First segment');
+
+    cy.log('1.4 Check second segment end time (Warning -> Critical boundary)');
+    incidentsPage.hoverOverIncidentBarSegment(0, 1);
+    verifyEndTimeRounded('Second segment');
+
+    cy.log('1.5 Check third segment end time (Critical end)');
+    incidentsPage.hoverOverIncidentBarSegment(0, 2);
+    verifyEndTimeRounded('Third segment');
+
+    cy.log('Verified: All tooltip End times at severity boundaries are at 5-minute precision (OU-1205)');
+  });
+
+  it('2. Start times match between incident tooltip, alert tooltip, and table; consecutive boundaries align',
+    () => {
+    cy.log('2.1 Setup: verify multi-severity incident loaded');
+    incidentsPage.clearAllFilters();
+    incidentsPage.setDays('1 day');
+    incidentsPage.elements.incidentsChartContainer().should('be.visible');
+    incidentsPage.elements.incidentsChartBarsGroups().should('have.length', 1);
+    cy.pause();
+
+    cy.log('2.2 Consecutive interval boundaries: End of segment 1 should equal Start of segment 2');
+    incidentsPage.hoverOverIncidentBarSegment(0, 0);
+    incidentsPage.elements.tooltip().invoke('text').then((firstText) => {
+      const firstEnd = extractTime(firstText, 'End');
+      cy.log(`First segment End: ${firstEnd}`);
+      expect(firstEnd, 'First segment End should be parseable').to.not.be.empty;
+
+      incidentsPage.hoverOverIncidentBarSegment(0, 1);
+      incidentsPage.elements.tooltip().invoke('text').then((secondText) => {
+        const secondStart = extractTime(secondText, 'Start');
+        cy.log(`Second segment Start: ${secondStart}`);
+        expect(secondStart, 'Second segment Start should be parseable').to.not.be.empty;
+        expect(secondStart,
+          `No 5-min gap: second Start (${secondStart}) should equal first End (${firstEnd})`
+        ).to.equal(firstEnd);
+      });
+    });
+    cy.pause();
+
+    cy.log('2.3 Incident tooltip Start vs alert tooltip Start vs alerts table Start');
+    incidentsPage.hoverOverIncidentBarSegment(0, 0);
+    incidentsPage.elements.tooltip().invoke('text').then((incidentText) => {
+      const incidentStart = extractTime(incidentText, 'Start');
+      cy.log(`Incident tooltip Start: ${incidentStart}`);
+      expect(incidentStart, 'Incident Start should be parseable').to.not.be.empty;
+
+      cy.log('2.4 Select incident and get alert tooltip Start');
+      incidentsPage.selectIncidentById('monitoring-multi-severity-boundary-001');
+      incidentsPage.elements.alertsChartCard().should('be.visible');
+
+      incidentsPage.hoverOverAlertBar(0);
+      incidentsPage.elements.alertsChartTooltip().invoke('text').then((alertText) => {
+        const alertStart = extractTime(alertText, 'Start');
+        cy.log(`Alert tooltip Start: ${alertStart}`);
+        expect(incidentStart,
+          `Incident Start (${incidentStart}) should match alert Start (${alertStart})`
+        ).to.equal(alertStart);
+      });
+
+      cy.log('2.5 Compare incident tooltip Start with alerts table Start');
+      incidentsPage.getSelectedIncidentAlerts().then((alerts) => {
+        expect(alerts.length, 'Should have at least 1 alert row').to.be.greaterThan(0);
+        alerts[0].getStartCell().invoke('text').then((cellText) => {
+          const tableMatch = cellText.trim().match(/(\d{1,2}:\d{2}(\s*[AP]M)?)/);
+          expect(tableMatch, 'Table Start time should be parseable').to.not.be.null;
+          const tableStart = tableMatch[1].trim();
+          cy.log(`Alerts table Start: ${tableStart}`);
+          expect(incidentStart,
+            `Incident Start (${incidentStart}) should match table Start (${tableStart})`
+          ).to.equal(tableStart);
+        });
+      });
+    });
+    cy.pause();
+
+    cy.log('Expected failure: Incident tooltip Start times are 5 minutes off (OU-1221)');
+  });
+});

web/cypress/e2e/incidents/regression/03.reg_api_calls.cy.ts

@@ -1,15 +1,20 @@
 /*
-Regression test for Silences Not Applied Correctly (Section 3.2)
+Regression tests for API Calls and Data Loading (Section 3)
 
-BUG: Silences were being matched by name only, not by name + namespace + severity.
-This test verifies that silence matching uses: alertname + namespace + severity.
+Tests:
+1. Silences Not Applied Correctly (Section 3.2)
+   BUG: Silences were being matched by name only, not by name + namespace + severity.
+   This test verifies that silence matching uses: alertname + namespace + severity.
 
-While targeting the bug, it verifies the basic Silences Implementation.
+2. Permission Denied Handling (Section 3.5)
+   Tests graceful handling of 403 Forbidden responses from rules/silences endpoints.
+   Incidents page should still function when user lacks permissions to view rules/silences.
 
-Verifies: OU-1020, OU-706
+Verifies: OU-1020, OU-706, OU-1213
 */
 
 import { incidentsPage } from '../../../views/incidents-page';
+import { nav } from '../../../views/nav';
 
 const MCP = {
   namespace: Cypress.env('COO_NAMESPACE'),
@@ -123,4 +128,39 @@ describe('Regression: Silences Not Applied Correctly', { tags: ['@incidents'] },
   });
 });
 
+describe('Regression: Permission Denied Handling', { tags: ['@incidents'] }, () => {
 
+  before(() => {
+    cy.beforeBlockCOO(MCP, MP, { dashboards: false, troubleshootingPanel: false });
+  });
+
+  beforeEach(() => {
+    cy.log('Mock all API endpoints as 403 Forbidden');
+    cy.mockPermissionDenied();
+    cy.log('Navigate to Observe -> Incidents');
+    // Using custom navigation commands to avoid waiting for the page to load which never happens in this test
+    nav.sidenav.clickNavLink(['Observe', 'Alerting']);
+    nav.tabs.switchTab('Incidents');
+
+  });
+
+  it('Page displays access denied state when all API endpoints return 403 Forbidden', () => {
+    cy.log('1.1 Verify 403 requests were intercepted');
+    const waitTimeout = { timeout: 120000 };
+    cy.wait('@rulesPermissionDenied', waitTimeout)
+      .its('response').should('exist')
+      .its('statusCode').should('eq', 403);
+    cy.wait('@silencesPermissionDenied', waitTimeout)
+      .its('response').should('exist')
+      .its('statusCode').should('eq', 403);
+    cy.wait('@prometheusQueryRangePermissionDenied', waitTimeout)
+      .its('response').should('exist')
+      .its('statusCode').should('eq', 403);
+
+    cy.log('1.2 Verify access denied empty state is displayed');
+    cy.byTestID('access-denied').should('be.visible');
+    cy.byTestID('access-denied').should('contain.text', 'You don\'t have access to this section due to cluster policy');
+
+    cy.log('Verified: Page displays restricted access state for permission denied');
+  });
+});

web/cypress/e2e/incidents/regression/05.reg_stress_testing_ui.cy.ts

@@ -0,0 +1,96 @@
+/*
+Regression tests for UI issues that manifest under stress conditions (high alert/incident counts).
+
+Section 5.1: Alerts chart padding with 100+ alerts (OU-1123)
+  - Height calculation should not produce excessive padding pushing bars below the visible area.
+  - A smaller gap with ~500+ alerts is accepted as a known limitation.
+
+Note: Stress fixtures use a short timeline (1h) to avoid a known Math.max/min call stack
+overflow when many alerts share a group_id with long timelines. The padding behavior under
+test is independent of timeline length. See WIP.stress-test-1000-alerts.cy.ts to reproduce
+the overflow with the original 5d timeline.
+*/
+
+import { incidentsPage } from '../../../views/incidents-page';
+
+const MCP = {
+  namespace: Cypress.env('COO_NAMESPACE'),
+  packageName: 'cluster-observability-operator',
+  operatorName: 'Cluster Observability Operator',
+  config: {
+    kind: 'UIPlugin',
+    name: 'monitoring',
+  },
+};
+
+const MP = {
+  namespace: 'openshift-monitoring',
+  operatorName: 'Cluster Monitoring Operator',
+};
+
+const MAX_GAP_STANDARD = 250;
+const MAX_GAP_RELAXED = 500;
+
+describe('Regression: Stress Testing UI', { tags: ['@incidents'] }, () => {
+
+  before(() => {
+    cy.beforeBlockCOO(MCP, MP, { dashboards: false, troubleshootingPanel: false });
+  });
+
+  it('5.1 No excessive padding between chart top and alert bars for 100, 200, and 500 alerts', () => {
+    const verifyAlertBarPadding = (
+      fixtureFile: string,
+      incidentId: string,
+      maxGap: number,
+      label: string
+    ) => {
+      cy.mockIncidentFixture(`incident-scenarios/${fixtureFile}`);
+      incidentsPage.clearAllFilters();
+      incidentsPage.setDays('1 day');
+
+      incidentsPage.elements.incidentsChartBarsGroups().should('have.length', 1);
+      incidentsPage.selectIncidentById(incidentId);
+
+      incidentsPage.elements.alertsChartCard().should('be.visible');
+      incidentsPage.elements.alertsChartBarsVisiblePaths()
+        .should('have.length.greaterThan', 0);
+
+      incidentsPage.elements.alertsChartContainer().first().scrollIntoView();
+      incidentsPage.elements.alertsChartContainer().first().then(($container) => {
+        const containerTop = $container[0].getBoundingClientRect().top;
+        incidentsPage.getAlertBarRect(0).then((barRect) => {
+          const gap = barRect.top - containerTop;
+          cy.log(`${label}: Gap between container top and first alert bar = ${gap}px`);
+          expect(gap, `${label}: first alert bar should start near chart top`).to.be.lessThan(maxGap);
+          expect(gap, `${label}: gap should be non-negative`).to.be.at.least(0);
+        });
+      });
+    };
+
+    cy.log('5.1.1 Verify no excessive padding with 100 alerts');
+    verifyAlertBarPadding(
+      '15-stress-test-100-alerts.yaml',
+      'cluster-wide-failure-100-alerts',
+      MAX_GAP_STANDARD,
+      '100 alerts'
+    );
+
+    cy.log('5.1.2 Verify no excessive padding with 200 alerts');
+    verifyAlertBarPadding(
+      '16-stress-test-200-alerts.yaml',
+      'cluster-wide-failure-200-alerts',
+      MAX_GAP_STANDARD,
+      '200 alerts'
+    );
+
+    cy.log('5.1.3 Verify accepted limitation with 500 alerts (relaxed threshold)');
+    verifyAlertBarPadding(
+      '17-stress-test-500-alerts.yaml',
+      'cluster-wide-failure-500-alerts',
+      MAX_GAP_RELAXED,
+      '500 alerts'
+    );
+
+    cy.log('Verified: Alert bars have no excessive padding for 100, 200, and 500 alerts');
+  });
+});