metacom/test/result.test.js at 3b9f09333adf04f40ad46c60e81429e4e22ce048 · metarhia/metacom · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
'use strict';

const { test } = require('node:test');
const assert = require('node:assert/strict');

const { Result } = require('../lib/websocket/result.js');

test('Result.ok: creates success result with given value', () => {
  const r = Result.ok(42);
  assert.equal(r.value, 42);
  assert.equal(r.error, null);
  assert.equal(r.ok, true);
});

test('Result.ok: defaults to null value', () => {
  const r = Result.ok();
  assert.equal(r.value, null);
  assert.equal(r.error, null);
  assert.equal(r.ok, true);
});

test('Result.fail: creates error result', () => {
  const err = new Error('boom');
  const r = Result.fail(err);
  assert.equal(r.value, null);
  assert.strictEqual(r.error, err);
  assert.equal(r.ok, false);
});

test('Result.from: wraps a function return value', () => {
  const r = Result.from(() => ({ code: 1000, reason: 'ok' }));
  assert.deepEqual(r.value, { code: 1000, reason: 'ok' });
  assert.equal(r.error, null);
  assert.equal(r.ok, true);
});

test('Result.from: catches thrown errors', () => {
  const err = new Error('boom');
  const r = Result.from(() => {
    throw err;
  });
  assert.equal(r.value, null);
  assert.strictEqual(r.error, err);
  assert.equal(r.ok, false);
});

test('Result.fromAsync: wraps an async return value', async () => {
  const r = await Result.fromAsync(async () => 99);
  assert.equal(r.value, 99);
  assert.equal(r.error, null);
  assert.equal(r.ok, true);
});

test('Result.fromAsync: catches rejected promises', async () => {
  const err = new Error('async boom');
  const r = await Result.fromAsync(async () => {
    throw err;
  });
  assert.equal(r.value, null);
  assert.strictEqual(r.error, err);
  assert.equal(r.ok, false);
});

test('Result.unwrap: returns value when ok', () => {
  assert.equal(Result.ok(7).unwrap(), 7);
});

test('Result.unwrap: throws error when failed', () => {
  const err = new Error('fail');
  assert.throws(
    () => Result.fail(err).unwrap(),
    (e) => e === err,
  );
});

test('Result.unwrap: returns defaultValue when failed', () => {
  const r = Result.fail(new Error('fail'));
  assert.equal(r.unwrap('default'), 'default');
});

test('Result.map: transforms value when ok', () => {
  const r = Result.ok(3).map((v) => v * 2);
  assert.equal(r.value, 6);
  assert.equal(r.ok, true);
});

test('Result.map: passes error through unchanged', () => {
  const err = new Error('fail');
  const r = Result.fail(err).map((v) => v * 2);
  assert.strictEqual(r.error, err);
  assert.equal(r.ok, false);
});

test('Result.map: catches error thrown inside mapper', () => {
  const mapErr = new Error('map fail');
  const r = Result.ok(1).map(() => {
    throw mapErr;
  });
  assert.strictEqual(r.error, mapErr);
  assert.equal(r.ok, false);
});

test('Result: value and error getters are read-only', () => {
  const r = Result.ok(42);
  assert.equal(r.value, 42);
  assert.throws(() => {
    r.value = 99;
  });
});