holepunch-hop 0.4.5 → 0.4.8

package/test/twopeers/reconnect-then-conerr.test.js

@@ -0,0 +1,309 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { spawn } from 'child_process'
+import path from 'path'
+import crypto from 'crypto'
+import Hyperswarm from 'hyperswarm'
+import NetworkPeers from '../../src/network/peers.js'
+
+// Set global test timeout to 10 seconds
+const testTimeout = 10000;
+
+describe('peer reconnection', () => {
+  let hopProcess
+  let clientPeer
+  let serverPeer
+  let clientSwarm
+  let serverSwarm
+  let clientPublicKey
+  let serverPublicKey
+  let savedPeerNetworkClient = []
+  let savedPeerNetworkServer = []
+  let topicReconnect = ''
+  let testConfig
+  let peerNetworkMock = []
+
+  beforeEach(async () => {
+    // Start HOP server
+    const baseHOPStepsUp = path.join(__dirname, '../..')
+    // hopProcess = spawn('npm', ['run', 'start'], { stdio: 'inherit', cwd: baseHOPStepsUp })
+    // await new Promise((resolve) => setTimeout(resolve, 3000))
+
+    // Initialize peers
+    // Create real swarms
+    clientSwarm = new Hyperswarm()
+    serverSwarm = new Hyperswarm()
+
+    // Create client and server peers
+    clientPeer = new NetworkPeers({}, clientSwarm) 
+    serverPeer = new NetworkPeers({}, serverSwarm)
+
+    testConfig = {
+      peer1to2: {
+        peer1: {
+          publicKey: clientPeer.swarm.keyPair.publicKey.toString('hex'),
+          client: true
+        },
+        peer2: {
+          publicKey: serverPeer.swarm.keyPair.publicKey.toString('hex'),
+          client: false
+        },
+      }
+    }
+
+    const randomString = crypto.randomBytes(32).toString('hex')
+    // Convert the random string to a buffer
+    const buffer = Buffer.from(randomString, 'hex')
+    topicReconnect =  randomString
+
+  }, 10000) // 10 second timeout for setup
+
+  afterEach(async () => {
+    console.log('Cleaning up test environment')
+    await clientSwarm.destroy()
+    await serverSwarm.destroy()
+    clientPeer = null
+    serverPeer = null
+  }, 20000) // 20 second timeout for cleanup
+
+  describe('initial connection and relationship storage', () => {
+    it('should save relationship data for reconnection', async () => {
+      // make initial connection
+      console.log('FIRT TIME CONNECT start')
+      let connectionCount = 0
+      let mockServerPeer = {
+        publickey: clientPeer.swarm.keyPair.publicKey.toString('hex'),
+        live: false,
+        value: {
+          live: false,
+          key: clientPeer.swarm.keyPair.publicKey.toString('hex')
+        }
+      }
+      // make client listen
+      clientPeer.peerJoinClient()
+      // serverPeer.peerJoinClient()
+      console.log('start NETWORK plumbing client peer1 and server peer2')
+      serverPeer.peerJoin(mockServerPeer)
+      // Create connection promise to verify connection details
+      let connectionPromise = new Promise((resolve) => {
+        clientPeer.swarm.on('connection', (conn, info) => {
+          connectionCount++
+          // Verify client connection details
+          console.log('Client FIRST connection details:')
+          expect(info.publicKey).toBeDefined()
+          expect(info.publicKey.toString('hex')).toBeDefined()
+          expect(info.client).toBe(false)  // Client sees itself as false
+          expect(info.topics.length).toBe(0)
+          expect(clientPeer.topicHolder['']).toBeUndefined()
+          
+          // Store connection for verification
+          const publicKeyHex = info.publicKey.toString('hex')
+          // expect(clientPeer.peerConnect[publicKeyHex]).toBeDefined()
+          
+          // Save the peer network data for reconnection
+          savedPeerNetworkClient.push({
+            key: publicKeyHex,
+            value: {
+              name: 'peer2',
+              publickey: publicKeyHex,
+              roletaken: true,
+              longterm: true,
+              settopic: true,
+              topic: topicReconnect,
+              live: false,
+              livePeerkey: ''
+            }
+          })
+          // Resolve when client connection is established
+          if (connectionCount === 2) {
+            console.log('resolve peer two')
+            resolve()
+          }
+        })
+
+        serverPeer.swarm.on('connection', (conn, info) => {
+          console.log('Server FIRST connection details:')
+          connectionCount++
+          const publicKeyHex2 = info.publicKey.toString('hex')
+          // Verify server connection details
+          expect(info.publicKey).toBeDefined()
+          expect(info.publicKey.toString('hex')).toBeDefined()
+          expect(info.client).toBe(true)  // Server sees itself as true
+          expect(info.topics.length).toBe(0)
+          expect(serverPeer.topicHolder['']).toBeUndefined()
+
+          // Store connection for verification on reconnect
+          savedPeerNetworkServer.push({
+            key: publicKeyHex2,
+            value: {
+              name: 'peer1',
+              publickey: publicKeyHex2,
+              roletaken: false,
+              longterm: true,
+              settopic: false,
+              topic: topicReconnect,
+              live: false,
+              livePeerkey: ''
+            }
+          })
+          
+          // Resolve when server connection is established
+          if (connectionCount === 2) {
+            console.log('resolve peer two')
+            resolve()
+          }
+        })
+      })
+
+      // Wait for connection to be established
+      await connectionPromise
+      
+      // Add timeout to prevent hanging
+      const timeout = setTimeout(() => {
+        throw new Error('Connection did not establish within timeout period')
+      }, 30000)
+
+      // Clear timeout if connection was successful
+      clearTimeout(timeout)
+    }, 50000) // 50 second timeout
+  })
+  
+  describe('reconnection using saved data', async() => {
+    it('should use saved relationship data for reconnection', async () => {
+      let connectionCount = 0
+      console.log('reconnection using saved data')
+      let logicPrepserverStatus = async function (holePunch, info, publicKey) {
+        return await holePunch.prepareConnectionInfo(info, publicKey)
+      }
+
+      // Reconnect using saved peer network data
+      clientPeer.setupConnectionBegin(savedPeerNetworkClient)
+      
+      // Add 3 second delay before starting serverPeer
+      await new Promise(resolve => setTimeout(resolve, 3000));
+      serverPeer.setupConnectionBegin(savedPeerNetworkServer)
+
+      // Create connection promise to verify reconnection details
+      let reconnectionPromise = new Promise(async (resolve) => {
+        clientPeer.swarm.on('connection', async (conn, info) => {
+          console.log('Client2 RECON connection details:')
+          connectionCount++
+          // Verify reconnection details
+          expect(info.publicKey).toBeDefined()
+          expect(info.publicKey.toString('hex')).toBeDefined()
+          expect(info.client).toBe(false)  // Client sees itself as false
+          expect(info.topics.length).toBe(0)
+          expect(clientPeer.topicHolder['']).toBeUndefined()
+          
+          peerNetworkMock.push({
+            key: testConfig.peer1to2.peer1.publicKey,
+            value: {
+              name: 'peer1',
+              publickey: testConfig.peer1to2.peer1.publicKey,
+              roletaken: true,
+              longterm: true,
+              settopic: true,
+              topic: 'letitbe',
+              live: false,
+              livePeerkey: testConfig.peer1to2.peer1.publicKey
+            }
+          })
+
+          // Store connection for verification
+          const publicKeyHex = info.publicKey.toString('hex')     
+          // check logic
+          let logicInfo = await logicPrepserverStatus(clientPeer, info)
+          // Verify reconnection logic
+          if (info.client === testConfig.peer1to2.peer1.client) {
+            expect(logicInfo.discoveryTopicInfo.firstTime).toBe(false)
+          } else {
+            // Either serverStatus is true or there's a topic set
+          }
+          // Resolve when reconnection is established
+          console.log('TEST COMPLERE 111')
+          if (connectionCount === 2) {
+            console.log('resolve peer two')
+            clientSwarm.destroy()
+            clientPeer = null
+            // resolve()
+            // esolve()
+          }
+        })
+
+        serverPeer.swarm.on('connection', async (conn, info) => {
+          console.log('Server2 RECON connection details:')
+          connectionCount++
+          // Verify server reconnection details
+          expect(info.publicKey).toBeDefined()
+          expect(info.publicKey.toString('hex')).toBeDefined()
+          expect(info.client).toBe(true)  // Server sees itself as true
+          expect(info.topics.length).toBe(1)
+          expect(serverPeer.topicHolder['']).toBeUndefined()
+          
+          // Store connection for verification
+          const publicKeyHex = info.publicKey.toString('hex')
+          // expect(serverPeer.peerConnect[publicKeyHex]).toBeDefined()
+
+          // Store connection for later disconnection
+          serverPeer.peerConnect = {}
+          serverPeer.peerConnect[testConfig.peer1to2.peer1.publicKey] = conn
+
+          // check logic
+          let logicInfo = await logicPrepserverStatus(serverPeer, info)
+          // Verify reconnection logic
+          if (info.client === testConfig.peer1to2.peer2.client) {
+            expect(logicInfo.discoveryTopicInfo.firstTime).toBe(false)
+          } else {
+            // Either serverStatus is true or there's a topic set
+          }
+          console.log('TEST COMPLERE 222')
+          if (connectionCount === 2) {
+            console.log('resolve peer two')
+            // resolve()
+          }
+
+          let disconnectCount = 0
+          // listen for error
+          conn.on('error', data => {
+            console.log('error incoming, which peer?')
+            disconnectCount++
+            expect(info).toBeDefined()
+            expect(info.publicKey).toBeDefined()
+            expect(info.publicKey.toString('hex')).toBe(testConfig.peer1to2.peer1.publicKey)
+            // match to peer info. and inform beebee ui
+            let connectLivekeys = Object.keys(serverPeer.peerConnect)
+            for (let peer of peerNetworkMock) {
+              for (let pconn of connectLivekeys) {
+                if (peer.value.livePeerkey === pconn) {
+                  // check if connect is close?
+                  // let keysNoise = Object.keys(serverPeer.peerConnect[pconn]['noiseStream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['rawStream']['_closed'])
+                  // console.log(this.peerConnect[pconn]['noiseStream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['rawStream']['_closed'])
+                  let closeStatus = serverPeer.peerConnect[pconn]['noiseStream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['rawStream']['_closed']
+                  expect(closeStatus).toBe(true)
+                }
+              }
+            }
+            // Verify disconnection info
+            if (disconnectCount === 1) {
+              resolve()
+            }
+          })
+
+
+        })
+
+
+      })
+
+      // Wait for connection to be established
+      await reconnectionPromise
+      
+      // Add timeout to prevent hanging
+      const timeout = setTimeout(() => {
+        throw new Error('Connection did not establish within timeout period')
+      }, 30000)
+
+      // Clear timeout if connection was successful
+      clearTimeout(timeout)
+    }, 20000) // 50 second timeout
+  })
+})

package/test/twopeers/two-peer-one-disconnect.test.js

@@ -0,0 +1,162 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import Hyperswarm from 'hyperswarm'
+import NetworkPeers from '../../src/network/peers.js'
+import crypto from 'crypto'
+
+// Set global test timeout to 10 seconds
+const testTimeout = 10000;
+
+describe('Peer Disconnection Tests', () => {
+  let clientPeer
+  let serverPeer
+  let clientSwarm
+  let serverSwarm
+  let testConfig
+  let peerNetworkMock = []
+
+  beforeEach(async () => {
+    // Create real swarms
+    clientSwarm = new Hyperswarm()
+    serverSwarm = new Hyperswarm()
+
+    // Create client and server peers
+    clientPeer = new NetworkPeers({}, clientSwarm)
+    serverPeer = new NetworkPeers({}, serverSwarm)
+
+    testConfig = {
+      peer1to2: {
+        peer1: {
+          publicKey: clientPeer.swarm.keyPair.publicKey.toString('hex'),
+          client: true
+        },
+        peer2: {
+          publicKey: serverPeer.swarm.keyPair.publicKey.toString('hex'),
+          client: false
+        }
+      }
+    }
+
+  
+    // Set up initial connection
+    clientPeer.peerJoinClient()
+    serverPeer.peerJoinClient()
+
+    // Create mock server peer for client to connect to
+    const mockServerPeer = {
+      publickey: serverPeer.swarm.keyPair.publicKey.toString('hex'),
+      live: false,
+      value: {
+        live: false,
+        key: serverPeer.swarm.keyPair.publicKey.toString('hex')
+      }
+    }
+    clientPeer.peerJoin(mockServerPeer)
+
+    // Wait for initial setup
+    await new Promise(resolve => setTimeout(resolve, 1000))
+  }, 10000)
+
+  afterEach(async () => {
+    console.log('Cleaning up test environment')
+    await Promise.all([
+      clientSwarm.destroy(),
+      serverSwarm.destroy()
+    ])
+    clientPeer = null
+    serverPeer = null
+  }, 10000)
+
+  describe('First-time connection and disconnection', () => {
+    it('should handle first-time connection and proper disconnection', async () => {
+      let connectionCount = 0
+      let disconnectCount = 0
+
+      // Track connection
+      const connectionPromise = new Promise((resolve) => {
+        clientPeer.swarm.on('connection', (conn, info) => {
+          connectionCount++
+          console.log('Client connection:')
+          expect(info.publicKey).toBeDefined()
+          expect(info.client).toBe(true)
+          expect(info.topics.length).toBe(0)
+          
+          // Store connection for later disconnection
+          clientPeer.connection = conn
+          
+          if (connectionCount === 1) {
+            console.log('Client disconnecting')
+            clientSwarm.destroy()
+            clientPeer = null
+            resolve()
+          }
+        })
+      })
+
+      // Track server connection
+      const serverConnectionPromise = new Promise((resolve) => {
+        serverPeer.swarm.on('connection', (conn, info) => {
+          connectionCount++
+          console.log('Server connection:')
+          expect(info.publicKey).toBeDefined()
+          expect(info.publicKey).toBeDefined()
+          // Server sees itself as false
+          expect(info.client).toBe(false)
+          expect(info.topics.length).toBe(0)
+          
+          // Store connection for later disconnection
+          serverPeer.peerConnect = {}
+          serverPeer.peerConnect[testConfig.peer1to2.peer1.publicKey] = conn
+
+          peerNetworkMock.push({
+            key: testConfig.peer1to2.peer1.publicKey,
+            value: {
+              name: 'peer1',
+              publickey: testConfig.peer1to2.peer1.publicKey,
+              roletaken: true,
+              longterm: true,
+              settopic: true,
+              topic: 'letitbe',
+              live: false,
+              livePeerkey: testConfig.peer1to2.peer1.publicKey
+            }
+          })
+          
+          if (connectionCount === 2) {
+            console.log('server count disconnecting')
+          }
+          // listen for error
+          conn.on('error', data => {
+            console.log('error incoming, which peer?')
+            disconnectCount++
+            expect(info).toBeDefined()
+            expect(info.publicKey).toBeDefined()
+            expect(info.publicKey.toString('hex')).toBe(testConfig.peer1to2.peer1.publicKey)
+            // match to peer info. and inform beebee ui
+            let connectLivekeys = Object.keys(serverPeer.peerConnect)
+            for (let peer of peerNetworkMock) {
+              for (let pconn of connectLivekeys) {
+                if (peer.value.livePeerkey === pconn) {
+                  // check if connect is close?
+                  // let keysNoise = Object.keys(serverPeer.peerConnect[pconn]['noiseStream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['rawStream']['_closed'])
+                  // console.log(this.peerConnect[pconn]['noiseStream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['rawStream']['_closed'])
+                  let closeStatus = serverPeer.peerConnect[pconn]['noiseStream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['rawStream']['_closed']
+                  expect(closeStatus).toBe(true)
+                }
+              }
+            }
+            // Verify disconnection info
+            if (disconnectCount === 1) {
+              resolve()
+            }
+          })
+
+        })
+      })
+
+      // Wait for both connections to be established
+      await Promise.all([connectionPromise, serverConnectionPromise])
+
+
+    }, 30000)
+  }) 
+})

package/test/twopeers/two-peer-server-disconnect.test.js

@@ -0,0 +1,167 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import Hyperswarm from 'hyperswarm'
+import NetworkPeers from '../../src/network/peers.js'
+import crypto from 'crypto'
+
+// Set global test timeout to 10 seconds
+const testTimeout = 10000;
+
+describe('Peer Disconnection Tests', () => {
+  let clientPeer
+  let serverPeer
+  let clientSwarm
+  let serverSwarm
+  let testConfig
+  let peerNetworkMock = []
+
+  beforeEach(async () => {
+    // Create real swarms
+    clientSwarm = new Hyperswarm()
+    serverSwarm = new Hyperswarm()
+
+    // Create client and server peers
+    clientPeer = new NetworkPeers({}, clientSwarm)
+    serverPeer = new NetworkPeers({}, serverSwarm)
+
+    testConfig = {
+      peer1to2: {
+        peer1: {
+          publicKey: clientPeer.swarm.keyPair.publicKey.toString('hex'),
+          client: true
+        },
+        peer2: {
+          publicKey: serverPeer.swarm.keyPair.publicKey.toString('hex'),
+          client: false
+        }
+      }
+    }
+
+  
+    // Set up initial connection
+    clientPeer.peerJoinClient()
+    serverPeer.peerJoinClient()
+
+    // Create mock server peer for client to connect to
+    const mockServerPeer = {
+      publickey: serverPeer.swarm.keyPair.publicKey.toString('hex'),
+      live: false,
+      value: {
+        live: false,
+        key: serverPeer.swarm.keyPair.publicKey.toString('hex')
+      }
+    }
+    clientPeer.peerJoin(mockServerPeer)
+
+    // Wait for initial setup
+    await new Promise(resolve => setTimeout(resolve, 1000))
+  }, 10000)
+
+  afterEach(async () => {
+    console.log('Cleaning up test environment')
+    await Promise.all([
+      clientSwarm.destroy(),
+      serverSwarm.destroy()
+    ])
+    clientPeer = null
+    serverPeer = null
+  }, 10000)
+
+  describe('First-time connection and disconnection', () => {
+    it('should handle first-time connection and proper disconnection', async () => {
+      let connectionCount = 0
+      let disconnectCount = 0
+
+      // Track connection
+      const connectionPromise = new Promise((resolve) => {
+        clientPeer.swarm.on('connection', (conn, info) => {
+          connectionCount++
+          console.log('Client connection:')
+          expect(info.publicKey).toBeDefined()
+          expect(info.client).toBe(true)
+          expect(info.topics.length).toBe(0)
+          
+          // Store connection for later disconnection
+          clientPeer.connection = conn
+          
+
+
+          clientPeer.peerConnect = {}
+          clientPeer.peerConnect[testConfig.peer1to2.peer2.publicKey] = conn
+
+          peerNetworkMock.push({
+            key: testConfig.peer1to2.peer2.publicKey,
+            value: {
+              name: 'peer2',
+              publickey: testConfig.peer1to2.peer2.publicKey,
+              roletaken: true,
+              longterm: true,
+              settopic: true,
+              topic: 'letitbe',
+              live: false,
+              livePeerkey: testConfig.peer1to2.peer2.publicKey
+            }
+          })
+
+          // listen for error
+          conn.on('error', data => {
+            let disconnectCount = 0
+            console.log('error incoming client, which peer?')
+            disconnectCount++
+            expect(info).toBeDefined()
+            expect(info.publicKey).toBeDefined()
+            expect(info.publicKey.toString('hex')).toBe(testConfig.peer1to2.peer2.publicKey)
+            // match to peer info. and inform beebee ui
+            let connectLivekeys = Object.keys(clientPeer.peerConnect)
+            for (let peer of peerNetworkMock) {
+              for (let pconn of connectLivekeys) {
+                if (peer.value.livePeerkey === pconn) {
+                  // check if connect is close?
+                  // let keysNoise = Object.keys(serverPeer.peerConnect[pconn]['noiseStream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['rawStream']['_closed'])
+                  // console.log(this.peerConnect[pconn]['noiseStream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['rawStream']['_closed'])
+                  let closeStatus = clientPeer.peerConnect[pconn]['noiseStream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['rawStream']['_closed']
+                  expect(closeStatus).toBe(true)
+                }
+              }
+            }
+            
+            // Verify disconnection info
+            if (disconnectCount === 1) {
+              console.log('resolve finish')
+              resolve()
+            }
+          })
+
+        })
+      })
+
+      // Track server connection
+      const serverConnectionPromise = new Promise((resolve) => {
+        serverPeer.swarm.on('connection', (conn, info) => {
+          connectionCount++
+          console.log('Server connection:')
+          expect(info.publicKey).toBeDefined()
+          expect(info.publicKey).toBeDefined()
+          // Server sees itself as false
+          expect(info.client).toBe(false)
+          expect(info.topics.length).toBe(0)
+          
+          // Store connection for later disconnection
+          serverPeer.peerConnect = {}
+          serverPeer.peerConnect[testConfig.peer1to2.peer1.publicKey] = conn
+
+          if (connectionCount === 2) {
+            console.log('server count disconnecting')
+            serverSwarm.destroy()
+            serverPeer = null
+            resolve()
+          }
+
+        })
+      })
+
+      // Wait for both connections to be established
+      await Promise.all([connectionPromise, serverConnectionPromise])
+
+    }, 50000)
+  }) 
+})

package/vitest.config.js

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    include: ['test/**/*.test.js'],
+  },
+});