dd-trace 5.110.0 → 5.112.0

package/packages/dd-trace/src/ci-visibility/exporters/git/git_metadata.js

@@ -50,7 +50,7 @@ function getCommonRequestOptions (url) {
   return {
     method: 'POST',
     headers: {
-      'dd-api-key': getConfig().apiKey,
+      'dd-api-key': getConfig().DD_API_KEY,
     },
     timeout: 15_000,
     url,
@@ -287,7 +287,7 @@ function sendGitMetadata (url, { isEvpProxy, evpProxyPrefix }, configRepositoryU
     }
     // Otherwise we unshallow and get commits to upload again
     log.debug('It is shallow clone, unshallowing...')
-    if (getConfig().DD_CIVISIBILITY_GIT_UNSHALLOW_ENABLED) {
+    if (getConfig().testOptimization.DD_CIVISIBILITY_GIT_UNSHALLOW_ENABLED) {
       unshallowRepository(false)
     }
 

package/packages/dd-trace/src/ci-visibility/exporters/test-worker/writer.js

@@ -3,6 +3,11 @@ const { JSONEncoder } = require('../../encode/json-encoder')
 const { getEnvironmentVariable } = require('../../../config/helper')
 const log = require('../../../log')
 
+function getVitestWorkerPort () {
+  const port = globalThis.__vitest_worker__?.ctx?.port
+  return typeof port?.postMessage === 'function' ? port : undefined
+}
+
 class Writer {
   constructor (interprocessCode) {
     this._encoder = new JSONEncoder()
@@ -37,6 +42,18 @@ class Writer {
       ? { __tinypool_worker_message__: true, interprocessCode: this._interprocessCode, data }
       : [this._interprocessCode, data]
 
+    const vitestWorkerPort = getVitestWorkerPort()
+    if (vitestWorkerPort) {
+      try {
+        vitestWorkerPort.postMessage(payload)
+      } catch (error) {
+        log.error('Error posting message to vitest worker port', error)
+      } finally {
+        onDone()
+      }
+      return
+    }
+
     // child_process workers (jest default, cucumber)
     if (process.send) {
       process.send(payload, () => {

package/packages/dd-trace/src/ci-visibility/intelligent-test-runner/get-skippable-suites.js

@@ -14,6 +14,42 @@ const {
   TELEMETRY_ITR_SKIPPABLE_TESTS_RESPONSE_BYTES,
 } = require('../../ci-visibility/telemetry')
 const { buildCacheKey, writeToCache, withCache } = require('../requests/fs-cache')
+const { validateSkippableTestsResponse } = require('../test-optimization-http-cache-schema')
+
+function parseJsonResponse (rawJson) {
+  return typeof rawJson === 'string' ? JSON.parse(rawJson) : rawJson
+}
+
+function parseSkippableSuitesResponse (
+  rawJson,
+  { testLevel = 'suite', isCoverageReportUploadEnabled = false, validateRequiredFields = false } = {}
+) {
+  const parsedResponse = parseJsonResponse(rawJson)
+  if (validateRequiredFields) {
+    validateSkippableTestsResponse(parsedResponse)
+  }
+  const coverage = parsedResponse.meta?.coverage || {}
+
+  const skippableItems = parsedResponse
+    .data
+    .filter(({ type }) => type === testLevel)
+  const skippableSuites = []
+  for (const {
+    attributes: {
+      suite,
+      name,
+      _is_missing_line_code_coverage: isMissingLineCodeCoverage,
+    },
+  } of skippableItems) {
+    // Only reject candidates without backend line coverage when we need that coverage to backfill reports.
+    if (isCoverageReportUploadEnabled && isMissingLineCodeCoverage) continue
+
+    skippableSuites.push(testLevel === 'suite' ? suite : { suite, name })
+  }
+  const correlationId = parsedResponse.meta?.correlation_id
+
+  return { skippableSuites, correlationId, coverage }
+}
 
 function getSkippableSuites ({
   url,
@@ -124,12 +160,12 @@ function fetchFromApi ({
     options.path = `${evpProxyPrefix}/api/v2/ci/tests/skippable`
     options.headers['X-Datadog-EVP-Subdomain'] = 'api'
   } else {
-    const { apiKey } = getConfig()
-    if (!apiKey) {
+    const { DD_API_KEY } = getConfig()
+    if (!DD_API_KEY) {
       return done(new Error('Skippable suites were not fetched because Datadog API key is not defined.'))
     }
 
-    options.headers['dd-api-key'] = apiKey
+    options.headers['dd-api-key'] = DD_API_KEY
   }
 
   const data = JSON.stringify({
@@ -163,26 +199,12 @@ function fetchFromApi ({
       done(err)
     } else {
       try {
-        const parsedResponse = JSON.parse(res)
-        const coverage = parsedResponse.meta?.coverage || {}
-
-        const skippableItems = parsedResponse
-          .data
-          .filter(({ type }) => type === testLevel)
-        const skippableSuites = []
-        for (const {
-          attributes: {
-            suite,
-            name,
-            _is_missing_line_code_coverage: isMissingLineCodeCoverage,
-          },
-        } of skippableItems) {
-          // Only reject candidates without backend line coverage when we need that coverage to backfill reports.
-          if (isCoverageReportUploadEnabled && isMissingLineCodeCoverage) continue
-
-          skippableSuites.push(testLevel === 'suite' ? suite : { suite, name })
-        }
-        const correlationId = parsedResponse.meta?.correlation_id
+        const parsedResponse = parseJsonResponse(res)
+        const result = parseSkippableSuitesResponse(parsedResponse, {
+          testLevel,
+          isCoverageReportUploadEnabled,
+        })
+        const skippableItems = parsedResponse.data.filter(({ type }) => type === testLevel)
         incrementCountMetric(
           testLevel === 'test'
             ? TELEMETRY_ITR_SKIPPABLE_TESTS_RESPONSE_TESTS
@@ -191,9 +213,8 @@ function fetchFromApi ({
           skippableItems.length
         )
         distributionMetric(TELEMETRY_ITR_SKIPPABLE_TESTS_RESPONSE_BYTES, {}, res.length)
-        log.debug('Number of received skippable %ss:', testLevel, skippableSuites.length)
+        log.debug('Number of received skippable %ss:', testLevel, result.skippableSuites.length)
 
-        const result = { skippableSuites, correlationId, coverage }
         writeToCache(cacheKey, result)
 
         done(null, result)
@@ -204,4 +225,4 @@ function fetchFromApi ({
   })
 }
 
-module.exports = { getSkippableSuites }
+module.exports = { getSkippableSuites, parseSkippableSuitesResponse }

package/packages/dd-trace/src/ci-visibility/log-submission/log-submission-plugin.js

@@ -4,14 +4,14 @@ const Plugin = require('../../plugins/plugin')
 const log = require('../../log')
 
 function getWinstonLogSubmissionParameters (config) {
-  const { site, service, apiKey, DD_AGENTLESS_LOG_SUBMISSION_URL } = config
+  const { site, service, DD_API_KEY, DD_AGENTLESS_LOG_SUBMISSION_URL } = config
 
   const defaultParameters = {
     host: `http-intake.logs.${site}`,
     path: `/api/v2/logs?ddsource=winston&service=${service}`,
     ssl: true,
     headers: {
-      'DD-API-KEY': apiKey,
+      'DD-API-KEY': DD_API_KEY,
     },
   }
 

package/packages/dd-trace/src/ci-visibility/requests/get-library-configuration.js

@@ -12,12 +12,72 @@ const {
   TELEMETRY_GIT_REQUESTS_SETTINGS_RESPONSE,
 } = require('../telemetry')
 const { writeSettingsToCache } = require('../test-optimization-cache')
+const { validateSettingsResponse } = require('../test-optimization-http-cache-schema')
 const request = require('./request')
 
 const DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES = 2
 const DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES = { '5s': 10, '10s': 5, '30s': 3, '5m': 2 }
 const DEFAULT_EARLY_FLAKE_DETECTION_ERROR_THRESHOLD = 30
 
+function parseJsonResponse (rawJson) {
+  return typeof rawJson === 'string' ? JSON.parse(rawJson) : rawJson
+}
+
+function parseLibraryConfigurationResponse (rawJson, config = getConfig(), options = {}) {
+  const parsedResponse = parseJsonResponse(rawJson)
+  if (options.validateRequiredFields) {
+    validateSettingsResponse(parsedResponse)
+  }
+  const {
+    code_coverage: isCodeCoverageEnabled,
+    tests_skipping: isSuitesSkippingEnabled,
+    itr_enabled: isItrEnabled,
+    require_git: requireGit,
+    early_flake_detection: earlyFlakeDetectionConfig,
+    flaky_test_retries_enabled: isFlakyTestRetriesEnabled,
+    di_enabled: isDiEnabled,
+    known_tests_enabled: isKnownTestsEnabled,
+    test_management: testManagementConfig,
+    impacted_tests_enabled: isImpactedTestsEnabled,
+    coverage_report_upload_enabled: isCoverageReportUploadEnabled,
+  } = parsedResponse?.data?.attributes ?? parsedResponse
+
+  const settings = {
+    isCodeCoverageEnabled,
+    isSuitesSkippingEnabled,
+    isItrEnabled,
+    requireGit,
+    isEarlyFlakeDetectionEnabled: isKnownTestsEnabled && (earlyFlakeDetectionConfig?.enabled ?? false),
+    earlyFlakeDetectionNumRetries:
+      earlyFlakeDetectionConfig?.slow_test_retries?.['5s'] || DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES,
+    earlyFlakeDetectionSlowTestRetries:
+      earlyFlakeDetectionConfig?.slow_test_retries ?? DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES,
+    earlyFlakeDetectionFaultyThreshold:
+      earlyFlakeDetectionConfig?.faulty_session_threshold ?? DEFAULT_EARLY_FLAKE_DETECTION_ERROR_THRESHOLD,
+    isFlakyTestRetriesEnabled,
+    isDiEnabled: isDiEnabled && isFlakyTestRetriesEnabled,
+    isKnownTestsEnabled,
+    isTestManagementEnabled: (testManagementConfig?.enabled ?? false),
+    testManagementAttemptToFixRetries:
+      testManagementConfig?.attempt_to_fix_retries,
+    isImpactedTestsEnabled,
+    isCoverageReportUploadEnabled: isCoverageReportUploadEnabled ?? false,
+  }
+
+  log.debug('Remote settings: %j', settings)
+
+  if (config.testOptimization.DD_CIVISIBILITY_DANGEROUSLY_FORCE_COVERAGE) {
+    settings.isCodeCoverageEnabled = true
+    log.debug('Dangerously set code coverage to true')
+  }
+  if (config.testOptimization.DD_CIVISIBILITY_DANGEROUSLY_FORCE_TEST_SKIPPING) {
+    settings.isSuitesSkippingEnabled = true
+    log.debug('Dangerously set test skipping to true')
+  }
+
+  return settings
+}
+
 function getLibraryConfiguration ({
   url,
   isEvpProxy,
@@ -51,10 +111,10 @@ function getLibraryConfiguration ({
     options.path = `${evpProxyPrefix}/api/v2/libraries/tests/services/setting`
     options.headers['X-Datadog-EVP-Subdomain'] = 'api'
   } else {
-    if (!config.apiKey) {
+    if (!config.DD_API_KEY) {
       return done(new Error('Request to settings endpoint was not done because Datadog API key is not defined.'))
     }
-    options.headers['dd-api-key'] = config.apiKey
+    options.headers['dd-api-key'] = config.DD_API_KEY
   }
 
   const data = JSON.stringify({
@@ -90,56 +150,7 @@ function getLibraryConfiguration ({
       done(err)
     } else {
       try {
-        const {
-          data: {
-            attributes: {
-              code_coverage: isCodeCoverageEnabled,
-              tests_skipping: isSuitesSkippingEnabled,
-              itr_enabled: isItrEnabled,
-              require_git: requireGit,
-              early_flake_detection: earlyFlakeDetectionConfig,
-              flaky_test_retries_enabled: isFlakyTestRetriesEnabled,
-              di_enabled: isDiEnabled,
-              known_tests_enabled: isKnownTestsEnabled,
-              test_management: testManagementConfig,
-              impacted_tests_enabled: isImpactedTestsEnabled,
-              coverage_report_upload_enabled: isCoverageReportUploadEnabled,
-            },
-          },
-        } = JSON.parse(res)
-
-        const settings = {
-          isCodeCoverageEnabled,
-          isSuitesSkippingEnabled,
-          isItrEnabled,
-          requireGit,
-          isEarlyFlakeDetectionEnabled: isKnownTestsEnabled && (earlyFlakeDetectionConfig?.enabled ?? false),
-          earlyFlakeDetectionNumRetries:
-            earlyFlakeDetectionConfig?.slow_test_retries?.['5s'] || DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES,
-          earlyFlakeDetectionSlowTestRetries:
-            earlyFlakeDetectionConfig?.slow_test_retries ?? DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES,
-          earlyFlakeDetectionFaultyThreshold:
-            earlyFlakeDetectionConfig?.faulty_session_threshold ?? DEFAULT_EARLY_FLAKE_DETECTION_ERROR_THRESHOLD,
-          isFlakyTestRetriesEnabled,
-          isDiEnabled: isDiEnabled && isFlakyTestRetriesEnabled,
-          isKnownTestsEnabled,
-          isTestManagementEnabled: (testManagementConfig?.enabled ?? false),
-          testManagementAttemptToFixRetries:
-            testManagementConfig?.attempt_to_fix_retries,
-          isImpactedTestsEnabled,
-          isCoverageReportUploadEnabled: isCoverageReportUploadEnabled ?? false,
-        }
-
-        log.debug('Remote settings: %j', settings)
-
-        if (config.DD_CIVISIBILITY_DANGEROUSLY_FORCE_COVERAGE) {
-          settings.isCodeCoverageEnabled = true
-          log.debug('Dangerously set code coverage to true')
-        }
-        if (config.DD_CIVISIBILITY_DANGEROUSLY_FORCE_TEST_SKIPPING) {
-          settings.isSuitesSkippingEnabled = true
-          log.debug('Dangerously set test skipping to true')
-        }
+        const settings = parseLibraryConfigurationResponse(res, config)
 
         incrementCountMetric(TELEMETRY_GIT_REQUESTS_SETTINGS_RESPONSE, settings)
 
@@ -153,4 +164,4 @@ function getLibraryConfiguration ({
   })
 }
 
-module.exports = { getLibraryConfiguration }
+module.exports = { getLibraryConfiguration, parseLibraryConfigurationResponse }

package/packages/dd-trace/src/ci-visibility/requests/upload-coverage-report.js

@@ -34,9 +34,9 @@ function uploadCoverageReport (
   { filePath, format, testEnvironmentMetadata, url, isEvpProxy, evpProxyPrefix },
   callback
 ) {
-  const apiKey = getConfig().apiKey
+  const { DD_API_KEY } = getConfig()
 
-  if (!apiKey && !isEvpProxy) {
+  if (!DD_API_KEY && !isEvpProxy) {
     return callback(new Error('DD_API_KEY is required for coverage report upload'))
   }
 
@@ -82,7 +82,7 @@ function uploadCoverageReport (
     options.headers['X-Datadog-EVP-Subdomain'] = 'ci-intake'
   } else {
     options.path = '/api/v2/cicovreprt'
-    options.headers['dd-api-key'] = apiKey
+    options.headers['dd-api-key'] = DD_API_KEY
   }
 
   log.debug('Uploading coverage report %s to %s%s', filePath, url, options.path)

package/packages/dd-trace/src/ci-visibility/requests/upload-test-screenshot.js

@@ -0,0 +1,156 @@
+'use strict'
+
+const { readFileSync } = require('node:fs')
+const { extname } = require('node:path')
+
+const getConfig = require('../../config')
+const request = require('../../exporters/common/request')
+const log = require('../../log')
+
+const UPLOAD_TIMEOUT_MS = 30_000
+const TEST_SCREENSHOT_ENDPOINT_PREFIX = '/api/v2/ci/test-runs/'
+const TEST_SCREENSHOT_ENDPOINT_SUFFIX = '/media'
+const UINT64_MAX = 18_446_744_073_709_551_615n
+
+function getContentType (filePath) {
+  const extension = extname(filePath).toLowerCase()
+  if (extension === '.gif') {
+    return 'image/gif'
+  }
+  if (extension === '.jpg' || extension === '.jpeg') {
+    return 'image/jpeg'
+  }
+  if (extension === '.webp') {
+    return 'image/webp'
+  }
+  return 'image/png'
+}
+
+function isValidTraceId (traceId) {
+  if (!/^[1-9]\d*$/.test(traceId)) {
+    return false
+  }
+  return BigInt(traceId) <= UINT64_MAX
+}
+
+/**
+ * Renders the idempotency key (`${traceId}:${basename(filePath)}`) into a value safe to carry in
+ * the upload's query string. The Agent's evp_proxy validates the forwarded query against a
+ * restrictive charset and rejects a raw Cypress filename (spaces, parens, non-ASCII), so the
+ * filename part is hex-encoded to [0-9a-f]; the decimal trace id and ':' separator are already in
+ * the allowed set and stay readable. Deterministic, so a retried upload reproduces the same key
+ * and the backend's UUIDv5 overwrite-on-retry holds.
+ *
+ * @param {string} idempotencyKey - The raw idempotency key (`<traceId>:<filename>`)
+ * @returns {string} A query-safe, deterministic representation of the key
+ */
+function toIdempotencyQueryValue (idempotencyKey) {
+  const separatorIndex = idempotencyKey.indexOf(':')
+  if (separatorIndex === -1) {
+    return Buffer.from(idempotencyKey, 'utf8').toString('hex')
+  }
+  const traceIdPart = idempotencyKey.slice(0, separatorIndex)
+  const filenamePart = idempotencyKey.slice(separatorIndex + 1)
+  return `${traceIdPart}:${Buffer.from(filenamePart, 'utf8').toString('hex')}`
+}
+
+/**
+ * Uploads a single test screenshot to the Test Optimization media intake.
+ * The trace id is included in the request path and the body is the raw image bytes.
+ *
+ * The media service requires two values from the tracer, sent as query params so they
+ * survive the Agent's evp_proxy (which forwards only an allow-listed header set and would
+ * otherwise strip the metadata, leaving the backend with an empty idempotency key):
+ * - `idempotencyKey`: stable per artifact and reused on retry, so a retried
+ *   upload overwrites the same stored object instead of creating a duplicate.
+ * - `capturedAtMs`: the capture time in epoch milliseconds, stamped once at
+ *   capture and resent unchanged on retry (it is part of the stored object key).
+ *
+ * @param {object} options - Upload options
+ * @param {string} options.filePath - Path to the screenshot file
+ * @param {string} options.traceId - Test trace id used as the screenshot key
+ * @param {string} options.idempotencyKey - Stable per-artifact key, reused on retry
+ * @param {number} options.capturedAtMs - Capture time in epoch milliseconds
+ * @param {URL} options.url - The base URL for the screenshot upload
+ * @param {boolean} [options.isEvpProxy] - Whether to upload through the Agent's evp_proxy
+ * @param {string} [options.evpProxyPrefix] - The evp_proxy path prefix (e.g. '/evp_proxy/v4')
+ * @param {Function} callback - Callback function (err)
+ */
+function uploadTestScreenshot (
+  { filePath, traceId, idempotencyKey, capturedAtMs, url, isEvpProxy, evpProxyPrefix },
+  callback
+) {
+  const { DD_API_KEY } = getConfig()
+
+  if (!isValidTraceId(traceId)) {
+    return callback(new Error('A non-zero decimal uint64 trace_id is required for test screenshot upload'))
+  }
+  if (!DD_API_KEY && !isEvpProxy) {
+    return callback(new Error('DD_API_KEY is required for test screenshot upload'))
+  }
+  if (!idempotencyKey) {
+    return callback(new Error('An idempotency key is required for test screenshot upload'))
+  }
+  if (!Number.isInteger(capturedAtMs) || capturedAtMs <= 0) {
+    return callback(new Error('A positive captured-at timestamp (epoch ms) is required for test screenshot upload'))
+  }
+
+  let screenshotContent
+  try {
+    screenshotContent = readFileSync(filePath)
+  } catch (err) {
+    return callback(new Error(`Failed to read screenshot at ${filePath}: ${err.message}`))
+  }
+  if (screenshotContent.length === 0) {
+    return callback(new Error(`Screenshot at ${filePath} is empty`))
+  }
+
+  // Metadata rides the query string, not X-Dd-* headers: the Agent's evp_proxy strips
+  // non-allow-listed headers, so header-borne metadata reached the backend empty. The key is
+  // rendered proxy-safe (see toIdempotencyQueryValue) because evp_proxy also validates the
+  // forwarded query against a restrictive charset. capturedAtMs is a plain integer and part of the
+  // stored object key, so it (and the key) must stay stable across retries.
+  const query = new URLSearchParams({
+    idempotency_key: toIdempotencyQueryValue(idempotencyKey),
+    captured_at_ms: String(capturedAtMs),
+  }).toString()
+  const basePath = `${TEST_SCREENSHOT_ENDPOINT_PREFIX}${traceId}${TEST_SCREENSHOT_ENDPOINT_SUFFIX}`
+
+  const contentType = getContentType(filePath)
+  const options = {
+    method: 'POST',
+    headers: {
+      'Content-Type': contentType,
+    },
+    path: `${basePath}?${query}`,
+    timeout: UPLOAD_TIMEOUT_MS,
+    url,
+  }
+
+  if (isEvpProxy) {
+    // Agent mode: prefix the evp_proxy path, tell the proxy which subdomain to forward to, and
+    // drop the API key — the Agent injects it. The query params survive the proxy.
+    options.path = `${evpProxyPrefix}${basePath}?${query}`
+    options.headers['X-Datadog-EVP-Subdomain'] = 'api'
+  } else {
+    options.headers['DD-API-KEY'] = DD_API_KEY
+  }
+
+  log.debug('Uploading test screenshot %s to %s', filePath, new URL(options.path, url).href)
+
+  request(screenshotContent, options, (err, res, statusCode) => {
+    if (err) {
+      log.error('Error uploading test screenshot: %s', err.message)
+      return callback(err)
+    }
+    if (statusCode === undefined) {
+      const uploadError = new Error('Test screenshot upload request was dropped before it was sent')
+      log.error('Error uploading test screenshot: %s', uploadError.message)
+      return callback(uploadError)
+    }
+    log.debug('Test screenshot uploaded successfully (status: %d)', statusCode)
+    callback(null)
+  })
+}
+
+module.exports = { TEST_SCREENSHOT_ENDPOINT_PREFIX, TEST_SCREENSHOT_ENDPOINT_SUFFIX, uploadTestScreenshot }

package/packages/dd-trace/src/ci-visibility/test-management/get-test-management-tests.js

@@ -16,6 +16,7 @@ const {
 } = require('../telemetry')
 
 const { buildCacheKey, writeToCache, withCache } = require('../requests/fs-cache')
+const { validateTestManagementTestsResponse } = require('../test-optimization-http-cache-schema')
 
 // Calculate the number of tests from the test management tests response, which has a shape like:
 // { module: { suites: { suite: { tests: { testName: { properties: {...} } } } } } }
@@ -39,6 +40,19 @@ function getNumFromTestManagementTests (testManagementTests) {
   return totalNumTests
 }
 
+function parseJsonResponse (rawJson) {
+  return typeof rawJson === 'string' ? JSON.parse(rawJson) : rawJson
+}
+
+function parseTestManagementTestsResponse (rawJson, options = {}) {
+  const parsedResponse = parseJsonResponse(rawJson)
+  if (options.validateRequiredFields) {
+    validateTestManagementTestsResponse(parsedResponse)
+  }
+  const { data: { attributes: { modules: testManagementTests } } } = parsedResponse
+  return testManagementTests
+}
+
 function getTestManagementTests ({
   url,
   isEvpProxy,
@@ -121,12 +135,12 @@ function fetchFromApi ({
     options.path = `${evpProxyPrefix}/api/v2/test/libraries/test-management/tests`
     options.headers['X-Datadog-EVP-Subdomain'] = 'api'
   } else {
-    const { apiKey } = getConfig()
-    if (!apiKey) {
+    const { DD_API_KEY } = getConfig()
+    if (!DD_API_KEY) {
       return done(new Error('Test management tests were not fetched because Datadog API key is not defined.'))
     }
 
-    options.headers['dd-api-key'] = apiKey
+    options.headers['dd-api-key'] = DD_API_KEY
   }
 
   const data = JSON.stringify({
@@ -155,7 +169,7 @@ function fetchFromApi ({
       done(err)
     } else {
       try {
-        const { data: { attributes: { modules: testManagementTests } } } = JSON.parse(res)
+        const testManagementTests = parseTestManagementTestsResponse(res)
 
         const numTests = getNumFromTestManagementTests(testManagementTests)
 
@@ -174,4 +188,8 @@ function fetchFromApi ({
   })
 }
 
-module.exports = { getTestManagementTests }
+module.exports = {
+  getNumFromTestManagementTests, // Exported for later use in the cache
+  getTestManagementTests,
+  parseTestManagementTestsResponse,
+}