activedirectory2/test/findgroups.js

'use strict'
/* eslint-env node, mocha */
/* eslint-disable no-unused-expressions */

const expect = require('chai').expect
const ActiveDirectory = require('../index')
const config = require('./config')

let server = require('./mockServer')

describe('findGroups Method', function () {
  let ad
  const settings = require('./settings').findGroups
  const timeout = 6000 // The timeout in milliseconds before a test is considered failed.

  before(function (done) {
    server(function (s) {
      ad = new ActiveDirectory(config)
      server = s
      done()
    })
  })

  describe('#findGroups()', function () {
    settings.groups.forEach((group) => {
      const len = group.results.length
      const query = (group.query.filter) ? group.query.filter : group.query
      it(`should return ${len} groups for query '${query}'`, function (done) {
        this.timeout(timeout)

        const expectedResults = group.results
        ad.findGroups(query, function (err, groups) {
          expect(err).to.be.null
          expect(groups).to.not.be.null
          expect(Array.isArray(groups)).to.be.true
          expect(groups.length).to.equal(len)

          const cns = groups.map((g) => g.cn)
          expect(cns).to.be.any.members(expectedResults)
          done()
        })
      })
    })

    it('should return default group attributes when not specified', function (done) {
      const defaultAttributes = ActiveDirectory.defaultAttributes.group
      const group = settings.groups[0]
      ad.findGroups(group.query, function (err, groups) {
        expect(err).to.be.null
        expect(groups).to.not.be.null
        expect(Array.isArray(groups)).to.be.true

        groups.forEach((group) => {
          const attributes = Object.keys(group)
          expect(attributes.length).to.be.lte(defaultAttributes.length)
          expect(attributes).to.be.any.members(defaultAttributes)
        })

        done()
      })
    })
  })

  describe('#findGroups(opts)', function () {
    it('should include groups/membership if opts.includeMembership[] = [ \'all\' ]', function (done) {
      this.timeout(timeout)

      const group = settings.groups[0]
      const opts = {
        includeMembership: [ 'all' ],
        filter: group.query
      }
      ad.findGroups(opts, function (err, groups) {
        expect(err).to.be.null
        expect(groups).to.not.be.null
        expect(Array.isArray(groups)).to.be.true

        groups.forEach((group) => {
          expect(group.groups).to.exist
        })

        done()
      })
    })

    it('should include groups/membership if opts.includeMembership[] = [ \'group\' ]', function (done) {
      this.timeout(timeout)

      const group = settings.groups[0]
      const opts = {
        includeMembership: [ 'group' ],
        filter: group.query
      }
      ad.findGroups(opts, function (err, groups) {
        expect(err).to.be.null
        expect(groups).to.not.be.null
        expect(Array.isArray(groups)).to.be.true

        groups.forEach((group) => {
          expect(group.groups).to.exist
        })

        done()
      })
    })
    it('should not include groups/membership if opts.includeMembership disabled', function (done) {
      var group = settings.groups[0]
      var opts = {
        includeMembership: false,
        filter: group.query
      }
      ad.findGroups(opts, function (err, groups) {
        expect(err).to.be.null
        expect(groups).to.not.be.null
        expect(Array.isArray(groups)).to.be.true

        groups.forEach((group) => {
          expect(group.groups).to.not.exist
        })

        done()
      })
    })

    it('should return only requested attributes', function (done) {
      const group = settings.groups[0]
      const opts = {
        attributes: [ 'cn' ],
        filter: group.query
      }
      ad.findGroups(opts, function (err, groups) {
        expect(err).to.be.null
        expect(groups).to.not.be.null
        expect(Array.isArray(groups)).to.be.true

        groups.forEach((group) => {
          const keys = Object.keys(group)
          expect(keys.length).to.equal(opts.attributes.length)
          expect(keys).to.be.any.members(opts.attributes)
        })

        done()
      })
    })
  })
})