add tests and fix missing cases

Author: rochdev

lib/diagnostics_channel.js

@@ -281,7 +281,7 @@ function tracingChannelFrom(nameOrChannels, name) {
 }
 
 class TracingChannel {
-  #generatorChannel
+  #nextChannel
 
   constructor(nameOrChannels) {
     for (let i = 0; i < traceEvents.length; ++i) {
@@ -436,10 +436,10 @@ class TracingChannel {
       return ReflectApply(fn, thisArg, args);
     }
 
-    const { channel, start, end, asyncStart, asyncEnd, error } = this;
+    const { start, end, asyncStart, asyncEnd, error } = this;
 
     if (!this.#nextChannel) {
-      this.#nextChannel = this.tracingChannel({
+      this.#nextChannel = tracingChannel({
         start: channel(start.name.slice(0, -6) + ':next:start'),
         end: channel(end.name.slice(0, -4) + ':next:end'),
         asyncStart: channel(asyncStart.name.slice(0, -11) + ':next:asyncStart'),
@@ -448,22 +448,26 @@ class TracingChannel {
       });
     }
 
-    const iter = this.#traceMaybePromise(fn, context, thisArg, ...args);
+    const nextChannel = this.#nextChannel;
+
+    const wrapIter = (iter) => {
+      const { next: iterNext, return: iterReturn, throw: iterThrow } = iter;
 
-    return iter instanceof Promise
-      ? iter.then((iter, method) => {
-        const { next: iterNext, return: iterReturn, throw: iterThrow } = iter;
+      iter.next = (...args) =>
+        nextChannel.#traceMaybePromise(iterNext, context, iter, ...args);
+      iter.return = (...args) =>
+        nextChannel.#traceMaybePromise(iterReturn, context, iter, ...args);
+      iter.throw = (...args) =>
+        nextChannel.#traceMaybePromise(iterThrow, context, iter, ...args);
+
+      return iter;
+    };
 
-        iter.next = (...args) =>
-          this.#nextChannel.#traceMaybePromise(iterNext, ctx, iter, ...args);
-        iter.return = (...args) =>
-          this.#nextChannel.#traceMaybePromise(iterReturn, ctx, iter, ...args);
-        iter.throw = (...args) =>
-          this.#nextChannel.#traceMaybePromise(iterThrow, ctx, iter, ...args);
+    const result = this.#traceMaybePromise(fn, context, thisArg, ...args);
 
-        return iter;
-      })
-      : iter;
+    return result instanceof Promise
+      ? PromisePrototypeThen(result, wrapIter)
+      : wrapIter(result);
   }
 
   #traceMaybePromise(fn, context = {}, thisArg, ...args) {

test/parallel/test-diagnostics-channel-tracing-channel-iterator-async-next.js

@@ -0,0 +1,54 @@
+'use strict';
+
+const common = require('../common');
+const dc = require('diagnostics_channel');
+const assert = require('assert');
+
+const channel = dc.tracingChannel('test');
+const nextChannel = dc.tracingChannel('test:next');
+
+const expectedResult = { foo: 'bar' };
+const input = { foo: 'bar' };
+const thisArg = { baz: 'buz' };
+
+function check(found) {
+  assert.deepStrictEqual(found, input);
+}
+
+function checkNextAsync(found) {
+  check(found);
+  assert.strictEqual(found.error, undefined);
+  assert.deepStrictEqual(found.result, { value: expectedResult, done: false });
+}
+
+// async function* returns an AsyncGenerator synchronously, so no asyncStart/asyncEnd
+// for the fn call itself
+const handlers = {
+  start: common.mustCall(check),
+  end: common.mustCall(check),
+  asyncStart: common.mustNotCall(),
+  asyncEnd: common.mustNotCall(),
+  error: common.mustNotCall(),
+};
+
+// next() on an AsyncGenerator returns a Promise
+const nextHandlers = {
+  start: common.mustCall(check),
+  end: common.mustCall(check),
+  asyncStart: common.mustCall(checkNextAsync),
+  asyncEnd: common.mustCall(checkNextAsync),
+  error: common.mustNotCall(),
+};
+
+channel.subscribe(handlers);
+nextChannel.subscribe(nextHandlers);
+
+const iter = channel.traceIterator(common.mustCall(async function*(value) {
+  assert.deepStrictEqual(this, thisArg);
+  yield value;
+}), input, thisArg, expectedResult);
+
+// next() returns a Promise since iter is an AsyncGenerator
+iter.next().then(common.mustCall((result) => {
+  assert.deepStrictEqual(result, { value: expectedResult, done: false });
+}));

test/parallel/test-diagnostics-channel-tracing-channel-iterator-early-exit.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const common = require('../common');
+const dc = require('diagnostics_channel');
+
+const channel = dc.tracingChannel('test');
+const nextChannel = dc.tracingChannel('test:next');
+
+const handlers = {
+  start: common.mustNotCall(),
+  end: common.mustNotCall(),
+  asyncStart: common.mustNotCall(),
+  asyncEnd: common.mustNotCall(),
+  error: common.mustNotCall(),
+};
+
+const nextHandlers = {
+  start: common.mustNotCall(),
+  end: common.mustNotCall(),
+  asyncStart: common.mustNotCall(),
+  asyncEnd: common.mustNotCall(),
+  error: common.mustNotCall(),
+};
+
+// Subscribe after traceIterator call - no events should fire for the iterator
+// or for subsequent next() calls since the iterator was not wrapped
+const iter = channel.traceIterator(function*() {
+  yield 1;
+}, {});
+
+channel.subscribe(handlers);
+nextChannel.subscribe(nextHandlers);
+
+iter.next();

test/parallel/test-diagnostics-channel-tracing-channel-iterator-error.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const common = require('../common');
+const dc = require('diagnostics_channel');
+const assert = require('assert');
+
+const channel = dc.tracingChannel('test');
+const nextChannel = dc.tracingChannel('test:next');
+
+const expectedError = new Error('test');
+const input = { foo: 'bar' };
+const thisArg = { baz: 'buz' };
+
+function check(found) {
+  assert.deepStrictEqual(found, input);
+}
+
+function checkError(found) {
+  check(found);
+  assert.deepStrictEqual(found.error, expectedError);
+}
+
+// Two traceIterator calls: one for next() error, one for throw() error
+const handlers = {
+  start: common.mustCall(check, 2),
+  end: common.mustCall(check, 2),
+  asyncStart: common.mustNotCall(),
+  asyncEnd: common.mustNotCall(),
+  error: common.mustNotCall(),
+};
+
+// next() and throw() each produce one error
+const nextHandlers = {
+  start: common.mustCall(check, 2),
+  end: common.mustCall(check, 2),
+  asyncStart: common.mustNotCall(),
+  asyncEnd: common.mustNotCall(),
+  error: common.mustCall(checkError, 2),
+};
+
+channel.subscribe(handlers);
+nextChannel.subscribe(nextHandlers);
+
+// Test next(): generator throws on first next() call
+const iter1 = channel.traceIterator(common.mustCall(function*() {
+  assert.deepStrictEqual(this, thisArg);
+  throw expectedError;
+}), input, thisArg);
+
+assert.throws(() => iter1.next(), expectedError);
+
+// Test throw(): propagates error through the iterator
+const iter2 = channel.traceIterator(common.mustCall(function*() {
+  yield 1;
+}), input, thisArg);
+
+assert.throws(() => iter2.throw(expectedError), expectedError);

test/parallel/test-diagnostics-channel-tracing-channel-iterator-promise-async-next.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const common = require('../common');
+const dc = require('diagnostics_channel');
+const assert = require('assert');
+
+const channel = dc.tracingChannel('test');
+const nextChannel = dc.tracingChannel('test:next');
+
+const expectedResult = { foo: 'bar' };
+const input = { foo: 'bar' };
+const thisArg = { baz: 'buz' };
+
+// An async generator that will be returned from the async fn
+async function* asyncGen(value) {
+  yield value;
+}
+const asyncIter = asyncGen(expectedResult);
+
+function check(found) {
+  assert.deepStrictEqual(found, input);
+}
+
+function checkAsync(found) {
+  check(found);
+  assert.strictEqual(found.error, undefined);
+  assert.strictEqual(found.result, asyncIter);
+}
+
+function checkNextAsync(found) {
+  check(found);
+  assert.strictEqual(found.error, undefined);
+  assert.deepStrictEqual(found.result, { value: expectedResult, done: false });
+}
+
+// async fn returns a Promise, so main channel fires asyncStart/asyncEnd
+const handlers = {
+  start: common.mustCall(check),
+  end: common.mustCall(check),
+  asyncStart: common.mustCall(checkAsync),
+  asyncEnd: common.mustCall(checkAsync),
+  error: common.mustNotCall(),
+};
+
+// next() on an AsyncGenerator returns a Promise
+const nextHandlers = {
+  start: common.mustCall(check),
+  end: common.mustCall(check),
+  asyncStart: common.mustCall(checkNextAsync),
+  asyncEnd: common.mustCall(checkNextAsync),
+  error: common.mustNotCall(),
+};
+
+channel.subscribe(handlers);
+nextChannel.subscribe(nextHandlers);
+
+// fn is async: returns a Promise resolving to an AsyncGenerator
+// traceIterator returns a Promise resolving to the wrapped AsyncGenerator
+channel.traceIterator(common.mustCall(async function() {
+  assert.deepStrictEqual(this, thisArg);
+  return asyncIter;
+}), input, thisArg).then(common.mustCall((iter) => {
+  // next() on AsyncGenerator returns a Promise
+  iter.next().then(common.mustCall((result) => {
+    assert.deepStrictEqual(result, { value: expectedResult, done: false });
+  }));
+}));

test/parallel/test-diagnostics-channel-tracing-channel-iterator-promise.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const common = require('../common');
+const dc = require('diagnostics_channel');
+const assert = require('assert');
+
+const channel = dc.tracingChannel('test');
+const nextChannel = dc.tracingChannel('test:next');
+
+const expectedResult = { foo: 'bar' };
+const input = { foo: 'bar' };
+const thisArg = { baz: 'buz' };
+
+// A sync iterator that will be returned from the async fn
+const syncIter = [expectedResult][Symbol.iterator]();
+
+function check(found) {
+  assert.deepStrictEqual(found, input);
+}
+
+function checkAsync(found) {
+  check(found);
+  assert.strictEqual(found.error, undefined);
+  assert.strictEqual(found.result, syncIter);
+}
+
+// async fn returns a Promise, so main channel fires asyncStart/asyncEnd
+const handlers = {
+  start: common.mustCall(check),
+  end: common.mustCall(check),
+  asyncStart: common.mustCall(checkAsync),
+  asyncEnd: common.mustCall(checkAsync),
+  error: common.mustNotCall(),
+};
+
+// next() on the wrapped sync iterator returns synchronously
+const nextHandlers = {
+  start: common.mustCall(check),
+  end: common.mustCall(check),
+  asyncStart: common.mustNotCall(),
+  asyncEnd: common.mustNotCall(),
+  error: common.mustNotCall(),
+};
+
+channel.subscribe(handlers);
+nextChannel.subscribe(nextHandlers);
+
+// fn is async: returns a Promise resolving to a sync iterator
+// traceIterator returns a Promise resolving to the wrapped iterator
+channel.traceIterator(common.mustCall(async function() {
+  assert.deepStrictEqual(this, thisArg);
+  return syncIter;
+}), input, thisArg).then(common.mustCall((iter) => {
+  assert.deepStrictEqual(iter.next(), { value: expectedResult, done: false });
+}));

test/parallel/test-diagnostics-channel-tracing-channel-iterator-run-stores.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const common = require('../common');
+const { AsyncLocalStorage } = require('async_hooks');
+const dc = require('diagnostics_channel');
+const assert = require('assert');
+
+const channel = dc.tracingChannel('test');
+const nextChannel = dc.tracingChannel('test:next');
+const store = new AsyncLocalStorage();
+
+const fnContext = { fn: 'context' };
+const nextContext = { next: 'context' };
+
+// Bind a store for the fn call (creates the generator object)
+channel.start.bindStore(store, common.mustCall(() => fnContext));
+
+// Bind a store for each next() call (runs the generator body)
+nextChannel.start.bindStore(store, common.mustCall(() => nextContext));
+
+assert.strictEqual(store.getStore(), undefined);
+
+const iter = channel.traceIterator(common.mustCall(function*() {
+  // Generator body runs during next(), inside nextChannel.start.runStores
+  assert.deepStrictEqual(store.getStore(), nextContext);
+  yield 1;
+}), {});
+
+assert.strictEqual(store.getStore(), undefined);
+iter.next();
+assert.strictEqual(store.getStore(), undefined);