Throw an error in pubsub if used in the browsers

Author: haadcode

src/api/pubsub.js

@@ -3,9 +3,12 @@
 const promisify = require('promisify-es6')
 const EventEmitter = require('events')
 const eos = require('end-of-stream')
+const isNode = require('detect-node')
 const PubsubMessageStream = require('../pubsub-message-stream')
 const stringlistToArray = require('../stringlist-to-array')
 
+const NotSupportedError = () => new Error('pubsub is currently not supported when run in the browser')
+
 /* Public API */
 module.exports = (send) => {
   /* Internal subscriptions state and functions */
@@ -28,6 +31,14 @@ module.exports = (send) => {
         options = defaultOptions
       }
 
+      // Throw an error if ran in the browsers
+      if (!isNode) {
+        if (!callback) {
+          return Promise.reject(NotSupportedError())
+        }
+        return callback(NotSupportedError())
+      }
+
       // promisify doesn't work as we always pass a
       // function as last argument (`handler`)
       if (!callback) {
@@ -43,7 +54,11 @@ module.exports = (send) => {
 
       subscribe(topic, options, handler, callback)
     },
-    unsubscribe (topic, handler) {
+    unsubscribe: (topic, handler) => {
+      if (!isNode) {
+        throw NotSupportedError()
+      }
+
       if (ps.listenerCount(topic) === 0 || !subscriptions[topic]) {
         throw new Error(`Not subscribed to '${topic}'`)
       }
@@ -57,6 +72,10 @@ module.exports = (send) => {
       }
     },
     publish: promisify((topic, data, callback) => {
+      if (!isNode) {
+        return callback(NotSupportedError())
+      }
+
       if (!Buffer.isBuffer(data)) {
         return callback(new Error('data must be a Buffer'))
       }
@@ -69,13 +88,21 @@ module.exports = (send) => {
       send(request, callback)
     }),
     ls: promisify((callback) => {
+      if (!isNode) {
+        return callback(NotSupportedError())
+      }
+
       const request = {
         path: 'pubsub/ls'
       }
 
       send.andTransform(request, stringlistToArray, callback)
     }),
     peers: promisify((topic, callback) => {
+      if (!isNode) {
+        return callback(NotSupportedError())
+      }
+
       const request = {
         path: 'pubsub/peers',
         args: [topic]

test/pubsub-in-browser.spec.js

@@ -0,0 +1,179 @@
+/*
+  We currently don't support pubsub when run in the browser,
+  and we test it with separate set of tests to make sure
+  if it's being used in the browser, pubsub errors.
+
+  More info: https://github.com/ipfs/js-ipfs-api/issues/518
+
+  This means:
+  - You can use pubsub from js-ipfs-api in Node.js
+  - You can use pubsub from js-ipfs-api in Electron
+    (when js-ipfs-api is ran in the main process of Electron)
+
+  - You can't use pubsub from js-ipfs-api in the browser
+  - You can't use pubsub from js-ipfs-api in Electron's
+    renderer process
+
+  - You can use pubsub from js-ipfs in the browsers
+  - You can use pubsub from js-ipfs in Node.js
+  - You can use pubsub from js-ipfs in Electron
+    (in both the main process and the renderer process)
+  - See https://github.com/ipfs/js-ipfs for details on
+    pubsub in js-ipfs
+*/
+
+/* eslint-env mocha */
+/* eslint max-nested-callbacks: ['error', 8] */
+'use strict'
+
+const expect = require('chai').expect
+const series = require('async/series')
+const waterfall = require('async/waterfall')
+const isNode = require('detect-node')
+const FactoryClient = require('./ipfs-factory/client')
+
+const expectedError = 'pubsub is currently not supported when run in the browser'
+
+function spawnWithId (factory, callback) {
+  waterfall([
+    (cb) => factory.spawnNode(cb),
+    (node, cb) => node.id((err, res) => {
+      if (err) {
+        return cb(err)
+      }
+      node.peerId = res
+      cb(null, node)
+    })
+  ], callback)
+}
+
+if (!isNode) {
+  describe('.pubsub-browser (pubsub not supported in the browsers currently)', () => {
+    const topic = 'pubsub-tests'
+
+    let factory
+    let ipfs1
+
+    before((done) => {
+      factory = new FactoryClient()
+
+      series([
+        (cb) => spawnWithId(factory, cb)
+      ], (err, nodes) => {
+        if (err) {
+          return done(err)
+        }
+
+        ipfs1 = nodes[0]
+        done()
+      })
+    })
+
+    after((done) => {
+      factory.dismantle(done)
+    })
+
+    describe('everything errors', () => {
+      describe('Callback API', () => {
+        describe('.publish', () => {
+          it('throws an error', (done) => {
+            ipfs1.pubsub.publish(topic, 'hello friend', (err, topics) => {
+              expect(err).to.exist
+              expect(err.message).to.equal(expectedError)
+              done()
+            })
+          })
+        })
+
+        describe('.subscribe', () => {
+          const handler = () => {}
+          it('throws an error', (done) => {
+            ipfs1.pubsub.subscribe(topic, {}, handler, (err, topics) => {
+              expect(err).to.exist
+              expect(err.message).to.equal(expectedError)
+              done()
+            })
+          })
+        })
+
+        describe('.peers', () => {
+          it('throws an error', (done) => {
+            ipfs1.pubsub.peers(topic, (err, topics) => {
+              expect(err).to.exist
+              expect(err.message).to.equal(expectedError)
+              done()
+            })
+          })
+        })
+
+        describe('.ls', () => {
+          it('throws an error', (done) => {
+            ipfs1.pubsub.ls((err, topics) => {
+              expect(err).to.exist
+              expect(err.message).to.equal(expectedError)
+              done()
+            })
+          })
+        })
+      })
+
+      describe('Promise API', () => {
+        describe('.publish', () => {
+          it('throws an error', () => {
+            return ipfs1.pubsub.publish(topic, 'hello friend')
+              .catch((e) => {
+                expect(e).to.exist
+                expect(e.message).to.equal(expectedError)
+              })
+          })
+        })
+
+        describe('.subscribe', () => {
+          const handler = () => {}
+          it('throws an error', (done) => {
+            ipfs1.pubsub.subscribe(topic, {}, handler)
+              .catch((e) => {
+                expect(e).to.exist
+                expect(e.message).to.equal(expectedError)
+                done()
+              })
+          })
+        })
+
+        describe('.peers', () => {
+          it('throws an error', (done) => {
+            ipfs1.pubsub.peers(topic)
+              .catch((e) => {
+                expect(e).to.exist
+                expect(e.message).to.equal(expectedError)
+                done()
+              })
+          })
+        })
+
+        describe('.ls', () => {
+          it('throws an error', () => {
+            return ipfs1.pubsub.ls()
+              .catch((e) => {
+                expect(e).to.exist
+                expect(e.message).to.equal(expectedError)
+              })
+          })
+        })
+      })
+
+      describe('.unsubscribe', () => {
+        it('throws an error', (done) => {
+          try {
+            ipfs1.pubsub.unsubscribe(topic)
+            done('unsubscribe() didn\'t throw an error')
+          } catch (e) {
+            expect(e).to.exist
+            expect(e.message).to.equal(expectedError)
+            done()
+          }
+        })
+      })
+    })
+  })
+}