node-dijkstra/test/PriorityQueue.test.js

A NodeJS implementation of Dijkstra's algorithm

/* eslint-env node, mocha */
/* eslint import/no-extraneous-dependencies: ["error", {"devDependencies": true}] */

require('must');
const demand = require('must');
const sinon = require('sinon');

const Queue = require('../libs/PriorityQueue');

describe('PriorityQueue', () => {
  describe('#constructor', () => {
    it('starts an empty queue and keys set', () => {
      const queue = new Queue();

      queue.keys.must.be.instanceOf(Set);
      queue.queue.must.be.an.array();
    });
  });

  describe('#sort()', () => {
    it('sorts by having the smallest first', () => {
      const queue = new Queue();
      queue.queue = [
        { priority: 10 },
        { priority: 1 },
      ];

      queue.sort();
      queue.queue[0].priority.must.equal(1);
    });
  });

  describe('#set()', () => {
    it('only accept numbers as priority values', () => {
      const queue = new Queue();

      demand(queue.set.bind(queue, 'key', {}))
        .throw(TypeError, /number/);
    });

    it('adds an unexisting key to the queue and reorders it', () => {
      const queue = new Queue();
      sinon.spy(queue, 'sort');

      queue.set('ok', 1);

      sinon.assert.calledOnce(queue.sort);
      queue.keys.size.must.equal(1);
      queue.queue.must.have.length(1);
      queue.queue[0].key.must.equal('ok');
      queue.queue[0].priority.must.equal(1);
    });

    it('updates the value of an existing key', () => {
      const queue = new Queue();
      sinon.spy(queue, 'sort');

      queue.set('ok', 1);
      queue.set('ok', 5);

      sinon.assert.calledTwice(queue.sort);
      queue.keys.size.must.equal(1);
      queue.queue.must.have.length(1);
      queue.queue[0].key.must.equal('ok');
      queue.queue[0].priority.must.equal(5);
    });
  });

  describe('#next()', () => {
    it('removes the first element in the queue', () => {
      const queue = new Queue();
      queue.set('ok', 10);
      queue.set('not-ok', 1);

      queue.next();

      queue.queue.must.have.length(1);
      queue.keys.size.must.equal(1);
    });

    it('return the first element in the queue', () => {
      const queue = new Queue();
      queue.set('ok', 10);
      queue.set('not-ok', 1);

      const el = queue.next();

      el.must.have.keys(['priority', 'key']);
      el.priority.must.equal(1);
      el.key.must.equal('not-ok');
    });
  });

  describe('#isEmpty()', () => {
    it('returns false when there are elements in the queue', () => {
      const queue = new Queue();
      queue.set('ok', 3);

      queue.isEmpty().must.be.false();
    });

    it('returns true when the queue is empty', () => {
      const queue = new Queue();

      queue.isEmpty().must.be.true();
    });
  });

  describe('#has()', () => {
    it('returns false when the key does not exist', () => {
      const queue = new Queue();
      queue.set('not-ok', 3);

      queue.has('ok').must.be.false();
    });

    it('returns false when the key does not exist', () => {
      const queue = new Queue();
      queue.set('not-ok', 3);

      queue.has('ok').must.be.false();
    });
  });

  describe('#get()', () => {
    it('gets the entry with the provided key', () => {
      const queue = new Queue();
      queue.set('ok', 3);

      const res = queue.get('ok');
      res.must.have.keys(['key', 'priority']);
      res.key.must.equal('ok');
      res.priority.must.equal(3);
    });
  });
});