fix: fix multiple establish connection calls (#1624)

**Summary**
This updates our base session class to _wait_ to call `establishConnection` more than once,
instead returning the already created promise if we're still waiting on a call to complete.

**Testing**
 - [x] Made sure there was only one call to `contextApi.createSession`

Author: scottdover

client/src/connection/session.ts

@@ -13,6 +13,7 @@ export type SessionContextAttributes =
 
 export abstract class Session {
   protected _rejectRun: (reason?: unknown) => void | undefined;
+  protected _connectionPromise: Promise<void> | undefined;
 
   protected _onSessionLogFn: OnLogFn | undefined;
   public set onSessionLogFn(value: OnLogFn) {
@@ -25,16 +26,25 @@ export abstract class Session {
   }
 
   async setup(silent?: boolean): Promise<void> {
+    // If we already have a connection promise we're awaiting, lets use that.
+    // Otherwise, establish a new connection
+    this._connectionPromise ||= this.establishConnection();
     if (silent) {
-      return await this.establishConnection();
+      const resolvedData = await this._connectionPromise;
+      this._connectionPromise = undefined;
+      return resolvedData;
     }
 
     await window.withProgress(
       {
         location: ProgressLocation.Notification,
         title: l10n.t("Connecting to SAS session..."),
       },
-      this.establishConnection,
+      async () => {
+        const resolvedData = await this._connectionPromise;
+        this._connectionPromise = undefined;
+        return resolvedData;
+      },
     );
   }
 
@@ -57,6 +67,7 @@ export abstract class Session {
       this._rejectRun({ message: l10n.t("The SAS session has closed.") });
       this._rejectRun = undefined;
     }
+    this._connectionPromise = undefined;
     return this._close();
   }
   protected abstract _close(): Promise<void> | void;

client/test/connection/session.test.ts

@@ -0,0 +1,43 @@
+import { expect } from "chai";
+import * as sinon from "sinon";
+
+import { RunResult } from "../../src/connection";
+import { Session } from "../../src/connection/session";
+
+class MockSession extends Session {
+  constructor(protected readonly connectionMock: () => void) {
+    super();
+  }
+  protected async establishConnection(): Promise<void> {
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        this.connectionMock();
+        resolve();
+      }, 100);
+    });
+  }
+  protected _run(code: string, ...args: any[]): Promise<RunResult> {
+    throw new Error("Method not implemented.");
+  }
+  protected _close(): Promise<void> | void {}
+  sessionId?(): string | undefined {
+    return;
+  }
+}
+
+describe("Session test", () => {
+  it("triggers establish connection only once", async () => {
+    const mockConnectionFn = sinon.mock();
+    const mockSession = new MockSession(mockConnectionFn);
+    const setupPromises: Promise<void>[] = Array(10)
+      .fill(true)
+      .map(() => mockSession.setup());
+
+    // Wait for everything to wrap up
+    await Promise.all(setupPromises);
+
+    // We called setup 10 times, but we expect to have only called establishConnection
+    // once.
+    expect(mockConnectionFn.callCount).to.equal(1);
+  });
+});