Better way to detect "Failed to start the HttpConnection before stop() was called." (#40018)

Author: z77ma

src/SignalR/clients/ts/signalr/src/HttpConnection.ts

@@ -2,7 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 import { DefaultHttpClient } from "./DefaultHttpClient";
-import { AggregateErrors, DisabledTransportError, FailedToNegotiateWithServerError, FailedToStartTransportError, HttpError, UnsupportedTransportError } from "./Errors";
+import { AggregateErrors, DisabledTransportError, FailedToNegotiateWithServerError, FailedToStartTransportError, HttpError, UnsupportedTransportError, AbortError } from "./Errors";
 import { HeaderNames } from "./HeaderNames";
 import { HttpClient } from "./HttpClient";
 import { IConnection } from "./IConnection";
@@ -146,12 +146,12 @@ export class HttpConnection implements IConnection {
             // We cannot await stopPromise inside startInternal since stopInternal awaits the startInternalPromise.
             await this._stopPromise;
 
-            return Promise.reject(new Error(message));
+            return Promise.reject(new AbortError(message));
         } else if (this._connectionState as any !== ConnectionState.Connected) {
             // stop() was called and transitioned the client into the Disconnecting state.
             const message = "HttpConnection.startInternal completed gracefully but didn't enter the connection into the connected state!";
             this._logger.log(LogLevel.Error, message);
-            return Promise.reject(new Error(message));
+            return Promise.reject(new AbortError(message));
         }
 
         this._connectionStarted = true;
@@ -247,7 +247,7 @@ export class HttpConnection implements IConnection {
                     negotiateResponse = await this._getNegotiationResponse(url);
                     // the user tries to stop the connection when it is being started
                     if (this._connectionState === ConnectionState.Disconnecting || this._connectionState === ConnectionState.Disconnected) {
-                        throw new Error("The connection was stopped during negotiation.");
+                        throw new AbortError("The connection was stopped during negotiation.");
                     }
 
                     if (negotiateResponse.error) {
@@ -401,7 +401,7 @@ export class HttpConnection implements IConnection {
                     if (this._connectionState !== ConnectionState.Connecting) {
                         const message = "Failed to select transport before stop() was called.";
                         this._logger.log(LogLevel.Debug, message);
-                        return Promise.reject(new Error(message));
+                        return Promise.reject(new AbortError(message));
                     }
                 }
             }

src/SignalR/clients/ts/signalr/src/HubConnection.ts

@@ -3,6 +3,7 @@
 
 import { HandshakeProtocol, HandshakeRequestMessage, HandshakeResponseMessage } from "./HandshakeProtocol";
 import { IConnection } from "./IConnection";
+import { AbortError } from "./Errors";
 import { CancelInvocationMessage, CompletionMessage, IHubProtocol, InvocationMessage, MessageType, StreamInvocationMessage, StreamItemMessage } from "./IHubProtocol";
 import { ILogger, LogLevel } from "./ILogger";
 import { IRetryPolicy } from "./IRetryPolicy";
@@ -296,7 +297,7 @@ export class HubConnection {
 
         this._cleanupTimeout();
         this._cleanupPingTimer();
-        this._stopDuringStartError = error || new Error("The connection was stopped before the hub handshake could complete.");
+        this._stopDuringStartError = error || new AbortError("The connection was stopped before the hub handshake could complete.");
 
         // HttpConnection.stop() should not complete until after either HttpConnection.start() fails
         // or the onclose callback is invoked. The onclose callback will transition the HubConnection
@@ -698,7 +699,7 @@ export class HubConnection {
         this._logger.log(LogLevel.Debug, `HubConnection.connectionClosed(${error}) called while in state ${this._connectionState}.`);
 
         // Triggering this.handshakeRejecter is insufficient because it could already be resolved without the continuation having run yet.
-        this._stopDuringStartError = this._stopDuringStartError || error || new Error("The underlying connection was closed before the hub handshake could complete.");
+        this._stopDuringStartError = this._stopDuringStartError || error || new AbortError("The underlying connection was closed before the hub handshake could complete.");
 
         // If the handshake is in progress, start will be waiting for the handshake promise, so we complete it.
         // If it has already completed, this should just noop.

src/SignalR/clients/ts/signalr/tests/HttpConnection.test.ts

@@ -7,7 +7,7 @@ import { IHttpConnectionOptions } from "../src/IHttpConnectionOptions";
 import { HttpTransportType, ITransport, TransferFormat } from "../src/ITransport";
 import { getUserAgentHeader } from "../src/Utils";
 
-import { HttpError } from "../src/Errors";
+import { AbortError, HttpError } from "../src/Errors";
 import { ILogger, LogLevel } from "../src/ILogger";
 import { NullLogger } from "../src/Loggers";
 import { EventSourceConstructor, WebSocketConstructor } from "../src/Polyfills";
@@ -161,9 +161,12 @@ describe("HttpConnection", () => {
 
             await stopPromise;
 
-            await expect(startPromise)
-                .rejects
-                .toThrow("The connection was stopped during negotiation.");
+            try {
+                await startPromise
+            } catch (e) {
+                expect(e).toBeInstanceOf(AbortError);
+                expect((e as AbortError).message).toBe("The connection was stopped during negotiation.");
+            }
         },
         "Failed to start the connection: Error: The connection was stopped during negotiation.");
     });

src/SignalR/clients/ts/signalr/tests/HubConnection.test.ts

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+import { AbortError } from "../src/Errors";
 import { HubConnection, HubConnectionState } from "../src/HubConnection";
 import { IConnection } from "../src/IConnection";
 import { HubMessage, IHubProtocol, MessageType } from "../src/IHubProtocol";
@@ -391,7 +392,10 @@ describe("HubConnection", () => {
                     await connection.stop();
                     try {
                         await startPromise;
-                    } catch { }
+                    } catch (e) {
+                        expect(e).toBeInstanceOf(AbortError);
+                        expect((e as AbortError).message).toBe("The underlying connection was closed before the hub handshake could complete.");
+                    }
                 } finally {
                     await hubConnection.stop();
                 }
@@ -802,6 +806,26 @@ describe("HubConnection", () => {
             "Server returned handshake error: Error!");
         });
 
+        it("connection stopped before handshake completes",async () => {
+            await VerifyLogger.run(async (logger) => {
+                const connection = new TestConnection(false);
+                const hubConnection = createHubConnection(connection, logger);
+
+                let startCompleted = false;
+                const startPromise = hubConnection.start().then(() => startCompleted = true);
+                expect(startCompleted).toBe(false);
+
+                await hubConnection.stop()
+
+                try {
+                    await startPromise
+                } catch (e) {
+                    expect(e).toBeInstanceOf(AbortError);
+                    expect((e as AbortError).message).toBe("The connection was stopped before the hub handshake could complete.");
+                }
+            }, "The connection was stopped before the hub handshake could complete.");
+        });
+
         it("stop on close message", async () => {
             await VerifyLogger.run(async (logger) => {
                 const connection = new TestConnection();