test: add tests for lib fns

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>

Author: Alan Shaw

test/lib.configure.spec.js

@@ -0,0 +1,60 @@
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+const dirtyChai = require('dirty-chai')
+const expect = chai.expect
+chai.use(dirtyChai)
+const Multiaddr = require('multiaddr')
+
+const configure = require('../src/lib/configure')
+
+describe('lib/configure', () => {
+  it('should accept no config', () => {
+    configure(config => {
+      expect(config.apiAddr).to.eql('http://localhost:5001')
+    })()
+  })
+
+  it('should accept string multiaddr', () => {
+    const input = '/ip4/127.0.0.1/tcp/5001'
+    configure(config => {
+      expect(config.apiAddr).to.eql('http://127.0.0.1:5001')
+    })(input)
+  })
+
+  it('should accept multiaddr instance', () => {
+    const input = Multiaddr('/ip4/127.0.0.1')
+    configure(config => {
+      expect(config.apiAddr).to.eql('http://127.0.0.1')
+    })(input)
+  })
+
+  it('should accept object with protocol, host and port', () => {
+    const input = { protocol: 'https', host: 'ipfs.io', port: 138 }
+    configure(config => {
+      expect(config.apiAddr).to.eql('https://ipfs.io:138')
+    })(input)
+  })
+
+  it('should accept object with protocol only', () => {
+    const input = { protocol: 'https' }
+    configure(config => {
+      expect(config.apiAddr).to.eql('https://localhost')
+    })(input)
+  })
+
+  it('should accept object with host only', () => {
+    const input = { host: 'ipfs.io' }
+    configure(config => {
+      expect(config.apiAddr).to.eql('http://ipfs.io')
+    })(input)
+  })
+
+  it('should accept object with port only', () => {
+    const input = { port: 138 }
+    configure(config => {
+      expect(config.apiAddr).to.eql('http://localhost:138')
+    })(input)
+  })
+})

test/lib.fetch.spec.js

@@ -0,0 +1,92 @@
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+const dirtyChai = require('dirty-chai')
+const expect = chai.expect
+chai.use(dirtyChai)
+const throwsAsync = require('./utils/throws-async')
+
+const { ok, toIterable } = require('../src/lib/fetch')
+
+describe('lib/fetch', () => {
+  describe('ok', () => {
+    it('should parse json error response', async () => {
+      const res = {
+        ok: false,
+        text: () => Promise.resolve(JSON.stringify({
+          Message: 'boom',
+          Code: 0,
+          Type: 'error'
+        })),
+        status: 500
+      }
+
+      const err = await throwsAsync(ok(res))
+
+      expect(err.message).to.eql('boom')
+      expect(err.status).to.eql(500)
+    })
+
+    it('should gracefully fail on parse json', async () => {
+      const res = {
+        ok: false,
+        text: () => 'boom', // not valid json!
+        status: 500
+      }
+
+      const err = await throwsAsync(ok(res))
+
+      expect(err.message).to.eql('boom')
+      expect(err.status).to.eql(500)
+    })
+
+    it('should gracefully fail on read text', async () => {
+      const res = {
+        ok: false,
+        text: () => Promise.reject(new Error('boom')),
+        status: 500
+      }
+
+      const err = await throwsAsync(ok(res))
+
+      expect(err.message).to.eql('unexpected status 500')
+      expect(err.status).to.eql(500)
+    })
+  })
+
+  describe('toIterable', () => {
+    it('should return input if already async iterable', () => {
+      const input = { [Symbol.asyncIterator] () { return this } }
+      expect(toIterable(input)).to.equal(input)
+    })
+
+    it('should convert reader to async iterable', async () => {
+      const inputData = [2, 31, 3, 4]
+      const input = {
+        getReader () {
+          let i = 0
+          return {
+            read: async () => {
+              return i === inputData.length
+                ? { done: true }
+                : { value: inputData[i++] }
+            },
+            releaseLock: () => {}
+          }
+        }
+      }
+
+      const chunks = []
+      for await (const chunk of toIterable(input)) {
+        chunks.push(chunk)
+      }
+
+      expect(chunks).to.eql(inputData)
+    })
+
+    it('should throw on unknown stream', () => {
+      expect(() => toIterable({})).to.throw('unknown stream')
+    })
+  })
+})

test/utils/throws-async.js

@@ -0,0 +1,8 @@
+module.exports = async fnOrPromise => {
+  try {
+    await (fnOrPromise.then ? fnOrPromise : fnOrPromise())
+  } catch (err) {
+    return err
+  }
+  throw new Error('did not throw')
+}