sangja/test/optional.js

JavaScript data structures library

/* eslint-env node, mocha */

const { assert } = require('chai');
const { Optional } = require('../src/index');

describe('Optional', () => {
  describe('Constructor', () => {
    it('Fails without new', () => {
      assert.throws(() => Optional(), TypeError);
    });

    it('Constructor without value', () => {
      const optional = new Optional();
      assert.isTrue(optional.isEmpty());
    });

    it('Constructor with value', () => {
      const optional = new Optional(123);
      assert.isFalse(optional.isEmpty());
    });
  });

  describe('Basic Methods', () => {
    it('get', () => {
      assert.equal(new Optional().get(), undefined);
      assert.equal(new Optional(123).get(), 123);
    });

    it('getOrElse', () => {
      assert.equal(new Optional().getOrElse(33), 33);
      assert.equal(new Optional(123).getOrElse(33), 123);
    });

    it('isEmpty', () => {
      assert.isTrue(new Optional().isEmpty());
      assert.isFalse(new Optional(123).isEmpty());
    });

    it('size', () => {
      assert.equal(new Optional().size(), 0);
      assert.equal(new Optional(123).size(), 1);
    });
  });

  describe('Iterator', () => {
    it('Iterate without value', () => {
      const optional = new Optional();
      assert.deepEqual([...optional], []);
    });

    it('Iterate one value', () => {
      const optional = new Optional(123);
      assert.deepEqual([...optional], [123]);
    });
  });

  describe('Functional tools', () => {
    it('forEach', () => {
      let acc = 0;
      const accmulate = (x) => { acc += x; };

      assert.equal(acc, 0);
      new Optional().forEach(accmulate);
      assert.equal(acc, 0);
      new Optional(123).forEach(accmulate);
      assert.equal(acc, 123);
      new Optional(5).forEach(accmulate);
      assert.equal(acc, 128);
    });

    it('map', () => {
      assert.equal(new Optional().map(x => x + 3).get(), undefined);
      assert.equal(new Optional(123).map(x => x + 3).get(), 126);
    });

    it('flatMap', () => {
      assert.equal(new Optional().flatMap(x => new Optional(x + 3)).get(), undefined);
      assert.equal(new Optional(123).flatMap(x => new Optional(x + 3)).get(), 126);
    });

    it('filter', () => {
      assert.equal(new Optional().filter(x => x % 2).get(), undefined);
      assert.equal(new Optional(123).filter(x => x % 2).get(), 123);
      assert.equal(new Optional(124).filter(x => x % 2).get(), undefined);
    });
  });

  describe('Checking tools', () => {
    it('some', () => {
      assert.equal(new Optional().some(x => x % 2), false);
      assert.equal(new Optional(1).some(x => x % 2), true);
      assert.equal(new Optional(2).some(x => x % 2), false);
    });

    it('every', () => {
      assert.equal(new Optional().every(x => x % 2), true);
      assert.equal(new Optional(1).every(x => x % 2), true);
      assert.equal(new Optional(2).every(x => x % 2), false);
    });

    it('includes', () => {
      assert.equal(new Optional().includes(1), false);
      assert.equal(new Optional(1).includes(1), true);
      assert.equal(new Optional(2).includes(1), false);
    });
  });
});