From e33807b817852bb7cdc93c9b171250df17a3b867 Mon Sep 17 00:00:00 2001 From: James Sumners Date: Tue, 24 Sep 2024 10:00:48 -0400 Subject: [PATCH] chore: Migrate block of unit tests to `node:test` (#2607) --- test/lib/temp-remove-listeners.js | 2 - test/unit/load-externals.test.js | 15 +- test/unit/logger.test.js | 239 ++++++------ test/unit/metrics-mapper.test.js | 160 ++++---- test/unit/name-state.test.js | 174 +++++---- test/unit/parse-proc-cpuinfo.test.js | 23 +- test/unit/parse-proc-meminfo.test.js | 25 +- test/unit/parsed-statement.test.js | 454 +++++++++++------------ test/unit/prioritized-attributes.test.js | 395 ++++++++------------ test/unit/priority-queue.test.js | 129 ++++--- test/unit/protocols.test.js | 40 +- 11 files changed, 775 insertions(+), 881 deletions(-) diff --git a/test/lib/temp-remove-listeners.js b/test/lib/temp-remove-listeners.js index 58e7010d90..add84af825 100644 --- a/test/lib/temp-remove-listeners.js +++ b/test/lib/temp-remove-listeners.js @@ -20,7 +20,6 @@ module.exports = function tempRemoveListeners({ t, emitter, event }) { return } - t.diagnostic(`Removing listeners for ${event}`) const listeners = emitter.listeners(event) emitter.removeAllListeners(event) @@ -28,7 +27,6 @@ module.exports = function tempRemoveListeners({ t, emitter, event }) { // be one `t.after` handler per test, and putting in here obscures the fact // that it has been added. t.after(() => { - t.diagnostic(`Re-adding listeners for ${event}`) for (const l of listeners) { emitter.on(event, l) } diff --git a/test/unit/load-externals.test.js b/test/unit/load-externals.test.js index bec9c45a8d..27a379ef40 100644 --- a/test/unit/load-externals.test.js +++ b/test/unit/load-externals.test.js @@ -5,23 +5,28 @@ 'use strict' -const tap = require('tap') +const test = require('node:test') +const assert = require('node:assert') + const loadExternals = require('../../load-externals') -tap.test('should load libs to webpack externals', async (t) => { +test('should load libs to webpack externals', async () => { const config = { target: 'node-20.x', externals: ['next'] } loadExternals(config) - t.ok(config.externals.length > 1, 'should add all libraries agent supports to the externals list') + assert.ok( + config.externals.length > 1, + 'should add all libraries agent supports to the externals list' + ) }) -tap.test('should not add externals when target is not node', async (t) => { +test('should not add externals when target is not node', async () => { const config = { target: 'web', externals: ['next'] } loadExternals(config) - t.ok(config.externals.length === 1, 'should not agent libraries when target is not node') + assert.ok(config.externals.length === 1, 'should not agent libraries when target is not node') }) diff --git a/test/unit/logger.test.js b/test/unit/logger.test.js index 4216539e83..9fbcb337f9 100644 --- a/test/unit/logger.test.js +++ b/test/unit/logger.test.js @@ -5,154 +5,155 @@ 'use strict' -const tap = require('tap') -const cp = require('child_process') +const test = require('node:test') +const assert = require('node:assert') +const path = require('node:path') +const cp = require('node:child_process') + +const tempRemoveListeners = require('../lib/temp-remove-listeners') + const Logger = require('../../lib/util/logger') -const path = require('path') - -tap.test('Logger', function (t) { - t.autoend() - let logger = null - - t.beforeEach(function () { - logger = new Logger({ - name: 'newrelic', - level: 'trace', - enabled: true, - configured: true - }) - }) - t.afterEach(function () { - logger = null +test.beforeEach((ctx) => { + ctx.nr = {} + ctx.nr.logger = new Logger({ + name: 'newrelic', + level: 'trace', + enabled: true, + configured: true }) +}) - t.test('should not throw when passed-in log level is 0', function (t) { - t.doesNotThrow(function () { - logger.level(0) - }) - t.end() +test('should not throw when passed-in log level is 0', (t) => { + const { logger } = t.nr + assert.doesNotThrow(() => { + logger.level(0) }) +}) - t.test('should not throw when passed-in log level is ONE MILLION', function (t) { - t.doesNotThrow(function () { - logger.level(1000000) - }) - t.end() +test('should not throw when passed-in log level is ONE MILLION', (t) => { + const { logger } = t.nr + assert.doesNotThrow(function () { + logger.level(1000000) }) +}) - t.test('should not throw when passed-in log level is "verbose"', function (t) { - t.doesNotThrow(function () { - logger.level('verbose') - }) - t.end() +test('should not throw when passed-in log level is "verbose"', (t) => { + const { logger } = t.nr + assert.doesNotThrow(function () { + logger.level('verbose') }) +}) - t.test('should enqueue logs until configured', function (t) { - logger.options.configured = false - logger.trace('trace') - logger.debug('debug') - logger.info('info') - logger.warn('warn') - logger.error('error') - logger.fatal('fatal') - t.ok(logger.logQueue.length === 6, 'should have 6 logs in the queue') - t.end() - }) +test('should enqueue logs until configured', (t) => { + const { logger } = t.nr + logger.options.configured = false + logger.trace('trace') + logger.debug('debug') + logger.info('info') + logger.warn('warn') + logger.error('error') + logger.fatal('fatal') + assert.ok(logger.logQueue.length === 6, 'should have 6 logs in the queue') +}) - t.test('should not enqueue logs when disabled', function (t) { - logger.trace('trace') - logger.debug('debug') - logger.info('info') - logger.warn('warn') - logger.error('error') - logger.fatal('fatal') - t.ok(logger.logQueue.length === 0, 'should have 0 logs in the queue') - t.end() - }) +test('should not enqueue logs when disabled', (t) => { + const { logger } = t.nr + logger.trace('trace') + logger.debug('debug') + logger.info('info') + logger.warn('warn') + logger.error('error') + logger.fatal('fatal') + assert.ok(logger.logQueue.length === 0, 'should have 0 logs in the queue') +}) - t.test('should flush logs when configured', function (t) { - logger.options.configured = false - logger.trace('trace') - logger.debug('debug') - logger.info('info') - logger.warn('warn') - logger.error('error') - logger.fatal('fatal') - - t.ok(logger.logQueue.length === 6, 'should have 6 logs in the queue') - - logger.configure({ - level: 'trace', - enabled: true, - name: 'test-logger' - }) +test('should flush logs when configured', (t) => { + const { logger } = t.nr + logger.options.configured = false + logger.trace('trace') + logger.debug('debug') + logger.info('info') + logger.warn('warn') + logger.error('error') + logger.fatal('fatal') - t.ok(logger.logQueue.length === 0, 'should have 0 logs in the queue') - t.end() + assert.ok(logger.logQueue.length === 6, 'should have 6 logs in the queue') + + logger.configure({ + level: 'trace', + enabled: true, + name: 'test-logger' }) - t.test('should fallback to default logging config when config is invalid', function (t) { - runTestFile('disabled-with-invalid-config/disabled.js', function (error, message) { - t.notOk(error) + assert.ok(logger.logQueue.length === 0, 'should have 0 logs in the queue') +}) + +test('should fallback to default logging config when config is invalid', (t, end) => { + runTestFile('disabled-with-invalid-config/disabled.js', function (error, message) { + assert.equal(error, undefined) - // should pipe logs to stdout if config is invalid, even if logging is disabled - t.ok(message) - t.end() - }) + // should pipe logs to stdout if config is invalid, even if logging is disabled + assert.ok(message) + end() }) +}) - t.test('should not cause crash if unwritable', function (t) { - runTestFile('unwritable-log/unwritable.js', t.end) - }) +test('should not cause crash if unwritable', (t, end) => { + runTestFile('unwritable-log/unwritable.js', end) +}) - t.test('should not be created if logger is disabled', function (t) { - runTestFile('disabled-log/disabled.js', t.end) - }) +test('should not be created if logger is disabled', (t, end) => { + runTestFile('disabled-log/disabled.js', end) +}) - t.test('should not log bootstrapping logs when logs disabled', function (t) { - runTestFile('disabled-with-log-queue/disabled.js', function (error, message) { - t.notOk(error) - t.notOk(message) - t.end() - }) +test('should not log bootstrapping logs when logs disabled', (t, end) => { + runTestFile('disabled-with-log-queue/disabled.js', function (error, message) { + assert.equal(error, undefined) + assert.equal(message, undefined) + end() }) +}) - t.test('should log bootstrapping logs at specified level when logs enabled', function (t) { - runTestFile('enabled-with-log-queue/enabled.js', function (error, message) { - t.notOk(error) - t.ok(message) +test('should log bootstrapping logs at specified level when logs enabled', (t, end) => { + runTestFile('enabled-with-log-queue/enabled.js', function (error, message) { + assert.equal(error, undefined) + assert.ok(message) - let logs = [] - t.doesNotThrow(function () { - logs = message.split('\n').filter(Boolean).map(JSON.parse) - }) + let logs = [] + assert.doesNotThrow(function () { + logs = message.split('\n').filter(Boolean).map(JSON.parse) + }) - t.ok(logs.length >= 1) - t.ok(logs.every((log) => log.level >= 30)) + assert.ok(logs.length >= 1) + assert.ok(logs.every((log) => log.level >= 30)) - t.end() - }) + end() }) +}) - t.test('should not throw for huge messages', function (t) { - process.once('warning', (warning) => { - t.equal(warning.name, 'NewRelicWarning') - t.ok(warning.message) - t.end() - }) +test('should not throw for huge messages', (t, end) => { + const { logger } = t.nr - let huge = 'a' - while (huge.length < Logger.MAX_LOG_BUFFER / 2) { - huge += huge - } - - t.doesNotThrow(() => { - logger.fatal('some message to start the buffer off') - logger.fatal(huge) - logger.fatal(huge) - }) + tempRemoveListeners({ t, emitter: process, event: 'warning' }) + process.once('warning', (warning) => { + assert.equal(warning.name, 'NewRelicWarning') + assert.ok(warning.message) + end() }) + + let huge = 'a' + while (huge.length < Logger.MAX_LOG_BUFFER / 2) { + huge += huge + } + + try { + logger.fatal('some message to start the buffer off') + logger.fatal(huge) + logger.fatal(huge) + } catch (error) { + assert.ifError(error) + } }) /** diff --git a/test/unit/metrics-mapper.test.js b/test/unit/metrics-mapper.test.js index 52f86dc38b..7f1b81c127 100644 --- a/test/unit/metrics-mapper.test.js +++ b/test/unit/metrics-mapper.test.js @@ -4,92 +4,102 @@ */ 'use strict' -const tap = require('tap') + +const test = require('node:test') +const assert = require('node:assert') + +const { match } = require('../lib/custom-assertions') + const MetricMapper = require('../../lib/metrics/mapper.js') -tap.test('MetricMapper', function (t) { - t.test("shouldn't throw if passed null", function (t) { - t.doesNotThrow(function () { - new MetricMapper().load(null) - }) - t.end() +test("shouldn't throw if passed null", () => { + try { + new MetricMapper().load(null) + } catch (error) { + assert.ifError(error) + } +}) + +test("shouldn't throw if passed undefined", () => { + try { + new MetricMapper().load(undefined) + } catch (error) { + assert.ifError(error) + } +}) + +test("shouldn't throw if passed an empty list", () => { + try { + new MetricMapper().load([]) + } catch (error) { + assert.ifError(error) + } +}) + +test("shouldn't throw if passed garbage input", () => { + try { + new MetricMapper().load({ name: 'garbage' }, 1001) + } catch (error) { + assert.ifError(error) + } +}) + +test('when loading mappings at creation', async (t) => { + t.beforeEach((ctx) => { + ctx.nr = {} + ctx.nr.mapper = new MetricMapper([ + [{ name: 'Test/RenameMe1' }, 1001], + [{ name: 'Test/RenameMe2', scope: 'TEST' }, 1002] + ]) + }) + + await t.test('should have loaded all the mappings', (t) => { + const { mapper } = t.nr + assert.equal(mapper.length, 2) + }) + + await t.test('should apply mappings', (t) => { + const { mapper } = t.nr + assert.equal(mapper.map('Test/RenameMe1'), 1001) + assert.equal(mapper.map('Test/RenameMe2', 'TEST'), 1002) }) - t.test("shouldn't throw if passed undefined", function (t) { - t.doesNotThrow(function () { - new MetricMapper().load(undefined) - }) - t.end() + await t.test('should turn non-mapped metrics into specs', (t) => { + const { mapper } = t.nr + assert.equal(match(mapper.map('Test/Metric1'), { name: 'Test/Metric1' }), true) + assert.equal( + match(mapper.map('Test/Metric2', 'TEST'), { name: 'Test/Metric2', scope: 'TEST' }), + true + ) }) +}) - t.test("shouldn't throw if passed an empty list", function (t) { - t.doesNotThrow(function () { - new MetricMapper().load([]) - }) - t.end() +test('when adding mappings after creation', async (t) => { + t.beforeEach((ctx) => { + ctx.nr = { + mapper: new MetricMapper() + } + ctx.nr.mapper.load([[{ name: 'Test/RenameMe1' }, 1001]]) + ctx.nr.mapper.load([[{ name: 'Test/RenameMe2', scope: 'TEST' }, 1002]]) }) - t.test("shouldn't throw if passed garbage input", function (t) { - t.doesNotThrow(function () { - new MetricMapper().load({ name: 'garbage' }, 1001) - }) - t.end() + await t.test('should have loaded all the mappings', (t) => { + const { mapper } = t.nr + assert.equal(mapper.length, 2) }) - t.test('when loading mappings at creation', function (t) { - let mapper - - t.before(function () { - mapper = new MetricMapper([ - [{ name: 'Test/RenameMe1' }, 1001], - [{ name: 'Test/RenameMe2', scope: 'TEST' }, 1002] - ]) - }) - - t.test('should have loaded all the mappings', function (t) { - t.equal(mapper.length, 2) - t.end() - }) - - t.test('should apply mappings', function (t) { - t.equal(mapper.map('Test/RenameMe1'), 1001) - t.equal(mapper.map('Test/RenameMe2', 'TEST'), 1002) - t.end() - }) - - t.test('should turn non-mapped metrics into specs', function (t) { - t.same(mapper.map('Test/Metric1'), { name: 'Test/Metric1' }) - t.same(mapper.map('Test/Metric2', 'TEST'), { name: 'Test/Metric2', scope: 'TEST' }) - t.end() - }) - t.end() + await t.test('should apply mappings', (t) => { + const { mapper } = t.nr + assert.equal(mapper.map('Test/RenameMe1'), 1001) + assert.equal(mapper.map('Test/RenameMe2', 'TEST'), 1002) }) - t.test('when adding mappings after creation', function (t) { - const mapper = new MetricMapper() - - t.before(function () { - mapper.load([[{ name: 'Test/RenameMe1' }, 1001]]) - mapper.load([[{ name: 'Test/RenameMe2', scope: 'TEST' }, 1002]]) - }) - - t.test('should have loaded all the mappings', function (t) { - t.equal(mapper.length, 2) - t.end() - }) - - t.test('should apply mappings', function (t) { - t.equal(mapper.map('Test/RenameMe1'), 1001) - t.equal(mapper.map('Test/RenameMe2', 'TEST'), 1002) - t.end() - }) - - t.test('should turn non-mapped metrics into specs', function (t) { - t.same(mapper.map('Test/Metric1'), { name: 'Test/Metric1' }) - t.same(mapper.map('Test/Metric2', 'TEST'), { name: 'Test/Metric2', scope: 'TEST' }) - t.end() - }) - t.end() + await t.test('should turn non-mapped metrics into specs', (t) => { + const { mapper } = t.nr + assert.equal(match(mapper.map('Test/Metric1'), { name: 'Test/Metric1' }), true) + assert.equal( + match(mapper.map('Test/Metric2', 'TEST'), { name: 'Test/Metric2', scope: 'TEST' }), + true + ) }) - t.end() }) diff --git a/test/unit/name-state.test.js b/test/unit/name-state.test.js index e0837d1bdd..896a7f8a01 100644 --- a/test/unit/name-state.test.js +++ b/test/unit/name-state.test.js @@ -4,97 +4,89 @@ */ 'use strict' -const tap = require('tap') + +const test = require('node:test') +const assert = require('node:assert') + const NameState = require('../../lib/transaction/name-state.js') -tap.test('NameState', function (t) { - t.autoend() - t.test('should handle basic naming', function (t) { - const state = new NameState('Nodejs', 'GET', '/', 'path1') - state.appendPath('path2') - t.equal(state.getName(), 'Nodejs/GET//path1/path2') - t.end() - }) - - t.test('should handle piece-wise naming', function (t) { - const state = new NameState(null, null, null, null) - state.setPrefix('Nodejs') - state.setVerb('GET') - state.setDelimiter('/') - state.appendPath('path1') - state.appendPath('path2') - state.appendPath('path3') - t.equal(state.getName(), 'Nodejs/GET//path1/path2/path3') - t.end() - }) - - t.test('should handle missing components', function (t) { - let state = new NameState('Nodejs', null, null, 'path1') - t.equal(state.getName(), 'Nodejs/path1') - - state = new NameState('Nodejs', null, '/', 'path1') - t.equal(state.getName(), 'Nodejs//path1') - - state = new NameState(null, null, null, 'path1') - t.equal(state.getName(), '/path1') - - state = new NameState('Nodejs', null, null, null) - t.equal(state.getName(), null) - t.end() - }) - - t.test('should delete the name when reset', function (t) { - const state = new NameState('Nodejs', 'GET', '/', 'path1') - t.equal(state.getName(), 'Nodejs/GET//path1') - - state.reset() - t.equal(state.getName(), null) - t.end() - }) - - t.test('should handle regex paths', function (t) { - const state = new NameState('Nodejs', 'GET', '/', []) - state.appendPath(new RegExp('regex1')) - state.appendPath('path1') - state.appendPath(/regex2/) - state.appendPath('path2') - - t.equal(state.getPath(), '/regex1/path1/regex2/path2') - t.equal(state.getName(), 'Nodejs/GET//regex1/path1/regex2/path2') - t.end() - }) - - t.test('should pick the current stack name over marked paths', function (t) { - const state = new NameState('Nodejs', 'GET', '/') - state.appendPath('path1') - state.markPath() - state.appendPath('path2') - - t.equal(state.getPath(), '/path1/path2') - t.equal(state.getName(), 'Nodejs/GET//path1/path2') - t.end() - }) - - t.test('should pick marked paths if the path stack is empty', function (t) { - const state = new NameState('Nodejs', 'GET', '/') - state.appendPath('path1') - state.markPath() - state.popPath() - - t.equal(state.getPath(), '/path1') - t.equal(state.getName(), 'Nodejs/GET//path1') - t.end() - }) - - t.test('should not report as empty if a path has been marked', function (t) { - const state = new NameState('Nodejs', 'GET', '/') - t.equal(state.isEmpty(), true) - - state.appendPath('path1') - state.markPath() - state.popPath() - - t.equal(state.isEmpty(), false) - t.end() - }) +test('should handle basic naming', () => { + const state = new NameState('Nodejs', 'GET', '/', 'path1') + state.appendPath('path2') + assert.equal(state.getName(), 'Nodejs/GET//path1/path2') +}) + +test('should handle piece-wise naming', () => { + const state = new NameState(null, null, null, null) + state.setPrefix('Nodejs') + state.setVerb('GET') + state.setDelimiter('/') + state.appendPath('path1') + state.appendPath('path2') + state.appendPath('path3') + assert.equal(state.getName(), 'Nodejs/GET//path1/path2/path3') +}) + +test('should handle missing components', () => { + let state = new NameState('Nodejs', null, null, 'path1') + assert.equal(state.getName(), 'Nodejs/path1') + + state = new NameState('Nodejs', null, '/', 'path1') + assert.equal(state.getName(), 'Nodejs//path1') + + state = new NameState(null, null, null, 'path1') + assert.equal(state.getName(), '/path1') + + state = new NameState('Nodejs', null, null, null) + assert.equal(state.getName(), null) +}) + +test('should delete the name when reset', () => { + const state = new NameState('Nodejs', 'GET', '/', 'path1') + assert.equal(state.getName(), 'Nodejs/GET//path1') + + state.reset() + assert.equal(state.getName(), null) +}) + +test('should handle regex paths', () => { + const state = new NameState('Nodejs', 'GET', '/', []) + state.appendPath(new RegExp('regex1')) + state.appendPath('path1') + state.appendPath(/regex2/) + state.appendPath('path2') + + assert.equal(state.getPath(), '/regex1/path1/regex2/path2') + assert.equal(state.getName(), 'Nodejs/GET//regex1/path1/regex2/path2') +}) + +test('should pick the current stack name over marked paths', () => { + const state = new NameState('Nodejs', 'GET', '/') + state.appendPath('path1') + state.markPath() + state.appendPath('path2') + + assert.equal(state.getPath(), '/path1/path2') + assert.equal(state.getName(), 'Nodejs/GET//path1/path2') +}) + +test('should pick marked paths if the path stack is empty', () => { + const state = new NameState('Nodejs', 'GET', '/') + state.appendPath('path1') + state.markPath() + state.popPath() + + assert.equal(state.getPath(), '/path1') + assert.equal(state.getName(), 'Nodejs/GET//path1') +}) + +test('should not report as empty if a path has been marked', () => { + const state = new NameState('Nodejs', 'GET', '/') + assert.equal(state.isEmpty(), true) + + state.appendPath('path1') + state.markPath() + state.popPath() + + assert.equal(state.isEmpty(), false) }) diff --git a/test/unit/parse-proc-cpuinfo.test.js b/test/unit/parse-proc-cpuinfo.test.js index 71b3f0fef3..6826a4975e 100644 --- a/test/unit/parse-proc-cpuinfo.test.js +++ b/test/unit/parse-proc-cpuinfo.test.js @@ -5,16 +5,17 @@ 'use strict' -const { test } = require('tap') +const test = require('node:test') +const assert = require('node:assert') + +const { match } = require('../lib/custom-assertions') const parseCpuInfo = require('../../lib/parse-proc-cpuinfo') -/** - * Most functionality is covered in-depth via cross-agent tests in - * test/integration/pricing/proc_cpuinfo.tap.js - */ +// Most functionality is covered in-depth via cross-agent tests in +// test/integration/pricing/proc_cpuinfo.tap.js -test('Should return object with null processor stats when data is null', (t) => { +test('Should return object with null processor stats when data is null', () => { const expectedStats = { logical: null, cores: null, @@ -23,12 +24,10 @@ test('Should return object with null processor stats when data is null', (t) => const result = parseCpuInfo(null) - t.same(result, expectedStats) - - t.end() + assert.equal(match(result, expectedStats), true) }) -test('Should return object with null processor stats when data is undefined', (t) => { +test('Should return object with null processor stats when data is undefined', () => { const expectedStats = { logical: null, cores: null, @@ -37,7 +36,5 @@ test('Should return object with null processor stats when data is undefined', (t const result = parseCpuInfo(undefined) - t.same(result, expectedStats) - - t.end() + assert.equal(match(result, expectedStats), true) }) diff --git a/test/unit/parse-proc-meminfo.test.js b/test/unit/parse-proc-meminfo.test.js index 51eb7adede..8172fc3b05 100644 --- a/test/unit/parse-proc-meminfo.test.js +++ b/test/unit/parse-proc-meminfo.test.js @@ -5,27 +5,22 @@ 'use strict' -const { test } = require('tap') +const test = require('node:test') +const assert = require('node:assert') + +const { match } = require('../lib/custom-assertions') const parseMemInfo = require('../../lib/parse-proc-meminfo') -/** - * Most functionality is covered in-depth via cross-agent tests in - * test/integration/pricing/proc_meminfo.tap.js - */ +// Most functionality is covered in-depth via cross-agent tests in +// test/integration/pricing/proc_meminfo.tap.js -test('Should return `null` when data is null', (t) => { +test('Should return `null` when data is null', () => { const result = parseMemInfo(null) - - t.same(result, null) - - t.end() + assert.equal(match(result, null), true) }) -test('Should return `null` when data is undefined', (t) => { +test('Should return `null` when data is undefined', () => { const result = parseMemInfo(undefined) - - t.same(result, undefined) - - t.end() + assert.equal(match(result, undefined), true) }) diff --git a/test/unit/parsed-statement.test.js b/test/unit/parsed-statement.test.js index 5f6c1e3a73..9a86be8d5c 100644 --- a/test/unit/parsed-statement.test.js +++ b/test/unit/parsed-statement.test.js @@ -5,30 +5,27 @@ 'use strict' -const tap = require('tap') +const test = require('node:test') +const assert = require('node:assert') const helper = require('../lib/agent_helper') +const { match } = require('../lib/custom-assertions') + const Transaction = require('../../lib/transaction') const ParsedStatement = require('../../lib/db/parsed-statement') -function checkMetric(t, metrics, name, scope) { - t.match(metrics.getMetric(name, scope), { total: 0.333 }) +function checkMetric(metrics, name, scope) { + assert.equal(match(metrics.getMetric(name, scope), { total: 0.333 }), true) } -tap.test('recording database metrics', (t) => { - t.autoend() - - let agent = null - let metrics = null - - t.test('setup', (t) => { - agent = helper.loadMockedAgent() - t.end() - }) +test('recording database metrics', async (t) => { + await t.test('on scoped transactions with parsed statements - with collection', async (t) => { + await t.test('with collection', async (t) => { + t.beforeEach((ctx) => { + ctx.nr = {} + const agent = helper.loadMockedAgent() + ctx.nr.agent = agent - t.test('on scoped transactions with parsed statements - with collection', (t) => { - t.test('with collection', (t) => { - t.beforeEach(() => { const ps = new ParsedStatement('NoSQL', 'select', 'test_collection') const transaction = new Transaction(agent) const segment = transaction.trace.add('test') @@ -38,59 +35,65 @@ tap.test('recording database metrics', (t) => { ps.recordMetrics(segment, 'TEST') transaction.end() - metrics = transaction.metrics + ctx.nr.metrics = transaction.metrics }) - t.test('should find 1 scoped metric', (t) => { - t.equal(metrics._toScopedData().length, 1) - t.end() + t.afterEach((ctx) => { + helper.unloadAgent(ctx.nr.agent) }) - t.test('should find 6 unscoped metrics', (t) => { - t.equal(metrics._toUnscopedData().length, 6) - t.end() + await t.test('should find 1 scoped metric', (t) => { + const { metrics } = t.nr + assert.equal(metrics._toScopedData().length, 1) }) - t.test('should find a scoped metric on the table and operation', (t) => { - checkMetric(t, metrics, 'Datastore/statement/NoSQL/test_collection/select', 'TEST') - t.end() + await t.test('should find 6 unscoped metrics', (t) => { + const { metrics } = t.nr + assert.equal(metrics._toUnscopedData().length, 6) }) - t.test('should find an unscoped metric on the table and operation', (t) => { - checkMetric(t, metrics, 'Datastore/statement/NoSQL/test_collection/select') - t.end() + await t.test('should find a scoped metric on the table and operation', (t) => { + const { metrics } = t.nr + checkMetric(metrics, 'Datastore/statement/NoSQL/test_collection/select', 'TEST') }) - t.test('should find an unscoped rollup metric on the operation', (t) => { - checkMetric(t, metrics, 'Datastore/operation/NoSQL/select') - t.end() + await t.test('should find an unscoped metric on the table and operation', (t) => { + const { metrics } = t.nr + checkMetric(metrics, 'Datastore/statement/NoSQL/test_collection/select') }) - t.test('should find a database rollup metric', (t) => { - checkMetric(t, metrics, 'Datastore/all') - t.end() + await t.test('should find an unscoped rollup metric on the operation', (t) => { + const { metrics } = t.nr + checkMetric(metrics, 'Datastore/operation/NoSQL/select') }) - t.test('should find a database rollup metric of type `Other`', (t) => { - checkMetric(t, metrics, 'Datastore/allOther') - t.end() + await t.test('should find a database rollup metric', (t) => { + const { metrics } = t.nr + checkMetric(metrics, 'Datastore/all') }) - t.test('should find a database type rollup metric of type `All`', (t) => { - checkMetric(t, metrics, 'Datastore/NoSQL/all') - t.end() + await t.test('should find a database rollup metric of type `Other`', (t) => { + const { metrics } = t.nr + checkMetric(metrics, 'Datastore/allOther') }) - t.test('should find a database type rollup metric of type `Other`', (t) => { - checkMetric(t, metrics, 'Datastore/NoSQL/allOther') - t.end() + await t.test('should find a database type rollup metric of type `All`', (t) => { + const { metrics } = t.nr + checkMetric(metrics, 'Datastore/NoSQL/all') }) - t.end() + await t.test('should find a database type rollup metric of type `Other`', (t) => { + const { metrics } = t.nr + checkMetric(metrics, 'Datastore/NoSQL/allOther') + }) }) - t.test('without collection', (t) => { - t.beforeEach(() => { + await t.test('without collection', async (t) => { + t.beforeEach((ctx) => { + ctx.nr = {} + const agent = helper.loadMockedAgent() + ctx.nr.agent = agent + const ps = new ParsedStatement('NoSQL', 'select') const transaction = new Transaction(agent) const segment = transaction.trace.add('test') @@ -100,64 +103,62 @@ tap.test('recording database metrics', (t) => { ps.recordMetrics(segment, 'TEST') transaction.end() - metrics = transaction.metrics + ctx.nr.metrics = transaction.metrics }) - t.test('should find 1 scoped metric', (t) => { - t.equal(metrics._toScopedData().length, 1) - t.end() + t.afterEach((ctx) => { + helper.unloadAgent(ctx.nr.agent) }) - t.test('should find 5 unscoped metrics', (t) => { - t.equal(metrics._toUnscopedData().length, 5) - t.end() + await t.test('should find 1 scoped metric', (t) => { + const { metrics } = t.nr + assert.equal(metrics._toScopedData().length, 1) }) - t.test('should find a scoped metric on the operation', (t) => { - checkMetric(t, metrics, 'Datastore/operation/NoSQL/select', 'TEST') - t.end() + await t.test('should find 5 unscoped metrics', (t) => { + const { metrics } = t.nr + assert.equal(metrics._toUnscopedData().length, 5) }) - t.test('should find an unscoped metric on the operation', (t) => { - checkMetric(t, metrics, 'Datastore/operation/NoSQL/select') - t.end() + await t.test('should find a scoped metric on the operation', (t) => { + const { metrics } = t.nr + checkMetric(metrics, 'Datastore/operation/NoSQL/select', 'TEST') }) - t.test('should find a database rollup metric', (t) => { - checkMetric(t, metrics, 'Datastore/all') - t.end() + await t.test('should find an unscoped metric on the operation', (t) => { + const { metrics } = t.nr + checkMetric(metrics, 'Datastore/operation/NoSQL/select') }) - t.test('should find a database rollup metric of type `Other`', (t) => { - checkMetric(t, metrics, 'Datastore/allOther') - t.end() + await t.test('should find a database rollup metric', (t) => { + const { metrics } = t.nr + checkMetric(metrics, 'Datastore/all') }) - t.test('should find a database type rollup metric of type `All`', (t) => { - checkMetric(t, metrics, 'Datastore/NoSQL/all') - t.end() + await t.test('should find a database rollup metric of type `Other`', (t) => { + const { metrics } = t.nr + checkMetric(metrics, 'Datastore/allOther') }) - t.test('should find a database type rollup metric of type `Other`', (t) => { - checkMetric(t, metrics, 'Datastore/NoSQL/allOther') - t.end() + await t.test('should find a database type rollup metric of type `All`', (t) => { + const { metrics } = t.nr + checkMetric(metrics, 'Datastore/NoSQL/all') }) - t.end() + await t.test('should find a database type rollup metric of type `Other`', (t) => { + const { metrics } = t.nr + checkMetric(metrics, 'Datastore/NoSQL/allOther') + }) }) - - t.end() }) - t.test('reset', (t) => { - helper.unloadAgent(agent) - agent = helper.loadMockedAgent() - t.end() - }) + await t.test('on unscoped transactions with parsed statements', async (t) => { + await t.test('with collection', async (t) => { + t.beforeEach((ctx) => { + ctx.nr = {} + const agent = helper.loadMockedAgent() + ctx.nr.agent = agent - t.test('on unscoped transactions with parsed statements', (t) => { - t.test('with collection', (t) => { - t.beforeEach(() => { const ps = new ParsedStatement('NoSQL', 'select', 'test_collection') const transaction = new Transaction(agent) const segment = transaction.trace.add('test') @@ -167,54 +168,60 @@ tap.test('recording database metrics', (t) => { ps.recordMetrics(segment, null) transaction.end() - metrics = transaction.metrics + ctx.nr.metrics = transaction.metrics }) - t.test('should find 0 unscoped metrics', (t) => { - t.equal(metrics._toScopedData().length, 0) - t.end() + t.afterEach((ctx) => { + helper.unloadAgent(ctx.nr.agent) }) - t.test('should find 6 unscoped metrics', (t) => { - t.equal(metrics._toUnscopedData().length, 6) - t.end() + await t.test('should find 0 unscoped metrics', (t) => { + const { metrics } = t.nr + assert.equal(metrics._toScopedData().length, 0) }) - t.test('should find an unscoped metric on the table and operation', (t) => { - checkMetric(t, metrics, 'Datastore/statement/NoSQL/test_collection/select') - t.end() + await t.test('should find 6 unscoped metrics', (t) => { + const { metrics } = t.nr + assert.equal(metrics._toUnscopedData().length, 6) }) - t.test('should find an unscoped rollup metric on the operation', (t) => { - checkMetric(t, metrics, 'Datastore/operation/NoSQL/select') - t.end() + await t.test('should find an unscoped metric on the table and operation', (t) => { + const { metrics } = t.nr + checkMetric(metrics, 'Datastore/statement/NoSQL/test_collection/select') }) - t.test('should find an unscoped rollup DB metric', (t) => { - checkMetric(t, metrics, 'Datastore/all') - t.end() + await t.test('should find an unscoped rollup metric on the operation', (t) => { + const { metrics } = t.nr + checkMetric(metrics, 'Datastore/operation/NoSQL/select') }) - t.test('should find an unscoped rollup DB metric of type `Other`', (t) => { - checkMetric(t, metrics, 'Datastore/allOther') - t.end() + await t.test('should find an unscoped rollup DB metric', (t) => { + const { metrics } = t.nr + checkMetric(metrics, 'Datastore/all') }) - t.test('should find a database type rollup metric of type `All`', (t) => { - checkMetric(t, metrics, 'Datastore/NoSQL/all') - t.end() + await test('should find an unscoped rollup DB metric of type `Other`', (t) => { + const { metrics } = t.nr + checkMetric(metrics, 'Datastore/allOther') }) - t.test('should find a database type rollup metric of type `Other`', (t) => { - checkMetric(t, metrics, 'Datastore/NoSQL/allOther') - t.end() + await test('should find a database type rollup metric of type `All`', (t) => { + const { metrics } = t.nr + checkMetric(metrics, 'Datastore/NoSQL/all') }) - t.end() + await test('should find a database type rollup metric of type `Other`', (t) => { + const { metrics } = t.nr + checkMetric(metrics, 'Datastore/NoSQL/allOther') + }) }) - t.test('without collection', (t) => { - t.beforeEach(() => { + await t.test('without collection', async (t) => { + t.beforeEach((ctx) => { + ctx.nr = {} + const agent = helper.loadMockedAgent() + ctx.nr.agent = agent + const ps = new ParsedStatement('NoSQL', 'select') const transaction = new Transaction(agent) const segment = transaction.trace.add('test') @@ -224,77 +231,70 @@ tap.test('recording database metrics', (t) => { ps.recordMetrics(segment, null) transaction.end() - metrics = transaction.metrics + ctx.nr.metrics = transaction.metrics }) - t.test('should find 0 unscoped metrics', (t) => { - t.equal(metrics._toScopedData().length, 0) - t.end() + t.afterEach((ctx) => { + helper.unloadAgent(ctx.nr.agent) }) - t.test('should find 5 unscoped metrics', (t) => { - t.equal(metrics._toUnscopedData().length, 5) - t.end() + await t.test('should find 0 unscoped metrics', (t) => { + const { metrics } = t.nr + assert.equal(metrics._toScopedData().length, 0) }) - t.test('should find an unscoped metric on the operation', (t) => { - checkMetric(t, metrics, 'Datastore/operation/NoSQL/select') - t.end() + await t.test('should find 5 unscoped metrics', (t) => { + const { metrics } = t.nr + assert.equal(metrics._toUnscopedData().length, 5) }) - t.test('should find an unscoped rollup DB metric', (t) => { - checkMetric(t, metrics, 'Datastore/all') - t.end() + await t.test('should find an unscoped metric on the operation', (t) => { + const { metrics } = t.nr + checkMetric(metrics, 'Datastore/operation/NoSQL/select') }) - t.test('should find an unscoped rollup DB metric of type `Other`', (t) => { - checkMetric(t, metrics, 'Datastore/allOther') - t.end() + await t.test('should find an unscoped rollup DB metric', (t) => { + const { metrics } = t.nr + checkMetric(metrics, 'Datastore/all') }) - t.test('should find a database type rollup metric of type `All`', (t) => { - checkMetric(t, metrics, 'Datastore/NoSQL/all') - t.end() + await t.test('should find an unscoped rollup DB metric of type `Other`', (t) => { + const { metrics } = t.nr + checkMetric(metrics, 'Datastore/allOther') }) - t.test('should find a database type rollup metric of type `Other`', (t) => { - checkMetric(t, metrics, 'Datastore/NoSQL/allOther') - t.end() + await t.test('should find a database type rollup metric of type `All`', (t) => { + const { metrics } = t.nr + checkMetric(metrics, 'Datastore/NoSQL/all') }) - t.end() + await t.test('should find a database type rollup metric of type `Other`', (t) => { + const { metrics } = t.nr + checkMetric(metrics, 'Datastore/NoSQL/allOther') + }) }) - - t.end() - }) - - t.test('teardown', (t) => { - helper.unloadAgent(agent) - t.end() }) }) -tap.test('recording slow queries', (t) => { - t.autoend() - - t.test('with collection', (t) => { - let transaction - let segment - let agent - - t.beforeEach(() => { - agent = helper.loadMockedAgent({ +test('recording slow queries', async (t) => { + await t.test('with collection', async (t) => { + t.beforeEach((ctx) => { + ctx.nr = {} + const agent = helper.loadMockedAgent({ slow_sql: { enabled: true }, transaction_tracer: { record_sql: 'obfuscated' } }) + ctx.nr.agent = agent const ps = new ParsedStatement('MySql', 'select', 'foo', 'select * from foo where b=1') - transaction = new Transaction(agent) + const transaction = new Transaction(agent) + ctx.nr.transaction = transaction transaction.type = Transaction.TYPES.BG - segment = transaction.trace.add('test') + const segment = transaction.trace.add('test') + ctx.nr.segment = segment segment.setDurationInMillis(503) ps.recordMetrics(segment, 'TEST') @@ -308,57 +308,54 @@ tap.test('recording slow queries', (t) => { transaction.end() }) - t.afterEach(() => { - helper.unloadAgent(agent) + t.afterEach((ctx) => { + helper.unloadAgent(ctx.nr.agent) }) - t.test('should update segment names', (t) => { - t.equal(segment.name, 'Datastore/statement/MySql/foo/select') - t.end() + await t.test('should update segment names', (t) => { + const { segment } = t.nr + assert.equal(segment.name, 'Datastore/statement/MySql/foo/select') }) - t.test('should capture queries', (t) => { - t.equal(agent.queries.samples.size, 1) + await t.test('should capture queries', (t) => { + const { agent } = t.nr + assert.equal(agent.queries.samples.size, 1) const sample = agent.queries.samples.values().next().value const trace = sample.trace - t.equal(sample.total, 1004) - t.equal(sample.totalExclusive, 1004) - t.equal(sample.min, 501) - t.equal(sample.max, 503) - t.equal(sample.sumOfSquares, 504010) - t.equal(sample.callCount, 2) - t.equal(trace.obfuscated, 'select * from foo where b=?') - t.equal(trace.normalized, 'select*fromfoowhereb=?') - t.equal(trace.id, 75330402683074160) - t.equal(trace.query, 'select * from foo where b=1') - t.equal(trace.metric, 'Datastore/statement/MySql/foo/select') - t.equal(typeof trace.trace, 'string') - - t.end() + assert.equal(sample.total, 1004) + assert.equal(sample.totalExclusive, 1004) + assert.equal(sample.min, 501) + assert.equal(sample.max, 503) + assert.equal(sample.sumOfSquares, 504010) + assert.equal(sample.callCount, 2) + assert.equal(trace.obfuscated, 'select * from foo where b=?') + assert.equal(trace.normalized, 'select*fromfoowhereb=?') + assert.equal(trace.id, 75330402683074160) + assert.equal(trace.query, 'select * from foo where b=1') + assert.equal(trace.metric, 'Datastore/statement/MySql/foo/select') + assert.equal(typeof trace.trace, 'string') }) - - t.end() }) - t.test('without collection', (t) => { - let transaction - let segment - let agent - - t.beforeEach(() => { - agent = helper.loadMockedAgent({ + await t.test('without collection', async (t) => { + t.beforeEach((ctx) => { + ctx.nr = {} + const agent = helper.loadMockedAgent({ slow_sql: { enabled: true }, transaction_tracer: { record_sql: 'obfuscated' } }) + ctx.nr.agent = agent const ps = new ParsedStatement('MySql', 'select', null, 'select * from foo where b=1') - transaction = new Transaction(agent) - segment = transaction.trace.add('test') + const transaction = new Transaction(agent) + const segment = transaction.trace.add('test') + ctx.nr.transaction = transaction + ctx.nr.segment = segment segment.setDurationInMillis(503) ps.recordMetrics(segment, 'TEST') @@ -372,67 +369,62 @@ tap.test('recording slow queries', (t) => { transaction.end() }) - t.afterEach(() => { - helper.unloadAgent(agent) - agent = null + t.afterEach((ctx) => { + helper.unloadAgent(ctx.nr.agent) }) - t.test('should update segment names', (t) => { - t.equal(segment.name, 'Datastore/operation/MySql/select') - t.end() + await t.test('should update segment names', (t) => { + const { segment } = t.nr + assert.equal(segment.name, 'Datastore/operation/MySql/select') }) - t.test('should have IDs that fit a signed long', (t) => { + await t.test('should have IDs that fit a signed long', (t) => { + const { agent } = t.nr const sample = agent.queries.samples.values().next().value const trace = sample.trace - t.ok(trace.id <= 2 ** 63 - 1) - - t.end() + assert.ok(trace.id <= 2 ** 63 - 1) }) - t.test('should capture queries', (t) => { - t.equal(agent.queries.samples.size, 1) + await t.test('should capture queries', (t) => { + const { agent } = t.nr + assert.equal(agent.queries.samples.size, 1) const sample = agent.queries.samples.values().next().value const trace = sample.trace - t.equal(sample.total, 1004) - t.equal(sample.totalExclusive, 1004) - t.equal(sample.min, 501) - t.equal(sample.max, 503) - t.equal(sample.sumOfSquares, 504010) - t.equal(sample.callCount, 2) - t.equal(trace.obfuscated, 'select * from foo where b=?') - t.equal(trace.normalized, 'select*fromfoowhereb=?') - t.equal(trace.id, 75330402683074160) - t.equal(trace.query, 'select * from foo where b=1') - t.equal(trace.metric, 'Datastore/operation/MySql/select') - t.equal(typeof trace.trace, 'string') - - t.end() + assert.equal(sample.total, 1004) + assert.equal(sample.totalExclusive, 1004) + assert.equal(sample.min, 501) + assert.equal(sample.max, 503) + assert.equal(sample.sumOfSquares, 504010) + assert.equal(sample.callCount, 2) + assert.equal(trace.obfuscated, 'select * from foo where b=?') + assert.equal(trace.normalized, 'select*fromfoowhereb=?') + assert.equal(trace.id, 75330402683074160) + assert.equal(trace.query, 'select * from foo where b=1') + assert.equal(trace.metric, 'Datastore/operation/MySql/select') + assert.equal(typeof trace.trace, 'string') }) - - t.end() }) - t.test('without query', (t) => { - let transaction - let segment - let agent - - t.beforeEach(() => { - agent = helper.loadMockedAgent({ + await t.test('without query', async (t) => { + t.beforeEach((ctx) => { + ctx.nr = {} + const agent = helper.loadMockedAgent({ slow_sql: { enabled: true }, transaction_tracer: { record_sql: 'obfuscated' } }) + ctx.nr.agent = agent const ps = new ParsedStatement('MySql', 'select', null, null) - transaction = new Transaction(agent) - segment = transaction.trace.add('test') + const transaction = new Transaction(agent) + const segment = transaction.trace.add('test') + ctx.nr.transaction = transaction + ctx.nr.segment = segment segment.setDurationInMillis(503) ps.recordMetrics(segment, 'TEST') @@ -446,20 +438,18 @@ tap.test('recording slow queries', (t) => { transaction.end() }) - t.afterEach(() => { - helper.unloadAgent(agent) + t.afterEach((ctx) => { + helper.unloadAgent(ctx.nr.agent) }) - t.test('should update segment names', (t) => { - t.equal(segment.name, 'Datastore/operation/MySql/select') - t.end() + await t.test('should update segment names', (t) => { + const { segment } = t.nr + assert.equal(segment.name, 'Datastore/operation/MySql/select') }) - t.test('should not capture queries', (t) => { - t.match(agent.queries.samples.size, 0) - t.end() + await t.test('should not capture queries', (t) => { + const { agent } = t.nr + assert.equal(match(agent.queries.samples.size, 0), true) }) - - t.end() }) }) diff --git a/test/unit/prioritized-attributes.test.js b/test/unit/prioritized-attributes.test.js index b0058052ab..30ffa1f86b 100644 --- a/test/unit/prioritized-attributes.test.js +++ b/test/unit/prioritized-attributes.test.js @@ -1,43 +1,40 @@ /* - * Copyright 2020 New Relic Corporation. All rights reserved. + * Copyright 2024 New Relic Corporation. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ 'use strict' -const tap = require('tap') +const test = require('node:test') +const assert = require('node:assert') const helper = require('../lib/agent_helper') + const { PrioritizedAttributes, ATTRIBUTE_PRIORITY } = require('../../lib/prioritized-attributes') const AttributeFilter = require('../../lib/config/attribute-filter') const DESTINATIONS = AttributeFilter.DESTINATIONS const TRANSACTION_SCOPE = 'transaction' -tap.test('#addAttribute', (t) => { - t.autoend() - - let agent = null - - t.beforeEach(() => { - agent = helper.loadMockedAgent() +test('#addAttribute', async (t) => { + t.beforeEach((ctx) => { + ctx.nr = {} + ctx.nr.agent = helper.loadMockedAgent() }) - t.afterEach(() => { - helper.unloadAgent(agent) + t.afterEach((ctx) => { + helper.unloadAgent(ctx.nr.agent) }) - t.test('adds an attribute to instance', (t) => { + await t.test('adds an attribute to instance', () => { const inst = new PrioritizedAttributes(TRANSACTION_SCOPE) inst.addAttribute(DESTINATIONS.TRANS_SCOPE, 'test', 'success') const attributes = inst.get(DESTINATIONS.TRANS_SCOPE) - t.equal(attributes.test, 'success') - - t.end() + assert.equal(attributes.test, 'success') }) - t.test('does not add attribute if key length limit is exceeded', (t) => { + await t.test('does not add attribute if key length limit is exceeded', () => { const tooLong = [ 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.', 'Cras id lacinia erat. Suspendisse mi nisl, sodales vel est eu,', @@ -48,26 +45,12 @@ tap.test('#addAttribute', (t) => { const inst = new PrioritizedAttributes(TRANSACTION_SCOPE) inst.addAttribute(DESTINATIONS.TRANS_SCOPE, tooLong, 'will fail') - t.notOk(inst.has(tooLong)) - - t.end() + assert.equal(inst.has(tooLong), undefined) }) }) -tap.test('#addAttribute - high priority', (t) => { - t.autoend() - - let agent = null - - t.beforeEach(() => { - agent = helper.loadMockedAgent() - }) - - t.afterEach(() => { - helper.unloadAgent(agent) - }) - - t.test('should overwrite existing high priority attribute', (t) => { +test('#addAttribute - high priority', async (t) => { + await t.test('should overwrite existing high priority attribute', () => { const inst = new PrioritizedAttributes(TRANSACTION_SCOPE, 2) inst.addAttribute(0x01, 'Roboto', 1, false, ATTRIBUTE_PRIORITY.HIGH) @@ -75,13 +58,11 @@ tap.test('#addAttribute - high priority', (t) => { const res = inst.get(0x01) - t.equal(Object.keys(res).length, 1) - t.equal(res.Roboto, 99) - - t.end() + assert.equal(Object.keys(res).length, 1) + assert.equal(res.Roboto, 99) }) - t.test('should overwrite existing low priority attribute', (t) => { + await t.test('should overwrite existing low priority attribute', () => { const inst = new PrioritizedAttributes(TRANSACTION_SCOPE, 2) inst.addAttribute(0x01, 'Roboto', 1, false, ATTRIBUTE_PRIORITY.LOW) @@ -89,13 +70,11 @@ tap.test('#addAttribute - high priority', (t) => { const res = inst.get(0x01) - t.equal(Object.keys(res).length, 1) - t.equal(res.Roboto, 99) - - t.end() + assert.equal(Object.keys(res).length, 1) + assert.equal(res.Roboto, 99) }) - t.test('should overwrite existing attribute even when at maximum', (t) => { + await t.test('should overwrite existing attribute even when at maximum', () => { const maxAttributeCount = 1 const inst = new PrioritizedAttributes(TRANSACTION_SCOPE, maxAttributeCount) inst.addAttribute(0x01, 'Roboto', 1, false, ATTRIBUTE_PRIORITY.LOW) @@ -104,81 +83,82 @@ tap.test('#addAttribute - high priority', (t) => { const res = inst.get(0x01) - t.equal(Object.keys(res).length, 1) - t.equal(res.Roboto, 99) - - t.end() + assert.equal(Object.keys(res).length, 1) + assert.equal(res.Roboto, 99) }) - t.test('should not add new attribute past maximum when no lower priority attributes', (t) => { - const maxAttributeCount = 1 - const inst = new PrioritizedAttributes(TRANSACTION_SCOPE, maxAttributeCount) - inst.addAttribute(0x01, 'old', 1, false, ATTRIBUTE_PRIORITY.HIGH) - - inst.addAttribute(0x01, 'new', 99, false, ATTRIBUTE_PRIORITY.HIGH) - - const res = inst.get(0x01) - const hasAttribute = Object.hasOwnProperty.bind(res) + await t.test( + 'should not add new attribute past maximum when no lower priority attributes', + () => { + const maxAttributeCount = 1 + const inst = new PrioritizedAttributes(TRANSACTION_SCOPE, maxAttributeCount) + inst.addAttribute(0x01, 'old', 1, false, ATTRIBUTE_PRIORITY.HIGH) - t.equal(Object.keys(res).length, maxAttributeCount) - t.equal(res.old, 1) - t.notOk(hasAttribute('new')) + inst.addAttribute(0x01, 'new', 99, false, ATTRIBUTE_PRIORITY.HIGH) - t.end() - }) + const res = inst.get(0x01) + const hasAttribute = Object.hasOwnProperty.bind(res) - t.test('should add new attribute, drop newest low priority attribute, when at maximum', (t) => { - const maxAttributeCount = 4 - const inst = new PrioritizedAttributes(TRANSACTION_SCOPE, maxAttributeCount) - inst.addAttribute(0x01, 'old-low', 1, false, ATTRIBUTE_PRIORITY.LOW) - inst.addAttribute(0x01, 'old-high', 1, false, ATTRIBUTE_PRIORITY.HIGH) - inst.addAttribute(0x01, 'new-low', 99, false, ATTRIBUTE_PRIORITY.LOW) - inst.addAttribute(0x01, 'newish-high', 50, false, ATTRIBUTE_PRIORITY.HIGH) + assert.equal(Object.keys(res).length, maxAttributeCount) + assert.equal(res.old, 1) + assert.equal(hasAttribute('new'), false) + } + ) - inst.addAttribute(0x01, 'new-high', 99, false, ATTRIBUTE_PRIORITY.HIGH) + await t.test( + 'should add new attribute, drop newest low priority attribute, when at maximum', + () => { + const maxAttributeCount = 4 + const inst = new PrioritizedAttributes(TRANSACTION_SCOPE, maxAttributeCount) + inst.addAttribute(0x01, 'old-low', 1, false, ATTRIBUTE_PRIORITY.LOW) + inst.addAttribute(0x01, 'old-high', 1, false, ATTRIBUTE_PRIORITY.HIGH) + inst.addAttribute(0x01, 'new-low', 99, false, ATTRIBUTE_PRIORITY.LOW) + inst.addAttribute(0x01, 'newish-high', 50, false, ATTRIBUTE_PRIORITY.HIGH) - const res = inst.get(0x01) - const hasAttribute = Object.hasOwnProperty.bind(res) + inst.addAttribute(0x01, 'new-high', 99, false, ATTRIBUTE_PRIORITY.HIGH) - t.equal(Object.keys(res).length, maxAttributeCount) - t.equal(res['old-low'], 1) - t.equal(res['old-high'], 1) - t.equal(res['newish-high'], 50) - t.equal(res['new-high'], 99) - t.notOk(hasAttribute('new-low')) + const res = inst.get(0x01) + const hasAttribute = Object.hasOwnProperty.bind(res) - t.end() - }) + assert.equal(Object.keys(res).length, maxAttributeCount) + assert.equal(res['old-low'], 1) + assert.equal(res['old-high'], 1) + assert.equal(res['newish-high'], 50) + assert.equal(res['new-high'], 99) + assert.equal(hasAttribute('new-low'), false) + } + ) - t.test('should stop adding attributes after all low priority dropped, when at maximum', (t) => { - const maxAttributeCount = 3 - const inst = new PrioritizedAttributes(TRANSACTION_SCOPE, maxAttributeCount) - inst.addAttribute(0x01, 'old-low', 1, false, ATTRIBUTE_PRIORITY.LOW) - inst.addAttribute(0x01, 'oldest-high', 1, false, ATTRIBUTE_PRIORITY.HIGH) - inst.addAttribute(0x01, 'new-low', 99, false, ATTRIBUTE_PRIORITY.LOW) - inst.addAttribute(0x01, 'older-high', 50, false, ATTRIBUTE_PRIORITY.HIGH) - inst.addAttribute(0x01, 'newish-high', 99, false, ATTRIBUTE_PRIORITY.HIGH) + await t.test( + 'should stop adding attributes after all low priority dropped, when at maximum', + () => { + const maxAttributeCount = 3 + const inst = new PrioritizedAttributes(TRANSACTION_SCOPE, maxAttributeCount) + inst.addAttribute(0x01, 'old-low', 1, false, ATTRIBUTE_PRIORITY.LOW) + inst.addAttribute(0x01, 'oldest-high', 1, false, ATTRIBUTE_PRIORITY.HIGH) + inst.addAttribute(0x01, 'new-low', 99, false, ATTRIBUTE_PRIORITY.LOW) + inst.addAttribute(0x01, 'older-high', 50, false, ATTRIBUTE_PRIORITY.HIGH) + inst.addAttribute(0x01, 'newish-high', 99, false, ATTRIBUTE_PRIORITY.HIGH) - inst.addAttribute(0x01, 'failed-new-high', 999, false, ATTRIBUTE_PRIORITY.HIGH) + inst.addAttribute(0x01, 'failed-new-high', 999, false, ATTRIBUTE_PRIORITY.HIGH) - const res = inst.get(0x01) - const hasAttribute = Object.hasOwnProperty.bind(res) - - t.equal(Object.keys(res).length, maxAttributeCount) - t.equal(res['oldest-high'], 1) - t.equal(res['older-high'], 50) - t.equal(res['newish-high'], 99) + const res = inst.get(0x01) + const hasAttribute = Object.hasOwnProperty.bind(res) - t.notOk(hasAttribute('old-low')) - t.notOk(hasAttribute('new-low')) - t.notOk(hasAttribute('failed-new-high')) + assert.equal(Object.keys(res).length, maxAttributeCount) + assert.equal(res['oldest-high'], 1) + assert.equal(res['older-high'], 50) + assert.equal(res['newish-high'], 99) - t.end() - }) + assert.equal(hasAttribute('old-low'), false) + assert.equal(hasAttribute('new-low'), false) + assert.equal(hasAttribute('failed-new-high'), false) + } + ) - t.test( + await t.test( 'should not drop low priority attribute overwritten by high priority, when at maximum', - (t) => { + () => { const maxAttributeCount = 4 const inst = new PrioritizedAttributes(TRANSACTION_SCOPE, maxAttributeCount) inst.addAttribute(0x01, 'old-low', 1, false, ATTRIBUTE_PRIORITY.LOW) @@ -198,33 +178,19 @@ tap.test('#addAttribute - high priority', (t) => { const res = inst.get(0x01) const hasAttribute = Object.hasOwnProperty.bind(res) - t.equal(Object.keys(res).length, maxAttributeCount) - t.equal(res['old-high'], 1) - t.equal(res['newish-high'], 50) - t.equal(res['new-high'], 99) - - t.equal(res.overwritten, 'high') - t.notOk(hasAttribute('old-low')) + assert.equal(Object.keys(res).length, maxAttributeCount) + assert.equal(res['old-high'], 1) + assert.equal(res['newish-high'], 50) + assert.equal(res['new-high'], 99) - t.end() + assert.equal(res.overwritten, 'high') + assert.equal(hasAttribute('old-low'), false) } ) }) -tap.test('#addAttribute - low priority', (t) => { - t.autoend() - - let agent = null - - t.beforeEach(() => { - agent = helper.loadMockedAgent() - }) - - t.afterEach(() => { - helper.unloadAgent(agent) - }) - - t.test('should overwrite existing low priority attribute', (t) => { +test('#addAttribute - low priority', async (t) => { + await t.test('should overwrite existing low priority attribute', () => { const inst = new PrioritizedAttributes(TRANSACTION_SCOPE, 2) inst.addAttribute(0x01, 'Roboto', 1, false, ATTRIBUTE_PRIORITY.LOW) @@ -232,13 +198,11 @@ tap.test('#addAttribute - low priority', (t) => { const res = inst.get(0x01) - t.equal(Object.keys(res).length, 1) - t.equal(res.Roboto, 99) - - t.end() + assert.equal(Object.keys(res).length, 1) + assert.equal(res.Roboto, 99) }) - t.test('should overwrite existing low priority attribute even when at maximum', (t) => { + await t.test('should overwrite existing low priority attribute even when at maximum', () => { const inst = new PrioritizedAttributes(TRANSACTION_SCOPE, 1) inst.addAttribute(0x01, 'Roboto', 1, false, ATTRIBUTE_PRIORITY.LOW) @@ -246,13 +210,11 @@ tap.test('#addAttribute - low priority', (t) => { const res = inst.get(0x01) - t.equal(Object.keys(res).length, 1) - t.equal(res.Roboto, 99) - - t.end() + assert.equal(Object.keys(res).length, 1) + assert.equal(res.Roboto, 99) }) - t.test('should not overwrite existing high priority attribute', (t) => { + await t.test('should not overwrite existing high priority attribute', () => { const inst = new PrioritizedAttributes(TRANSACTION_SCOPE, 1) inst.addAttribute(0x01, 'Roboto', 1, false, ATTRIBUTE_PRIORITY.HIGH) @@ -260,13 +222,11 @@ tap.test('#addAttribute - low priority', (t) => { const res = inst.get(0x01) - t.equal(Object.keys(res).length, 1) - t.equal(res.Roboto, 1) - - t.end() + assert.equal(Object.keys(res).length, 1) + assert.equal(res.Roboto, 1) }) - t.test('should not add new attribute past maximum', (t) => { + await t.test('should not add new attribute past maximum', () => { const maxAttributeCount = 2 const inst = new PrioritizedAttributes(TRANSACTION_SCOPE, maxAttributeCount) inst.addAttribute(0x01, 'old-high', 1, false, ATTRIBUTE_PRIORITY.HIGH) @@ -277,40 +237,24 @@ tap.test('#addAttribute - low priority', (t) => { const res = inst.get(0x01) const hasAttribute = Object.hasOwnProperty.bind(res) - t.equal(Object.keys(res).length, maxAttributeCount) - t.equal(res['old-high'], 1) - t.equal(res['old-low'], 99) - t.notOk(hasAttribute('failed-new-low')) - - t.end() + assert.equal(Object.keys(res).length, maxAttributeCount) + assert.equal(res['old-high'], 1) + assert.equal(res['old-low'], 99) + assert.equal(hasAttribute('failed-new-low'), false) }) }) -tap.test('#addAttributes', (t) => { - t.autoend() - - let agent = null - - t.beforeEach(() => { - agent = helper.loadMockedAgent() - }) - - t.afterEach(() => { - helper.unloadAgent(agent) - }) - - t.test('adds multiple attributes to instance', (t) => { +test('#addAttributes', async (t) => { + await t.test('adds multiple attributes to instance', () => { const inst = new PrioritizedAttributes(TRANSACTION_SCOPE) inst.addAttributes(DESTINATIONS.TRANS_SCOPE, { one: '1', two: '2' }) const attributes = inst.get(DESTINATIONS.TRANS_SCOPE) - t.equal(attributes.one, '1') - t.equal(attributes.two, '2') - - t.end() + assert.equal(attributes.one, '1') + assert.equal(attributes.two, '2') }) - t.test('only allows non-null-type primitive attribute values', (t) => { + await t.test('only allows non-null-type primitive attribute values', () => { const inst = new PrioritizedAttributes(TRANSACTION_SCOPE, 10) const attributes = { first: 'first', @@ -327,20 +271,18 @@ tap.test('#addAttributes', (t) => { inst.addAttributes(DESTINATIONS.TRANS_SCOPE, attributes) const res = inst.get(DESTINATIONS.TRANS_SCOPE) - t.equal(Object.keys(res).length, 3) + assert.equal(Object.keys(res).length, 3) const hasAttribute = Object.hasOwnProperty.bind(res) - t.notOk(hasAttribute('second')) - t.notOk(hasAttribute('third')) - t.notOk(hasAttribute('sixth')) - t.notOk(hasAttribute('seventh')) - t.notOk(hasAttribute('eighth')) - t.notOk(hasAttribute('ninth')) - - t.end() + assert.equal(hasAttribute('second'), false) + assert.equal(hasAttribute('third'), false) + assert.equal(hasAttribute('sixth'), false) + assert.equal(hasAttribute('seventh'), false) + assert.equal(hasAttribute('eighth'), false) + assert.equal(hasAttribute('ninth'), false) }) - t.test('disallows adding more than maximum allowed attributes', (t) => { + await t.test('disallows adding more than maximum allowed attributes', () => { const inst = new PrioritizedAttributes(TRANSACTION_SCOPE, 3) const attributes = { first: 1, @@ -352,39 +294,23 @@ tap.test('#addAttributes', (t) => { inst.addAttributes(DESTINATIONS.TRANS_SCOPE, attributes) const res = inst.get(DESTINATIONS.TRANS_SCOPE) - t.equal(Object.keys(res).length, 3) - - t.end() + assert.equal(Object.keys(res).length, 3) }) - t.test('Overwrites value of added attribute with same key', (t) => { + await t.test('Overwrites value of added attribute with same key', () => { const inst = new PrioritizedAttributes(TRANSACTION_SCOPE, 2) inst.addAttribute(0x01, 'Roboto', 1) inst.addAttribute(0x01, 'Roboto', 99) const res = inst.get(0x01) - t.equal(Object.keys(res).length, 1) - t.equal(res.Roboto, 99) - - t.end() + assert.equal(Object.keys(res).length, 1) + assert.equal(res.Roboto, 99) }) }) -tap.test('#get', (t) => { - t.autoend() - - let agent = null - - t.beforeEach(() => { - agent = helper.loadMockedAgent() - }) - - t.afterEach(() => { - helper.unloadAgent(agent) - }) - - t.test('gets attributes by destination, truncating values if necessary', (t) => { +test('#get', async (t) => { + await t.test('gets attributes by destination, truncating values if necessary', () => { const longVal = [ 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.', 'Cras id lacinia erat. Suspendisse mi nisl, sodales vel est eu,', @@ -398,17 +324,15 @@ tap.test('#get', (t) => { inst.addAttribute(0x01, 'tooLong', longVal) inst.addAttribute(0x08, 'wrongDest', 'hello') - t.ok(Buffer.byteLength(longVal) > 255) + assert.ok(Buffer.byteLength(longVal) > 255) const res = inst.get(0x01) - t.equal(res.valid, 50) + assert.equal(res.valid, 50) - t.equal(Buffer.byteLength(res.tooLong), 255) - - t.end() + assert.equal(Buffer.byteLength(res.tooLong), 255) }) - t.test('only returns attributes up to specified limit', (t) => { + await t.test('only returns attributes up to specified limit', () => { const inst = new PrioritizedAttributes(TRANSACTION_SCOPE, 2) inst.addAttribute(0x01, 'first', 'first') inst.addAttribute(0x01, 'second', 'second') @@ -417,44 +341,38 @@ tap.test('#get', (t) => { const res = inst.get(0x01) const hasAttribute = Object.hasOwnProperty.bind(res) - t.equal(Object.keys(res).length, 2) - t.notOk(hasAttribute('third')) - - t.end() + assert.equal(Object.keys(res).length, 2) + assert.equal(hasAttribute('third'), false) }) }) -tap.test('#hasValidDestination', (t) => { - t.autoend() - - let agent = null - - t.beforeEach(() => { - agent = helper.loadMockedAgent() +test('#hasValidDestination', async (t) => { + t.beforeEach((ctx) => { + ctx.nr = {} + ctx.nr.agent = helper.loadMockedAgent() }) - t.afterEach(() => { - helper.unloadAgent(agent) + t.afterEach((ctx) => { + helper.unloadAgent(ctx.nr.agent) }) - t.test('should return true if single destination valid', (t) => { + await t.test('should return true if single destination valid', () => { const attributes = new PrioritizedAttributes(TRANSACTION_SCOPE) const hasDestination = attributes.hasValidDestination(DESTINATIONS.TRANS_EVENT, 'testAttr') - t.equal(hasDestination, true) - t.end() + assert.equal(hasDestination, true) }) - t.test('should return true if all destinations valid', (t) => { + await t.test('should return true if all destinations valid', () => { const attributes = new PrioritizedAttributes(TRANSACTION_SCOPE) const destinations = DESTINATIONS.TRANS_EVENT | DESTINATIONS.TRANS_TRACE const hasDestination = attributes.hasValidDestination(destinations, 'testAttr') - t.equal(hasDestination, true) - t.end() + assert.equal(hasDestination, true) }) - t.test('should return true if only one destination valid', (t) => { + await t.test('should return true if only one destination valid', (t) => { + const { agent } = t.nr const attributeName = 'testAttr' agent.config.transaction_events.attributes.exclude = [attributeName] agent.config.emit('transaction_events.attributes.exclude') @@ -463,11 +381,11 @@ tap.test('#hasValidDestination', (t) => { const destinations = DESTINATIONS.TRANS_EVENT | DESTINATIONS.TRANS_TRACE const hasDestination = attributes.hasValidDestination(destinations, attributeName) - t.equal(hasDestination, true) - t.end() + assert.equal(hasDestination, true) }) - t.test('should return false if no valid destinations', (t) => { + await t.test('should return false if no valid destinations', (t) => { + const { agent } = t.nr const attributeName = 'testAttr' agent.config.attributes.exclude = [attributeName] agent.config.emit('attributes.exclude') @@ -476,25 +394,12 @@ tap.test('#hasValidDestination', (t) => { const destinations = DESTINATIONS.TRANS_EVENT | DESTINATIONS.TRANS_TRACE const hasDestination = attributes.hasValidDestination(destinations, attributeName) - t.equal(hasDestination, false) - t.end() + assert.equal(hasDestination, false) }) }) -tap.test('#reset', (t) => { - t.autoend() - - let agent = null - - t.beforeEach(() => { - agent = helper.loadMockedAgent() - }) - - t.afterEach(() => { - helper.unloadAgent(agent) - }) - - t.test('resets instance attributes', (t) => { +test('#reset', async (t) => { + await t.test('resets instance attributes', () => { const inst = new PrioritizedAttributes(TRANSACTION_SCOPE) inst.addAttribute(0x01, 'first', 'first') inst.addAttribute(0x01, 'second', 'second') @@ -502,10 +407,8 @@ tap.test('#reset', (t) => { inst.reset() - t.notOk(inst.has('first')) - t.notOk(inst.has('second')) - t.notOk(inst.has('third')) - - t.end() + assert.equal(inst.has('first'), undefined) + assert.equal(inst.has('second'), undefined) + assert.equal(inst.has('third'), undefined) }) }) diff --git a/test/unit/priority-queue.test.js b/test/unit/priority-queue.test.js index bed8059b92..ed99e679c6 100644 --- a/test/unit/priority-queue.test.js +++ b/test/unit/priority-queue.test.js @@ -5,91 +5,88 @@ 'use strict' -const tap = require('tap') -const PriorityQueue = require('../../lib/priority-queue') - -tap.test('PriorityQueue', function (t) { - t.autoend() - let queue = null +const test = require('node:test') +const assert = require('node:assert') - t.test('#add', function (t) { - t.autoend() +const { match } = require('../lib/custom-assertions') - t.test('structures the data as a min heap', function (t) { - queue = new PriorityQueue() +const PriorityQueue = require('../../lib/priority-queue') - queue.add('left grandchild', 10) - queue.add('parent', 1) - queue.add('right child', 5) - queue.add('left child', 8) +test('#add', async (t) => { + await t.test('structures the data as a min heap', () => { + const queue = new PriorityQueue() - t.same(queue.toArray(), ['parent', 'left child', 'right child', 'left grandchild']) - t.end() - }) + queue.add('left grandchild', 10) + queue.add('parent', 1) + queue.add('right child', 5) + queue.add('left child', 8) - t.test('replaces lowest priority item if limit is met', function (t) { - queue = new PriorityQueue(4) + assert.equal( + match(queue.toArray(), ['parent', 'left child', 'right child', 'left grandchild']), + true + ) + }) - queue.add('left grandchild', 10) - queue.add('parent', 1) - queue.add('right child', 5) - queue.add('left child', 8) + await t.test('replaces lowest priority item if limit is met', () => { + const queue = new PriorityQueue(4) - t.same(queue.toArray(), ['parent', 'left child', 'right child', 'left grandchild']) + queue.add('left grandchild', 10) + queue.add('parent', 1) + queue.add('right child', 5) + queue.add('left child', 8) - queue.add('new parent', 2) + assert.equal( + match(queue.toArray(), ['parent', 'left child', 'right child', 'left grandchild']), + true + ) - t.same(queue.toArray(), ['new parent', 'right child', 'left grandchild', 'left child']) - t.end() - }) + queue.add('new parent', 2) - t.test('does not insert events in the case the limit is 0', function (t) { - queue = new PriorityQueue(0) - t.equal(queue.add('test', 1), false) - t.equal(queue.length, 0) - t.end() - }) + assert.equal( + match(queue.toArray(), ['new parent', 'right child', 'left grandchild', 'left child']), + true + ) }) - t.test('#merge', function (t) { - t.autoend() + await t.test('does not insert events in the case the limit is 0', () => { + const queue = new PriorityQueue(0) + assert.equal(queue.add('test', 1), false) + assert.equal(queue.length, 0) + }) +}) - t.test('merges two sources and maintains the limit', function (t) { - const queueLimit = 4 - const queue1 = new PriorityQueue(queueLimit) - const queue2 = new PriorityQueue(queueLimit) +test('#merge', async (t) => { + await t.test('merges two sources and maintains the limit', () => { + const queueLimit = 4 + const queue1 = new PriorityQueue(queueLimit) + const queue2 = new PriorityQueue(queueLimit) - for (let pri = 0; pri < queueLimit; ++pri) { - queue1.add('test', pri) - queue2.add('test', pri) - } + for (let pri = 0; pri < queueLimit; ++pri) { + queue1.add('test', pri) + queue2.add('test', pri) + } - queue1.merge(queue2) - t.equal(queue1.length, queueLimit) - t.end() - }) + queue1.merge(queue2) + assert.equal(queue1.length, queueLimit) }) +}) - t.test('#setLimit', function (t) { - t.autoend() - - t.test('resets the limit property and slices the data if necessary', function (t) { - queue = new PriorityQueue(5) +test('#setLimit', async (t) => { + await t.test('resets the limit property and slices the data if necessary', () => { + const queue = new PriorityQueue(5) - t.equal(queue.limit, 5) - queue.setLimit(10) - t.equal(queue.limit, 10) + assert.equal(queue.limit, 5) + queue.setLimit(10) + assert.equal(queue.limit, 10) - for (let i = 0; i < 6; i++) { - queue.add(i, i) - } + for (let i = 0; i < 6; i++) { + queue.add(i, i) + } - t.equal(queue.length, 6) - t.same(queue.toArray(), [0, 5, 4, 3, 2, 1]) - queue.setLimit(5) - t.same(queue.toArray(), [1, 2, 3, 4, 5]) - t.equal(queue.length, 5) - t.end() - }) + assert.equal(queue.length, 6) + assert.equal(match(queue.toArray(), [0, 5, 4, 3, 2, 1]), true) + queue.setLimit(5) + assert.equal(match(queue.toArray(), [1, 2, 3, 4, 5]), true) + assert.equal(queue.length, 5) }) }) diff --git a/test/unit/protocols.test.js b/test/unit/protocols.test.js index cd094f8dc0..20fb737920 100644 --- a/test/unit/protocols.test.js +++ b/test/unit/protocols.test.js @@ -5,42 +5,48 @@ 'use strict' -const tap = require('tap') +const test = require('node:test') +const assert = require('node:assert') +const { match } = require('../lib/custom-assertions') const helper = require('../lib/agent_helper') -const RemoteMethod = require('../../lib/collector/remote-method') -tap.test('errors', (t) => { - let agent +const RemoteMethod = require('../../lib/collector/remote-method') - t.beforeEach(() => { - agent = helper.loadMockedAgent() +test('errors', async (t) => { + t.beforeEach((ctx) => { + ctx.nr = {} + const agent = helper.loadMockedAgent() agent.config.attributes.enabled = true agent.config.run_id = 1 agent.errors.traceAggregator.reconfigure(agent.config) + + ctx.nr.agent = agent }) - t.afterEach(() => { - helper.unloadAgent(agent) + t.afterEach((ctx) => { + helper.unloadAgent(ctx.nr.agent) }) - t.test('should serialize down to match the protocol', (t) => { + await t.test('should serialize down to match the protocol', (t, end) => { + const { agent } = t.nr const error = new Error('test') error.stack = 'test stack' agent.errors.add(null, error) const payload = agent.errors.traceAggregator._toPayloadSync() RemoteMethod.prototype.serialize(payload, (err, errors) => { - t.equal(err, null) - t.same( - errors, - '[1,[[0,"Unknown","test","Error",{"userAttributes":{},"agentAttributes":{},' + - '"intrinsics":{"error.expected":false},"stack_trace":["test stack"]},null]]]' + assert.equal(err, null) + assert.equal( + match( + errors, + '[1,[[0,"Unknown","test","Error",{"userAttributes":{},"agentAttributes":{},' + + '"intrinsics":{"error.expected":false},"stack_trace":["test stack"]},null]]]' + ), + true ) - t.end() + end() }) }) - - t.end() })