test: rewrite assertion to use Node.js assert (#6951)

Most of these changes are done by a script including a lint:fix run
afterwards.

The script used was listed for visibility in the PR as separate
commit that was reverted.

Author: BridgeAR

integration-tests/aiguard/index.spec.js

@@ -1,10 +1,13 @@
 'use strict'
 
-const { describe, it, before, after } = require('mocha')
+const assert = require('node:assert/strict')
 const path = require('path')
+
+const { expect } = require('chai')
+const { after, afterEach, before, beforeEach, describe, it } = require('mocha')
+
 const { sandboxCwd, useSandbox, FakeAgent, spawnProc } = require('../helpers')
 const startApiMock = require('./api-mock')
-const { expect } = require('chai')
 const { executeRequest } = require('./util')
 
 describe('AIGuard SDK integration tests', () => {
@@ -59,16 +62,16 @@ describe('AIGuard SDK integration tests', () => {
       const headers = blocking ? { 'x-blocking-enabled': true } : null
       const response = await executeRequest(`${url}${endpoint}`, 'GET', headers)
       if (blocking && action !== 'ALLOW') {
-        expect(response.status).to.equal(403)
+        assert.strictEqual(response.status, 403)
         expect(response.body).to.contain(reason)
       } else {
-        expect(response.status).to.equal(200)
+        assert.strictEqual(response.status, 200)
         expect(response.body).to.have.nested.property('action', action)
         expect(response.body).to.have.nested.property('reason', reason)
       }
       await agent.assertMessageReceived(({ headers, payload }) => {
         const span = payload[0].find(span => span.name === 'ai_guard')
-        expect(span).not.to.be.null
+        assert.notStrictEqual(span, null)
       })
     })
   }

integration-tests/appsec/endpoints-collection.spec.js

@@ -1,10 +1,10 @@
 'use strict'
 
-const { expect } = require('chai')
-const { describe, before, it } = require('mocha')
-
+const assert = require('node:assert/strict')
 const path = require('node:path')
 
+const { before, describe, it } = require('mocha')
+
 const { sandboxCwd, useSandbox, FakeAgent, spawnProc } = require('../helpers')
 
 describe('Endpoints collection', () => {
@@ -166,30 +166,30 @@ describe('Endpoints collection', () => {
       await telemetryPromise
 
       const trueCount = isFirstFlags.filter(v => v === true).length
-      expect(trueCount).to.equal(1)
+      assert.strictEqual(trueCount, 1)
 
       // Check that all expected endpoints were found
       expectedEndpoints.forEach(expected => {
         const found = endpointsFound.find(e =>
           e.method === expected.method && e.path === expected.path
         )
 
-        expect(found).to.exist
-        expect(found.type).to.equal('REST')
-        expect(found.operation_name).to.equal('http.request')
-        expect(found.resource_name).to.equal(`${expected.method} ${expected.path}`)
+        assert.ok(found != null)
+        assert.strictEqual(found.type, 'REST')
+        assert.strictEqual(found.operation_name, 'http.request')
+        assert.strictEqual(found.resource_name, `${expected.method} ${expected.path}`)
       })
 
       // check that no additional endpoints were found
-      expect(endpointsFound.length).to.equal(expectedEndpoints.length)
+      assert.strictEqual(endpointsFound.length, expectedEndpoints.length)
 
       // Explicitly verify invalid endpoints are NOT reported
       if (framework === 'express') {
         const cycleEndpoints = endpointsFound.filter(e => e.path.includes('cycle'))
-        expect(cycleEndpoints).to.have.lengthOf(0, 'Cycle router endpoints should not be collected')
+        assert.strictEqual(cycleEndpoints.length, 0, 'Cycle router endpoints should not be collected')
 
         const invalidEndpoints = endpointsFound.filter(e => e.path.includes('invalid'))
-        expect(invalidEndpoints).to.have.lengthOf(0, 'Invalid router paths should not be collected')
+        assert.strictEqual(invalidEndpoints.length, 0, 'Invalid router paths should not be collected')
       }
     } finally {
       proc?.kill()

integration-tests/telemetry.spec.js

@@ -1,10 +1,10 @@
 'use strict'
 
-const { expect } = require('chai')
-const { describe, before, it, beforeEach, afterEach } = require('mocha')
-
+const assert = require('node:assert/strict')
 const path = require('node:path')
 
+const { afterEach, before, beforeEach, describe, it } = require('mocha')
+
 const { sandboxCwd, useSandbox, FakeAgent, spawnProc, assertObjectContains } = require('./helpers')
 
 describe('telemetry', () => {
@@ -58,8 +58,8 @@ describe('telemetry', () => {
         }
       }, 'app-dependencies-loaded', 5_000, 1)
 
-      expect(ddTraceFound).to.be.true
-      expect(importInTheMiddleFound).to.be.true
+      assert.strictEqual(ddTraceFound, true)
+      assert.strictEqual(importInTheMiddleFound, true)
     })
 
     it('Assert configuration chaining data is sent', async () => {

packages/datadog-core/test/storage.spec.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { expect } = require('chai')
+const assert = require('node:assert/strict')
 const { describe, it, beforeEach, afterEach } = require('tap').mocha
 const { executionAsyncResource } = require('async_hooks')
 
@@ -28,7 +28,7 @@ describe('storage', () => {
     testStorage.enterWith(store)
 
     setImmediate(() => {
-      expect(testStorage.getStore()).to.equal(store)
+      assert.strictEqual(testStorage.getStore(), store)
       done()
     })
   })
@@ -41,14 +41,14 @@ describe('storage', () => {
     testStorage2.enterWith(store2)
 
     setImmediate(() => {
-      expect(testStorage.getStore()).to.equal(store)
-      expect(testStorage2.getStore()).to.equal(store2)
+      assert.strictEqual(testStorage.getStore(), store)
+      assert.strictEqual(testStorage2.getStore(), store2)
       done()
     })
   })
 
   it('should return the same storage for a namespace', () => {
-    expect(storage('test')).to.equal(testStorage)
+    assert.strictEqual(storage('test'), testStorage)
   })
 
   it('should not have its store referenced by the underlying async resource', () => {
@@ -58,7 +58,7 @@ describe('storage', () => {
 
     for (const sym of Object.getOwnPropertySymbols(resource)) {
       if (sym.toString() === 'Symbol(kResourceStore)' && resource[sym]) {
-        expect(resource[sym]).to.not.have.property('internal')
+        assert.ok(!Object.hasOwn(resource[sym], 'internal'))
       }
     }
   })

packages/datadog-core/test/utils/src/parse-tags.spec.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { expect } = require('chai')
+const assert = require('node:assert/strict')
 const { describe, it } = require('tap').mocha
 
 require('../../../../dd-trace/test/setup/core')
@@ -15,12 +15,12 @@ describe('parseTags', () => {
       'a.1.a': 'baz'
     }
 
-    expect(parseTags(obj)).to.deep.equal({
+    assert.deepStrictEqual(parseTags(obj), {
       a: [{ a: 'foo', b: 'bar' }, { a: 'baz' }]
     })
   })
 
   it('should work with empty object', () => {
-    expect(parseTags({})).to.deep.equal({})
+    assert.deepStrictEqual(parseTags({}), {})
   })
 })

packages/datadog-core/test/utils/src/set.spec.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { expect } = require('chai')
+const assert = require('node:assert/strict')
 const { describe, it } = require('tap').mocha
 
 require('../../../../dd-trace/test/setup/core')
@@ -14,6 +14,6 @@ describe('set', () => {
     set(obj, 'a', 1)
     set(obj, 'b.c', 2)
     set(obj, 'b.d.e', 3)
-    expect(obj).to.deep.equal({ a: 1, b: { c: 2, d: { e: 3 } } })
+    assert.deepStrictEqual(obj, { a: 1, b: { c: 2, d: { e: 3 } } })
   })
 })

packages/datadog-instrumentations/test/body-parser.spec.js

@@ -1,15 +1,16 @@
 'use strict'
 
+const assert = require('node:assert/strict')
+
 const axios = require('axios')
 const { expect } = require('chai')
 const dc = require('dc-polyfill')
-const { describe, it, beforeEach, before, after } = require('mocha')
+const { after, before, beforeEach, describe, it } = require('mocha')
 const sinon = require('sinon')
 
-const agent = require('../../dd-trace/test/plugins/agent')
 const { storage } = require('../../datadog-core')
+const agent = require('../../dd-trace/test/plugins/agent')
 const { withVersions } = require('../../dd-trace/test/setup/mocha')
-
 withVersions('body-parser', 'body-parser', version => {
   describe('body parser instrumentation', () => {
     const bodyParserReadCh = dc.channel('datadog:body-parser:read:finish')
@@ -46,8 +47,8 @@ withVersions('body-parser', 'body-parser', version => {
     it('should not abort the request by default', async () => {
       const res = await axios.post(`http://localhost:${port}/`, { key: 'value' })
 
-      expect(middlewareProcessBodyStub).to.be.calledOnce
-      expect(res.data).to.be.equal('DONE')
+      sinon.assert.calledOnce(middlewareProcessBodyStub)
+      assert.strictEqual(res.data, 'DONE')
     })
 
     it('should not abort the request with non blocker subscription', async () => {
@@ -56,8 +57,8 @@ withVersions('body-parser', 'body-parser', version => {
 
       const res = await axios.post(`http://localhost:${port}/`, { key: 'value' })
 
-      expect(middlewareProcessBodyStub).to.be.calledOnce
-      expect(res.data).to.be.equal('DONE')
+      sinon.assert.calledOnce(middlewareProcessBodyStub)
+      assert.strictEqual(res.data, 'DONE')
 
       bodyParserReadCh.unsubscribe(noop)
     })
@@ -72,7 +73,7 @@ withVersions('body-parser', 'body-parser', version => {
       const res = await axios.post(`http://localhost:${port}/`, { key: 'value' })
 
       expect(middlewareProcessBodyStub).not.to.be.called
-      expect(res.data).to.be.equal('BLOCKED')
+      assert.strictEqual(res.data, 'BLOCKED')
 
       bodyParserReadCh.unsubscribe(blockRequest)
     })
@@ -89,12 +90,12 @@ withVersions('body-parser', 'body-parser', version => {
 
       const res = await axios.post(`http://localhost:${port}/`, { key: 'value' })
 
-      expect(store).to.have.property('req', payload.req)
-      expect(store).to.have.property('res', payload.res)
-      expect(store).to.have.property('span')
+      assert.strictEqual(store.req, payload.req)
+      assert.strictEqual(store.res, payload.res)
+      assert.ok(Object.hasOwn(store, 'span'))
 
-      expect(middlewareProcessBodyStub).to.be.calledOnce
-      expect(res.data).to.be.equal('DONE')
+      sinon.assert.calledOnce(middlewareProcessBodyStub)
+      assert.strictEqual(res.data, 'DONE')
 
       bodyParserReadCh.unsubscribe(handler)
     })