fix: close WebSocket while listening test

rpc/provider/proxy.test.ts

@@ -1,4 +1,4 @@
-import { deferred, delay } from "../../deps/std/async.ts"
+import { deferred } from "../../deps/std/async.ts"
 import * as A from "../../deps/std/testing/asserts.ts"
 import * as T from "../../test_util/mod.ts"
 import { proxyProvider } from "./proxy.ts"
@@ -49,25 +49,28 @@ Deno.test({
 
     await t.step({
       name: "close WebSocket while listening",
-      ignore: true,
       async fn() {
-        const server = createWebSocketServer()
-        const stopped = deferred()
-        const provider = proxyProvider(server.url, (message) => {
-          A.assertInstanceOf(message, Error)
-          stopped.resolve()
+        const server = createWebSocketServer(function() {
+          this.close()
         })
+        const stopped = deferred()
+        const provider = proxyProvider(
+          server.url,
+          (message) => {
+            A.assertInstanceOf(message, Error)
+            stopped.resolve()
+          },
+        )
         provider.send({
           jsonrpc: "2.0",
           id: provider.nextId(),
           method: "system_health",
           params: [],
         })
-        await delay(0)
-        server.close()
         await stopped
         const providerRelease = await provider.release()
         A.assertNotInstanceOf(providerRelease, Error)
+        server.close()
       },
     })
 

rpc/provider/proxy.ts

@@ -65,6 +65,9 @@ function connection(
     ws.addEventListener("error", (e) => {
       conn!.forEachListener(new ProviderHandlerError(e))
     }, controller)
+    ws.addEventListener("close", (e) => {
+      conn!.forEachListener(new ProviderHandlerError(e))
+    }, controller)
     return new ProviderConnection(ws, () => controller.abort())
   })
   conn.addListener(listener)
@@ -74,18 +77,21 @@ function connection(
 function ensureWsOpen(ws: WebSocket): Promise<undefined | Event> {
   if (ws.readyState === WebSocket.OPEN) {
     return Promise.resolve(undefined)
+  } else if (ws.readyState === WebSocket.CLOSING || ws.readyState === WebSocket.CLOSED) {
+    return Promise.resolve(new Event("error"))
+  } else {
+    return new Promise<undefined | Event>((resolve) => {
+      const controller = new AbortController()
+      ws.addEventListener("open", () => {
+        controller.abort()
+        resolve(undefined)
+      }, controller)
+      ws.addEventListener("error", (e) => {
+        controller.abort()
+        resolve(e)
+      }, controller)
+    })
   }
-  return new Promise<undefined | Event>((resolve) => {
-    const controller = new AbortController()
-    ws.addEventListener("open", () => {
-      controller.abort()
-      resolve(undefined)
-    }, controller)
-    ws.addEventListener("error", (e) => {
-      controller.abort()
-      resolve(e)
-    }, controller)
-  })
 }
 
 function closeWs(socket: WebSocket): Promise<undefined | ProviderCloseError<Event>> {