dd-trace 2.25.1 → 2.26.0

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

@@ -0,0 +1,236 @@
+const { addHook, channel, AsyncResource } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const testStartCh = channel('ci:playwright:test:start')
+const testFinishCh = channel('ci:playwright:test:finish')
+
+const testSessionStartCh = channel('ci:playwright:session:start')
+const testSessionFinishCh = channel('ci:playwright:session:finish')
+
+const testSuiteStartCh = channel('ci:playwright:test-suite:start')
+const testSuiteFinishCh = channel('ci:playwright:test-suite:finish')
+
+const testToAr = new WeakMap()
+const testSuiteToAr = new Map()
+const testSuiteToTestStatuses = new Map()
+
+let startedSuites = []
+
+const STATUS_TO_TEST_STATUS = {
+  passed: 'pass',
+  failed: 'fail',
+  timedOut: 'fail',
+  skipped: 'skip'
+}
+
+let remainingTestsByFile = {}
+
+function getTestsBySuiteFromTestsById (testsById) {
+  const testsByTestSuite = {}
+  for (const { test } of testsById.values()) {
+    const { _requireFile } = test
+    if (test._type === 'beforeAll' || test._type === 'afterAll') {
+      continue
+    }
+    if (testsByTestSuite[_requireFile]) {
+      testsByTestSuite[_requireFile].push(test)
+    } else {
+      testsByTestSuite[_requireFile] = [test]
+    }
+  }
+  return testsByTestSuite
+}
+
+function getPlaywrightConfig (playwrightRunner) {
+  try {
+    return playwrightRunner._configLoader.fullConfig()
+  } catch (e) {
+    try {
+      return playwrightRunner._loader.fullConfig()
+    } catch (e) {
+      return {}
+    }
+  }
+}
+
+function getRootDir (playwrightRunner) {
+  const config = getPlaywrightConfig(playwrightRunner)
+  if (config.rootDir) {
+    return config.rootDir
+  }
+  if (playwrightRunner._configDir) {
+    return playwrightRunner._configDir
+  }
+  return process.cwd()
+}
+
+function testBeginHandler (test) {
+  const { title: testName, location: { file: testSuiteAbsolutePath }, _type } = test
+
+  if (_type === 'beforeAll' || _type === 'afterAll') {
+    return
+  }
+
+  const isNewTestSuite = !startedSuites.includes(testSuiteAbsolutePath)
+
+  if (isNewTestSuite) {
+    startedSuites.push(testSuiteAbsolutePath)
+    const testSuiteAsyncResource = new AsyncResource('bound-anonymous-fn')
+    testSuiteToAr.set(testSuiteAbsolutePath, testSuiteAsyncResource)
+    testSuiteAsyncResource.runInAsyncScope(() => {
+      testSuiteStartCh.publish(testSuiteAbsolutePath)
+    })
+  }
+
+  const testAsyncResource = new AsyncResource('bound-anonymous-fn')
+  testToAr.set(test, testAsyncResource)
+  testAsyncResource.runInAsyncScope(() => {
+    testStartCh.publish({ testName, testSuiteAbsolutePath })
+  })
+}
+
+function testEndHandler (test, testStatus, error) {
+  const { location: { file: testSuiteAbsolutePath }, results, _type } = test
+
+  if (_type === 'beforeAll' || _type === 'afterAll') {
+    return
+  }
+
+  const testResult = results[results.length - 1]
+  const testAsyncResource = testToAr.get(test)
+  testAsyncResource.runInAsyncScope(() => {
+    testFinishCh.publish({ testStatus, steps: testResult.steps, error })
+  })
+
+  if (!testSuiteToTestStatuses.has(testSuiteAbsolutePath)) {
+    testSuiteToTestStatuses.set(testSuiteAbsolutePath, [testStatus])
+  } else {
+    testSuiteToTestStatuses.get(testSuiteAbsolutePath).push(testStatus)
+  }
+
+  remainingTestsByFile[testSuiteAbsolutePath] = remainingTestsByFile[testSuiteAbsolutePath]
+    .filter(currentTest => currentTest !== test)
+
+  if (!remainingTestsByFile[testSuiteAbsolutePath].length) {
+    const testStatuses = testSuiteToTestStatuses.get(testSuiteAbsolutePath)
+
+    let testSuiteStatus = 'pass'
+    if (testStatuses.some(status => status === 'fail')) {
+      testSuiteStatus = 'fail'
+    } else if (testStatuses.every(status => status === 'skip')) {
+      testSuiteStatus = 'skip'
+    }
+
+    const testSuiteAsyncResource = testSuiteToAr.get(testSuiteAbsolutePath)
+    testSuiteAsyncResource.runInAsyncScope(() => {
+      testSuiteFinishCh.publish(testSuiteStatus)
+    })
+  }
+}
+
+function dispatcherRunWrapper (run) {
+  return function () {
+    remainingTestsByFile = getTestsBySuiteFromTestsById(this._testById)
+    return run.apply(this, arguments)
+  }
+}
+
+function dispatcherHook (dispatcherExport) {
+  shimmer.wrap(dispatcherExport.Dispatcher.prototype, 'run', dispatcherRunWrapper)
+  shimmer.wrap(dispatcherExport.Dispatcher.prototype, '_createWorker', createWorker => function () {
+    const dispatcher = this
+    const worker = createWorker.apply(this, arguments)
+
+    worker.process.on('message', ({ method, params }) => {
+      if (method === 'testBegin') {
+        const { test } = dispatcher._testById.get(params.testId)
+        testBeginHandler(test)
+      } else if (method === 'testEnd') {
+        const { test } = dispatcher._testById.get(params.testId)
+
+        const { results } = test
+        const testResult = results[results.length - 1]
+
+        testEndHandler(test, STATUS_TO_TEST_STATUS[testResult.status], testResult.error)
+      }
+    })
+
+    return worker
+  })
+  return dispatcherExport
+}
+
+function dispatcherHookNew (dispatcherExport) {
+  shimmer.wrap(dispatcherExport.Dispatcher.prototype, 'run', dispatcherRunWrapper)
+  shimmer.wrap(dispatcherExport.Dispatcher.prototype, '_createWorker', createWorker => function () {
+    const dispatcher = this
+    const worker = createWorker.apply(this, arguments)
+
+    worker.on('testBegin', ({ testId }) => {
+      const { test } = dispatcher._testById.get(testId)
+      testBeginHandler(test)
+    })
+    worker.on('testEnd', ({ testId, status, errors }) => {
+      const { test } = dispatcher._testById.get(testId)
+
+      testEndHandler(test, STATUS_TO_TEST_STATUS[status], errors && errors[0])
+    })
+
+    return worker
+  })
+  return dispatcherExport
+}
+
+function runnerHook (runnerExport) {
+  shimmer.wrap(runnerExport.Runner.prototype, 'runAllTests', runAllTests => async function () {
+    const testSessionAsyncResource = new AsyncResource('bound-anonymous-fn')
+    const { version: frameworkVersion } = getPlaywrightConfig(this)
+
+    const rootDir = getRootDir(this)
+
+    const processArgv = process.argv.slice(2).join(' ')
+    const command = `playwright ${processArgv}`
+    testSessionAsyncResource.runInAsyncScope(() => {
+      testSessionStartCh.publish({ command, frameworkVersion, rootDir })
+    })
+
+    const res = await runAllTests.apply(this, arguments)
+    const sessionStatus = STATUS_TO_TEST_STATUS[res.status]
+
+    let onDone
+
+    const flushWait = new Promise(resolve => {
+      onDone = resolve
+    })
+
+    testSessionAsyncResource.runInAsyncScope(() => {
+      testSessionFinishCh.publish({ status: sessionStatus, onDone })
+    })
+    await flushWait
+
+    startedSuites = []
+    remainingTestsByFile = {}
+
+    return res
+  })
+
+  return runnerExport
+}
+
+addHook({
+  name: '@playwright/test',
+  file: 'lib/runner.js',
+  versions: ['>=1.18.0']
+}, runnerHook)
+
+addHook({
+  name: '@playwright/test',
+  file: 'lib/dispatcher.js',
+  versions: ['>=1.18.0  <1.30.0']
+}, dispatcherHook)
+
+addHook({
+  name: '@playwright/test',
+  file: 'lib/dispatcher.js',
+  versions: ['>=1.30.0']
+}, dispatcherHookNew)