[squash] cleanup tests

test/async-hooks/test-promise.chain-promise-before-init-hooks.js

@@ -5,37 +5,34 @@ const assert = require('assert');
 const initHooks = require('./init-hooks');
 const { checkInvocations } = require('./hook-checks');
 
-const p = (new Promise(common.mustCall(executor)));
-p.then(afterresolution);
+const p = new Promise(common.mustCall(function executor(resolve, reject) {
+  resolve(5);
+}));
+
+p.then(function afterresolution(val) {
+  assert.strictEqual(val, 5);
+  return val;
+});
 
 // init hooks after chained promise is created
 const hooks = initHooks();
 hooks._allowNoInit = true;
 hooks.enable();
 
-function executor(resolve, reject) {
-  resolve(5);
-}
-
-function afterresolution(val) {
-  assert.strictEqual(val, 5);
-  return val;
-}
 
-process.on('exit', onexit);
-function onexit() {
+process.on('exit', function onexit() {
   hooks.disable();
   hooks.sanityCheck('PROMISE');
 
+  // Because the init event was never emitted the hooks listener doesn't
+  // know what the type was. Thus check for Unknown rather than PROMISE.
   const as = hooks.activitiesOfTypes('PROMISE');
   const unknown = hooks.activitiesOfTypes('Unknown');
-  assert.strictEqual(as.length, 0, 'no activities with PROMISE type');
-  assert.strictEqual(unknown.length, 1,
-                     'one activity with Unknown type which in fact is PROMISE');
+  assert.strictEqual(as.length, 0);
+  assert.strictEqual(unknown.length, 1);
 
   const a0 = unknown[0];
-  assert.strictEqual(a0.type, 'Unknown',
-                     'unknown request which in fact is PROMISE');
-  assert.strictEqual(typeof a0.uid, 'number', 'uid is a number');
+  assert.strictEqual(a0.type, 'Unknown');
+  assert.strictEqual(typeof a0.uid, 'number');
   checkInvocations(a0, { before: 1, after: 1 }, 'when process exits');
-}
+});

test/async-hooks/test-promise.js

@@ -14,7 +14,7 @@ p.then(afterresolution);
 
 function executor(resolve, reject) {
   const as = hooks.activitiesOfTypes('PROMISE');
-  assert.strictEqual(as.length, 1, 'one activity');
+  assert.strictEqual(as.length, 1, 'one activities');
   const a = as[0];
   checkInvocations(a, { init: 1 }, 'while in promise executor');
   resolve(5);
@@ -46,8 +46,7 @@ function onexit() {
   const a1 = as[1];
   assert.strictEqual(a1.type, 'PROMISE', 'promise request');
   assert.strictEqual(typeof a1.uid, 'number', 'uid is a number');
-  assert.strictEqual(a1.triggerId, a0.uid,
-                     'child promise should use parent uid as triggerId');
+  assert.strictEqual(a1.triggerId, a0.uid);
   // We expect a destroy hook as well but we cannot guarentee predictable gc.
   checkInvocations(a1, { init: 1, before: 1, after: 1 }, 'when process exits');
 }

test/async-hooks/test-promise.promise-before-init-hooks.js

@@ -5,43 +5,38 @@ const assert = require('assert');
 const initHooks = require('./init-hooks');
 const { checkInvocations } = require('./hook-checks');
 
-const p = (new Promise(common.mustCall(executor)));
+const p = new Promise(common.mustCall(function executor(resolve, reject) {
+  resolve(5);
+}));
 
 // init hooks after promise was created
-const hooks = initHooks();
-hooks._allowNoInit = true;
+const hooks = initHooks({allowNoInit: true});
 hooks.enable();
 
-p.then(afterresolution);
-
-function executor(resolve, reject) {
-  resolve(5);
-}
-
-function afterresolution(val) {
+p.then(function afterresolution(val) {
   assert.strictEqual(val, 5);
   const as = hooks.activitiesOfTypes('PROMISE');
   assert.strictEqual(as.length, 1, 'one activity');
   checkInvocations(as[0], { init: 1, before: 1 },
                    'after resolution child promise');
   return val;
-}
+});
 
-process.on('exit', onexit);
-function onexit() {
+process.on('exit', function onexit() {
   hooks.disable();
   hooks.sanityCheck('PROMISE');
 
   const as = hooks.activitiesOfTypes('PROMISE');
-  assert.strictEqual(as.length, 1,
-                     'should only get one activity(child promise)');
+  assert.strictEqual(as.length, 1);
 
   const a0 = as[0];
-  assert.strictEqual(a0.type, 'PROMISE', 'promise request');
-  assert.strictEqual(typeof a0.uid, 'number', 'uid is a number');
-  // we can't get the triggerId dynamically, we have to use static number here
-  assert.strictEqual(a0.triggerId - (a0.uid - 3), 2,
-                     'child promise should use parent uid as triggerId');
+  assert.strictEqual(a0.type, 'PROMISE');
+  assert.strictEqual(typeof a0.uid, 'number');
+  // we can't get the asyncId from the parent dynamically, since init was
+  // never called. However, it is known that the parent promise was created
+  // immediately before the child promise, thus there should only be one
+  // difference in id.
+  assert.strictEqual(a0.triggerId, a0.uid - 1);
   // We expect a destroy hook as well but we cannot guarentee predictable gc.
   checkInvocations(a0, { init: 1, before: 1, after: 1 }, 'when process exits');
-}
+});