wip

Author: dryajov

test/interop/circuit/index.js

@@ -0,0 +1,108 @@
+/* eslint max-nested-callbacks: ["error", 8] */
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+const dirtyChai = require('dirty-chai')
+const expect = chai.expect
+const waterfall = require('async/waterfall')
+const parallel = require('async/parallel')
+const Factory = require('../../utils/ipfs-factory-daemon/index')
+const GoDaemon = require('../daemons/go')
+
+const utils = require('./utils')
+
+chai.use(dirtyChai)
+
+describe('circuit interop', function () {
+  this.timeout(20 * 1000)
+
+  let jsTCP
+  let jsWS
+  let jsRelayPeer
+  let jsRelayAddrs
+  let goTCP = new GoDaemon()
+  let goRelayAddrs
+  let factory = new Factory()
+
+  beforeEach((done) => {
+    jsTCP = utils.setupNode([
+      '/ip4/0.0.0.0/tcp/9002'
+    ])
+
+    jsWS = utils.setupNode([
+      '/ip4/0.0.0.0/tcp/9003/ws'
+    ])
+
+    waterfall([
+      (pCb) => utils.setupRelay(['/ip4/127.0.0.1/tcp/61452/ws', '/ip4/127.0.0.1/tcp/61453'], factory, pCb),
+      (peer, addr, pCb) => {
+        jsRelayAddrs = addr
+        jsRelayPeer = peer
+        pCb()
+      },
+      (pCb) => jsWS.start(pCb),
+      (pCb) => jsTCP.start(pCb),
+      (pCb) => goTCP.start(pCb),
+      (pCb) => {
+        goTCP.api.id((err, peer) => {
+          expect(err).to.not.exist()
+          console.log(JSON.stringify(peer.addresses))
+
+          goRelayAddrs = peer.addresses
+          pCb()
+        })
+      }
+    ], done)
+  })
+
+  afterEach((done) => {
+    waterfall([
+      (cb) => jsWS.stop(cb),
+      (cb) => jsTCP.stop(cb),
+      (cb) => goTCP.stop(cb),
+      (cb) => factory.dismantle((err) => done(err))
+    ], done)
+  })
+
+  it('jsES <-> js-relay <-> jsTCP', function (done) {
+    let addr = goRelayAddrs.filter((a) => !a.toString().includes('/p2p-circuit'))
+    parallel([
+      (cb) => jsWS.swarm.connect(addr[0], cb),
+      (cb) => jsTCP.swarm.connect(addr[1], cb)
+    ], (err) => {
+      expect(err).to.not.exist()
+      waterfall([
+        (cb) => jsTCP.swarm.connect(jsWS._peerInfo, cb),
+        (conn, cb) => utils.addAndCat(new jsTCP.types.Buffer('Hello world over circuit!'),
+          jsWS,
+          jsTCP,
+          (err, data) => {
+            expect(err).to.not.exist()
+            expect(data).to.be.equal('Hello world over circuit!')
+            cb()
+          })
+      ], done)
+    })
+  })
+
+  it('goTCP <-> js-relay <-> jsWS', function (done) {
+    let addr = jsRelayAddrs.filter((a) => !a.toString().includes('/p2p-circuit'))
+    parallel([
+      (cb) => jsWS.swarm.connect(addr[0], cb),
+      (cb) => goTCP.api.swarm.connect(addr[1], cb)
+    ], (err) => {
+      expect(err).to.not.exist()
+      waterfall([
+        (cb) => goTCP.api.swarm.connect(jsWS._peerInfo, cb),
+        (conn, cb) => utils.addAndCat(new jsTCP.types.Buffer('Hello world over circuit!'),
+          jsWS,
+          goTCP.api,
+          (err, data) => {
+            expect(err).to.not.exist()
+            expect(data).to.be.equal('Hello world over circuit!')
+          })
+      ], done)
+    })
+  })
+})

test/interop/circuit/utils.js

@@ -0,0 +1,90 @@
+'use strict'
+
+const chai = require('chai')
+const expect = chai.expect
+const waterfall = require('async/waterfall')
+const IPFS = require('../../../src/core/index')
+const createTempRepo = require('../../utils/create-repo-nodejs')
+const relayConfig = require('../../utils/ipfs-factory-daemon/default-config.json')
+
+exports.setupNode = function setupNode (addrs, circuitEnabled) {
+  return new IPFS({
+    repo: createTempRepo(),
+    start: false,
+    config: {
+      Addresses: {
+        Swarm: addrs
+      },
+      Bootstrap: [],
+      EXPERIMENTAL: {
+        Relay: {
+          Enabled: circuitEnabled || false
+        }
+      }
+    }
+  })
+}
+
+exports.setupRelay = function setupRelay (addrs, factory, cb) {
+  let relayPeer
+  let relayAddrs
+
+  waterfall([
+    (pCb) => {
+      factory.spawnNode(createTempRepo(), Object.assign(relayConfig, {
+        Addresses: {
+          Swarm: addrs
+        },
+        EXPERIMENTAL: {
+          Relay: {
+            Enabled: true,
+            HOP: {
+              Enabled: true,
+              Active: false
+            }
+          }
+        }
+      }), (err, node) => {
+        expect(err).to.not.exist()
+        relayPeer = node
+        pCb()
+      })
+    },
+    (pCb) => {
+      relayPeer.swarm.localAddrs((err, addrs) => {
+        expect(err).to.not.exist()
+        relayAddrs = addrs
+        pCb()
+      })
+    }], (err) => {
+    expect(err).to.not.exist()
+    cb(null, relayPeer, relayAddrs)
+  })
+}
+
+exports.addAndCat = function addAndCat (data, ipfsSrc, ipfsDst, callback) {
+  waterfall([
+    (cb) => ipfsDst.files.add(data, cb),
+    (res, cb) => {
+      expect(res[0]).to.not.be.null()
+      cb(null, res[0].hash)
+    },
+    (hash, cb) => ipfsSrc.files.cat(hash, function (err, stream) {
+      expect(err).to.be.null()
+
+      var res = ''
+
+      stream.on('data', function (chunk) {
+        res += chunk.toString()
+      })
+
+      stream.on('error', function (err) {
+        cb(err)
+      })
+
+      stream.on('end', function () {
+        cb(null, res)
+      })
+    })
+  ], callback)
+}