dd-trace 5.83.0 → 5.85.0

package/packages/datadog-instrumentations/src/jest.js

@@ -13,17 +13,18 @@ const {
   getIsFaultyEarlyFlakeDetection,
   JEST_WORKER_LOGS_PAYLOAD_CODE,
   getTestEndLine,
-  isModifiedTest
+  isModifiedTest,
 } = require('../../dd-trace/src/plugins/util/test')
 const {
   getFormattedJestTestParameters,
   getJestTestName,
-  getJestSuitesToRun
+  getJestSuitesToRun,
 } = require('../../datadog-plugin-jest/src/util')
 const { addHook, channel } = require('./helpers/instrument')
 
 const testSessionStartCh = channel('ci:jest:session:start')
 const testSessionFinishCh = channel('ci:jest:session:finish')
+const codeCoverageReportCh = channel('ci:jest:coverage-report')
 
 const testSessionConfigurationCh = channel('ci:jest:session:configuration')
 
@@ -91,6 +92,7 @@ const wrappedWorkers = new WeakSet()
 const testSuiteMockedFiles = new Map()
 const testsToBeRetried = new Set()
 const testSuiteAbsolutePathsWithFastCheck = new Set()
+const testSuiteJestObjects = new Map()
 
 const BREAKPOINT_HIT_GRACE_PERIOD_MS = 200
 const ATR_RETRY_SUPPRESSION_FLAG = '_ddDisableAtrRetry'
@@ -237,6 +239,28 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       }
     }
 
+    /**
+     * Jest mock state issue during test retries
+     *
+     * Problem:
+     * - Jest tracks mock function calls using internal state (call count, call arguments, etc.)
+     * - When a test is retried, the mock state is not automatically reset
+     * - This causes assertions like `toHaveBeenCalledTimes(1)` to fail because the call count
+     *   accumulates across retries
+     *
+     * The solution is to clear all mocks before each retry attempt.
+     */
+    resetMockState () {
+      try {
+        const jestObject = testSuiteJestObjects.get(this.testSuiteAbsolutePath)
+        if (jestObject?.clearAllMocks) {
+          jestObject.clearAllMocks()
+        }
+      } catch (e) {
+        log.warn('Error resetting mock state', e)
+      }
+    }
+
     // This function returns an array if the known tests are valid and null otherwise.
     getKnownTestsForSuite (suiteKnownTests) {
       // `suiteKnownTests` is `this.testEnvironmentOptions._ddKnownTests`,
@@ -261,7 +285,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         return {
           attemptToFix: [],
           disabled: [],
-          quarantined: []
+          quarantined: [],
         }
       }
       let testManagementTestsForSuite = testManagementTests
@@ -274,10 +298,10 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       const result = {
         attemptToFix: [],
         disabled: [],
-        quarantined: []
+        quarantined: [],
       }
 
-      Object.entries(testManagementTestsForSuite).forEach(([testName, { properties }]) => {
+      for (const [testName, { properties }] of Object.entries(testManagementTestsForSuite)) {
         if (properties?.attempt_to_fix) {
           result.attemptToFix.push(testName)
         }
@@ -287,7 +311,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         if (properties?.quarantined) {
           result.quarantined.push(testName)
         }
-      })
+      }
 
       return result
     }
@@ -296,7 +320,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
     retryTest ({
       jestEvent,
       retryCount,
-      retryType
+      retryType,
     }) {
       const { testName, fn, timeout } = jestEvent
       for (let retryIndex = 0; retryIndex < retryCount; retryIndex++) {
@@ -339,8 +363,9 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       if (event.name === 'test_start') {
         const testName = getJestTestName(event.test, this.getShouldStripSeedFromTestName())
         if (testsToBeRetried.has(testName)) {
-          // This is needed because we're trying tests with the same name
+          // This is needed because we're retrying tests with the same name
           this.resetSnapshotState()
+          this.resetMockState()
         }
 
         let isNewTest = false
@@ -404,7 +429,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           isDisabled,
           isQuarantined,
           isModified,
-          testSuiteAbsolutePath: this.testSuiteAbsolutePath
+          testSuiteAbsolutePath: this.testSuiteAbsolutePath,
         }
         testContexts.set(event.test, ctx)
 
@@ -451,7 +476,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           this.retryTest({
             jestEvent: event,
             retryCount: testManagementAttemptToFixRetries,
-            retryType: 'Test Management (Attempt to Fix)'
+            retryType: 'Test Management (Attempt to Fix)',
           })
         }
         if (!isAttemptToFix && this.isImpactedTestsEnabled) {
@@ -470,7 +495,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             this.retryTest({
               jestEvent: event,
               retryCount: earlyFlakeDetectionNumRetries,
-              retryType: 'Impacted tests'
+              retryType: 'Impacted tests',
             })
           }
         }
@@ -483,7 +508,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
               this.retryTest({
                 jestEvent: event,
                 retryCount: earlyFlakeDetectionNumRetries,
-                retryType: 'Early flake detection'
+                retryType: 'Early flake detection',
               })
             }
           }
@@ -536,8 +561,8 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
 
         let isEfdRetry = false
         // We'll store the test statuses of the retries
+        const testName = getJestTestName(event.test, this.getShouldStripSeedFromTestName())
         if (this.isKnownTestsEnabled) {
-          const testName = getJestTestName(event.test, this.getShouldStripSeedFromTestName())
           const isNewTest = retriedTestsToNumAttempts.has(testName)
           if (isNewTest) {
             if (newTestsTestStatuses.has(testName)) {
@@ -552,18 +577,27 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         const promises = {}
         const numRetries = this.global[RETRY_TIMES]
         const numTestExecutions = event.test?.invocations
-        const willBeRetried = numRetries > 0 && numTestExecutions - 1 < numRetries
+        const willBeRetriedByFailedTestReplay = numRetries > 0 && numTestExecutions - 1 < numRetries
         const mightHitBreakpoint = this.isDiEnabled && numTestExecutions >= 2
 
         const ctx = testContexts.get(event.test)
 
+        const finalStatus = this.getFinalStatus(testName,
+          status,
+          !!ctx?.isNew,
+          !!ctx?.isModified,
+          isEfdRetry,
+          isAttemptToFix,
+          numTestExecutions)
+
         if (status === 'fail') {
-          const shouldSetProbe = this.isDiEnabled && willBeRetried && numTestExecutions === 1
+          const shouldSetProbe = this.isDiEnabled && willBeRetriedByFailedTestReplay && numTestExecutions === 1
           testErrCh.publish({
             ...ctx.currentStore,
             error: formatJestError(event.test.errors[0]),
             shouldSetProbe,
-            promises
+            promises,
+            finalStatus,
           })
         }
 
@@ -589,7 +623,8 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           attemptToFixPassed,
           failedAllTests,
           attemptToFixFailed,
-          isAtrRetry
+          isAtrRetry,
+          finalStatus,
         })
 
         if (promises.isProbeReady) {
@@ -611,13 +646,102 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             testSourceFile: this.testSourceFile,
             displayName: this.displayName,
             frameworkVersion: jestVersion,
-            testStartLine: getTestLineStart(event.test.asyncError, this.testSuite)
+            testStartLine: getTestLineStart(event.test.asyncError, this.testSuite),
           },
-          isDisabled: this.testManagementTestsForThisSuite?.disabled?.includes(testName)
+          isDisabled: this.testManagementTestsForThisSuite?.disabled?.includes(testName),
         })
       }
     }
 
+    getEfdResult ({ testName, isNewTest, isModifiedTest, isEfdRetry, numberOfExecutedRetries }) {
+      const isEfdEnabled = this.isEarlyFlakeDetectionEnabled
+      const isEfdActive = isEfdEnabled && (isNewTest || isModifiedTest)
+      const isLastEfdRetry = isEfdRetry && numberOfExecutedRetries >= (earlyFlakeDetectionNumRetries + 1)
+      const isFinalEfdTestExecution = isEfdActive && isLastEfdRetry
+
+      let finalStatus
+      if (isEfdActive && isFinalEfdTestExecution) {
+        // For EFD: The framework reports 'pass' if ANY attempt passed (flaky but not failing)
+        const testStatuses = newTestsTestStatuses.get(testName)
+        finalStatus = testStatuses && testStatuses.includes('pass') ? 'pass' : 'fail'
+      }
+
+      return { isEfdEnabled, isEfdActive, isFinalEfdTestExecution, finalStatus }
+    }
+
+    getAtrResult ({ status, isEfdRetry, isAttemptToFix, numberOfTestInvocations }) {
+      const isAtrEnabled =
+        this.isFlakyTestRetriesEnabled &&
+        !isEfdRetry &&
+        !isAttemptToFix &&
+        Number.isFinite(this.global[RETRY_TIMES])
+      const isLastAtrRetry =
+        status === 'pass' || numberOfTestInvocations >= (Number(this.global[RETRY_TIMES]) + 1)
+      const isFinalAtrTestExecution = isAtrEnabled && isLastAtrRetry
+
+      // For ATR: The last execution's status is what the framework reports
+      return { isAtrEnabled, isFinalAtrTestExecution, finalStatus: status }
+    }
+
+    getAttemptToFixResult ({ testName, isAttemptToFix, numberOfExecutedRetries }) {
+      const isAttemptToFixEnabled =
+        this.isTestManagementTestsEnabled &&
+        isAttemptToFix &&
+        Number.isFinite(testManagementAttemptToFixRetries)
+      const isFinalAttemptToFixExecution = isAttemptToFixEnabled &&
+        numberOfExecutedRetries >= (testManagementAttemptToFixRetries + 1)
+
+      let finalStatus
+      if (isAttemptToFixEnabled && isFinalAttemptToFixExecution) {
+        // For Attempt to Fix: 'pass' only if ALL attempts passed, 'fail' if ANY failed
+        const testStatuses = attemptToFixRetriedTestsStatuses.get(testName)
+        finalStatus = testStatuses && testStatuses.every(status => status === 'pass') ? 'pass' : 'fail'
+      }
+
+      return { isAttemptToFixEnabled, isFinalAttemptToFixExecution, finalStatus }
+    }
+
+    getFinalStatus (testName, status, isNewTest, isModifiedTest, isEfdRetry, isAttemptToFix, numberOfTestInvocations) {
+      const numberOfExecutedRetries = retriedTestsToNumAttempts.get(testName) ?? 0
+
+      const efdResult = this.getEfdResult({
+        testName,
+        isNewTest,
+        isModifiedTest,
+        isEfdRetry,
+        numberOfExecutedRetries,
+      })
+      const atrResult = this.getAtrResult({ status, isEfdRetry, isAttemptToFix, numberOfTestInvocations })
+      const attemptToFixResult = this.getAttemptToFixResult({
+        testName,
+        isAttemptToFix,
+        numberOfExecutedRetries,
+      })
+
+      // When no retry features are active, every test execution is final
+      const noRetryFeaturesActive =
+        !efdResult.isEfdActive &&
+        !atrResult.isAtrEnabled &&
+        !attemptToFixResult.isAttemptToFixEnabled
+      const isFinalTestExecution = noRetryFeaturesActive ||
+        efdResult.isFinalEfdTestExecution ||
+        atrResult.isFinalAtrTestExecution ||
+        attemptToFixResult.isFinalAttemptToFixExecution
+
+      if (!isFinalTestExecution) {
+        return
+      }
+
+      // If the test is quarantined, regardless of its actual execution result,
+      // the final status of its last execution should be reported as 'skip'.
+      if (this.isTestManagementTestsEnabled &&
+        this.testManagementTestsForThisSuite?.quarantined?.includes(testName)) {
+        return 'skip'
+      }
+
+      return efdResult.finalStatus || attemptToFixResult.finalStatus || atrResult.finalStatus
+    }
+
     teardown () {
       if (this._globalProxy?.propertyToValue) {
         for (const [key] of this._globalProxy.propertyToValue) {
@@ -643,7 +767,7 @@ function getTestEnvironment (pkg, jestVersion) {
           return wrappedTestEnvironment
         }
         return target[prop]
-      }
+      },
     })
   }
   return getWrappedEnvironment(pkg, jestVersion)
@@ -652,9 +776,7 @@ function getTestEnvironment (pkg, jestVersion) {
 function applySuiteSkipping (originalTests, rootDir, frameworkVersion) {
   const jestSuitesToRun = getJestSuitesToRun(skippableSuites, originalTests, rootDir || process.cwd())
   hasFilteredSkippableSuites = true
-  log.debug(
-    () => `${jestSuitesToRun.suitesToRun.length} out of ${originalTests.length} suites are going to run.`
-  )
+  log.debug('%d out of %d suites are going to run.', jestSuitesToRun.suitesToRun.length, originalTests.length)
   hasUnskippableSuites = jestSuitesToRun.hasUnskippableSuites
   hasForcedToRunSuites = jestSuitesToRun.hasForcedToRunSuites
 
@@ -668,17 +790,17 @@ function applySuiteSkipping (originalTests, rootDir, frameworkVersion) {
 
 addHook({
   name: 'jest-environment-node',
-  versions: ['>=24.8.0']
+  versions: ['>=24.8.0'],
 }, getTestEnvironment)
 
 addHook({
   name: 'jest-environment-jsdom',
-  versions: ['>=24.8.0']
+  versions: ['>=24.8.0'],
 }, getTestEnvironment)
 
 addHook({
   name: '@happy-dom/jest-environment',
-  versions: ['>=10.0.0']
+  versions: ['>=10.0.0'],
 }, getTestEnvironment)
 
 function getWrappedScheduleTests (scheduleTests, frameworkVersion) {
@@ -864,13 +986,12 @@ function getCliWrapper (isNewJestVersion) {
 
       const {
         results: {
-          success,
           coverageMap,
           numFailedTestSuites,
           numFailedTests,
           numTotalTests,
-          numTotalTestSuites
-        }
+          numTotalTestSuites,
+        },
       } = result
 
       let testCodeCoverageLinesTotal
@@ -883,53 +1004,6 @@ function getCliWrapper (isNewJestVersion) {
           // ignore errors
         }
       }
-      let status, error
-
-      if (success) {
-        status = numTotalTests === 0 && numTotalTestSuites === 0 ? 'skip' : 'pass'
-      } else {
-        status = 'fail'
-        error = new Error(`Failed test suites: ${numFailedTestSuites}. Failed tests: ${numFailedTests}`)
-      }
-      let timeoutId
-
-      // Pass the resolve callback to defer it to DC listener
-      const flushPromise = new Promise((resolve) => {
-        onDone = () => {
-          clearTimeout(timeoutId)
-          resolve()
-        }
-      })
-
-      const timeoutPromise = new Promise((resolve) => {
-        timeoutId = setTimeout(() => {
-          resolve('timeout')
-        }, FLUSH_TIMEOUT).unref()
-      })
-
-      testSessionFinishCh.publish({
-        status,
-        isSuitesSkipped,
-        isSuitesSkippingEnabled,
-        isCodeCoverageEnabled,
-        testCodeCoverageLinesTotal,
-        numSkippedSuites,
-        hasUnskippableSuites,
-        hasForcedToRunSuites,
-        error,
-        isEarlyFlakeDetectionEnabled,
-        isEarlyFlakeDetectionFaulty,
-        isTestManagementTestsEnabled,
-        onDone
-      })
-
-      const waitingResult = await Promise.race([flushPromise, timeoutPromise])
-
-      if (waitingResult === 'timeout') {
-        log.error('Timeout waiting for the tracer to flush')
-      }
-
-      numSkippedSuites = 0
 
       /**
        * If Early Flake Detection (EFD) is enabled the logic is as follows:
@@ -938,7 +1012,6 @@ function getCliWrapper (isNewJestVersion) {
        * The rationale behind is the following: you may still be able to block your CI pipeline by gating
        * on flakiness (the test will be considered flaky), but you may choose to unblock the pipeline too.
        */
-
       if (isEarlyFlakeDetectionEnabled) {
         let numFailedTestsToIgnore = 0
         for (const testStatuses of newTestsTestStatuses.values()) {
@@ -996,9 +1069,65 @@ function getCliWrapper (isNewJestVersion) {
         }
       }
 
+      // Determine session status after EFD and quarantine checks have potentially modified success
+      let status, error
+      if (result.results.success) {
+        status = numTotalTests === 0 && numTotalTestSuites === 0 ? 'skip' : 'pass'
+      } else {
+        status = 'fail'
+        error = new Error(`Failed test suites: ${numFailedTestSuites}. Failed tests: ${numFailedTests}`)
+      }
+
+      let timeoutId
+
+      // Pass the resolve callback to defer it to DC listener
+      const flushPromise = new Promise((resolve) => {
+        onDone = () => {
+          clearTimeout(timeoutId)
+          resolve()
+        }
+      })
+
+      const timeoutPromise = new Promise((resolve) => {
+        timeoutId = setTimeout(() => {
+          resolve('timeout')
+        }, FLUSH_TIMEOUT).unref()
+      })
+
+      testSessionFinishCh.publish({
+        status,
+        isSuitesSkipped,
+        isSuitesSkippingEnabled,
+        isCodeCoverageEnabled,
+        testCodeCoverageLinesTotal,
+        numSkippedSuites,
+        hasUnskippableSuites,
+        hasForcedToRunSuites,
+        error,
+        isEarlyFlakeDetectionEnabled,
+        isEarlyFlakeDetectionFaulty,
+        isTestManagementTestsEnabled,
+        onDone,
+      })
+
+      const waitingResult = await Promise.race([flushPromise, timeoutPromise])
+
+      if (waitingResult === 'timeout') {
+        log.error('Timeout waiting for the tracer to flush')
+      }
+
+      if (codeCoverageReportCh.hasSubscribers) {
+        const rootDir = result.globalConfig?.rootDir || process.cwd()
+        await new Promise((resolve) => {
+          codeCoverageReportCh.publish({ rootDir, onDone: resolve })
+        })
+      }
+
+      numSkippedSuites = 0
+
       return result
     }, {
-      replaceGetter: true
+      replaceGetter: true,
     })
   }
 }
@@ -1027,7 +1156,7 @@ function coverageReporterWrapper (coverageReporter) {
 addHook({
   name: '@jest/core',
   file: 'build/TestScheduler.js',
-  versions: ['>=27.0.0']
+  versions: ['>=27.0.0'],
 }, (testSchedulerPackage, frameworkVersion) => {
   const oldCreateTestScheduler = testSchedulerPackage.createTestScheduler
   const newCreateTestScheduler = async function () {
@@ -1046,7 +1175,7 @@ addHook({
 addHook({
   name: '@jest/core',
   file: 'build/TestScheduler.js',
-  versions: ['>=24.8.0 <27.0.0']
+  versions: ['>=24.8.0 <27.0.0'],
 }, (testSchedulerPackage, frameworkVersion) => {
   shimmer.wrap(
     testSchedulerPackage.default.prototype,
@@ -1057,7 +1186,7 @@ addHook({
 
 addHook({
   name: '@jest/test-sequencer',
-  versions: ['>=28']
+  versions: ['>=28'],
 }, (sequencerPackage, frameworkVersion) => {
   shimmer.wrap(sequencerPackage.default.prototype, 'shard', shard => function () {
     const shardedTests = shard.apply(this, arguments)
@@ -1076,18 +1205,18 @@ addHook({
 addHook({
   name: '@jest/reporters',
   file: 'build/coverage_reporter.js',
-  versions: ['>=24.8.0 <26.6.2']
+  versions: ['>=24.8.0 <26.6.2'],
 }, coverageReporterWrapper)
 
 addHook({
   name: '@jest/reporters',
   file: 'build/CoverageReporter.js',
-  versions: ['>=26.6.2']
+  versions: ['>=26.6.2'],
 }, coverageReporterWrapper)
 
 addHook({
   name: '@jest/reporters',
-  versions: ['>=30.0.0']
+  versions: ['>=30.0.0'],
 }, (reporters) => {
   return shimmer.wrap(reporters, 'CoverageReporter', coverageReporterWrapper, { replaceGetter: true })
 })
@@ -1095,12 +1224,12 @@ addHook({
 addHook({
   name: '@jest/core',
   file: 'build/cli/index.js',
-  versions: ['>=24.8.0 <30.0.0']
+  versions: ['>=24.8.0 <30.0.0'],
 }, getCliWrapper(false))
 
 addHook({
   name: '@jest/core',
-  versions: ['>=30.0.0']
+  versions: ['>=30.0.0'],
 }, getCliWrapper(true))
 
 function jestAdapterWrapper (jestAdapter, jestVersion) {
@@ -1116,7 +1245,7 @@ function jestAdapterWrapper (jestAdapter, jestVersion) {
       testSourceFile: environment.testSourceFile,
       displayName: environment.displayName,
       frameworkVersion: jestVersion,
-      testSuiteAbsolutePath: environment.testSuiteAbsolutePath
+      testSuiteAbsolutePath: environment.testSuiteAbsolutePath,
     })
     return adapter.apply(this, arguments).then(suiteResults => {
       const { numFailingTests, skipped, failureMessage: errorMessage } = suiteResults
@@ -1144,13 +1273,23 @@ function jestAdapterWrapper (jestAdapter, jestVersion) {
           coverageFiles,
           testSuite: environment.testSourceFile,
           mockedFiles,
-          testSuiteAbsolutePath: environment.testSuiteAbsolutePath
+          testSuiteAbsolutePath: environment.testSuiteAbsolutePath,
         })
       }
       testSuiteFinishCh.publish({ status, errorMessage, testSuiteAbsolutePath: environment.testSuiteAbsolutePath })
+
+      // Cleanup per-suite state to avoid memory leaks
+      testSuiteMockedFiles.delete(environment.testSuiteAbsolutePath)
+      testSuiteJestObjects.delete(environment.testSuiteAbsolutePath)
+
       return suiteResults
     }).catch(error => {
       testSuiteFinishCh.publish({ status: 'fail', error, testSuiteAbsolutePath: environment.testSuiteAbsolutePath })
+
+      // Cleanup per-suite state to avoid memory leaks
+      testSuiteMockedFiles.delete(environment.testSuiteAbsolutePath)
+      testSuiteJestObjects.delete(environment.testSuiteAbsolutePath)
+
       throw error
     })
   })
@@ -1166,13 +1305,13 @@ function jestAdapterWrapper (jestAdapter, jestVersion) {
 addHook({
   name: 'jest-circus',
   file: 'build/runner.js',
-  versions: ['>=30.0.0']
+  versions: ['>=30.0.0'],
 }, jestAdapterWrapper)
 
 addHook({
   name: 'jest-circus',
   file: 'build/legacy-code-todo-rewrite/jestAdapter.js',
-  versions: ['>=24.8.0']
+  versions: ['>=24.8.0'],
 }, jestAdapterWrapper)
 
 function configureTestEnvironment (readConfigsResult) {
@@ -1180,9 +1319,9 @@ function configureTestEnvironment (readConfigsResult) {
   testSessionConfigurationCh.publish(configs.map(config => config.testEnvironmentOptions))
   // We can't directly use isCodeCoverageEnabled when reporting coverage in `jestAdapterWrapper`
   // because `jestAdapterWrapper` runs in a different process. We have to go through `testEnvironmentOptions`
-  configs.forEach(config => {
+  for (const config of configs) {
     config.testEnvironmentOptions._ddTestCodeCoverageEnabled = isCodeCoverageEnabled
-  })
+  }
 
   isUserCodeCoverageEnabled = !!readConfigsResult.globalConfig.collectCoverage
 
@@ -1193,7 +1332,7 @@ function configureTestEnvironment (readConfigsResult) {
   if (isCodeCoverageEnabled) {
     const globalConfig = {
       ...readConfigsResult.globalConfig,
-      collectCoverage: true
+      collectCoverage: true,
     }
     readConfigsResult.globalConfig = globalConfig
   }
@@ -1204,7 +1343,7 @@ function configureTestEnvironment (readConfigsResult) {
     const globalConfig = {
       ...readConfigsResult.globalConfig,
       coverageReporters: ['none'],
-      passWithNoTests: true
+      passWithNoTests: true,
     }
     readConfigsResult.globalConfig = globalConfig
   }
@@ -1231,7 +1370,7 @@ function jestConfigSyncWrapper (jestConfig) {
 addHook({
   name: '@jest/transform',
   versions: ['>=24.8.0'],
-  file: 'build/ScriptTransformer.js'
+  file: 'build/ScriptTransformer.js',
 }, transformPackage => {
   const originalCreateScriptTransformer = transformPackage.createScriptTransformer
 
@@ -1277,18 +1416,18 @@ addHook({
 addHook({
   name: '@jest/core',
   versions: ['>=24.8.0 <30.0.0'],
-  file: 'build/SearchSource.js'
+  file: 'build/SearchSource.js',
 }, searchSourceWrapper)
 
 // from 25.1.0 on, readConfigs becomes async
 addHook({
   name: 'jest-config',
-  versions: ['>=25.1.0']
+  versions: ['>=25.1.0'],
 }, jestConfigAsyncWrapper)
 
 addHook({
   name: 'jest-config',
-  versions: ['24.8.0 - 24.9.0']
+  versions: ['24.8.0 - 24.9.0'],
 }, jestConfigSyncWrapper)
 
 const LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE = new Set([
@@ -1299,12 +1438,12 @@ const LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE = new Set([
   'selenium-webdriver/firefox',
   'selenium-webdriver/ie',
   'selenium-webdriver/chromium',
-  'winston'
+  'winston',
 ])
 
 addHook({
   name: 'jest-runtime',
-  versions: ['>=24.8.0']
+  versions: ['>=24.8.0'],
 }, (runtimePackage) => {
   const Runtime = runtimePackage.default ?? runtimePackage
 
@@ -1312,6 +1451,11 @@ addHook({
     const result = _createJestObjectFor.apply(this, arguments)
     const suiteFilePath = this._testPath || from
 
+    // Store the jest object so we can access it later for resetting mock state
+    if (suiteFilePath) {
+      testSuiteJestObjects.set(suiteFilePath, result)
+    }
+
     shimmer.wrap(result, 'mock', mock => function (moduleName) {
       // If the library is mocked with `jest.mock`, we don't want to bypass jest's own require engine
       if (LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE.has(moduleName)) {
@@ -1356,12 +1500,12 @@ addHook({
           const errorMessage = [...this.loggedReferenceErrors][0]
           testSuiteErrorCh.publish({
             errorMessage,
-            testSuiteAbsolutePath: this._testPath
+            testSuiteAbsolutePath: this._testPath,
           })
         } else {
           testSuiteErrorCh.publish({
             errorMessage: 'An error occurred while importing a module',
-            testSuiteAbsolutePath: this._testPath
+            testSuiteAbsolutePath: this._testPath,
           })
         }
       }
@@ -1427,8 +1571,8 @@ function sendWrapper (send) {
           _ddTestManagementTests: suiteTestManagementTests,
           // TODO: figure out if we can reduce the size of the modified files object
           // Can we use `testSuite` (it'd have to be relative to repository root though)
-          _ddModifiedFiles: modifiedFiles
-        }
+          _ddModifiedFiles: modifiedFiles,
+        },
       }
     }
     return send.apply(this, arguments)
@@ -1460,7 +1604,7 @@ function enqueueWrapper (enqueue) {
 addHook({
   name: 'jest-worker',
   versions: ['>=24.9.0 <30.0.0'],
-  file: 'build/workers/ChildProcessWorker.js'
+  file: 'build/workers/ChildProcessWorker.js',
 }, (childProcessWorker) => {
   const ChildProcessWorker = childProcessWorker.default
   shimmer.wrap(ChildProcessWorker.prototype, 'send', sendWrapper)
@@ -1474,7 +1618,7 @@ addHook({
 
 addHook({
   name: 'jest-worker',
-  versions: ['>=30.0.0']
+  versions: ['>=30.0.0'],
 }, (jestWorkerPackage) => {
   shimmer.wrap(jestWorkerPackage.FifoQueue.prototype, 'enqueue', enqueueWrapper)
   shimmer.wrap(jestWorkerPackage.PriorityQueue.prototype, 'enqueue', enqueueWrapper)