@farthershore/cli 0.3.10 → 0.3.12

package/node_modules/@pinojs/redact/test/index.test.js

@@ -1,824 +0,0 @@
-const { test } = require('node:test')
-const { strict: assert } = require('node:assert')
-const slowRedact = require('../index.js')
-
-test('basic path redaction', () => {
-  const obj = {
-    headers: {
-      cookie: 'secret-cookie',
-      authorization: 'Bearer token'
-    },
-    body: { message: 'hello' }
-  }
-
-  const redact = slowRedact({ paths: ['headers.cookie'] })
-  const result = redact(obj)
-
-  // Original object should remain unchanged
-  assert.strictEqual(obj.headers.cookie, 'secret-cookie')
-
-  // Result should have redacted path
-  const parsed = JSON.parse(result)
-  assert.strictEqual(parsed.headers.cookie, '[REDACTED]')
-  assert.strictEqual(parsed.headers.authorization, 'Bearer token')
-  assert.strictEqual(parsed.body.message, 'hello')
-})
-
-test('multiple paths redaction', () => {
-  const obj = {
-    user: { name: 'john', password: 'secret' },
-    session: { token: 'abc123' }
-  }
-
-  const redact = slowRedact({
-    paths: ['user.password', 'session.token']
-  })
-  const result = redact(obj)
-
-  // Original unchanged
-  assert.strictEqual(obj.user.password, 'secret')
-  assert.strictEqual(obj.session.token, 'abc123')
-
-  // Result redacted
-  const parsed = JSON.parse(result)
-  assert.strictEqual(parsed.user.password, '[REDACTED]')
-  assert.strictEqual(parsed.session.token, '[REDACTED]')
-  assert.strictEqual(parsed.user.name, 'john')
-})
-
-test('custom censor value', () => {
-  const obj = { secret: 'hidden' }
-  const redact = slowRedact({
-    paths: ['secret'],
-    censor: '***'
-  })
-  const result = redact(obj)
-
-  const parsed = JSON.parse(result)
-  assert.strictEqual(parsed.secret, '***')
-})
-
-test('serialize: false returns object with restore method', () => {
-  const obj = { secret: 'hidden' }
-  const redact = slowRedact({
-    paths: ['secret'],
-    serialize: false
-  })
-  const result = redact(obj)
-
-  // Should be object, not string
-  assert.strictEqual(typeof result, 'object')
-  assert.strictEqual(result.secret, '[REDACTED]')
-
-  // Should have restore method
-  assert.strictEqual(typeof result.restore, 'function')
-
-  const restored = result.restore()
-  assert.strictEqual(restored.secret, 'hidden')
-})
-
-test('bracket notation paths', () => {
-  const obj = {
-    'weird-key': { 'another-weird': 'secret' },
-    normal: 'public'
-  }
-
-  const redact = slowRedact({
-    paths: ['["weird-key"]["another-weird"]']
-  })
-  const result = redact(obj)
-
-  const parsed = JSON.parse(result)
-  assert.strictEqual(parsed['weird-key']['another-weird'], '[REDACTED]')
-  assert.strictEqual(parsed.normal, 'public')
-})
-
-test('array paths', () => {
-  const obj = {
-    users: [
-      { name: 'john', password: 'secret1' },
-      { name: 'jane', password: 'secret2' }
-    ]
-  }
-
-  const redact = slowRedact({
-    paths: ['users[0].password', 'users[1].password']
-  })
-  const result = redact(obj)
-
-  const parsed = JSON.parse(result)
-  assert.strictEqual(parsed.users[0].password, '[REDACTED]')
-  assert.strictEqual(parsed.users[1].password, '[REDACTED]')
-  assert.strictEqual(parsed.users[0].name, 'john')
-  assert.strictEqual(parsed.users[1].name, 'jane')
-})
-
-test('wildcard at end of path', () => {
-  const obj = {
-    secrets: {
-      key1: 'secret1',
-      key2: 'secret2'
-    },
-    public: 'data'
-  }
-
-  const redact = slowRedact({
-    paths: ['secrets.*']
-  })
-  const result = redact(obj)
-
-  const parsed = JSON.parse(result)
-  assert.strictEqual(parsed.secrets.key1, '[REDACTED]')
-  assert.strictEqual(parsed.secrets.key2, '[REDACTED]')
-  assert.strictEqual(parsed.public, 'data')
-})
-
-test('wildcard with arrays', () => {
-  const obj = {
-    items: ['secret1', 'secret2', 'secret3']
-  }
-
-  const redact = slowRedact({
-    paths: ['items.*']
-  })
-  const result = redact(obj)
-
-  const parsed = JSON.parse(result)
-  assert.strictEqual(parsed.items[0], '[REDACTED]')
-  assert.strictEqual(parsed.items[1], '[REDACTED]')
-  assert.strictEqual(parsed.items[2], '[REDACTED]')
-})
-
-test('intermediate wildcard', () => {
-  const obj = {
-    users: {
-      user1: { password: 'secret1' },
-      user2: { password: 'secret2' }
-    }
-  }
-
-  const redact = slowRedact({
-    paths: ['users.*.password']
-  })
-  const result = redact(obj)
-
-  const parsed = JSON.parse(result)
-  assert.strictEqual(parsed.users.user1.password, '[REDACTED]')
-  assert.strictEqual(parsed.users.user2.password, '[REDACTED]')
-})
-
-test('censor function', () => {
-  const obj = { secret: 'hidden' }
-  const redact = slowRedact({
-    paths: ['secret'],
-    censor: (value, path) => `REDACTED:${path.join('.')}`
-  })
-  const result = redact(obj)
-
-  const parsed = JSON.parse(result)
-  assert.strictEqual(parsed.secret, 'REDACTED:secret')
-})
-
-test('custom serialize function', () => {
-  const obj = { secret: 'hidden', public: 'data' }
-  const redact = slowRedact({
-    paths: ['secret'],
-    serialize: (obj) => `custom:${JSON.stringify(obj)}`
-  })
-  const result = redact(obj)
-
-  assert(result.startsWith('custom:'))
-  const parsed = JSON.parse(result.slice(7))
-  assert.strictEqual(parsed.secret, '[REDACTED]')
-  assert.strictEqual(parsed.public, 'data')
-})
-
-test('nested paths', () => {
-  const obj = {
-    level1: {
-      level2: {
-        level3: {
-          secret: 'hidden'
-        }
-      }
-    }
-  }
-
-  const redact = slowRedact({
-    paths: ['level1.level2.level3.secret']
-  })
-  const result = redact(obj)
-
-  const parsed = JSON.parse(result)
-  assert.strictEqual(parsed.level1.level2.level3.secret, '[REDACTED]')
-})
-
-test('non-existent paths are ignored', () => {
-  const obj = { existing: 'value' }
-  const redact = slowRedact({
-    paths: ['nonexistent.path']
-  })
-  const result = redact(obj)
-
-  const parsed = JSON.parse(result)
-  assert.strictEqual(parsed.existing, 'value')
-  assert.strictEqual(parsed.nonexistent, undefined)
-})
-
-test('null and undefined handling', () => {
-  const obj = {
-    nullValue: null,
-    undefinedValue: undefined,
-    nested: {
-      nullValue: null
-    }
-  }
-
-  const redact = slowRedact({
-    paths: ['nullValue', 'nested.nullValue']
-  })
-  const result = redact(obj)
-
-  const parsed = JSON.parse(result)
-  assert.strictEqual(parsed.nullValue, '[REDACTED]')
-  assert.strictEqual(parsed.nested.nullValue, '[REDACTED]')
-})
-
-test('original object remains unchanged', () => {
-  const original = {
-    secret: 'hidden',
-    nested: { secret: 'hidden2' }
-  }
-  const copy = JSON.parse(JSON.stringify(original))
-
-  const redact = slowRedact({
-    paths: ['secret', 'nested.secret']
-  })
-  redact(original)
-
-  // Original should be completely unchanged
-  assert.deepStrictEqual(original, copy)
-})
-
-test('strict mode with primitives', () => {
-  const redact = slowRedact({
-    paths: ['test'],
-    strict: true
-  })
-
-  const stringResult = redact('primitive')
-  assert.strictEqual(stringResult, '"primitive"')
-
-  const numberResult = redact(42)
-  assert.strictEqual(numberResult, '42')
-})
-
-// Path validation tests to match fast-redact behavior
-test('path validation - non-string paths should throw', () => {
-  assert.throws(() => {
-    slowRedact({ paths: [123] })
-  }, {
-    message: 'Paths must be (non-empty) strings'
-  })
-
-  assert.throws(() => {
-    slowRedact({ paths: [null] })
-  }, {
-    message: 'Paths must be (non-empty) strings'
-  })
-
-  assert.throws(() => {
-    slowRedact({ paths: [undefined] })
-  }, {
-    message: 'Paths must be (non-empty) strings'
-  })
-})
-
-test('path validation - empty string should throw', () => {
-  assert.throws(() => {
-    slowRedact({ paths: [''] })
-  }, {
-    message: 'Invalid redaction path ()'
-  })
-})
-
-test('path validation - double dots should throw', () => {
-  assert.throws(() => {
-    slowRedact({ paths: ['invalid..path'] })
-  }, {
-    message: 'Invalid redaction path (invalid..path)'
-  })
-
-  assert.throws(() => {
-    slowRedact({ paths: ['a..b..c'] })
-  }, {
-    message: 'Invalid redaction path (a..b..c)'
-  })
-})
-
-test('path validation - unmatched brackets should throw', () => {
-  assert.throws(() => {
-    slowRedact({ paths: ['invalid[unclosed'] })
-  }, {
-    message: 'Invalid redaction path (invalid[unclosed)'
-  })
-
-  assert.throws(() => {
-    slowRedact({ paths: ['invalid]unopened'] })
-  }, {
-    message: 'Invalid redaction path (invalid]unopened)'
-  })
-
-  assert.throws(() => {
-    slowRedact({ paths: ['nested[a[b]'] })
-  }, {
-    message: 'Invalid redaction path (nested[a[b])'
-  })
-})
-
-test('path validation - comma-separated paths should throw', () => {
-  assert.throws(() => {
-    slowRedact({ paths: ['req,headers.cookie'] })
-  }, {
-    message: 'Invalid redaction path (req,headers.cookie)'
-  })
-
-  assert.throws(() => {
-    slowRedact({ paths: ['user,profile,name'] })
-  }, {
-    message: 'Invalid redaction path (user,profile,name)'
-  })
-
-  assert.throws(() => {
-    slowRedact({ paths: ['a,b'] })
-  }, {
-    message: 'Invalid redaction path (a,b)'
-  })
-})
-
-test('path validation - mixed valid and invalid should throw', () => {
-  assert.throws(() => {
-    slowRedact({ paths: ['valid.path', 123, 'another.valid'] })
-  }, {
-    message: 'Paths must be (non-empty) strings'
-  })
-
-  assert.throws(() => {
-    slowRedact({ paths: ['valid.path', 'invalid..path'] })
-  }, {
-    message: 'Invalid redaction path (invalid..path)'
-  })
-
-  assert.throws(() => {
-    slowRedact({ paths: ['valid.path', 'req,headers.cookie'] })
-  }, {
-    message: 'Invalid redaction path (req,headers.cookie)'
-  })
-})
-
-test('path validation - valid paths should work', () => {
-  // These should not throw
-  assert.doesNotThrow(() => {
-    slowRedact({ paths: [] })
-  })
-
-  assert.doesNotThrow(() => {
-    slowRedact({ paths: ['valid.path'] })
-  })
-
-  assert.doesNotThrow(() => {
-    slowRedact({ paths: ['user.password', 'data[0].secret'] })
-  })
-
-  assert.doesNotThrow(() => {
-    slowRedact({ paths: ['["quoted-key"].value'] })
-  })
-
-  assert.doesNotThrow(() => {
-    slowRedact({ paths: ["['single-quoted'].value"] })
-  })
-
-  assert.doesNotThrow(() => {
-    slowRedact({ paths: ['array[0]', 'object.property', 'wildcard.*'] })
-  })
-})
-
-// fast-redact compatibility tests
-test('censor function receives path as array (fast-redact compatibility)', () => {
-  const obj = {
-    headers: {
-      authorization: 'Bearer token',
-      'x-api-key': 'secret-key'
-    }
-  }
-
-  const pathsReceived = []
-  const redact = slowRedact({
-    paths: ['headers.authorization', 'headers["x-api-key"]'],
-    censor: (value, path) => {
-      pathsReceived.push(path)
-      assert(Array.isArray(path), 'Path should be an array')
-      return '[REDACTED]'
-    }
-  })
-
-  redact(obj)
-
-  // Verify paths are arrays
-  assert.strictEqual(pathsReceived.length, 2)
-  assert.deepStrictEqual(pathsReceived[0], ['headers', 'authorization'])
-  assert.deepStrictEqual(pathsReceived[1], ['headers', 'x-api-key'])
-})
-
-test('censor function with nested paths receives correct array', () => {
-  const obj = {
-    user: {
-      profile: {
-        credentials: {
-          password: 'secret123'
-        }
-      }
-    }
-  }
-
-  let receivedPath
-  const redact = slowRedact({
-    paths: ['user.profile.credentials.password'],
-    censor: (value, path) => {
-      receivedPath = path
-      assert.strictEqual(value, 'secret123')
-      assert(Array.isArray(path))
-      return '[REDACTED]'
-    }
-  })
-
-  redact(obj)
-
-  assert.deepStrictEqual(receivedPath, ['user', 'profile', 'credentials', 'password'])
-})
-
-test('censor function with wildcards receives correct array paths', () => {
-  const obj = {
-    users: {
-      user1: { password: 'secret1' },
-      user2: { password: 'secret2' }
-    }
-  }
-
-  const pathsReceived = []
-  const redact = slowRedact({
-    paths: ['users.*.password'],
-    censor: (value, path) => {
-      pathsReceived.push([...path]) // copy the array
-      assert(Array.isArray(path))
-      return '[REDACTED]'
-    }
-  })
-
-  redact(obj)
-
-  assert.strictEqual(pathsReceived.length, 2)
-  assert.deepStrictEqual(pathsReceived[0], ['users', 'user1', 'password'])
-  assert.deepStrictEqual(pathsReceived[1], ['users', 'user2', 'password'])
-})
-
-test('censor function with array wildcard receives correct array paths', () => {
-  const obj = {
-    items: [
-      { secret: 'value1' },
-      { secret: 'value2' }
-    ]
-  }
-
-  const pathsReceived = []
-  const redact = slowRedact({
-    paths: ['items.*.secret'],
-    censor: (value, path) => {
-      pathsReceived.push([...path])
-      assert(Array.isArray(path))
-      return '[REDACTED]'
-    }
-  })
-
-  redact(obj)
-
-  assert.strictEqual(pathsReceived.length, 2)
-  assert.deepStrictEqual(pathsReceived[0], ['items', '0', 'secret'])
-  assert.deepStrictEqual(pathsReceived[1], ['items', '1', 'secret'])
-})
-
-test('censor function with end wildcard receives correct array paths', () => {
-  const obj = {
-    secrets: {
-      key1: 'secret1',
-      key2: 'secret2'
-    }
-  }
-
-  const pathsReceived = []
-  const redact = slowRedact({
-    paths: ['secrets.*'],
-    censor: (value, path) => {
-      pathsReceived.push([...path])
-      assert(Array.isArray(path))
-      return '[REDACTED]'
-    }
-  })
-
-  redact(obj)
-
-  assert.strictEqual(pathsReceived.length, 2)
-  // Sort paths for consistent testing since object iteration order isn't guaranteed
-  pathsReceived.sort((a, b) => a[1].localeCompare(b[1]))
-  assert.deepStrictEqual(pathsReceived[0], ['secrets', 'key1'])
-  assert.deepStrictEqual(pathsReceived[1], ['secrets', 'key2'])
-})
-
-test('type safety: accessing properties on primitive values should not throw', () => {
-  // Test case from GitHub issue #5
-  const redactor = slowRedact({ paths: ['headers.authorization'] })
-  const data = {
-    headers: 123 // primitive value
-  }
-
-  assert.doesNotThrow(() => {
-    const result = redactor(data)
-    const parsed = JSON.parse(result)
-    assert.strictEqual(parsed.headers, 123) // Should remain unchanged
-  })
-
-  // Test wildcards with primitives
-  const redactor2 = slowRedact({ paths: ['data.*.nested'] })
-  const data2 = {
-    data: {
-      item1: 123, // primitive, trying to access .nested on it
-      item2: { nested: 'secret' }
-    }
-  }
-
-  assert.doesNotThrow(() => {
-    const result2 = redactor2(data2)
-    const parsed2 = JSON.parse(result2)
-    assert.strictEqual(parsed2.data.item1, 123) // Primitive unchanged
-    assert.strictEqual(parsed2.data.item2.nested, '[REDACTED]') // Object property redacted
-  })
-
-  // Test deep nested access on primitives
-  const redactor3 = slowRedact({ paths: ['user.name.first.charAt'] })
-  const data3 = {
-    user: {
-      name: 'John' // string primitive
-    }
-  }
-
-  assert.doesNotThrow(() => {
-    const result3 = redactor3(data3)
-    const parsed3 = JSON.parse(result3)
-    assert.strictEqual(parsed3.user.name, 'John') // Should remain unchanged
-  })
-})
-
-// Remove option tests
-test('remove option: basic key removal', () => {
-  const obj = { username: 'john', password: 'secret123' }
-  const redact = slowRedact({ paths: ['password'], remove: true })
-  const result = redact(obj)
-
-  // Original object should remain unchanged
-  assert.strictEqual(obj.password, 'secret123')
-
-  // Result should have password completely removed
-  const parsed = JSON.parse(result)
-  assert.strictEqual(parsed.username, 'john')
-  assert.strictEqual('password' in parsed, false)
-  assert.strictEqual(parsed.password, undefined)
-})
-
-test('remove option: multiple paths removal', () => {
-  const obj = {
-    user: { name: 'john', password: 'secret' },
-    session: { token: 'abc123', id: 'session1' }
-  }
-
-  const redact = slowRedact({
-    paths: ['user.password', 'session.token'],
-    remove: true
-  })
-  const result = redact(obj)
-
-  // Original unchanged
-  assert.strictEqual(obj.user.password, 'secret')
-  assert.strictEqual(obj.session.token, 'abc123')
-
-  // Result has keys completely removed
-  const parsed = JSON.parse(result)
-  assert.strictEqual(parsed.user.name, 'john')
-  assert.strictEqual(parsed.session.id, 'session1')
-  assert.strictEqual('password' in parsed.user, false)
-  assert.strictEqual('token' in parsed.session, false)
-})
-
-test('remove option: wildcard removal', () => {
-  const obj = {
-    secrets: {
-      key1: 'secret1',
-      key2: 'secret2'
-    },
-    public: 'data'
-  }
-
-  const redact = slowRedact({
-    paths: ['secrets.*'],
-    remove: true
-  })
-  const result = redact(obj)
-
-  const parsed = JSON.parse(result)
-  assert.strictEqual(parsed.public, 'data')
-  assert.deepStrictEqual(parsed.secrets, {}) // All keys removed
-})
-
-test('remove option: array wildcard removal', () => {
-  const obj = {
-    items: ['secret1', 'secret2', 'secret3'],
-    meta: 'data'
-  }
-
-  const redact = slowRedact({
-    paths: ['items.*'],
-    remove: true
-  })
-  const result = redact(obj)
-
-  const parsed = JSON.parse(result)
-  assert.strictEqual(parsed.meta, 'data')
-  // Array items set to undefined are omitted by JSON.stringify
-  assert.deepStrictEqual(parsed.items, [null, null, null])
-})
-
-test('remove option: intermediate wildcard removal', () => {
-  const obj = {
-    users: {
-      user1: { password: 'secret1', name: 'john' },
-      user2: { password: 'secret2', name: 'jane' }
-    }
-  }
-
-  const redact = slowRedact({
-    paths: ['users.*.password'],
-    remove: true
-  })
-  const result = redact(obj)
-
-  const parsed = JSON.parse(result)
-  assert.strictEqual(parsed.users.user1.name, 'john')
-  assert.strictEqual(parsed.users.user2.name, 'jane')
-  assert.strictEqual('password' in parsed.users.user1, false)
-  assert.strictEqual('password' in parsed.users.user2, false)
-})
-
-test('remove option: serialize false returns object with removed keys', () => {
-  const obj = { secret: 'hidden', public: 'data' }
-  const redact = slowRedact({
-    paths: ['secret'],
-    remove: true,
-    serialize: false
-  })
-  const result = redact(obj)
-
-  // Should be object, not string
-  assert.strictEqual(typeof result, 'object')
-  assert.strictEqual(result.public, 'data')
-  assert.strictEqual('secret' in result, false)
-
-  // Should have restore method
-  assert.strictEqual(typeof result.restore, 'function')
-
-  const restored = result.restore()
-  assert.strictEqual(restored.secret, 'hidden')
-})
-
-test('remove option: non-existent paths are ignored', () => {
-  const obj = { existing: 'value' }
-  const redact = slowRedact({
-    paths: ['nonexistent.path'],
-    remove: true
-  })
-  const result = redact(obj)
-
-  const parsed = JSON.parse(result)
-  assert.strictEqual(parsed.existing, 'value')
-  assert.strictEqual(parsed.nonexistent, undefined)
-})
-
-// Test for Issue #13: Empty string bracket notation paths not being redacted correctly
-test('empty string bracket notation path', () => {
-  const obj = { '': { c: 'sensitive-data' } }
-  const redact = slowRedact({ paths: ["[''].c"] })
-  const result = redact(obj)
-
-  // Original object should remain unchanged
-  assert.strictEqual(obj[''].c, 'sensitive-data')
-
-  // Result should have redacted path
-  const parsed = JSON.parse(result)
-  assert.strictEqual(parsed[''].c, '[REDACTED]')
-})
-
-test('empty string bracket notation with double quotes', () => {
-  const obj = { '': { c: 'sensitive-data' } }
-  const redact = slowRedact({ paths: ['[""].c'] })
-  const result = redact(obj)
-
-  // Original object should remain unchanged
-  assert.strictEqual(obj[''].c, 'sensitive-data')
-
-  // Result should have redacted path
-  const parsed = JSON.parse(result)
-  assert.strictEqual(parsed[''].c, '[REDACTED]')
-})
-
-test('empty string key with nested bracket notation', () => {
-  const obj = { '': { '': { secret: 'value' } } }
-  const redact = slowRedact({ paths: ["[''][''].secret"] })
-  const result = redact(obj)
-
-  // Original object should remain unchanged
-  assert.strictEqual(obj[''][''].secret, 'value')
-
-  // Result should have redacted path
-  const parsed = JSON.parse(result)
-  assert.strictEqual(parsed[''][''].secret, '[REDACTED]')
-})
-
-// Test for Pino issue #2313: censor should only be called when path exists
-test('censor function not called for non-existent paths', () => {
-  let censorCallCount = 0
-  const censorCalls = []
-
-  const redact = slowRedact({
-    paths: ['a.b.c', 'req.authorization', 'url'],
-    serialize: false,
-    censor (value, path) {
-      censorCallCount++
-      censorCalls.push({ value, path: path.slice() })
-      return '***'
-    }
-  })
-
-  // Test case 1: { req: { id: 'test' } }
-  // req.authorization doesn't exist, censor should not be called for it
-  censorCallCount = 0
-  censorCalls.length = 0
-  redact({ req: { id: 'test' } })
-
-  // Should not have been called for any path since none exist
-  assert.strictEqual(censorCallCount, 0, 'censor should not be called when paths do not exist')
-
-  // Test case 2: { a: { d: 'test' } }
-  // a.b.c doesn't exist (a.d exists, but not a.b.c)
-  censorCallCount = 0
-  redact({ a: { d: 'test' } })
-  assert.strictEqual(censorCallCount, 0)
-
-  // Test case 3: paths that do exist should still call censor
-  censorCallCount = 0
-  censorCalls.length = 0
-  const result = redact({ req: { authorization: 'bearer token' } })
-  assert.strictEqual(censorCallCount, 1, 'censor should be called when path exists')
-  assert.deepStrictEqual(censorCalls[0].path, ['req', 'authorization'])
-  assert.strictEqual(censorCalls[0].value, 'bearer token')
-  assert.strictEqual(result.req.authorization, '***')
-})
-
-test('censor function not called for non-existent nested paths', () => {
-  let censorCallCount = 0
-
-  const redact = slowRedact({
-    paths: ['headers.authorization'],
-    serialize: false,
-    censor (value, path) {
-      censorCallCount++
-      return '[REDACTED]'
-    }
-  })
-
-  // headers exists but authorization doesn't
-  censorCallCount = 0
-  const result1 = redact({ headers: { 'content-type': 'application/json' } })
-  assert.strictEqual(censorCallCount, 0)
-  assert.deepStrictEqual(result1.headers, { 'content-type': 'application/json' })
-
-  // headers doesn't exist at all
-  censorCallCount = 0
-  const result2 = redact({ body: 'data' })
-  assert.strictEqual(censorCallCount, 0)
-  assert.strictEqual(result2.body, 'data')
-  assert.strictEqual(typeof result2.restore, 'function')
-
-  // headers.authorization exists - should call censor
-  censorCallCount = 0
-  const result3 = redact({ headers: { authorization: 'Bearer token' } })
-  assert.strictEqual(censorCallCount, 1)
-  assert.strictEqual(result3.headers.authorization, '[REDACTED]')
-})