Wrap up connection + in memory store

src/Tests/_test.manual_tests.ts

@@ -0,0 +1,112 @@
+
+describe ('Reconnects', () => {
+    const verifyConnectionOpen = async (conn: Connection) => {
+        expect((await conn.getState()).user).toBeDefined()
+        let failed = false
+        // check that the connection stays open
+		conn.ev.on('state.update', ({ connection, lastDisconnect }) => {
+			if(connection === 'close' && !!lastDisconnect.error) {
+				failed = true
+			}
+		})
+        await delay (60*1000)
+        conn.close ()
+
+        expect(failed).toBe(false)
+    }
+    it('should dispose correctly on bad_session', async () => {
+        const conn = makeConnection({
+			reconnectMode: 'on-any-error',
+			credentials: './auth_info.json',
+			maxRetries: 2,
+			connectCooldownMs: 500
+		})
+        let gotClose0 = false
+        let gotClose1 = false
+
+		const openPromise = conn.open()
+
+        conn.getSocket().ev.once('ws-close', () => {
+            gotClose0 = true
+        })
+        conn.ev.on('state.update', ({ lastDisconnect }) => {
+			//@ts-ignore
+            if(lastDisconnect?.error?.output?.statusCode === DisconnectReason.badSession) {
+                gotClose1 = true
+            }
+        })
+        setTimeout (() => conn.getSocket().ws.emit ('message', Buffer.from('some-tag,sdjjij1jo2ejo1je')), 1500)
+        await openPromise
+
+        console.log('opened connection')
+
+		await delay(1000)
+		conn.getSocket().ws.emit ('message', Buffer.from('some-tag,sdjjij1jo2ejo1je'))
+		
+		await delay(2000)
+        await conn.waitForConnection()
+
+        conn.close()
+
+		expect(gotClose0).toBe(true)
+		expect(gotClose1).toBe(true)
+    }, 20_000)
+    /**
+     * the idea is to test closing the connection at multiple points in the connection 
+     * and see if the library cleans up resources correctly
+     */
+    it('should cleanup correctly', async () => {
+        const conn = makeConnection({
+			reconnectMode: 'on-any-error',
+			credentials: './auth_info.json'
+		})
+        let timeoutMs = 100
+        while (true) {
+            let tmout = setTimeout (() => {
+                conn.close()
+            }, timeoutMs)
+            try {
+                await conn.open()
+                clearTimeout (tmout)
+                break
+            } catch (error) {
+
+            }
+            // exponentially increase the timeout disconnect
+            timeoutMs *= 2
+        }
+        await verifyConnectionOpen(conn)
+    }, 120_000)
+    /**
+     * the idea is to test closing the connection at multiple points in the connection 
+     * and see if the library cleans up resources correctly
+     */
+    it('should disrupt connect loop', async () => {
+        const conn = makeConnection({
+			reconnectMode: 'on-any-error',
+			credentials: './auth_info.json'
+		})
+
+        let timeout = 1000
+        let tmout
+        const endConnection = async () => {
+            while (!conn.getSocket()) {
+                await delay(100)
+            }
+            conn.getSocket().end(Boom.preconditionRequired('conn close'))
+
+            while (conn.getSocket()) {
+                await delay(100)
+            }
+
+            timeout *= 2
+            tmout = setTimeout (endConnection, timeout) 
+        }
+        tmout = setTimeout (endConnection, timeout) 
+
+        await conn.open()
+        clearTimeout (tmout)
+
+        await verifyConnectionOpen(conn)
+    }, 120_000)
+})