test: add async/await tests

src/listener.js

@@ -33,7 +33,7 @@ module.exports = (handler) => {
 
     log('new connection', addr.toString())
 
-    const s = new Libp2pSocket(socket)
+    const s = new Libp2pSocket(socket, addr)
     trackSocket(server, socket)
 
     handler && handler(s)

test/adapter/connection-wrap.spec.js

@@ -6,7 +6,7 @@ const chai = require('chai')
 const dirtyChai = require('dirty-chai')
 const expect = chai.expect
 chai.use(dirtyChai)
-const TCP = require('../src/adapter')
+const TCP = require('../../src/adapter')
 const multiaddr = require('multiaddr')
 const Connection = require('interface-connection').Connection
 

test/adapter/connection.spec.js

@@ -0,0 +1,111 @@
+/* eslint-env mocha */
+'use strict'
+
+const pull = require('pull-stream')
+const chai = require('chai')
+const dirtyChai = require('dirty-chai')
+const expect = chai.expect
+chai.use(dirtyChai)
+const TCP = require('../../src/adapter')
+const multiaddr = require('multiaddr')
+
+describe('valid Connection', () => {
+  let tcp
+
+  beforeEach(() => {
+    tcp = new TCP()
+  })
+
+  const ma = multiaddr('/ip4/127.0.0.1/tcp/9090')
+
+  it('get observed addrs', (done) => {
+    let dialerObsAddrs
+
+    const listener = tcp.createListener((conn) => {
+      expect(conn).to.exist()
+      conn.getObservedAddrs((err, addrs) => {
+        expect(err).to.not.exist()
+        dialerObsAddrs = addrs
+        pull(pull.empty(), conn)
+      })
+    })
+
+    listener.listen(ma, () => {
+      const conn = tcp.dial(ma)
+      pull(
+        conn,
+        pull.onEnd(endHandler)
+      )
+
+      function endHandler () {
+        conn.getObservedAddrs((err, addrs) => {
+          expect(err).to.not.exist()
+          pull(pull.empty(), conn)
+          closeAndAssert(listener, addrs)
+        })
+      }
+
+      function closeAndAssert (listener, addrs) {
+        listener.close(() => {
+          expect(addrs[0]).to.deep.equal(ma)
+          expect(dialerObsAddrs.length).to.equal(1)
+          done()
+        })
+      }
+    })
+  })
+
+  it('get Peer Info', (done) => {
+    const listener = tcp.createListener((conn) => {
+      expect(conn).to.exist()
+      conn.getPeerInfo((err, peerInfo) => {
+        expect(err).to.exist()
+        expect(peerInfo).to.not.exist()
+        pull(pull.empty(), conn)
+      })
+    })
+
+    listener.listen(ma, () => {
+      const conn = tcp.dial(ma)
+
+      pull(conn, pull.onEnd(endHandler))
+
+      function endHandler () {
+        conn.getPeerInfo((err, peerInfo) => {
+          expect(err).to.exist()
+          expect(peerInfo).to.not.exist()
+
+          listener.close(done)
+        })
+      }
+    })
+  })
+
+  it('set Peer Info', (done) => {
+    const listener = tcp.createListener((conn) => {
+      expect(conn).to.exist()
+      conn.setPeerInfo('batatas')
+      conn.getPeerInfo((err, peerInfo) => {
+        expect(err).to.not.exist()
+        expect(peerInfo).to.equal('batatas')
+        pull(pull.empty(), conn)
+      })
+    })
+
+    listener.listen(ma, () => {
+      const conn = tcp.dial(ma)
+
+      pull(conn, pull.onEnd(endHandler))
+
+      function endHandler () {
+        conn.setPeerInfo('arroz')
+        conn.getPeerInfo((err, peerInfo) => {
+          expect(err).to.not.exist()
+          expect(peerInfo).to.equal('arroz')
+
+          listener.close(done)
+        })
+      }
+    })
+  })
+})

test/adapter/listen-dial.spec.js

@@ -6,7 +6,7 @@ const chai = require('chai')
 const dirtyChai = require('dirty-chai')
 const expect = chai.expect
 chai.use(dirtyChai)
-const TCP = require('../src/adapter')
+const TCP = require('../../src/adapter')
 const net = require('net')
 const multiaddr = require('multiaddr')
 const isCI = process.env.CI

test/connection.spec.js

@@ -1,12 +1,11 @@
 /* eslint-env mocha */
 'use strict'
 
-const pull = require('pull-stream')
 const chai = require('chai')
 const dirtyChai = require('dirty-chai')
 const expect = chai.expect
 chai.use(dirtyChai)
-const TCP = require('../src/adapter')
+const TCP = require('../src')
 const multiaddr = require('multiaddr')
 
 describe('valid Connection', () => {
@@ -18,94 +17,39 @@ describe('valid Connection', () => {
 
   const ma = multiaddr('/ip4/127.0.0.1/tcp/9090')
 
-  it('get observed addrs', (done) => {
-    let dialerObsAddrs
+  it('get observed addrs', async () => {
+    // Create a Promise that resolves when a connection is handled
+    let handled
+    const handlerPromise = new Promise((resolve) => {
+      handled = resolve
+    })
 
-    const listener = tcp.createListener((conn) => {
+    const handler = async (conn) => {
       expect(conn).to.exist()
-      conn.getObservedAddrs((err, addrs) => {
-        expect(err).to.not.exist()
-        dialerObsAddrs = addrs
-        pull(pull.empty(), conn)
-      })
-    })
+      const dialerObsAddrs = await conn.getObservedAddrs()
+      handled(dialerObsAddrs)
+    }
 
-    listener.listen(ma, () => {
-      const conn = tcp.dial(ma)
-      pull(
-        conn,
-        pull.onEnd(endHandler)
-      )
+    // Create a listener with the handler
+    const listener = tcp.createListener(handler)
 
-      function endHandler () {
-        conn.getObservedAddrs((err, addrs) => {
-          expect(err).to.not.exist()
-          pull(pull.empty(), conn)
-          closeAndAssert(listener, addrs)
-        })
-      }
+    // Listen on the multi-address
+    await listener.listen(ma)
 
-      function closeAndAssert (listener, addrs) {
-        listener.close(() => {
-          expect(addrs[0]).to.deep.equal(ma)
-          expect(dialerObsAddrs.length).to.equal(1)
-          done()
-        })
-      }
-    })
-  })
+    // Dial to that same address
+    const conn = await tcp.dial(ma)
+    const addrs = await conn.getObservedAddrs()
 
-  it('get Peer Info', (done) => {
-    const listener = tcp.createListener((conn) => {
-      expect(conn).to.exist()
-      conn.getPeerInfo((err, peerInfo) => {
-        expect(err).to.exist()
-        expect(peerInfo).to.not.exist()
-        pull(pull.empty(), conn)
-      })
-    })
+    // Wait for the incoming dial to be handled
+    const dialerObsAddrs = await handlerPromise
 
-    listener.listen(ma, () => {
-      const conn = tcp.dial(ma)
+    // Close the listener
+    await listener.close()
 
-      pull(conn, pull.onEnd(endHandler))
-
-      function endHandler () {
-        conn.getPeerInfo((err, peerInfo) => {
-          expect(err).to.exist()
-          expect(peerInfo).to.not.exist()
-
-          listener.close(done)
-        })
-      }
-    })
-  })
-
-  it('set Peer Info', (done) => {
-    const listener = tcp.createListener((conn) => {
-      expect(conn).to.exist()
-      conn.setPeerInfo('batatas')
-      conn.getPeerInfo((err, peerInfo) => {
-        expect(err).to.not.exist()
-        expect(peerInfo).to.equal('batatas')
-        pull(pull.empty(), conn)
-      })
-    })
-
-    listener.listen(ma, () => {
-      const conn = tcp.dial(ma)
-
-      pull(conn, pull.onEnd(endHandler))
-
-      function endHandler () {
-        conn.setPeerInfo('arroz')
-        conn.getPeerInfo((err, peerInfo) => {
-          expect(err).to.not.exist()
-          expect(peerInfo).to.equal('arroz')
-
-          listener.close(done)
-        })
-      }
-    })
+    // The addresses should match
+    expect(addrs.length).to.equal(1)
+    expect(addrs[0]).to.deep.equal(ma)
+    expect(dialerObsAddrs.length).to.equal(1)
+    expect(dialerObsAddrs[0]).to.exist()
   })
 })

test/listen-dial.spec.js

@@ -0,0 +1,239 @@
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+const dirtyChai = require('dirty-chai')
+const expect = chai.expect
+chai.use(dirtyChai)
+
+const TCP = require('../src')
+const net = require('net')
+const multiaddr = require('multiaddr')
+const pipe = require('it-pipe')
+const { collect, map } = require('streaming-iterables')
+const isCI = process.env.CI
+
+describe('listen', () => {
+  let tcp
+
+  beforeEach(() => {
+    tcp = new TCP()
+  })
+
+  it('close listener with connections, through timeout', async () => {
+    const mh = multiaddr('/ip4/127.0.0.1/tcp/9090/ipfs/Qmb6owHp6eaWArVbcJJbQSyifyJBttMMjYV76N2hMbf5Vw')
+    const listener = tcp.createListener((conn) => {
+      pipe(conn, conn)
+    })
+
+    await listener.listen(mh)
+
+    const socket1 = net.connect(9090)
+    const socket2 = net.connect(9090)
+
+    socket1.write('Some data that is never handled')
+    socket1.end()
+    socket1.on('error', () => {})
+    socket2.on('error', () => {})
+
+    await new Promise((resolve) => {
+      socket1.on('connect', async () => {
+        await listener.close()
+        resolve()
+      })
+    })
+  })
+
+  it('listen on port 0', async () => {
+    const mh = multiaddr('/ip4/127.0.0.1/tcp/0')
+    const listener = tcp.createListener((conn) => {})
+    await listener.listen(mh)
+    await listener.close()
+  })
+
+  it('listen on IPv6 addr', async () => {
+    if (isCI) {
+      return
+    }
+    const mh = multiaddr('/ip6/::/tcp/9090')
+    const listener = tcp.createListener((conn) => {})
+    await listener.listen(mh)
+    await listener.close()
+  })
+
+  it('listen on any Interface', async () => {
+    const mh = multiaddr('/ip4/0.0.0.0/tcp/9090')
+    const listener = tcp.createListener((conn) => {})
+    await listener.listen(mh)
+    await listener.close()
+  })
+
+  it('getAddrs', async () => {
+    const mh = multiaddr('/ip4/127.0.0.1/tcp/9090')
+    const listener = tcp.createListener((conn) => {})
+    await listener.listen(mh)
+
+    const multiaddrs = listener.getAddrs()
+    expect(multiaddrs.length).to.equal(1)
+    expect(multiaddrs[0]).to.deep.equal(mh)
+
+    await listener.close()
+  })
+
+  it('getAddrs on port 0 listen', async () => {
+    const mh = multiaddr('/ip4/127.0.0.1/tcp/0')
+    const listener = tcp.createListener((conn) => {})
+    await listener.listen(mh)
+
+    const multiaddrs = listener.getAddrs()
+    expect(multiaddrs.length).to.equal(1)
+
+    await listener.close()
+  })
+
+  it('getAddrs from listening on 0.0.0.0', async () => {
+    const mh = multiaddr('/ip4/0.0.0.0/tcp/9090')
+    const listener = tcp.createListener((conn) => {})
+    await listener.listen(mh)
+
+    const multiaddrs = listener.getAddrs()
+    expect(multiaddrs.length > 0).to.equal(true)
+    expect(multiaddrs[0].toString().indexOf('0.0.0.0')).to.equal(-1)
+
+    await listener.close()
+  })
+
+  it('getAddrs from listening on 0.0.0.0 and port 0', async () => {
+    const mh = multiaddr('/ip4/0.0.0.0/tcp/0')
+    const listener = tcp.createListener((conn) => {})
+    await listener.listen(mh)
+
+    const multiaddrs = listener.getAddrs()
+    expect(multiaddrs.length > 0).to.equal(true)
+    expect(multiaddrs[0].toString().indexOf('0.0.0.0')).to.equal(-1)
+
+    await listener.close()
+  })
+
+  it('getAddrs preserves IPFS Id', async () => {
+    const mh = multiaddr('/ip4/127.0.0.1/tcp/9090/ipfs/Qmb6owHp6eaWArVbcJJbQSyifyJBttMMjYV76N2hMbf5Vw')
+    const listener = tcp.createListener((conn) => {})
+    await listener.listen(mh)
+
+    const multiaddrs = listener.getAddrs()
+    expect(multiaddrs.length).to.equal(1)
+    expect(multiaddrs[0]).to.deep.equal(mh)
+
+    await listener.close()
+  })
+})
+
+describe('dial', () => {
+  let tcp
+  let listener
+  const ma = multiaddr('/ip4/127.0.0.1/tcp/9090')
+
+  beforeEach(async () => {
+    tcp = new TCP()
+    listener = tcp.createListener((conn) => {
+      pipe(
+        conn,
+        map((x) => Buffer.from(x.toString() + '!')),
+        conn
+      )
+    })
+    await listener.listen(ma)
+  })
+
+  afterEach(() => listener.close())
+
+  it('dial on IPv4', async () => {
+    const values = await pipe(
+      ['hey'],
+      await tcp.dial(ma),
+      collect
+    )
+    expect(values).to.eql([Buffer.from('hey!')])
+  })
+
+  it('dial on IPv6', async () => {
+    if (isCI) {
+      return
+    }
+
+    const ma = multiaddr('/ip6/::/tcp/9066')
+    const listener = tcp.createListener((conn) => {
+      pipe(conn, conn)
+    })
+    await listener.listen(ma)
+
+    const values = await pipe(
+      ['hey'],
+      await tcp.dial(ma),
+      collect
+    )
+    expect(values).to.be.eql([Buffer.from('hey')])
+
+    await listener.close()
+  })
+
+  it('dial and destroy on listener', async () => {
+    let handled
+    const handledPromise = new Promise((resolve) => {
+      handled = resolve
+    })
+
+    const ma = multiaddr('/ip6/::/tcp/9067')
+
+    const listener = tcp.createListener(async (conn) => {
+      await pipe(
+        [],
+        conn
+      )
+      handled()
+    })
+
+    await listener.listen(ma)
+    await pipe(await tcp.dial(ma))
+
+    await handledPromise
+    await listener.close()
+  })
+
+  it('dial and destroy on dialer', async () => {
+    if (isCI) {
+      return
+    }
+
+    let handled
+    const handledPromise = new Promise((resolve) => {
+      handled = resolve
+    })
+
+    const ma = multiaddr('/ip6/::/tcp/9068')
+
+    const listener = tcp.createListener(async (conn) => {
+      // pull(conn, pull.onEnd(destroyed))
+      await pipe(conn)
+      handled()
+    })
+
+    await listener.listen(ma)
+    await pipe([], await tcp.dial(ma))
+
+    await handledPromise
+    await listener.close()
+  })
+
+  it('dial on IPv4 with IPFS Id', async () => {
+    const ma = multiaddr('/ip4/127.0.0.1/tcp/9090/ipfs/Qmb6owHp6eaWArVbcJJbQSyifyJBttMMjYV76N2hMbf5Vw')
+    const conn = await tcp.dial(ma)
+
+    const res = await pipe(
+      ['hey'],
+      conn,
+      collect
+    )
+    expect(res).to.be.eql([Buffer.from('hey!')])
+  })
+})