cleaning for ws tests

test/inverse/ws.private.test.ts

@@ -68,12 +68,10 @@ describe('Private Inverse Perps Websocket Client', () => {
     it('should open a ws connection', async () => {
       const wsOpenPromise = waitForSocketEvent(wsClient, 'open');
 
-      expect(wsOpenPromise).resolves.toMatchObject({
+      expect(await wsOpenPromise).toMatchObject({
         event: WS_OPEN_EVENT_PARTIAL,
         wsKey: WS_KEY_MAP.inverse,
       });
-
-      await Promise.all([wsOpenPromise]);
     });
 
     it('should subscribe to private wallet events', async () => {

test/inverse/ws.public.test.ts

@@ -30,12 +30,14 @@ describe('Public Inverse Perps Websocket Client', () => {
   it('should open a public ws connection', async () => {
     const wsOpenPromise = waitForSocketEvent(wsClient, 'open');
 
-    expect(wsOpenPromise).resolves.toMatchObject({
+    try {
+      expect(await wsOpenPromise).toMatchObject({
         event: WS_OPEN_EVENT_PARTIAL,
         wsKey: WS_KEY_MAP.inverse,
       });
-
+    } catch (e) {
-    await Promise.all([wsOpenPromise]);
+      expect(e).toBeFalsy();
+    }
   });
 
   it('should subscribe to public orderBookL2_25 events', async () => {

test/linear/ws.private.test.ts

@@ -71,12 +71,14 @@ describe('Private Linear Perps Websocket Client', () => {
     it('should open a ws connection', async () => {
       const wsOpenPromise = waitForSocketEvent(wsClient, 'open');
 
-      expect(wsOpenPromise).resolves.toMatchObject({
+      try {
+        expect(await wsOpenPromise).toMatchObject({
           event: WS_OPEN_EVENT_PARTIAL,
           wsKey: WS_KEY_MAP.linearPrivate,
         });
-
+      } catch (e) {
-      await Promise.all([wsOpenPromise]);
+        expect(e).toBeFalsy();
+      }
     });
 
     it('should subscribe to private wallet events', async () => {

test/linear/ws.public.test.ts

@@ -23,17 +23,16 @@ describe('Public Linear Perps Websocket Client', () => {
 
   afterAll(() => {
     wsClient.closeAll();
+    wsClient.removeAllListeners();
   });
 
   it('should open a public ws connection', async () => {
     const wsOpenPromise = waitForSocketEvent(wsClient, 'open');
 
-    expect(wsOpenPromise).resolves.toMatchObject({
+    expect(await wsOpenPromise).toMatchObject({
       event: WS_OPEN_EVENT_PARTIAL,
       wsKey: WS_KEY_MAP.linearPublic,
     });
-
-    await Promise.all([wsOpenPromise]);
   });
 
   it('should subscribe to public orderBookL2_25 events', async () => {
@@ -41,33 +40,27 @@ describe('Public Linear Perps Websocket Client', () => {
     const wsUpdatePromise = waitForSocketEvent(wsClient, 'update');
 
     const wsTopic = 'orderBookL2_25.BTCUSDT';
-    expect(wsResponsePromise).resolves.toMatchObject({
+    wsClient.subscribe(wsTopic);
+
+    try {
+      expect(await wsResponsePromise).toMatchObject({
         request: {
           args: [wsTopic],
           op: 'subscribe',
         },
         success: true,
       });
-    expect(wsUpdatePromise).resolves.toMatchObject({
+    } catch (e) {
+      expect(e).toBeFalsy();
+    }
+
+    try {
+      expect(await wsUpdatePromise).toMatchObject({
         topic: wsTopic,
         data: {
           order_book: expect.any(Array),
         },
       });
-
-    wsClient.subscribe(wsTopic);
-
-    try {
-      await wsResponsePromise;
-    } catch (e) {
-      console.error(
-        `Wait for "${wsTopic}" subscription response exception: `,
-        e
-      );
-    }
-
-    try {
-      await wsUpdatePromise;
     } catch (e) {
       console.error(`Wait for "${wsTopic}" event exception: `, e);
     }
@@ -78,13 +71,6 @@ describe('Public Linear Perps Websocket Client', () => {
     // const wsUpdatePromise = waitForSocketEvent(wsClient, 'update');
 
     const wsTopic = 'wallet';
-    expect(wsResponsePromise).resolves.toMatchObject({
-      request: {
-        args: [wsTopic],
-        op: 'subscribe',
-      },
-      success: true,
-    });
 
     // No easy way to trigger a private event (other than executing trades)
     // expect(wsUpdatePromise).resolves.toMatchObject({
@@ -95,9 +81,15 @@ describe('Public Linear Perps Websocket Client', () => {
     wsClient.subscribe(wsTopic);
 
     try {
-      await Promise.all([wsResponsePromise]);
+      expect(await wsResponsePromise).toBeFalsy();
     } catch (e) {
-      //
+      expect(e).toMatchObject({
+        request: {
+          args: [wsTopic],
+          op: 'subscribe',
+        },
+        success: false,
+      });
     }
   });
 });

test/spot/ws.private.v1.test.ts

@@ -46,15 +46,20 @@ describe('Private Spot V1 Websocket Client', () => {
 
     wsClient.connectPrivate();
 
-    expect(wsOpenPromise).resolves.toMatchObject({
+    try {
+      expect(await wsOpenPromise).toMatchObject({
         event: WS_OPEN_EVENT_PARTIAL,
-      wsKey: WS_KEY_MAP.spotPrivate,
+        // wsKey: WS_KEY_MAP.spotPrivate,
+        // also opens public conn automatically, which can confuse the test
       });
+    } catch (e) {
+      expect(e).toBeFalsy();
+    }
     // expect(wsUpdatePromise).resolves.toMatchObject({
     //   topic: 'wsTopic',
     //   data: expect.any(Array),
     // });
-    await Promise.all([wsOpenPromise]);
+
     // await Promise.all([wsUpdatePromise]);
     // await promiseSleep(4000);
   });

test/spot/ws.private.v3.test.ts

@@ -79,13 +79,11 @@ describe('Private Spot V3 Websocket Client', () => {
       const wsOpenPromise = waitForSocketEvent(wsClient, 'open');
       const wsResponsePromise = waitForSocketEvent(wsClient, 'response');
 
-      expect(wsOpenPromise).resolves.toMatchObject({
+      try {
+        expect(await wsOpenPromise).toMatchObject({
           event: WS_OPEN_EVENT_PARTIAL,
           wsKey: WS_KEY_MAP.spotV3Private,
         });
-
-      try {
-        await Promise.all([wsOpenPromise]);
       } catch (e) {
         expect(e).toBeFalsy();
       }

test/spot/ws.public.v1.test.ts

@@ -34,12 +34,14 @@ describe('Public Spot V1 Websocket Client', () => {
   it('should open a public ws connection', async () => {
     const wsOpenPromise = waitForSocketEvent(wsClient, 'open');
 
-    expect(wsOpenPromise).resolves.toMatchObject({
+    try {
+      expect(await wsOpenPromise).toMatchObject({
         event: WS_OPEN_EVENT_PARTIAL,
         wsKey: WS_KEY_MAP.spotPublic,
       });
-
+    } catch (e) {
-    await Promise.all([wsOpenPromise]);
+      expect(e).toBeFalsy();
+    }
   });
 
   it('should subscribe to public orderbook events', async () => {

test/spot/ws.public.v3.test.ts

@@ -34,12 +34,14 @@ describe('Public Spot V3 Websocket Client', () => {
   it('should open a public ws connection', async () => {
     const wsOpenPromise = waitForSocketEvent(wsClient, 'open');
 
-    expect(wsOpenPromise).resolves.toMatchObject({
+    try {
+      expect(await wsOpenPromise).toMatchObject({
         event: WS_OPEN_EVENT_PARTIAL,
         wsKey: WS_KEY_MAP.spotV3Public,
       });
-
+    } catch (e) {
-    await Promise.all([wsOpenPromise]);
+      expect(e).toBeFalsy();
+    }
   });
 
   it('should subscribe to public orderbook events', async () => {

test/usdc/options/ws.private.test.ts

@@ -77,7 +77,6 @@ describe('Private USDC Option Websocket Client', () => {
         wsClientOptions,
         getSilentLogger('expectSuccess')
       );
-      wsClient.connectPrivate();
       // logAllEvents(wsClient);
     });
 
@@ -86,16 +85,15 @@ describe('Private USDC Option Websocket Client', () => {
     });
 
     it('should open a private ws connection', async () => {
+      wsClient.connectPrivate();
       const wsOpenPromise = waitForSocketEvent(wsClient, 'open');
       const wsResponsePromise = waitForSocketEvent(wsClient, 'response');
 
-      expect(wsOpenPromise).resolves.toMatchObject({
+      try {
+        expect(await wsOpenPromise).toMatchObject({
           event: WS_OPEN_EVENT_PARTIAL,
           wsKey: WS_KEY_MAP.usdcOptionPrivate,
         });
-
-      try {
-        await Promise.all([wsOpenPromise]);
       } catch (e) {
         expect(e).toBeFalsy();
       }
@@ -113,6 +111,7 @@ describe('Private USDC Option Websocket Client', () => {
     });
 
     it(`should subscribe to private "${wsTopic}" events`, async () => {
+      wsClient.connectPrivate();
       const wsResponsePromise = waitForSocketEvent(wsClient, 'response');
       const wsUpdatePromise = waitForSocketEvent(wsClient, 'update');
 

test/usdc/options/ws.public.test.ts

@@ -31,13 +31,14 @@ describe('Public USDC Option Websocket Client', () => {
 
   it('should open a public ws connection', async () => {
     const wsOpenPromise = waitForSocketEvent(wsClient, 'open');
-
+    try {
-    expect(wsOpenPromise).resolves.toMatchObject({
+      expect(await wsOpenPromise).toMatchObject({
         event: WS_OPEN_EVENT_PARTIAL,
         wsKey: WS_KEY_MAP.usdcOptionPublic,
       });
-
+    } catch (e) {
-    await Promise.all([wsOpenPromise]);
+      expect(e).toBeFalsy();
+    }
   });
 
   it('should subscribe to public trade events', async () => {

test/usdc/perpetual/ws.private.test.ts

@@ -89,13 +89,11 @@ describe('Private USDC Perp Websocket Client', () => {
       const wsOpenPromise = waitForSocketEvent(wsClient, 'open');
       const wsResponsePromise = waitForSocketEvent(wsClient, 'response');
 
-      expect(wsOpenPromise).resolves.toMatchObject({
+      try {
+        expect(await wsOpenPromise).toMatchObject({
           event: WS_OPEN_EVENT_PARTIAL,
           wsKey: WS_KEY_MAP.usdcPerpPrivate,
         });
-
-      try {
-        await Promise.all([wsOpenPromise]);
       } catch (e) {
         expect(e).toBeFalsy();
       }

test/usdc/perpetual/ws.public.test.ts

@@ -33,12 +33,10 @@ describe('Public USDC Perp Websocket Client', () => {
   it('should open a public ws connection', async () => {
     const wsOpenPromise = waitForSocketEvent(wsClient, 'open');
 
-    expect(wsOpenPromise).resolves.toMatchObject({
+    expect(await wsOpenPromise).toMatchObject({
       event: WS_OPEN_EVENT_PARTIAL,
       wsKey: WS_KEY_MAP.usdcPerpPublic,
     });
-
-    await Promise.all([wsOpenPromise]);
   });
 
   it('should subscribe to public trade events', async () => {