test(debugger): cover breakpoint error paths (#8996)

Add focused unit coverage for existing debugger breakpoint behavior that was
previously untested. The new cases cover source map location translation
failures, inspector breakpoint operation failures, and async re-evaluation
error logging.

Author: watson

packages/dd-trace/test/debugger/devtools_client/breakpoints.spec.js

@@ -23,6 +23,13 @@ describe('breakpoints', function () {
    * }}
    */
   let sessionMock
+  /**
+   * @type {{
+   *   getGeneratedPosition: sinon.SinonStub;
+   *   '@noCallThru': boolean;
+   * }}
+   */
+  let sourceMapsMock
   /**
    * @type {{
    *   debug: sinon.SinonStub;
@@ -31,6 +38,8 @@ describe('breakpoints', function () {
    * }}
    */
   let logMock
+  /** @type {() => void} */
+  let scriptLoadingStabilizedCallback
   /**
    * @type {{
    *   findScriptFromPartialPath: sinon.SinonStub;
@@ -77,14 +86,22 @@ describe('breakpoints', function () {
       }),
       /**
        * @param {string} event
-       * @param {Function} callback
+       * @param {() => void} callback
        */
       on (event, callback) {
-        if (event === 'scriptLoadingStabilized') callback()
+        if (event === 'scriptLoadingStabilized') {
+          scriptLoadingStabilizedCallback = callback
+          callback()
+        }
       },
       '@noCallThru': true,
     }
 
+    sourceMapsMock = {
+      getGeneratedPosition: sinon.stub(),
+      '@noCallThru': true,
+    }
+
     logMock = {
       debug: sinon.stub(),
       error: sinon.stub(),
@@ -108,6 +125,7 @@ describe('breakpoints', function () {
 
     breakpoints = proxyquire('../../../src/debugger/devtools_client/breakpoints', {
       './session': sessionMock,
+      './source-maps': sourceMapsMock,
       './state': stateMock,
       './log': logMock,
     })
@@ -176,6 +194,51 @@ describe('breakpoints', function () {
       )
     })
 
+    it('should translate source-mapped locations before setting the breakpoint', async function () {
+      stateMock.findScriptFromPartialPath.returns({
+        url: 'file:///path/to/test.js',
+        scriptId: 'script-1',
+        sourceMapURL: 'test.js.map',
+        source: 'source',
+      })
+      sourceMapsMock.getGeneratedPosition.resolves({ line: 12, column: 4 })
+
+      await addProbe()
+
+      sinon.assert.calledOnceWithExactly(
+        sourceMapsMock.getGeneratedPosition,
+        'file:///path/to/test.js',
+        'source',
+        10,
+        'test.js.map'
+      )
+      sinon.assert.calledWith(sessionMock.post.secondCall, 'Debugger.setBreakpoint', {
+        location: {
+          scriptId: 'script-1',
+          lineNumber: 11,
+          columnNumber: 4,
+        },
+        condition: compileBreakpointCondition([{ id: 'probe-1', samplingIndex: 0, nsBetweenSampling: 200000n }]),
+      })
+    })
+
+    it('should throw if a source map cannot resolve the generated location', async function () {
+      stateMock.findScriptFromPartialPath.returns({
+        url: 'file:///path/to/test.js',
+        scriptId: 'script-1',
+        sourceMapURL: 'test.js.map',
+        source: 'source',
+      })
+      sourceMapsMock.getGeneratedPosition.resolves({ line: null, column: null })
+
+      await assert.rejects(
+        addProbe(),
+        {
+          message: 'Could not find generated position for file:///path/to/test.js:10:0 (probe: probe-1, version: 1)',
+        }
+      )
+    })
+
     describe('capture limits', function () {
       it('should set default capture limits when captureSnapshot is true', async function () {
         await addProbe({ captureSnapshot: true })
@@ -468,6 +531,26 @@ describe('breakpoints', function () {
         })
     })
 
+    it('should wrap errors when setting a new breakpoint fails', async function () {
+      const cause = new Error('inspector failure')
+      sessionMock.post.callsFake((method, { location } = {}) => {
+        if (method === 'Debugger.setBreakpoint') {
+          return Promise.reject(cause)
+        }
+        return Promise.resolve({})
+      })
+
+      await assert.rejects(
+        addProbe(),
+        (err) => {
+          assert(err instanceof Error)
+          assert.strictEqual(err.message, 'Error setting breakpoint for probe probe-1 (version: 1)')
+          assert.strictEqual(err.cause, cause)
+          return true
+        }
+      )
+    })
+
     it('should wrap errors when replacing a breakpoint while adding a probe fails', async function () {
       await addProbe()
       sessionMock.post.resetHistory()
@@ -942,6 +1025,35 @@ describe('breakpoints', function () {
       })
     })
 
+    it('should wrap errors when removing a breakpoint fails', async function () {
+      await addProbe()
+      await addProbe({ id: 'probe-2', where: { sourceFile: 'test2.js', lines: ['20'] } })
+      sessionMock.post.resetHistory()
+
+      const cause = new Error('inspector failure')
+      sessionMock.post.callsFake((method, { location } = {}) => {
+        if (method === 'Debugger.removeBreakpoint') {
+          return Promise.reject(cause)
+        }
+        if (method === 'Debugger.setBreakpoint') {
+          return Promise.resolve({
+            breakpointId: `bp-${location.scriptId}:${location.lineNumber}:${location.columnNumber}`,
+          })
+        }
+        return Promise.resolve({})
+      })
+
+      await assert.rejects(
+        breakpoints.removeBreakpoint({ id: 'probe-1' }),
+        (err) => {
+          assert(err instanceof Error)
+          assert.strictEqual(err.message, 'Error removing breakpoint for probe probe-1')
+          assert.strictEqual(err.cause, cause)
+          return true
+        }
+      )
+    })
+
     it('should throw error if debugger not started', async function () {
       await breakpoints.removeBreakpoint({ id: 'probe-1' })
         .then(() => {
@@ -1032,6 +1144,26 @@ describe('breakpoints', function () {
     })
   })
 
+  describe('re-evaluation', function () {
+    it('should log errors from async probe re-evaluation', async function () {
+      await addProbe()
+      logMock.error.resetHistory()
+
+      const cause = new Error('script lookup failure')
+      stateMock.findScriptFromPartialPath.throws(cause)
+
+      scriptLoadingStabilizedCallback()
+      await Promise.resolve()
+
+      sinon.assert.calledWith(
+        logMock.error,
+        '[debugger:devtools_client] Error re-evaluating probe %s',
+        'probe-1',
+        cause
+      )
+    })
+  })
+
   /**
    * Add a generated probe.
    *