مشاهدة ملف: index.js

'use strict'

const { test } = require('tap')
const fastRedact = require('..')

const censor = '[REDACTED]'
const censorFct = value => !value ? value : 'xxx' + value.substr(-2)
const censorWithPath = (v, p) => p.join('.') + ' ' + censorFct(v)

test('returns no-op when passed no paths [serialize: false]', ({ end, doesNotThrow }) => {
  const redact = fastRedact({ paths: [], serialize: false })
  doesNotThrow(() => redact({}))
  doesNotThrow(() => {
    const o = redact({})
    redact.restore(o)
  })
  end()
})

test('returns serializer when passed no paths [serialize: default]', ({ end, is }) => {
  is(fastRedact({ paths: [] }), JSON.stringify)
  is(fastRedact(), JSON.stringify)
  end()
})

test('throws when passed non-object using defaults', ({ end, throws }) => {
  const redact = fastRedact({ paths: ['a.b.c'] })
  throws(() => redact(1))
  end()
})

test('throws when passed non-object number using [strict: true]', ({ end, throws }) => {
  const redact = fastRedact({ paths: ['a.b.c'], strict: true })
  throws(() => redact(1))
  end()
})

test('returns JSON.stringified value when passed non-object using [strict: false] and no serialize option', ({ end, is, doesNotThrow }) => {
  const redactDefaultSerialize = fastRedact({ paths: ['a.b.c'], strict: false })

  // expectedOutputs holds `JSON.stringify`ied versions of each primitive.
  // We write them out explicitly though to make the test a bit clearer.
  const primitives = [null, undefined, 'A', 1, false]
  const expectedOutputs = ['null', undefined, '"A"', '1', 'false']

  primitives.forEach((it, i) => {
    doesNotThrow(() => redactDefaultSerialize(it))
    const res = redactDefaultSerialize(it)
    is(res, expectedOutputs[i])
  })

  end()
})

test('returns custom serialized value when passed non-object using [strict: false, serialize: fn]', ({ end, is, doesNotThrow }) => {
  const customSerialize = (v) => `Hello ${v}!`
  const redactCustomSerialize = fastRedact({
    paths: ['a.b.c'],
    strict: false,
    serialize: customSerialize
  })

  const primitives = [null, undefined, 'A', 1, false]

  primitives.forEach((it) => {
    doesNotThrow(() => redactCustomSerialize(it))
    const res = redactCustomSerialize(it)
    is(res, customSerialize(it))
  })

  end()
})

test('returns original value when passed non-object using [strict: false, serialize: false]', ({ end, is, doesNotThrow }) => {
  const redactSerializeFalse = fastRedact({
    paths: ['a.b.c'],
    strict: false,
    serialize: false
  })

  const primitives = [null, undefined, 'A', 1, false]

  primitives.forEach((it) => {
    doesNotThrow(() => redactSerializeFalse(it))
    const res = redactSerializeFalse(it)
    is(res, it)
  })

  end()
})

test('throws if a path is not a string', ({ end, throws }) => {
  const invalidTypeMsg = 'fast-redact - Paths must be (non-empty) strings'
  throws((e) => {
    fastRedact({ paths: [1] })
  }, Error(invalidTypeMsg))
  throws((e) => {
    fastRedact({ paths: [null] })
  }, Error(invalidTypeMsg))
  throws((e) => {
    fastRedact({ paths: [undefined] })
  }, Error(invalidTypeMsg))
  throws((e) => {
    fastRedact({ paths: [{}] })
  }, Error(invalidTypeMsg))
  throws((e) => {
    fastRedact({ paths: [[null]] })
  }, Error(invalidTypeMsg))
  end()
})

test('throws when passed illegal paths', ({ end, throws }) => {
  const err = (s) => Error(`fast-redact – Invalid path (${s})`)
  throws((e) => {
    fastRedact({ paths: ['@'] })
  }, err('@'))
  throws((e) => {
    fastRedact({ paths: ['0'] })
  }, err('0'))
  throws((e) => {
    fastRedact({ paths: ['〇'] })
  }, err('〇'))
  throws((e) => {
    fastRedact({ paths: ['a.1.c'] })
  }, err('a.1.c'))
  throws((e) => {
    fastRedact({ paths: ['a..c'] })
  }, err('a..c'))
  throws((e) => {
    fastRedact({ paths: ['1..c'] })
  }, err('1..c'))
  throws((e) => {
    fastRedact({ paths: ['a = b'] })
  }, err('a = b'))
  throws((e) => {
    fastRedact({ paths: ['a(b)'] })
  }, err('a(b)'))
  throws((e) => {
    fastRedact({ paths: ['//a.b.c'] })
  }, err('//a.b.c'))
  throws((e) => {
    fastRedact({ paths: ['\\a.b.c'] })
  }, err('\\a.b.c'))
  throws((e) => {
    fastRedact({ paths: ['a.#.c'] })
  }, err('a.#.c'))
  throws((e) => {
    fastRedact({ paths: ['~~a.b.c'] })
  }, err('~~a.b.c'))
  throws((e) => {
    fastRedact({ paths: ['^a.b.c'] })
  }, err('^a.b.c'))
  throws((e) => {
    fastRedact({ paths: ['a + b'] })
  }, err('a + b'))
  throws((e) => {
    fastRedact({ paths: ['return a + b'] })
  }, err('return a + b'))
  throws((e) => {
    fastRedact({ paths: ['a / b'] })
  }, err('a / b'))
  throws((e) => {
    fastRedact({ paths: ['a * b'] })
  }, err('a * b'))
  throws((e) => {
    fastRedact({ paths: ['a - b'] })
  }, err('a - b'))
  throws((e) => {
    fastRedact({ paths: ['a ** b'] })
  }, err('a ** b'))
  throws((e) => {
    fastRedact({ paths: ['a % b'] })
  }, err('a % b'))
  throws((e) => {
    fastRedact({ paths: ['a.b*.c'] })
  }, err('a.b*.c'))
  throws((e) => {
    fastRedact({ paths: ['a;global.foo = "bar"'] })
  }, err('a;global.foo = "bar"'))
  throws((e) => {
    fastRedact({ paths: ['a;while(1){}'] })
  }, err('a;while(1){}'))
  throws((e) => {
    fastRedact({ paths: ['a//'] })
  }, err('a//'))
  throws((e) => {
    fastRedact({ paths: ['a/*foo*/'] })
  }, err('a/*foo*/'))
  throws((e) => {
    fastRedact({ paths: ['a,o.b'] })
  }, err('a,o.b'))
  throws((e) => {
    fastRedact({ paths: ['a = o.b'] })
  }, err('a = o.b'))
  throws((e) => {
    fastRedact({ paths: ['a\n'] })
  }, err('a\n'))
  throws((e) => {
    fastRedact({ paths: ['a\r'] })
  }, err('a\r'))
  throws((e) => {
    fastRedact({ paths: [''] })
  }, err(''))
  throws((e) => {
    fastRedact({ paths: ['[""""]'] })
  }, err('[""""]'))
  end()
})

test('throws if a custom serializer is used and remove is true', ({ end, throws }) => {
  throws(() => {
    fastRedact({ paths: ['a'], serialize: (o) => o, remove: true })
  }, Error('fast-redact – remove option may only be set when serializer is JSON.stringify'))
  end()
})

test('throws if serialize is false and remove is true', ({ end, throws }) => {
  throws(() => {
    fastRedact({ paths: ['a'], serialize: false, remove: true })
  }, Error('fast-redact – remove option may only be set when serializer is JSON.stringify'))
  end()
})

test('supports path segments that aren\'t identifiers if bracketed', ({ end, strictSame }) => {
  const redactSerializeFalse = fastRedact({
    paths: ['a[""]', 'a["x-y"]', 'a[\'"y"\']', "a['\\'x\\'']"],
    serialize: false,
    censor: 'X'
  })

  const res = redactSerializeFalse({ a: { '': 'Hi!', 'x-y': 'Hi!', '"y"': 'Hi!', "'x'": 'Hi!' } })
  strictSame(res, { a: { '': 'X', 'x-y': 'X', '"y"': 'X', "'x'": 'X' } })
  end()
})

test('supports consecutive bracketed path segments', ({ end, strictSame }) => {
  const redactSerializeFalse = fastRedact({
    paths: ['a[""]["y"]'],
    serialize: false,
    censor: 'X'
  })

  const res = redactSerializeFalse({ a: { '': { 'y': 'Hi!' } } })
  strictSame(res, { a: { '': { 'y': 'X' } } })
  end()
})

test('supports leading bracketed widcard', ({ end, strictSame }) => {
  const redactSerializeFalse = fastRedact({
    paths: ['[*]["y"]'],
    serialize: false,
    censor: 'X'
  })

  const res = redactSerializeFalse({ 'x': { 'y': 'Hi!' } })
  strictSame(res, { 'x': { 'y': 'X' } })
  end()
})

test('masks according to supplied censor', ({ end, is }) => {
  const censor = 'test'
  const redact = fastRedact({ paths: ['a'], censor, serialize: false })
  is(redact({ a: 'a' }).a, censor)
  end()
})

test('redact.restore function is available when serialize is false', ({ end, is }) => {
  const censor = 'test'
  const redact = fastRedact({ paths: ['a'], censor, serialize: false })
  is(typeof redact.restore, 'function')
  end()
})

test('redact.restore function places original values back in place', ({ end, is }) => {
  const censor = 'test'
  const redact = fastRedact({ paths: ['a'], censor, serialize: false })
  const o = { a: 'a' }
  redact(o)
  is(o.a, censor)
  redact.restore(o)
  is(o.a, 'a')
  end()
})

test('redact.restore function places original values back in place when called twice and the first call is precensored', ({ end, is }) => {
  const censor = 'test'
  const redact = fastRedact({ paths: ['a'], censor, serialize: false })
  const o1 = { a: censor }
  const o2 = { a: 'a' }
  redact(o1)
  is(o1.a, censor)
  redact.restore(o1)
  is(o1.a, censor)
  redact(o2)
  is(o2.a, censor)
  redact.restore(o2)
  is(o2.a, 'a')
  end()
})

test('masks according to supplied censor function', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a'], censor: censorFct, serialize: false })
  is(redact({ a: '0123456' }).a, 'xxx56')
  end()
})

test('masks according to supplied censor function with wildcards', ({ end, is }) => {
  const redact = fastRedact({ paths: '*', censor: censorFct, serialize: false })
  is(redact({ a: '0123456' }).a, 'xxx56')
  end()
})

test('masks according to supplied censor function with nested wildcards', ({ end, is }) => {
  const redact = fastRedact({ paths: ['*.b'], censor: censorFct, serialize: false })
  is(redact({ a: { b: '0123456' } }).a.b, 'xxx56')
  is(redact({ c: { b: '0123456', d: 'pristine' } }).c.b, 'xxx56')
  is(redact({ c: { b: '0123456', d: 'pristine' } }).c.d, 'pristine')
  end()
})

test('masks according to supplied censor-with-path function', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a'], censor: censorWithPath, serialize: false })
  is(redact({ a: '0123456' }).a, 'a xxx56')
  end()
})

test('masks according to supplied censor-with-path function with wildcards', ({ end, is }) => {
  const redact = fastRedact({ paths: '*', censor: censorWithPath, serialize: false })
  is(redact({ a: '0123456' }).a, 'a xxx56')
  end()
})

test('masks according to supplied censor-with-path function with nested wildcards', ({ end, is }) => {
  const redact = fastRedact({ paths: ['*.b'], censor: censorWithPath, serialize: false })
  is(redact({ a: { b: '0123456' } }).a.b, 'a.b xxx56')
  is(redact({ c: { b: '0123456', d: 'pristine' } }).c.b, 'c.b xxx56')
  is(redact({ c: { b: '0123456', d: 'pristine' } }).c.d, 'pristine')
  end()
})

test('redact.restore function places original values back in place with censor function', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a'], censor: censorFct, serialize: false })
  const o = { a: 'qwerty' }
  redact(o)
  is(o.a, 'xxxty')
  redact.restore(o)
  is(o.a, 'qwerty')
  end()
})

test('serializes with JSON.stringify by default', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a'] })
  const o = { a: 'a' }
  is(redact(o), `{"a":"${censor}"}`)
  is(o.a, 'a')
  end()
})

test('removes during serialization instead of redacting when remove option is true', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a'], remove: true })
  const o = { a: 'a', b: 'b' }
  is(redact(o), `{"b":"b"}`)
  is(o.a, 'a')
  end()
})

test('serializes with JSON.stringify if serialize is true', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a'], serialize: true })
  const o = { a: 'a' }
  is(redact(o), `{"a":"${censor}"}`)
  is(o.a, 'a')
  end()
})

test('serializes with JSON.stringify if serialize is not a function', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a'], serialize: {} })
  const o = { a: 'a' }
  is(redact(o), `{"a":"${censor}"}`)
  is(o.a, 'a')
  end()
})

test('serializes with custom serializer if supplied', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a'], serialize: (o) => JSON.stringify(o, 0, 2) })
  const o = { a: 'a' }
  is(redact(o), `{\n  "a": "${censor}"\n}`)
  is(o.a, 'a')
  end()
})

test('redacts parent keys', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a.b.c'], serialize: false })
  const result = redact({ a: { b: { c: 's' }, d: { a: 's', b: 's', c: 's' } } })
  is(result.a.b.c, censor)
  end()
})

test('supports paths with array indexes', ({ end, same }) => {
  const redact = fastRedact({ paths: ['insideArray.like[3].this'], serialize: false })
  same(redact({ insideArray: { like: ['a', 'b', 'c', { this: { foo: 'meow' } }] } }), { insideArray: { like: ['a', 'b', 'c', { this: censor }] } })
  end()
})

test('censor may be any type, including function', ({ end, same }) => {
  const redactToString = fastRedact({ paths: ['a.b.c', 'a.b.d.*'], censor: 'censor', serialize: false })
  const redactToUndefined = fastRedact({ paths: ['a.b.c', 'a.b.d.*'], censor: undefined, serialize: false })
  const sym = Symbol('sym')
  const redactToSymbol = fastRedact({ paths: ['a.b.c', 'a.b.d.*'], censor: sym, serialize: false })
  const redactToNumber = fastRedact({ paths: ['a.b.c', 'a.b.d.*'], censor: 0, serialize: false })
  const redactToBoolean = fastRedact({ paths: ['a.b.c', 'a.b.d.*'], censor: false, serialize: false })
  const redactToNull = fastRedact({ paths: ['a.b.c', 'a.b.d.*'], censor: null, serialize: false })
  const redactToObject = fastRedact({ paths: ['a.b.c', 'a.b.d.*'], censor: { redacted: true }, serialize: false })
  const redactToArray = fastRedact({ paths: ['a.b.c', 'a.b.d.*'], censor: ['redacted'], serialize: false })
  const redactToBuffer = fastRedact({ paths: ['a.b.c', 'a.b.d.*'], censor: Buffer.from('redacted'), serialize: false })
  const redactToError = fastRedact({ paths: ['a.b.c', 'a.b.d.*'], censor: Error('redacted'), serialize: false })
  const redactToFunction = fastRedact({ paths: ['a.b.c', 'a.b.d.*'], censor: () => 'redacted', serialize: false })
  same(redactToString({ a: { b: { c: 's', d: { x: 's', y: 's' } } } }), { a: { b: { c: 'censor', d: { x: 'censor', y: 'censor' } } } })
  same(redactToUndefined({ a: { b: { c: 's', d: { x: 's', y: 's' } } } }), { a: { b: { c: undefined, d: { x: undefined, y: undefined } } } })
  same(redactToSymbol({ a: { b: { c: 's', d: { x: 's', y: 's' } } } }), { a: { b: { c: sym, d: { x: sym, y: sym } } } })
  same(redactToNumber({ a: { b: { c: 's', d: { x: 's', y: 's' } } } }), { a: { b: { c: 0, d: { x: 0, y: 0 } } } })
  same(redactToBoolean({ a: { b: { c: 's', d: { x: 's', y: 's' } } } }), { a: { b: { c: false, d: { x: false, y: false } } } })
  same(redactToNull({ a: { b: { c: 's', d: { x: 's', y: 's' } } } }), { a: { b: { c: null, d: { x: null, y: null } } } })
  same(redactToObject({ a: { b: { c: 's', d: { x: 's', y: 's' } } } }), { a: { b: { c: { redacted: true }, d: { x: { redacted: true }, y: { redacted: true } } } } })
  same(redactToArray({ a: { b: { c: 's', d: { x: 's', y: 's' } } } }), { a: { b: { c: ['redacted'], d: { x: ['redacted'], y: ['redacted'] } } } })
  same(redactToBuffer({ a: { b: { c: 's', d: { x: 's', y: 's' } } } }), { a: { b: { c: Buffer.from('redacted'), d: { x: Buffer.from('redacted'), y: Buffer.from('redacted') } } } })
  same(redactToError({ a: { b: { c: 's', d: { x: 's', y: 's' } } } }), { a: { b: { c: Error('redacted'), d: { x: Error('redacted'), y: Error('redacted') } } } })
  same(redactToFunction({ a: { b: { c: 's', d: { x: 's', y: 's' } } } }), { a: { b: { c: 'redacted', d: { x: 'redacted', y: 'redacted' } } } })
  end()
})

test('supports multiple paths from the same root', ({ end, same }) => {
  const redact = fastRedact({ paths: ['deep.bar.shoe', 'deep.baz.shoe', 'deep.foo', 'deep.not.there.sooo', 'deep.fum.shoe'], serialize: false })
  same(redact({ deep: { bar: 'hmm', baz: { shoe: { k: 1 } }, foo: {}, fum: { shoe: 'moo' } } }), { deep: { bar: 'hmm', baz: { shoe: censor }, foo: censor, fum: { shoe: censor } } })
  end()
})

test('supports strings in bracket notation paths (single quote)', ({ end, is }) => {
  const redact = fastRedact({ paths: [`a['@#!='].c`], serialize: false })
  const result = redact({ a: { '@#!=': { c: 's' }, d: { a: 's', b: 's', c: 's' } } })
  is(result.a['@#!='].c, censor)
  end()
})

test('supports strings in bracket notation paths (double quote)', ({ end, is }) => {
  const redact = fastRedact({ paths: [`a["@#!="].c`], serialize: false })
  const result = redact({ a: { '@#!=': { c: 's' }, d: { a: 's', b: 's', c: 's' } } })
  is(result.a['@#!='].c, censor)
  end()
})

test('supports strings in bracket notation paths (backtick quote)', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a[`@#!=`].c'], serialize: false })
  const result = redact({ a: { '@#!=': { c: 's' }, d: { a: 's', b: 's', c: 's' } } })
  is(result.a['@#!='].c, censor)
  end()
})

test('allows * within a bracket notation string', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a["*"].c'], serialize: false })
  const result = redact({ a: { '*': { c: 's', x: 1 } } })
  is(result.a['*'].c, censor)
  is(result.a['*'].x, 1)
  end()
})

test('redacts parent keys – restore', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a.b.c'], serialize: false })
  const result = redact({ a: { b: { c: 's' }, d: { a: 's', b: 's', c: 's' } } })
  is(result.a.b.c, censor)
  redact.restore(result)
  is(result.a.b.c, 's')
  end()
})

test('handles null proto objects', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a.b.c'], serialize: false })
  const result = redact({ __proto__: null, a: { b: { c: 's' }, d: { a: 's', b: 's', c: 's' } } })
  is(result.a.b.c, censor)
  end()
})

test('handles null proto objects – restore', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a.b.c'], serialize: false })
  const result = redact({ __proto__: null, a: { b: { c: 's' }, d: { a: 's', b: 's', c: 's' } } })
  is(result.a.b.c, censor)
  redact.restore(result, 's')
  is(result.a.b.c, 's')
  end()
})

test('handles paths that do not match object structure', ({ end, same }) => {
  const redact = fastRedact({ paths: ['x.y.z'], serialize: false })
  same(redact({ a: { b: { c: 's' } } }), { a: { b: { c: 's' } } })
  end()
})

test('ignores missing paths in object', ({ end, same }) => {
  const redact = fastRedact({ paths: ['a.b.c', 'a.z.d', 'a.b.z'], serialize: false })
  same(redact({ a: { b: { c: 's' } } }), { a: { b: { c: censor } } })
  end()
})

test('ignores missing paths in object – restore', ({ end, doesNotThrow }) => {
  const redact = fastRedact({ paths: ['a.b.c', 'a.z.d', 'a.b.z'], serialize: false })
  const o = { a: { b: { c: 's' } } }
  redact(o)
  doesNotThrow(() => {
    redact.restore(o)
  })

  end()
})

test('gracefully handles primitives that match intermediate keys in paths', ({ end, same }) => {
  const redact = fastRedact({ paths: ['a.b.c', 'a.b.c.d'], serialize: false })
  same(redact({ a: { b: null } }), { a: { b: null } })
  same(redact({ a: { b: 's' } }), { a: { b: 's' } })
  same(redact({ a: { b: 1 } }), { a: { b: 1 } })
  same(redact({ a: { b: undefined } }), { a: { b: undefined } })
  same(redact({ a: { b: true } }), { a: { b: true } })
  const sym = Symbol('sym')
  same(redact({ a: { b: sym } }), { a: { b: sym } })
  end()
})

test('handles circulars', ({ end, is, same }) => {
  const redact = fastRedact({ paths: ['bar.baz.baz'], serialize: false })
  const bar = { b: 2 }
  const o = { a: 1, bar }
  bar.baz = bar
  o.bar.baz = o.bar
  same(redact(o), { a: 1, bar: { b: 2, baz: censor } })
  end()
})

test('handles circulars – restore', ({ end, is, same }) => {
  const redact = fastRedact({ paths: ['bar.baz.baz'], serialize: false })
  const bar = { b: 2 }
  const o = { a: 1, bar }
  bar.baz = bar
  o.bar.baz = o.bar
  is(o.bar.baz, bar)
  redact(o)
  is(o.bar.baz, censor)
  redact.restore(o)
  is(o.bar.baz, bar)
  end()
})

test('handles circulars and cross references – restore', ({ end, is, same }) => {
  const redact = fastRedact({ paths: ['bar.baz.baz', 'cf.bar'], serialize: false })
  const bar = { b: 2 }
  const o = { a: 1, bar, cf: { bar } }
  bar.baz = bar
  o.bar.baz = o.bar
  is(o.bar.baz, bar)
  is(o.cf.bar, bar)
  redact(o)
  is(o.bar.baz, censor)
  is(o.cf.bar, censor)
  redact.restore(o)
  is(o.bar.baz, bar)
  is(o.cf.bar, bar)
  end()
})

test('ultimate wildcards – shallow', ({ end, same }) => {
  const redact = fastRedact({ paths: ['test.*'], serialize: false })
  same(redact({ test: { baz: 1, bar: 'private' } }), { test: { baz: censor, bar: censor } })
  end()
})

test('ultimate wildcards – deep', ({ end, same }) => {
  const redact = fastRedact({ paths: ['deep.bar.baz.ding.*'], serialize: false })
  same(redact({ deep: { a: 1, bar: { b: 2, baz: { c: 3, ding: { d: 4, e: 5, f: 'six' } } } } }), { deep: { a: 1, bar: { b: 2, baz: { c: 3, ding: { d: censor, e: censor, f: censor } } } } })
  end()
})

test('ultimate wildcards - array – shallow', ({ end, same }) => {
  const redact = fastRedact({ paths: ['array[*]'], serialize: false })
  same(redact({ array: ['a', 'b', 'c', 'd'] }), { array: [censor, censor, censor, censor] })
  end()
})

test('ultimate wildcards – array – deep', ({ end, same }) => {
  const redact = fastRedact({ paths: ['deepArray.down.here[*]'], serialize: false })
  same(redact({ deepArray: { down: { here: ['a', 'b', 'c'] } } }), { deepArray: { down: { here: [censor, censor, censor] } } })
  end()
})

test('ultimate wildcards – array – single index', ({ end, same }) => {
  const redact = fastRedact({ paths: ['insideArray.like[3].this.*'], serialize: false })
  same(redact({ insideArray: { like: ['a', 'b', 'c', { this: { foo: 'meow' } }] } }), { insideArray: { like: ['a', 'b', 'c', { this: { foo: censor } }] } })
  end()
})

test('ultimate wildcards - handles null proto objects', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a.b.c'], serialize: false })
  const result = redact({ __proto__: null, a: { b: { c: 's' }, d: { a: 's', b: 's', c: 's' } } })
  is(result.a.b.c, censor)
  end()
})

test('ultimate wildcards - handles paths that do not match object structure', ({ end, same }) => {
  const redact = fastRedact({ paths: ['x.y.z'], serialize: false })
  same(redact({ a: { b: { c: 's' } } }), { a: { b: { c: 's' } } })
  end()
})

test('ultimate wildcards - gracefully handles primitives that match intermediate keys in paths', ({ end, same }) => {
  const redact = fastRedact({ paths: ['a.b.c', 'a.b.c.d'], serialize: false })
  same(redact({ a: { b: null } }), { a: { b: null } })
  same(redact({ a: { b: 's' } }), { a: { b: 's' } })
  same(redact({ a: { b: 1 } }), { a: { b: 1 } })
  same(redact({ a: { b: undefined } }), { a: { b: undefined } })
  same(redact({ a: { b: true } }), { a: { b: true } })
  const sym = Symbol('sym')
  same(redact({ a: { b: sym } }), { a: { b: sym } })
  end()
})

test('ultimate wildcards – handles circulars', ({ end, is, same }) => {
  const redact = fastRedact({ paths: ['bar.baz.*'], serialize: false })
  const bar = { b: 2 }
  const o = { a: 1, bar }
  bar.baz = bar
  o.bar.baz = o.bar
  same(redact(o), { a: 1, bar: { b: censor, baz: censor } })
  end()
})

test('ultimate wildcards – handles circulars – restore', ({ end, is }) => {
  const redact = fastRedact({ paths: ['bar.baz.*'], serialize: false })
  const bar = { b: 2 }
  const o = { a: 1, bar }
  bar.baz = bar
  o.bar.baz = o.bar
  is(o.bar.baz, bar)
  redact(o)
  is(o.bar.baz, censor)
  redact.restore(o)
  is(o.bar.baz, bar)
  end()
})

test('ultimate multi wildcards – handles circulars – restore', ({ end, is, same }) => {
  const redact = fastRedact({ paths: ['bar.*.baz.*.b'], serialize: false })
  const bar = { b: 2 }
  const o = { a: 1, bar }
  bar.baz = bar
  o.bar.baz = o.bar
  is(o.bar.baz, bar)
  redact(o)
  is(o.bar.baz.b, censor)
  redact.restore(o)
  same(o.bar.baz, bar)
  end()
})

test('ultimate wildcards – handles circulars and cross references – restore', ({ end, is }) => {
  const redact = fastRedact({ paths: ['bar.baz.*', 'cf.*'], serialize: false })
  const bar = { b: 2 }
  const o = { a: 1, bar, cf: { bar } }
  bar.baz = bar
  o.bar.baz = o.bar
  is(o.bar.baz, bar)
  is(o.cf.bar, bar)
  redact(o)
  is(o.bar.baz, censor)
  is(o.cf.bar, censor)
  redact.restore(o)
  is(o.bar.baz, bar)
  is(o.cf.bar, bar)
  end()
})

test('static + wildcards', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a.b.c', 'a.d.*', 'a.b.z.*'], serialize: false })
  const result = redact({ a: { b: { c: 's', z: { x: 's', y: 's' } }, d: { a: 's', b: 's', c: 's' } } })

  is(result.a.b.c, censor)
  is(result.a.d.a, censor)
  is(result.a.d.b, censor)
  is(result.a.d.c, censor)
  is(result.a.b.z.x, censor)
  is(result.a.b.z.y, censor)
  end()
})

test('static + wildcards reuse', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a.b.c', 'a.d.*'], serialize: false })
  const result = redact({ a: { b: { c: 's' }, d: { a: 's', b: 's', c: 's' } } })

  is(result.a.b.c, censor)
  is(result.a.d.a, censor)
  is(result.a.d.b, censor)
  is(result.a.d.c, censor)

  redact.restore(result)

  const result2 = redact({ a: { b: { c: 's' }, d: { a: 's', b: 's', c: 's' } } })
  is(result2.a.b.c, censor)
  is(result2.a.d.a, censor)
  is(result2.a.d.b, censor)
  is(result2.a.d.c, censor)

  redact.restore(result2)
  end()
})

test('parent wildcard – first position', ({ end, is }) => {
  const redact = fastRedact({ paths: ['*.c'], serialize: false })
  const result = redact({ b: { c: 's' }, d: { a: 's', b: 's', c: 's' } })
  is(result.b.c, censor)
  is(result.d.a, 's')
  is(result.d.b, 's')
  is(result.d.c, censor)
  end()
})

test('parent wildcard – one following key', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a.*.c'], serialize: false })
  const result = redact({ a: { b: { c: 's' }, d: { a: 's', b: 's', c: 's' } } })
  is(result.a.b.c, censor)
  is(result.a.d.a, 's')
  is(result.a.d.b, 's')
  is(result.a.d.c, censor)
  end()
})

test('restore parent wildcard  – one following key', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a.*.c'], serialize: false })
  const result = redact({ a: { b: { c: 's' }, d: { a: 's', b: 's', c: 's' } } })
  redact.restore(result)
  is(result.a.b.c, 's')
  is(result.a.d.a, 's')
  is(result.a.d.b, 's')
  is(result.a.d.c, 's')
  end()
})

test('parent wildcard – one following key – reuse', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a.*.c'], serialize: false })
  const result = redact({ a: { b: { c: 's' }, d: { a: 's', b: 's', c: 's' } } })
  is(result.a.b.c, censor)
  is(result.a.d.a, 's')
  is(result.a.d.b, 's')
  is(result.a.d.c, censor)
  const result2 = redact({ a: { b: { c: 's' }, d: { a: 's', b: 's', c: 's' } } })
  is(result2.a.b.c, censor)
  is(result2.a.d.a, 's')
  is(result2.a.d.b, 's')
  is(result2.a.d.c, censor)
  redact.restore(result2)
  end()
})

test('parent wildcard – two following keys', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a.*.x.c'], serialize: false })
  const result = redact({ a: { b: { x: { c: 's' } }, d: { x: { a: 's', b: 's', c: 's' } } } })
  is(result.a.b.x.c, censor)
  is(result.a.d.x.a, 's')
  is(result.a.d.x.b, 's')
  is(result.a.d.x.c, censor)
  end()
})

test('multi object wildcard', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a.*.x.*.c'], serialize: false })
  const result = redact({ a: { b: { x: { z: { c: 's' } } }, d: { x: { u: { a: 's', b: 's', c: 's' } } } } })
  is(result.a.b.x.z.c, censor)
  is(result.a.d.x.u.a, 's')
  is(result.a.d.x.u.b, 's')
  is(result.a.d.x.u.c, censor)
  redact.restore(result)
  is(result.a.b.x.z.c, 's')
  is(result.a.d.x.u.a, 's')
  is(result.a.d.x.u.b, 's')
  is(result.a.d.x.u.c, 's')
  end()
})

test('parent wildcard  – two following keys – reuse', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a.*.x.c'], serialize: false })
  const result = redact({ a: { b: { x: { c: 's' } }, d: { x: { a: 's', b: 's', c: 's' } } } })
  is(result.a.b.x.c, censor)
  is(result.a.d.x.a, 's')
  is(result.a.d.x.b, 's')
  is(result.a.d.x.c, censor)
  redact.restore(result)
  const result2 = redact({ a: { b: { x: { c: 's' } }, d: { x: { a: 's', b: 's', c: 's' } } } })
  is(result2.a.b.x.c, censor)
  is(result2.a.d.x.a, 's')
  is(result2.a.d.x.b, 's')
  is(result2.a.d.x.c, censor)
  end()
})

test('restore parent wildcard  – two following keys', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a.*.x.c'], serialize: false })
  const result = redact({ a: { b: { x: { c: 's' } }, d: { x: { a: 's', b: 's', c: 's' } } } })
  redact.restore(result)
  is(result.a.b.x.c, 's')
  is(result.a.d.x.a, 's')
  is(result.a.d.x.b, 's')
  is(result.a.d.x.c, 's')
  end()
})

test('parent wildcard - array', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a.b[*].x'], serialize: false })
  const result = redact({ a: { b: [{ x: 1 }, { a: 2 }], d: { a: 's', b: 's', c: 's' } } })
  is(result.a.b[0].x, censor)
  is(result.a.b[1].a, 2)
  is(result.a.d.a, 's')
  is(result.a.d.b, 's')
  end()
})

test('multiple wildcards', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a[*].c[*].d'], serialize: false })
  const obj = {
    a: [
      { c: [{ d: '1', e: '2' }, { d: '1', e: '3' }, { d: '1', e: '4' }] },
      { c: [{ d: '1', f: '5' }] },
      { c: [{ d: '2', g: '6' }] }
    ]
  }
  const result = redact(obj)
  is(result.a[0].c[0].d, censor)
  is(result.a[0].c[0].e, '2')
  is(result.a[0].c[1].d, censor)
  is(result.a[0].c[1].e, '3')
  is(result.a[0].c[2].d, censor)
  is(result.a[0].c[2].e, '4')
  is(result.a[1].c[0].d, censor)
  is(result.a[1].c[0].f, '5')
  is(result.a[2].c[0].d, censor)
  is(result.a[2].c[0].g, '6')
  redact.restore(result)
  is(result.a[0].c[0].d, '1')
  is(result.a[0].c[0].e, '2')
  is(result.a[0].c[1].d, '1')
  is(result.a[0].c[1].e, '3')
  is(result.a[0].c[2].d, '1')
  is(result.a[0].c[2].e, '4')
  is(result.a[1].c[0].d, '1')
  is(result.a[1].c[0].f, '5')
  is(result.a[2].c[0].d, '2')
  is(result.a[2].c[0].g, '6')
  end()
})

test('multiple wildcards - censor function', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a[*].c[*].d'], censor: censorFct, serialize: false })
  const obj = {
    a: [
      { c: [{ d: '1', e: '2' }, { d: '1', e: '3' }, { d: '1', e: '4' }] },
      { c: [{ d: '1', f: '5' }] },
      { c: [{ d: '2', g: '6' }] }
    ]
  }
  const result = redact(obj)
  is(result.a[0].c[0].d, 'xxx1')
  is(result.a[0].c[0].e, '2')
  is(result.a[0].c[1].d, 'xxx1')
  is(result.a[0].c[1].e, '3')
  is(result.a[0].c[2].d, 'xxx1')
  is(result.a[0].c[2].e, '4')
  is(result.a[1].c[0].d, 'xxx1')
  is(result.a[1].c[0].f, '5')
  is(result.a[2].c[0].d, 'xxx2')
  is(result.a[2].c[0].g, '6')
  end()
})

test('multiple wildcards end', ({ end, is, same }) => {
  const redact = fastRedact({ paths: ['a[*].c.d[*]'], serialize: false })
  const obj = {
    a: [
      { c: { d: [ '1', '2' ], e: '3' } },
      { c: { d: [ '1' ], f: '4' } },
      { c: { d: [ '1' ], g: '5' } }
    ]
  }
  const result = redact(obj)
  same(result.a[0].c.d, [censor, censor])
  is(result.a[0].c.e, '3')
  same(result.a[1].c.d, [censor])
  is(result.a[1].c.f, '4')
  same(result.a[2].c.d, [censor])
  is(result.a[2].c.g, '5')
  end()
})

test('multiple wildcards depth after n wildcard', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a[*].c.d[*].i'], serialize: false })
  const obj = {
    a: [
      { c: { d: [ { i: '1', j: '2' } ], e: '3' } },
      { c: { d: [ { i: '1', j: '2' }, { i: '1', j: '3' } ], f: '4' } },
      { c: { d: [ { i: '1', j: '2' } ], g: '5' } }
    ]
  }
  const result = redact(obj)
  is(result.a[0].c.d[0].i, censor)
  is(result.a[0].c.d[0].j, '2')
  is(result.a[0].c.e, '3')
  is(result.a[1].c.d[0].i, censor)
  is(result.a[1].c.d[0].j, '2')
  is(result.a[1].c.d[1].i, censor)
  is(result.a[1].c.d[1].j, '3')
  is(result.a[1].c.f, '4')
  is(result.a[2].c.d[0].i, censor)
  is(result.a[2].c.d[0].j, '2')
  is(result.a[2].c.g, '5')
  end()
})

test('parent wildcards – array – single index', ({ end, same }) => {
  const redact = fastRedact({ paths: ['insideArray.like[3].*.foo'], serialize: false })
  same(redact({ insideArray: { like: ['a', 'b', 'c', { this: { foo: 'meow' } }] } }), { insideArray: { like: ['a', 'b', 'c', { this: { foo: censor } }] } })
  end()
})

test('parent wildcards - handles null proto objects', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a.*.c'], serialize: false })
  const result = redact({ __proto__: null, a: { b: { c: 's' }, d: { a: 's', b: 's', c: 's' } } })
  is(result.a.b.c, censor)
  end()
})

test('parent wildcards - handles paths that do not match object structure', ({ end, same }) => {
  const redact = fastRedact({ paths: ['a.*.y.z'], serialize: false })
  same(redact({ a: { b: { c: 's' } } }), { a: { b: { c: 's' } } })
  end()
})

test('parent wildcards - gracefully handles primitives that match intermediate keys in paths', ({ end, same }) => {
  const redact = fastRedact({ paths: ['a.*.c'], serialize: false })
  same(redact({ a: { b: null } }), { a: { b: null } })
  same(redact({ a: { b: 's' } }), { a: { b: 's' } })
  same(redact({ a: { b: 1 } }), { a: { b: 1 } })
  same(redact({ a: { b: undefined } }), { a: { b: undefined } })
  same(redact({ a: { b: true } }), { a: { b: true } })
  const sym = Symbol('sym')
  same(redact({ a: { b: sym } }), { a: { b: sym } })
  end()
})

test('parent wildcards – handles circulars', ({ end, same }) => {
  const redact = fastRedact({ paths: ['x.*.baz'], serialize: false })
  const bar = { b: 2 }
  const o = { x: { a: 1, bar } }
  bar.baz = bar
  o.x.bar.baz = o.x.bar
  same(redact(o), { x: { a: 1, bar: { b: 2, baz: censor } } })
  end()
})

test('parent wildcards – handles circulars – restore', ({ end, is }) => {
  const redact = fastRedact({ paths: ['x.*.baz'], serialize: false })
  const bar = { b: 2 }
  const o = { x: { a: 1, bar } }
  bar.baz = bar
  o.x.bar.baz = o.x.bar
  is(o.x.bar.baz, bar)
  redact(o)
  is(o.x.a, 1)
  is(o.x.bar.baz, censor)
  redact.restore(o)
  is(o.x.bar.baz, bar)
  end()
})

test('parent wildcards – handles circulars and cross references – restore', ({ end, is }) => {
  const redact = fastRedact({ paths: ['x.*.baz', 'x.*.cf.bar'], serialize: false })
  const bar = { b: 2 }
  const o = { x: { a: 1, bar, y: { cf: { bar } } } }
  bar.baz = bar
  o.x.bar.baz = o.x.bar
  is(o.x.bar.baz, bar)
  is(o.x.y.cf.bar, bar)
  redact(o)
  is(o.x.bar.baz, censor)
  is(o.x.y.cf.bar, censor)
  redact.restore(o)
  is(o.x.bar.baz, bar)
  is(o.x.y.cf.bar, bar)
  end()
})

test('parent wildcards – handles missing paths', ({ end, is }) => {
  const redact = fastRedact({ paths: ['z.*.baz'] })
  const o = { a: { b: { c: 's' }, d: { a: 's', b: 's', c: 's' } } }
  is(redact(o), JSON.stringify(o))
  end()
})

test('ultimate wildcards – handles missing paths', ({ end, is }) => {
  const redact = fastRedact({ paths: ['z.*'] })
  const o = { a: { b: { c: 's' }, d: { a: 's', b: 's', c: 's' } } }
  is(redact(o), JSON.stringify(o))
  end()
})

test('parent wildcards – removes during serialization instead of redacting when remove option is true', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a.*.c'], remove: true })
  const o = { a: { b: { c: 'c' }, x: { c: 1 } } }
  is(redact(o), `{"a":{"b":{},"x":{}}}`)
  end()
})

test('ultimate wildcards – removes during serialization instead of redacting when remove option is true', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a.b.*'], remove: true })
  const o = { a: { b: { c: 'c' }, x: { c: 1 } } }
  is(redact(o), `{"a":{"b":{},"x":{"c":1}}}`)
  end()
})

test('supports leading bracket notation', ({ end, is }) => {
  const redact = fastRedact({ paths: ['["a"].b.c'] })
  const o = { a: { b: { c: 'd' } } }
  is(redact(o), `{"a":{"b":{"c":"${censor}"}}}`)
  end()
})

test('supports leading bracket notation containing non-legal keyword characters', ({ end, is }) => {
  const redact = fastRedact({ paths: ['["a-x"].b.c'] })
  const o = { 'a-x': { b: { c: 'd' } } }
  is(redact(o), `{"a-x":{"b":{"c":"${censor}"}}}`)
  end()
})

test('supports single leading bracket', ({ end, is }) => {
  const censor = 'test'
  const redact = fastRedact({ paths: ['["a"]'], censor, serialize: false })
  is(redact({ a: 'a' }).a, censor)
  end()
})

test('supports single leading bracket containing non-legal keyword characters', ({ end, is }) => {
  const censor = 'test'
  const redact = fastRedact({ paths: ['["a-x"]'], censor, serialize: false })
  is(redact({ 'a-x': 'a' })['a-x'], censor)
  end()
})

test('(leading brackets) ultimate wildcards – handles circulars and cross references – restore', ({ end, is }) => {
  const redact = fastRedact({ paths: ['bar.baz.*', 'cf.*'], serialize: false })
  const bar = { b: 2 }
  const o = { a: 1, bar, cf: { bar } }
  bar.baz = bar
  o.bar.baz = o.bar
  is(o.bar.baz, bar)
  is(o.cf.bar, bar)
  redact(o)
  is(o.bar.baz, censor)
  is(o.cf.bar, censor)
  redact.restore(o)
  is(o.bar.baz, bar)
  is(o.cf.bar, bar)
  end()
})

test('(leading brackets) parent wildcards – handles circulars and cross references – restore', ({ end, is }) => {
  const redact = fastRedact({ paths: ['["x"].*.baz', '["x"].*.cf.bar'], serialize: false })
  const bar = { b: 2 }
  const o = { x: { a: 1, bar, y: { cf: { bar } } } }
  bar.baz = bar
  o.x.bar.baz = o.x.bar
  is(o.x.bar.baz, bar)
  is(o.x.y.cf.bar, bar)
  redact(o)
  is(o.x.bar.baz, censor)
  is(o.x.y.cf.bar, censor)
  redact.restore(o)
  is(o.x.bar.baz, bar)
  is(o.x.y.cf.bar, bar)
  end()
})

test('(leading brackets) ultimate wildcards – handles missing paths', ({ end, is }) => {
  const redact = fastRedact({ paths: ['["z"].*'] })
  const o = { a: { b: { c: 's' }, d: { a: 's', b: 's', c: 's' } } }
  is(redact(o), JSON.stringify(o))
  end()
})

test('(leading brackets) static + wildcards reuse', ({ end, is }) => {
  const redact = fastRedact({ paths: ['["a"].b.c', '["a"].d.*'], serialize: false })
  const result = redact({ a: { b: { c: 's' }, d: { a: 's', b: 's', c: 's' } } })

  is(result.a.b.c, censor)
  is(result.a.d.a, censor)
  is(result.a.d.b, censor)
  is(result.a.d.c, censor)

  redact.restore(result)

  const result2 = redact({ a: { b: { c: 's' }, d: { a: 's', b: 's', c: 's' } } })
  is(result2.a.b.c, censor)
  is(result2.a.d.a, censor)
  is(result2.a.d.b, censor)
  is(result2.a.d.c, censor)

  redact.restore(result2)
  end()
})

test('correctly restores original object when a path does not match object', ({ end, is }) => {
  const redact = fastRedact({ paths: ['foo.bar'], strict: false })
  const o = {}
  is(redact({ foo: o }), '{"foo":{}}')
  is(o.hasOwnProperty('bar'), false)
  end()
})

test('correctly restores original object when a matching path has value of `undefined`', ({ end, is }) => {
  const redact = fastRedact({ paths: ['foo.bar'], strict: false })
  const o = { bar: undefined }
  is(redact({ foo: o }), '{"foo":{}}')
  is(o.hasOwnProperty('bar'), true)
  is(o.bar, undefined)
  end()
})

test('correctly restores keys matching a static path and a wildcard', ({ end, is }) => {
  const redact = fastRedact({
    paths: ['a', '*.b', 'x.b'],
    serialize: false
  })
  const o = { x: { a: 'a', b: 'b' } }
  redact(o)
  is(o.x.a, 'a')
  is(o.x.b, '[REDACTED]')
  redact.restore(o)
  is(o.x.a, 'a')
  is(o.x.b, 'b')
  end()
})

test('correctly restores keys matching multiple wildcards', ({ end, is }) => {
  const redact = fastRedact({
    paths: ['a', '*.b', 'x.*', 'y.*.z'],
    serialize: false
  })
  const o = { x: { a: 'a', b: 'b' }, y: { f: { z: 'z' } } }
  redact(o)
  is(o.x.a, '[REDACTED]')
  is(o.x.b, '[REDACTED]')
  is(o.y.f.z, '[REDACTED]')
  redact.restore(o)
  is(o.x.a, 'a')
  is(o.x.b, 'b')
  is(o.y.f.z, 'z')
  end()
})

test('handles multiple paths with leading brackets', ({ end, is }) => {
  const redact = fastRedact({ paths: ['["x-y"]', '["y-x"]'] })
  const o = { 'x-y': 'test', 'y-x': 'test2' }
  is(redact(o), '{"x-y":"[REDACTED]","y-x":"[REDACTED]"}')
  end()
})

test('handles objects with and then without target paths', ({ end, is }) => {
  const redact = fastRedact({ paths: ['test'] })
  const o1 = { test: 'check' }
  const o2 = {}
  is(redact(o1), '{"test":"[REDACTED]"}')
  is(redact(o2), '{}')
  // run each check twice to ensure no mutations
  is(redact(o1), '{"test":"[REDACTED]"}')
  is(redact(o2), '{}')
  is('test' in o1, true)
  is('test' in o2, false)
  end()
})

test('handles leading wildcards and null values', ({ end, is }) => {
  const redact = fastRedact({ paths: ['*.test'] })
  const o = { prop: null }
  is(redact(o), '{"prop":null}')
  is(o.prop, null)
  end()
})

test('handles keys with dots', ({ end, is }) => {
  const redactSingleQ = fastRedact({ paths: [`a['b.c']`], serialize: false })
  const redactDoubleQ = fastRedact({ paths: [`a["b.c"]`], serialize: false })
  const redactBacktickQ = fastRedact({ paths: ['a[`b.c`]'], serialize: false })
  const redactNum = fastRedact({ paths: [`a[-1.2]`], serialize: false })
  const redactLeading = fastRedact({ paths: [`["b.c"]`], serialize: false })
  is(redactSingleQ({ a: { 'b.c': 'x', '-1.2': 'x' } }).a['b.c'], censor)
  is(redactDoubleQ({ a: { 'b.c': 'x', '-1.2': 'x' } }).a['b.c'], censor)
  is(redactBacktickQ({ a: { 'b.c': 'x', '-1.2': 'x' } }).a['b.c'], censor)
  is(redactNum({ a: { 'b.c': 'x', '-1.2': 'x' } }).a['-1.2'], censor)
  is(redactLeading({ 'b.c': 'x', '-1.2': 'x' })['b.c'], censor)
  end()
})

test('handles multi wildcards within arrays', ({ end, is }) => {
  const redact = fastRedact({
    paths: ['a[*].x.d[*].i.*']
  })
  const o = {
    a: [ { x: { d: [ { j: { i: 'R' } }, { i: 'R', j: 'NR' } ] } } ]
  }
  is(redact(o), '{"a":[{"x":{"d":["[REDACTED]","[REDACTED]"]}}]}')
  end()
})

test('handles multi wildcards within arrays with a censorFct', ({ end, is }) => {
  const redact = fastRedact({
    paths: ['a[*].x.d[*].i.*.i'],
    censor: censorWithPath
  })
  const o = {
    a: [
      { x: { d: [ { i: 'R', j: 'NR' } ] } }
    ]
  }
  is(redact(o), '{"a":[{"x":{"d":[{"i":"a.0.x.d.*.i.*.i xxxR","j":"NR"}]}}]}')
  end()
})

test('handles multi wildcards within arrays with undefined values', ({ end, is }) => {
  const redact = fastRedact({
    paths: ['a[*].x.d[*].i.*.i']
  })
  const o = {
    a: [
      { x: { d: [ { i: undefined, j: 'NR' } ] } }
    ]
  }
  is(redact(o), '{"a":[{"x":{"d":[{"i":"[REDACTED]","j":"NR"}]}}]}')
  end()
})

test('handles multi wildcards with objects containing nulls', ({ end, is }) => {
  const redact = fastRedact({
    paths: ['*.*.x'],
    serialize: false,
    censor: '[REDACTED]'
  })
  const o = { a: { b: null } }
  is(redact(o), o)
  end()
})

test('handles multi wildcards with pattern repetition', ({ end, is }) => {
  const redact = fastRedact({
    paths: ['*.d', '*.*.d', '*.*.*.d']
  })
  const o = {
    x: { c: { d: 'hide me', e: 'leave me be' } },
    y: { c: { d: 'and me', f: 'I want to live' } },
    z: { c: { d: 'and also I', g: 'I want to run in a stream' } }
  }
  is(redact(o), '{"x":{"c":{"d":"[REDACTED]","e":"leave me be"}},"y":{"c":{"d":"[REDACTED]","f":"I want to live"}},"z":{"c":{"d":"[REDACTED]","g":"I want to run in a stream"}}}')
  end()
})

test('restores multi wildcards with pattern repetition', ({ end, is }) => {
  const redact = fastRedact({
    paths: ['*.d', '*.*.d', '*.*.*.d']
  })
  const o = {
    x: { c: { d: 'hide me', e: 'leave me be' } },
    y: { c: { d: 'and me', f: 'I want to live' } },
    z: { c: { d: 'and also I', g: 'I want to run in a stream' } }
  }
  redact(o)
  is(o.x.c.d, 'hide me')
  is(o.y.c.d, 'and me')
  is(o.z.c.d, 'and also I')
  end()
})

test('multi level wildcards with level > 3', ({ end, is }) => {
  const redact = fastRedact({ paths: ['*.*.*.c', '*.*.*.*.c'] })
  const o = {
    a: {
      b: {
        x: {
          c: 's'
        }
      },
      d: {
        x: {
          u: {
            a: 's',
            b: 's',
            c: 's'
          }
        }
      }
    }
  }
  is(redact(o), '{"a":{"b":{"x":{"c":"[REDACTED]"}},"d":{"x":{"u":{"a":"s","b":"s","c":"[REDACTED]"}}}}}')
  end()
})

test('multi level wildcards at nested level inside object', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a.*.*.c', 'a.d.*.*.c'] })
  const o = {
    a: {
      b: {
        x: {
          c: 's'
        }
      },
      d: {
        x: {
          u: {
            a: 's',
            b: 's',
            c: 's'
          }
        }
      }
    }
  }
  is(redact(o), '{"a":{"b":{"x":{"c":"[REDACTED]"}},"d":{"x":{"u":{"a":"s","b":"s","c":"[REDACTED]"}}}}}')
  end()
})

test('multi level wildcards with level > 3 with serialize false', ({ end, is }) => {
  const redact = fastRedact({ paths: ['*.*.*.c', '*.*.*.*.c'], serialize: false })
  const result = redact({ a: { b: { x: { c: 's' } }, d: { x: { u: { a: 's', b: 's', c: 's' } } } } })
  is(result.a.b.x.c, censor)
  is(result.a.d.x.u.a, 's')
  is(result.a.d.x.u.b, 's')
  is(result.a.d.x.u.c, censor)
  redact.restore(result)
  is(result.a.b.x.c, 's')
  is(result.a.d.x.u.a, 's')
  is(result.a.d.x.u.b, 's')
  is(result.a.d.x.u.c, 's')
  end()
})

test('multi level wildcards at nested level inside object with serialize false', ({ end, is }) => {
  const redact = fastRedact({ paths: ['a.*.*.c', 'a.d.*.*.c'], serialize: false })
  const result = redact({ a: { b: { x: { c: 's' } }, d: { x: { u: { a: 's', b: 's', c: 's' } } } } })
  is(result.a.b.x.c, censor)
  is(result.a.d.x.u.a, 's')
  is(result.a.d.x.u.b, 's')
  is(result.a.d.x.u.c, censor)
  redact.restore(result)
  is(result.a.b.x.c, 's')
  is(result.a.d.x.u.a, 's')
  is(result.a.d.x.u.b, 's')
  is(result.a.d.x.u.c, 's')
  end()
})

test('restores nested wildcard values', ({ end, is }) => {
  const o = { a: { b: [{ c: [
    { d: '123' },
    { d: '456' }
  ] }] } }

  const censor = 'censor'
  const paths = ['a.b[*].c[*].d']
  const redact = fastRedact({ paths, censor, serialize: false })

  redact(o)
  is(o.a.b[0].c[0].d, censor)
  is(o.a.b[0].c[1].d, censor)
  redact.restore(o)
  is(o.a.b[0].c[0].d, '123')
  is(o.a.b[0].c[1].d, '456')
  end()
})

test('restores multi nested wildcard values', ({ end, is }) => {
  const o = {
    a: {
      b1: {
        c1: {
          d1: { e: '123' },
          d2: { e: '456' }
        },
        c2: {
          d1: { e: '789' },
          d2: { e: '012' }
        }
      },
      b2: {
        c1: {
          d1: { e: '345' },
          d2: { e: '678' }
        },
        c2: {
          d1: { e: '901' },
          d2: { e: '234' }
        }
      }
    }
  }

  const censor = 'censor'
  const paths = ['a.*.*.*.e']
  const redact = fastRedact({ paths, censor, serialize: false })

  redact(o)
  is(o.a.b1.c1.d1.e, censor)
  is(o.a.b1.c1.d2.e, censor)
  is(o.a.b1.c2.d1.e, censor)
  is(o.a.b1.c2.d2.e, censor)
  is(o.a.b2.c1.d1.e, censor)
  is(o.a.b2.c1.d2.e, censor)
  is(o.a.b2.c2.d1.e, censor)
  is(o.a.b2.c2.d2.e, censor)
  redact.restore(o)
  is(o.a.b1.c1.d1.e, '123')
  is(o.a.b1.c1.d2.e, '456')
  is(o.a.b1.c2.d1.e, '789')
  is(o.a.b1.c2.d2.e, '012')
  is(o.a.b2.c1.d1.e, '345')
  is(o.a.b2.c1.d2.e, '678')
  is(o.a.b2.c2.d1.e, '901')
  is(o.a.b2.c2.d2.e, '234')
  end()
})

test('redact multi trailing wildcard', ({ end, is }) => {
  const o = { a: { b: { c: 'value' } } }

  const censor = 'censor'
  const paths = ['a.*.*']
  const redact = fastRedact({ paths, censor, serialize: false })

  redact(o)
  is(o.a.b.c, censor)
  redact.restore(o)
  is(o.a.b.c, 'value')
  end()
})