chore: Attach fatal run errors to the active test for Cloud results (#33617)

Author: emilyrohrbough

packages/server/lib/errors.ts

@@ -28,5 +28,3 @@ export const warning = errors.warning
 export const throwErr = errors.throwErr
 
 export const cloneErr = errors.cloneErr
-
-export const stripAnsi = errors.stripAnsi

packages/server/lib/util/graceful_crash_handling.ts

@@ -1,20 +1,38 @@
 import type { ProjectBase } from '../project-base'
 import type { BaseReporterResults, ReporterResults } from '../types/reporter'
-import * as errors from '../errors'
+import { log, stackUtils, stripAnsi } from '@packages/errors'
 import Debug from 'debug'
 import pDefer, { DeferredPromise } from 'p-defer'
 
 const debug = Debug('cypress:util:crash_handling')
 
-const patchRunResultsAfterCrash = (error: Error, reporterResults: ReporterResults, mostRecentRunnable: any): ReporterResults => {
+/** Matches attempt `error` shape from `reporter.js` `normalizeTest` for Cypress Cloud. */
+export const fatalErrorToAttemptError = (error: Error) => {
+  const codeFrame = (error as { codeFrame?: unknown }).codeFrame
+  const stackLines = error.stack ? stackUtils.stackWithoutMessage(error.stack) : undefined
+
+  return {
+    name: error.name,
+    message: stripAnsi(error.message),
+    stack: stackLines !== undefined ? stripAnsi(stackLines) : undefined,
+    ...(codeFrame !== undefined ? { codeFrame } : {}),
+  }
+}
+
+export const patchRunResultsAfterCrash = (
+  error: Error,
+  reporterResults: ReporterResults,
+  mostRecentRunnable: { id?: string } | undefined,
+): ReporterResults => {
   const endTime: number = reporterResults?.stats?.wallClockEndedAt ? Date.parse(reporterResults?.stats?.wallClockEndedAt) : new Date().getTime()
   const wallClockDuration = reporterResults?.stats?.wallClockStartedAt ?
     endTime - Date.parse(reporterResults.stats.wallClockStartedAt) : 0
   const endTimeStamp = new Date(endTime).toJSON()
 
   // in crash situations, the most recent report will not have the triggering test
   // so the results are manually patched, which produces the expected exit=1 and
-  // terminal output indicating the failed test
+  // terminal output indicating the failed test. Per-attempt `error` + `displayError`
+  // are set so Cypress Cloud can show the fatal/config message on the impacted test.
   return {
     ...reporterResults,
     stats: {
@@ -32,29 +50,32 @@ const patchRunResultsAfterCrash = (error: Error, reporterResults: ReporterResult
       failures: (reporterResults?.reporterStats?.failures ?? 0) + 1,
     },
     tests: (reporterResults?.tests || []).map((test) => {
-      if (test.testId === mostRecentRunnable.id) {
+      if (test.testId === mostRecentRunnable?.id) {
+        const prevAttempts = test.attempts.slice(0, -1)
+        const lastAttempt = test.attempts[test.attempts.length - 1]
+        const attemptError = fatalErrorToAttemptError(error)
+
         return {
           ...test,
           state: 'failed',
-          attempts: [
-            ...test.attempts.slice(0, -1),
-            {
-              ...test.attempts[test.attempts.length - 1],
-              state: 'failed',
-            },
-          ],
+          displayError: stripAnsi(error.stack || error.message),
+          attempts: [...prevAttempts, {
+            ...lastAttempt,
+            state: 'failed',
+            error: attemptError,
+          }],
         }
       }
 
       return test
     }),
-    error: errors.stripAnsi(error.message),
+    error: stripAnsi(error.message),
   }
 }
 
 const defaultStats = (error: Error): BaseReporterResults => {
   return {
-    error: errors.stripAnsi(error.message),
+    error: stripAnsi(error.message),
     stats: {
       failures: 1,
       tests: 0,
@@ -104,7 +125,7 @@ export class EarlyExitTerminator {
 
     // eslint-disable-next-line no-console
     console.log('')
-    errors.log(error)
+    log(error)
 
     const runResults: BaseReporterResults = (this.intermediateStats && this.pendingRunnable) ?
       patchRunResultsAfterCrash(error, this.intermediateStats, this.pendingRunnable) :

packages/server/test/unit/util/graceful_crash_handling_spec.ts

@@ -0,0 +1,178 @@
+// Intentionally omit spec_helper: it pulls in lib/cache before this file's imports; that chain
+// fails under some Node/ts-node setups. Chai's `expect` is sufficient for this pure unit test.
+import { expect } from 'chai'
+
+import type { ReporterResults } from '../../../lib/types/reporter'
+import { patchRunResultsAfterCrash } from '../../../lib/util/graceful_crash_handling'
+
+const baseReporterResults = (): ReporterResults => ({
+  reporter: 'spec',
+  reporterStats: {
+    suites: 1,
+    tests: 1,
+    passes: 0,
+    pending: 0,
+    failures: 0,
+    start: new Date(0).toJSON(),
+    end: new Date(0).toJSON(),
+    duration: 0,
+  },
+  hooks: [],
+  stats: {
+    failures: 0,
+    tests: 1,
+    passes: 0,
+    pending: 0,
+    suites: 1,
+    skipped: 1,
+    wallClockDuration: 0,
+    wallClockStartedAt: new Date(0).toJSON(),
+    wallClockEndedAt: new Date(0).toJSON(),
+  },
+  tests: [
+    {
+      testId: 'r1',
+      title: ['Suite', 'fails on crash'],
+      state: 'skipped',
+      body: '',
+      displayError: null,
+      attempts: [{
+        state: 'skipped',
+        error: null,
+        timings: null,
+        failedFromHookId: null,
+        wallClockStartedAt: new Date(0),
+        wallClockDuration: 0,
+        videoTimestamp: null,
+      }],
+    },
+  ],
+})
+
+describe('lib/util/graceful_crash_handling', () => {
+  describe('patchRunResultsAfterCrash', () => {
+    it('sets last attempt error and displayError when runnable id matches', () => {
+      const fatal = new Error('Your configFile threw an error')
+
+      fatal.stack = `Error: Your configFile threw an error\n    at cfg (cypress.config.js:1:1)`
+
+      const out = patchRunResultsAfterCrash(fatal, baseReporterResults(), { id: 'r1' })
+
+      expect(out.error).to.include('Your configFile threw an error')
+
+      const test = out.tests[0]
+
+      expect(test.state).to.eq('failed')
+      expect(test.displayError).to.eq(fatal.stack)
+      expect(test.attempts).to.have.length(1)
+      expect(test.attempts[0].state).to.eq('failed')
+      expect(test.attempts[0].error).to.include({
+        name: 'Error',
+        message: 'Your configFile threw an error',
+      })
+
+      expect(test.attempts[0].error.stack).to.eq(`    at cfg (cypress.config.js:1:1)`)
+    })
+
+    it('serializes attempt stack without message line (matches reporter normalizeTest)', () => {
+      const err = new Error('config blew up')
+
+      err.stack = `Error: config blew up\n    at foo (bar.js:1:1)`
+
+      const out = patchRunResultsAfterCrash(err, baseReporterResults(), { id: 'r1' })
+      const attemptErr = out.tests[0].attempts[0].error
+
+      expect(attemptErr?.name).to.eq('Error')
+      expect(attemptErr?.message).to.eq('config blew up')
+      expect(attemptErr?.stack).to.eq(`    at foo (bar.js:1:1)`)
+    })
+
+    it('strips ANSI from displayError and attempt fields for Cypress errors', () => {
+      const fatal = new Error(
+        'Your \u001b[33mconfigFile\u001b[39m threw an error from: \u001b[94mcypress.config.js\u001b[39m\n\nWe stopped running your tests because your config file crashed.',
+      )
+
+      fatal.stack = `${fatal.message}\n    at x (y:1:1)`
+
+      const out = patchRunResultsAfterCrash(fatal, baseReporterResults(), { id: 'r1' })
+
+      expect(out.tests[0].displayError).to.not.include('\u001b[')
+      expect(out.tests[0].attempts[0].error?.message).to.not.include('\u001b[')
+      expect(out.tests[0].attempts[0].error?.message).to.include('configFile')
+      expect(out.tests[0].attempts[0].error?.message).to.include('cypress.config.js')
+      expect(out.tests[0].attempts[0].error?.stack).to.not.include('\u001b[')
+    })
+
+    it('does not throw and does not patch tests when mostRecentRunnable is undefined', () => {
+      const fatal = new Error('boom')
+      const results = baseReporterResults()
+      const out = patchRunResultsAfterCrash(fatal, results, undefined)
+
+      expect(out.tests[0].state).to.eq('skipped')
+      expect(out.tests[0].attempts[0].error).to.eq(null)
+    })
+
+    it('does not patch test when runnable id does not match a test (stats still reflect fatal)', () => {
+      const fatal = new Error('config process died')
+      const results = baseReporterResults()
+
+      results.tests.push({
+        testId: 'r2',
+        title: ['Suite', 'other'],
+        state: 'passed',
+        body: '',
+        displayError: null,
+        attempts: [{
+          state: 'passed',
+          error: null,
+          timings: null,
+          failedFromHookId: null,
+          wallClockStartedAt: new Date(0),
+          wallClockDuration: 1,
+          videoTimestamp: null,
+        }],
+      })
+
+      const out = patchRunResultsAfterCrash(fatal, results, { id: 'nonexistent' })
+
+      expect(out.tests[0].state).to.eq('skipped')
+      expect(out.tests[0].attempts[0].error).to.eq(null)
+      expect(out.tests[1].state).to.eq('passed')
+      expect(out.tests[1].attempts[0].error).to.eq(null)
+      expect(out.stats.failures).to.equal(results.stats.failures + 1)
+    })
+
+    it('only replaces the last attempt when there are prior attempts (retries)', () => {
+      const fatal = new Error('tab crashed')
+      const results = baseReporterResults()
+
+      results.tests[0].attempts = [
+        {
+          state: 'failed',
+          error: { name: 'Error', message: 'first flake', stack: 'at a' },
+          timings: null,
+          failedFromHookId: null,
+          wallClockStartedAt: new Date(0),
+          wallClockDuration: 1,
+          videoTimestamp: null,
+        },
+        {
+          state: 'skipped',
+          error: null,
+          timings: null,
+          failedFromHookId: null,
+          wallClockStartedAt: new Date(1),
+          wallClockDuration: 0,
+          videoTimestamp: null,
+        },
+      ]
+
+      const out = patchRunResultsAfterCrash(fatal, results, { id: 'r1' })
+
+      expect(out.tests[0].attempts).to.have.length(2)
+      expect(out.tests[0].attempts[0].error).to.deep.include({ message: 'first flake' })
+      expect(out.tests[0].attempts[1].state).to.eq('failed')
+      expect(out.tests[0].attempts[1].error?.message).to.eq('tab crashed')
+    })
+  })
+})

system-tests/test/record_spec.js

@@ -2721,6 +2721,18 @@ describe('e2e record', () => {
             expect(postResultsRequest.body.stats.passes).to.equal(1)
             expect(postResultsRequest.body.stats.failures).to.equal(1)
             expect(postResultsRequest.body.stats.skipped).to.equal(0)
+
+            // Early-exit crash patching should attach structured error to the impacted test for Cloud
+            const failedWithCrashOnAttempt = postResultsRequest.body.tests.filter((t) => {
+              if (t.state !== 'failed' || !t.attempts?.length) return false
+
+              const err = t.attempts[t.attempts.length - 1].error
+
+              return err && err.message && err.message.includes('Chrome')
+            })
+
+            expect(failedWithCrashOnAttempt, 'failed test should carry crash error on last attempt').to.have.length.greaterThan(0)
+            expect(failedWithCrashOnAttempt[0].displayError).to.be.a('string').and.not.empty
           })
         })
       })