node-ldapjs/test/change.test.js

'use strict'

const { test } = require('tap')
const { BerReader, BerWriter } = require('asn1')
const { Attribute, Change } = require('../lib')

test('new no args', function (t) {
  t.ok(new Change())
  t.end()
})

test('new with args', function (t) {
  const change = new Change({
    operation: 'add',
    modification: new Attribute({
      type: 'cn',
      vals: ['foo', 'bar']
    })
  })
  t.ok(change)

  t.equal(change.operation, 'add')
  t.equal(change.modification.type, 'cn')
  t.equal(change.modification.vals.length, 2)
  t.equal(change.modification.vals[0], 'foo')
  t.equal(change.modification.vals[1], 'bar')

  t.end()
})

test('validate fields', function (t) {
  const c = new Change()
  t.ok(c)
  t.throws(function () {
    c.operation = 'bogus'
  })
  t.throws(function () {
    c.modification = { too: 'many', fields: 'here' }
  })
  c.modification = {
    foo: ['bar', 'baz']
  }
  t.ok(c.modification)
  t.end()
})

test('GH-31 (multiple attributes per Change)', function (t) {
  t.throws(function () {
    const c = new Change({
      operation: 'replace',
      modification: {
        cn: 'foo',
        sn: 'bar'
      }
    })
    t.notOk(c)
  })
  t.end()
})

test('toBer', function (t) {
  const change = new Change({
    operation: 'Add',
    modification: new Attribute({
      type: 'cn',
      vals: ['foo', 'bar']
    })
  })
  t.ok(change)

  const ber = new BerWriter()
  change.toBer(ber)
  const reader = new BerReader(ber.buffer)
  t.ok(reader.readSequence())
  t.equal(reader.readEnumeration(), 0x00)
  t.ok(reader.readSequence())
  t.equal(reader.readString(), 'cn')
  t.equal(reader.readSequence(), 0x31) // lber set
  t.equal(reader.readString(), 'foo')
  t.equal(reader.readString(), 'bar')
  t.end()
})

test('parse', function (t) {
  const ber = new BerWriter()
  ber.startSequence()
  ber.writeEnumeration(0x00)
  ber.startSequence()
  ber.writeString('cn')
  ber.startSequence(0x31)
  ber.writeStringArray(['foo', 'bar'])
  ber.endSequence()
  ber.endSequence()
  ber.endSequence()

  const change = new Change()
  t.ok(change)
  t.ok(change.parse(new BerReader(ber.buffer)))

  t.equal(change.operation, 'add')
  t.equal(change.modification.type, 'cn')
  t.equal(change.modification.vals.length, 2)
  t.equal(change.modification.vals[0], 'foo')
  t.equal(change.modification.vals[1], 'bar')

  t.end()
})

test('apply - replace', function (t) {
  let res
  const single = new Change({
    operation: 'replace',
    modification: {
      type: 'cn',
      vals: ['new']
    }
  })
  const twin = new Change({
    operation: 'replace',
    modification: {
      type: 'cn',
      vals: ['new', 'two']
    }
  })
  const empty = new Change({
    operation: 'replace',
    modification: {
      type: 'cn',
      vals: []
    }
  })

  // plain
  res = Change.apply(single, { cn: ['old'] })
  t.deepEqual(res.cn, ['new'])

  // multiple
  res = Change.apply(single, { cn: ['old', 'also'] })
  t.deepEqual(res.cn, ['new'])

  // empty
  res = Change.apply(empty, { cn: ['existing'] })
  t.equal(res.cn, undefined)
  t.ok(Object.keys(res).indexOf('cn') === -1)

  // absent
  res = Change.apply(single, { dn: ['otherjunk'] })
  t.deepEqual(res.cn, ['new'])

  // scalar formatting "success"
  res = Change.apply(single, { cn: 'old' }, true)
  t.equal(res.cn, 'new')

  // scalar formatting "failure"
  res = Change.apply(twin, { cn: 'old' }, true)
  t.deepEqual(res.cn, ['new', 'two'])

  t.end()
})

test('apply - add', function (t) {
  let res
  const single = new Change({
    operation: 'add',
    modification: {
      type: 'cn',
      vals: ['new']
    }
  })

  // plain
  res = Change.apply(single, { cn: ['old'] })
  t.deepEqual(res.cn, ['old', 'new'])

  // multiple
  res = Change.apply(single, { cn: ['old', 'also'] })
  t.deepEqual(res.cn, ['old', 'also', 'new'])

  // absent
  res = Change.apply(single, { dn: ['otherjunk'] })
  t.deepEqual(res.cn, ['new'])

  // scalar formatting "success"
  res = Change.apply(single, { }, true)
  t.equal(res.cn, 'new')

  // scalar formatting "failure"
  res = Change.apply(single, { cn: 'old' }, true)
  t.deepEqual(res.cn, ['old', 'new'])

  // duplicate add
  res = Change.apply(single, { cn: 'new' })
  t.deepEqual(res.cn, ['new'])

  t.end()
})

test('apply - delete', function (t) {
  let res
  const single = new Change({
    operation: 'delete',
    modification: {
      type: 'cn',
      vals: ['old']
    }
  })

  // plain
  res = Change.apply(single, { cn: ['old', 'new'] })
  t.deepEqual(res.cn, ['new'])

  // empty
  res = Change.apply(single, { cn: ['old'] })
  t.equal(res.cn, undefined)
  t.ok(Object.keys(res).indexOf('cn') === -1)

  // scalar formatting "success"
  res = Change.apply(single, { cn: ['old', 'one'] }, true)
  t.equal(res.cn, 'one')

  // scalar formatting "failure"
  res = Change.apply(single, { cn: ['old', 'several', 'items'] }, true)
  t.deepEqual(res.cn, ['several', 'items'])

  // absent
  res = Change.apply(single, { dn: ['otherjunk'] })
  t.ok(res)
  t.equal(res.cn, undefined)

  t.end()
})