Observe acceptance rejection so it doesn't crash the process

Author: AArnott

src/nerdbank-streams/src/Channel.ts

@@ -203,6 +203,9 @@ export class ChannelClass extends Channel {
         // or even expect it to be recognized by anyone else.
         // The acceptance promise rejection is observed by the offer channel method.
         caught(this._completion.promise);
+
+        // Inform the remote side that the offer is rescinded.
+        this.dispose();
     }
 
     public onAccepted(acceptanceParameter: AcceptanceParameters): boolean {
@@ -248,7 +251,10 @@ export class ChannelClass extends Channel {
         if (!this.isDisposed) {
             super.dispose();
 
-            this._acceptance.reject(new CancellationToken.CancellationError("disposed"));
+            if (this._acceptance.reject(new CancellationToken.CancellationError("disposed"))) {
+                // Don't crash node due to an unnoticed rejection when dispose was explicitly called.
+                caught(this.acceptance);
+            }
 
             // For the pipes, we Complete *our* ends, and leave the user's ends alone.
             // The completion will propagate when it's ready to.

src/nerdbank-streams/src/tests/MultiplexingStream.spec.ts

@@ -8,6 +8,7 @@ import { timeout } from "./Timeout";
 import { Channel } from "../Channel";
 import CancellationToken from "cancellationtoken";
 import * as assert from "assert";
+import { nextTick } from "process";
 
 [1, 2, 3].forEach(protocolMajorVersion => {
     describe(`MultiplexingStream v${protocolMajorVersion}`, () => {
@@ -114,6 +115,24 @@ import * as assert from "assert";
             await assert.rejects(offer);
         });
 
+        it("Channel offer is canceled by sender after receiver gets it", async () => {
+            // Arrange to cancel the offer only after the remote party receives it (but before they accept it.)
+            const cts = CancellationToken.create();
+            mx2.on('channelOffered', args => {
+                cts.cancel('rescind offer');
+            });
+            const offer = mx1.offerChannelAsync("test", undefined, cts.token);
+            await expectAsync(offer).toBeRejected()
+
+            // Give time for the termination fram to arrive *before* we try to accept the channel.
+            for (let i = 0; i < 100; i++) {
+                await new Promise<void>(resolve => nextTick(() => resolve()));
+            }
+
+            // We expect this to timeout. But we need this for the test to fail if we have unobserved promise rejections.
+            await expectAsync(timeout(mx2.acceptChannelAsync('test'), 1000)).toBeRejected();
+        });
+
         it("Channel offer is rejected by event handler", async () => {
             const handler = new Deferred<void>();
             mx2.on("channelOffered", (args) => {