typed-utilities/build/__tests__/AsyncResult.test.js

Strongly typed general purpose utilities

"use strict";

var _ = require("..");

describe(`AsyncResult`, () => {
  test(`basic`, async () => {
    const testError = new Error(`test error`);

    const pending = _.AsyncResult.of.pending();

    const rejected = _.AsyncResult.of.rejected(testError);

    const resolved = _.AsyncResult.of.resolved(42);

    expect(_.AsyncResult.is.pending(pending)).toEqual(true);
    expect(_.AsyncResult.is.rejected(pending)).toEqual(false);
    expect(_.AsyncResult.is.resolved(pending)).toEqual(false);
    expect(() => _.AsyncResult.assert.pending(pending)).not.toThrow();
    expect(() => _.AsyncResult.assert.rejected(pending)).toThrow();
    expect(() => _.AsyncResult.assert.resolved(pending)).toThrow();
    expect(_.AsyncResult.is.pending(rejected)).toEqual(false);
    expect(_.AsyncResult.is.rejected(rejected)).toEqual(true);
    expect(_.AsyncResult.is.resolved(rejected)).toEqual(false);
    expect(() => _.AsyncResult.assert.pending(rejected)).toThrow();
    expect(() => _.AsyncResult.assert.rejected(rejected)).not.toThrow();
    expect(() => _.AsyncResult.assert.resolved(rejected)).toThrow();
    expect(_.AsyncResult.is.pending(resolved)).toEqual(false);
    expect(_.AsyncResult.is.rejected(resolved)).toEqual(false);
    expect(_.AsyncResult.is.resolved(resolved)).toEqual(true);
    expect(() => _.AsyncResult.assert.pending(resolved)).toThrow();
    expect(() => _.AsyncResult.assert.rejected(resolved)).toThrow();
    expect(() => _.AsyncResult.assert.resolved(resolved)).not.toThrow();
    expect(_.AsyncResult.to.rejectedError(rejected)).toEqual(testError);
    expect(_.AsyncResult.to.resolvedValue(resolved)).toEqual(42);
    expect(_.AsyncResult.to.dependencyList(pending)).toEqual([_.AsyncResult.Tag.Pending, null, null]);
    expect(_.AsyncResult.to.dependencyList(resolved)).toEqual([_.AsyncResult.Tag.Resolved, 42, null]);
    expect(_.AsyncResult.to.dependencyList(rejected)).toEqual([_.AsyncResult.Tag.Rejected, null, testError]);
    const match = {
      pending: () => `pending`,
      rejected: error => `error: ${error.message}`,
      resolved: value => `value: ${value}`
    };
    expect(_.AsyncResult.match(pending, match)).toEqual(`pending`);
    expect(_.AsyncResult.match(rejected, match)).toEqual(`error: test error`);
    expect(_.AsyncResult.match(resolved, match)).toEqual(`value: 42`);
  });
  test(`join`, () => {
    const error1 = new SyntaxError(`error1`);
    const error2 = new TypeError(`error2`);
    expect(_.AsyncResult.join([])).toEqual(_.AsyncResult.of.resolved([]));
    expect(_.AsyncResult.join([_.AsyncResult.of.pending()])).toEqual(_.AsyncResult.of.pending());
    expect(_.AsyncResult.join([_.AsyncResult.of.rejected(error1)])).toEqual(_.AsyncResult.of.rejected(new AggregateError([error1])));
    expect(_.AsyncResult.join([_.AsyncResult.of.resolved(null)])).toEqual(_.AsyncResult.of.resolved([null]));
    const t1 = [_.AsyncResult.of.pending(), _.AsyncResult.of.rejected(error1), _.AsyncResult.of.resolved(null)];

    const j1 = _.AsyncResult.join(t1);

    expect(j1).toEqual(_.AsyncResult.of.pending());
    const t2 = [_.AsyncResult.of.rejected(error1), _.AsyncResult.of.resolved(null)];

    const j2 = _.AsyncResult.join(t2);

    expect(j2).toEqual(_.AsyncResult.of.rejected(new AggregateError([error1])));
    const t3 = [_.AsyncResult.of.resolved(null), _.AsyncResult.of.rejected(error1), _.AsyncResult.of.rejected(error2)];

    const j3 = _.AsyncResult.join(t3);

    expect(j3).toEqual(_.AsyncResult.of.rejected(new AggregateError([error1, error2])));
    const t4 = [_.AsyncResult.of.resolved(null), _.AsyncResult.of.resolved(0), _.AsyncResult.of.resolved([`a`])];

    const j4 = _.AsyncResult.join(t4);

    expect(j4).toEqual(_.AsyncResult.of.resolved([null, 0, [`a`]]));
    const t5 = (0, _.range)(10).map(k => _.AsyncResult.of.resolved(k));
    expect(_.AsyncResult.join(t5)).toEqual(_.AsyncResult.of.resolved((0, _.range)(10)));
  });
  test(`pipe`, () => {
    expect(_.AsyncResult.pipe(_.AsyncResult.of.pending(), () => 42)).toEqual(_.AsyncResult.of.pending());
    const error1 = new Error(`error 1`);
    expect(_.AsyncResult.pipe(_.AsyncResult.of.rejected(error1), () => 42)).toEqual(_.AsyncResult.of.rejected(error1));
    expect(_.AsyncResult.pipe(_.AsyncResult.of.resolved(21), x => 2 * x)).toEqual(_.AsyncResult.of.resolved(42));
    const error2 = new Error(`error 2`);
    expect(_.AsyncResult.pipe(_.AsyncResult.of.resolved(21), x => {
      if (x === 21) {
        throw error2;
      }

      return 2 * x;
    })).toEqual(_.AsyncResult.of.rejected(error2));
  });
  test(`catch`, () => {
    expect(_.AsyncResult.catch(_.AsyncResult.of.pending(), () => 42)).toEqual(_.AsyncResult.of.pending());
    expect(_.AsyncResult.catch(_.AsyncResult.of.resolved(1337), () => 42)).toEqual(_.AsyncResult.of.resolved(1337));
    const error1 = new Error(`error1`);
    expect(_.AsyncResult.catch(_.AsyncResult.of.rejected(error1), () => 42)).toEqual(_.AsyncResult.of.resolved(42));
    const error2 = new Error(`error2`);
    expect(_.AsyncResult.catch(_.AsyncResult.of.rejected(error1), () => {
      throw error2;
    })).toEqual(_.AsyncResult.of.rejected(error2));
  });
});
//# sourceMappingURL=AsyncResult.test.js.map