refactor: CloudSqlInstance.forceRefresh() should schedule a refresh and return immediately.

This avoids the situation where a refresh process is forced to start but may never finish, causing the 
node process to hang indefiniately awaiting the refresh promise that does not resolve. This also adds
a new method used in the test cases: CloudSqlInstance.refreshComplete() which returns a promise that 
will resolve when the refresh operation has finished.

Author: hessjcg

src/cloud-sql-instance.ts

@@ -106,14 +106,34 @@ export class CloudSQLInstance {
     }) as ReturnType<typeof pThrottle>;
   }
 
-  forceRefresh(): Promise<RefreshResult> {
+  forceRefresh(){
     // if a refresh is already ongoing, just await for its promise to fulfill
     // so that a new instance info is available before reconnecting
     if (this.next) {
-      return this.next;
+      return;
     }
     this.cancelRefresh();
-    return this.refresh();
+    this.scheduleRefresh(0);
+  }
+
+  // refreshComplete Returns a promise that resolves when the current refresh
+  // cycle has completed, either with success or failure. If no refresh is
+  // in progress, the promise will resolve immediately.
+  refreshComplete(): Promise<void> {
+    return new Promise((resolve) => {
+      // setTimeout() to yield execution to allow other refresh background
+      // tasks to start.
+      setTimeout(()=> {
+        if(this.next){
+          // If there is a refresh promise in progress, resolve this promise
+          // when the refresh is complete.
+          this.next.finally(resolve)
+        } else {
+          // Else resolve immediately.
+          resolve()
+        }
+      }, 0);
+    });
   }
 
   refresh(): Promise<RefreshResult> {

src/connector.ts

@@ -230,8 +230,8 @@ export class Connector {
             serverCaMode,
             dnsName,
           });
-          tlsSocket.once('error', async () => {
-            await cloudSqlInstance.forceRefresh();
+          tlsSocket.once('error', () => {
+            cloudSqlInstance.forceRefresh();
           });
           tlsSocket.once('secureConnect', async () => {
             cloudSqlInstance.setEstablishedConnection();

test/cloud-sql-instance.ts

@@ -269,7 +269,10 @@ t.test('CloudSQLInstance', async t => {
       await CloudSQLInstance.prototype.refresh.call(instance);
       instance.refresh = CloudSQLInstance.prototype.refresh;
     };
-    await instance.forceRefresh();
+
+    instance.forceRefresh();
+    await instance.refreshComplete();
+
     t.ok(
       cancelRefreshCalled,
       'should cancelRefresh current refresh cycle on force refresh'
@@ -302,13 +305,8 @@ t.test('CloudSQLInstance', async t => {
       return CloudSQLInstance.prototype.refresh.call(instance);
     };
 
-    const forceRefreshPromise = instance.forceRefresh();
-    t.strictSame(
-      refreshPromise,
-      forceRefreshPromise,
-      'forceRefresh should return same promise ref from initial refresh call'
-    );
-    await forceRefreshPromise;
+    instance.forceRefresh();
+    await instance.refreshComplete()
 
     t.ok(
       !cancelRefreshCalled,