test: split up and refactor test-domain

Split up test-domain into multiple, more focused test files
and use more modern JS inside of them.

PR-URL: #13614
Reviewed-By: Refael Ackermann <refack@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>

Author: addaleax

test/parallel/test-domain-bind-timeout.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const domain = require('domain');
+
+const d = new domain.Domain();
+
+d.on('error', common.mustCall((err) => {
+  assert.strictEqual(err.message, 'foobar');
+  assert.strictEqual(err.domain, d);
+  assert.strictEqual(err.domainEmitter, undefined);
+  assert.strictEqual(err.domainBound, undefined);
+  assert.strictEqual(err.domainThrown, true);
+}));
+
+setTimeout(d.bind(() => { throw new Error('foobar'); }), 1);

test/parallel/test-domain-ee-implicit.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const domain = require('domain');
+const EventEmitter = require('events');
+
+const d = new domain.Domain();
+let implicit;
+
+d.on('error', common.mustCall((err) => {
+  assert.strictEqual(err.message, 'foobar');
+  assert.strictEqual(err.domain, d);
+  assert.strictEqual(err.domainEmitter, implicit);
+  assert.strictEqual(err.domainBound, undefined);
+  assert.strictEqual(err.domainThrown, false);
+}));
+
+// Implicit addition of the EventEmitter by being created within a domain-bound
+// context.
+d.run(common.mustCall(() => {
+  implicit = new EventEmitter();
+}));
+
+setTimeout(common.mustCall(() => {
+  // escape from the domain, but implicit is still bound to it.
+  implicit.emit('error', new Error('foobar'));
+}), 1);

test/parallel/test-domain-ee.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const domain = require('domain');
+const EventEmitter = require('events');
+
+const d = new domain.Domain();
+const e = new EventEmitter();
+
+d.on('error', common.mustCall((err) => {
+  assert.strictEqual(err.message, 'foobar');
+  assert.strictEqual(err.domain, d);
+  assert.strictEqual(err.domainEmitter, e);
+  assert.strictEqual(err.domainBound, undefined);
+  assert.strictEqual(err.domainThrown, false);
+}));
+
+d.add(e);
+e.emit('error', new Error('foobar'));

test/parallel/test-domain-error-types.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const domain = require('domain');
+
+// This test is similar to test-domain-multiple-errors, but uses a new domain
+// for each errors.
+
+for (const something of [
+  42, null, undefined, false, () => {}, 'string', Symbol('foo')
+]) {
+  const d = new domain.Domain();
+  d.run(common.mustCall(() => {
+    process.nextTick(common.mustCall(() => {
+      throw something;
+    }));
+  }));
+
+  d.on('error', common.mustCall((err) => {
+    assert.strictEqual(something, err);
+  }));
+}

test/parallel/test-domain-fs-enoent-stream.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const domain = require('domain');
+const fs = require('fs');
+
+const d = new domain.Domain();
+
+const fst = fs.createReadStream('stream for nonexistent file');
+
+d.on('error', common.mustCall((err) => {
+  assert.ok(err.message.match(/^ENOENT: no such file or directory, open '/));
+  assert.strictEqual(err.domain, d);
+  assert.strictEqual(err.domainEmitter, fst);
+  assert.strictEqual(err.domainBound, undefined);
+  assert.strictEqual(err.domainThrown, false);
+}));
+
+d.add(fst);

test/parallel/test-domain-implicit-binding.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const domain = require('domain');
+const fs = require('fs');
+
+{
+  const d = new domain.Domain();
+
+  d.on('error', common.mustCall((err) => {
+    assert.strictEqual(err.message, 'foobar');
+    assert.strictEqual(err.domain, d);
+    assert.strictEqual(err.domainEmitter, undefined);
+    assert.strictEqual(err.domainBound, undefined);
+    assert.strictEqual(err.domainThrown, true);
+  }));
+
+  d.run(common.mustCall(() => {
+    process.nextTick(common.mustCall(() => {
+      const i = setInterval(common.mustCall(() => {
+        clearInterval(i);
+        setTimeout(common.mustCall(() => {
+          fs.stat('this file does not exist', common.mustCall((er, stat) => {
+            throw new Error('foobar');
+          }));
+        }), 1);
+      }), 1);
+    }));
+  }));
+}

test/parallel/test-domain-intercept.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const domain = require('domain');
+
+{
+  const d = new domain.Domain();
+
+  const mustNotCall = common.mustNotCall();
+
+  d.on('error', common.mustCall((err) => {
+    assert.strictEqual(err.message, 'foobar');
+    assert.strictEqual(err.domain, d);
+    assert.strictEqual(err.domainEmitter, undefined);
+    assert.strictEqual(err.domainBound, mustNotCall);
+    assert.strictEqual(err.domainThrown, false);
+  }));
+
+  const bound = d.intercept(mustNotCall);
+  bound(new Error('foobar'));
+}
+
+{
+  const d = new domain.Domain();
+
+  const bound = d.intercept(common.mustCall((data) => {
+    assert.strictEqual(data, 'data');
+  }));
+
+  bound(null, 'data');
+}
+
+{
+  const d = new domain.Domain();
+
+  const bound = d.intercept(common.mustCall((data, data2) => {
+    assert.strictEqual(data, 'data');
+    assert.strictEqual(data2, 'data2');
+  }));
+
+  bound(null, 'data', 'data2');
+}

test/parallel/test-domain-multiple-errors.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const domain = require('domain');
+
+// This test is similar to test-domain-error-types, but uses a single domain
+// to emit all errors.
+
+const d = new domain.Domain();
+
+const values = [
+  42, null, undefined, false, () => {}, 'string', Symbol('foo')
+];
+
+d.on('error', common.mustCall((err) => {
+  assert(values.includes(err));
+}, values.length));
+
+for (const something of values) {
+  d.run(common.mustCall(() => {
+    process.nextTick(common.mustCall(() => {
+      throw something;
+    }));
+  }));
+}

test/parallel/test-domain-nexttick.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const domain = require('domain');
+
+const d = new domain.Domain();
+
+d.on('error', common.mustCall((err) => {
+  assert.strictEqual(err.message, 'foobar');
+  assert.strictEqual(err.domain, d);
+  assert.strictEqual(err.domainEmitter, undefined);
+  assert.strictEqual(err.domainBound, undefined);
+  assert.strictEqual(err.domainThrown, true);
+}));
+
+d.run(common.mustCall(() => {
+  process.nextTick(common.mustCall(() => {
+    throw new Error('foobar');
+  }));
+}));

test/parallel/test-domain-run.js

@@ -0,0 +1,13 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const domain = require('domain');
+
+const d = new domain.Domain();
+
+assert.strictEqual(d.run(() => 'return value'),
+                   'return value');
+
+assert.strictEqual(d.run((a, b) => `${a} ${b}`, 'return', 'value'),
+                   'return value');

test/parallel/test-domain-timer.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const domain = require('domain');
+
+const d = new domain.Domain();
+
+d.on('error', common.mustCall((err) => {
+  assert.strictEqual(err.message, 'foobar');
+  assert.strictEqual(err.domain, d);
+  assert.strictEqual(err.domainEmitter, undefined);
+  assert.strictEqual(err.domainBound, undefined);
+  assert.strictEqual(err.domainThrown, true);
+}));
+
+d.run(common.mustCall(() => {
+  setTimeout(common.mustCall(() => {
+    throw new Error('foobar');
+  }), 1);
+}));