chore: update assertion on failure tests

Author: Pedro Santos

src/bitswap/stat.js

@@ -31,12 +31,7 @@ module.exports = (common, options) => {
       const node = await common.node()
       await node.stop()
 
-      try {
-        await node.api.bitswap.stat()
-        expect.fail('bitswap.stat() did not throw an error as expected')
-      } catch (err) {
-        expect(err).to.exist()
-      }
+      await expect(node.api.bitswap.stat()).to.be.rejected()
     })
   })
 }

src/bitswap/wantlist.js

@@ -42,12 +42,7 @@ module.exports = (common, options) => {
       const node = await common.node()
       await node.stop()
 
-      try {
-        await node.bitswap.wantlist()
-        expect.fail('bitswap.wantlist() did not throw an error as expected')
-      } catch (err) {
-        expect(err).to.exist()
-      }
+      await expect(node.api.bitswap.wantlist()).to.be.rejected()
     })
   })
 }

src/block/get.js

@@ -82,13 +82,8 @@ module.exports = (common, options) => {
       expect(block.data).to.eql(input)
     })
 
-    it('should return an error for an invalid CID', async () => {
-      try {
-        await ipfs.block.get('invalid')
-        expect.fail('should have returned an error for invalid argument')
-      } catch (err) {
-        expect(err).to.be.an.instanceof(Error)
-      }
+    it('should return an error for an invalid CID', () => {
+      return expect(ipfs.block.get('invalid')).to.eventually.be.rejected.and.be.an.instanceOf(Error)
     })
   })
 }

src/block/put.js

@@ -72,15 +72,10 @@ module.exports = (common, options) => {
       expect(block.cid.multihash).to.eql(multihash.fromB58String(expectedHash))
     })
 
-    it('should error with array of blocks', async () => {
+    it('should error with array of blocks', () => {
       const blob = Buffer.from('blorb')
 
-      try {
-        await ipfs.block.put([blob, blob])
-        expect.fail('should have returned an error for array of blocks')
-      } catch (err) {
-        expect(err).to.be.an.instanceof(Error)
-      }
+      return expect(ipfs.block.put([blob, blob])).to.eventually.be.rejected.and.be.an.instanceOf(Error)
     })
   })
 }

src/block/stat.js

@@ -35,22 +35,12 @@ module.exports = (common, options) => {
       expect(stats).to.have.property('size')
     })
 
-    it('should return error for missing argument', async () => {
-      try {
-        await ipfs.block.stat(null)
-        expect.fail('should have thrown for missing parameter')
-      } catch (err) {
-        expect(err).to.be.an.instanceof(Error)
-      }
+    it('should return error for missing argument', () => {
+      return expect(ipfs.block.stat(null)).to.eventually.be.rejected.and.be.an.instanceOf(Error)
     })
 
-    it('should return error for invalid argument', async () => {
-      try {
-        await ipfs.block.stat('invalid')
-        expect.fail('should have thrown for invalid parameter')
-      } catch (err) {
-        expect(err).to.be.an.instanceof(Error)
-      }
+    it('should return error for invalid argument', () => {
+      return expect(ipfs.block.stat('invalid')).to.eventually.be.rejected.and.be.an.instanceOf(Error)
     })
   })
 }

src/bootstrap/add.js

@@ -26,13 +26,8 @@ module.exports = (common, options) => {
 
     after(() => common.teardown())
 
-    it('should return an error when called with an invalid arg', async () => {
-      try {
-        await ipfs.bootstrap.add(invalidArg)
-        expect.fail('bootstrap.add() did not throw when called with an invalid arg')
-      } catch (err) {
-        expect(err).to.be.an.instanceof(Error)
-      }
+    it('should return an error when called with an invalid arg', () => {
+      return expect(ipfs.bootstrap.add(invalidArg)).to.eventually.be.rejected.and.be.an.instanceOf(Error)
     })
 
     it('should return a list containing the bootstrap peer when called with a valid arg (ip4)', async () => {

src/bootstrap/rm.js

@@ -24,13 +24,8 @@ module.exports = (common, options) => {
 
     after(() => common.teardown())
 
-    it('should return an error when called with an invalid arg', async () => {
-      try {
-        await ipfs.bootstrap.rm(invalidArg)
-        expect.fail('bootstrap.rm() did not throw when called with an invalid arg')
-      } catch (err) {
-        expect(err).to.be.an.instanceof(Error)
-      }
+    it('should return an error when called with an invalid arg', () => {
+      return expect(ipfs.bootstrap.rm(invalidArg)).to.eventually.be.rejected.and.be.an.instanceOf(Error)
     })
 
     it('should return an empty list because no peers removed when called without an arg or options', async () => {

src/config/get.js

@@ -38,22 +38,12 @@ module.exports = (common, options) => {
       expect(swarmAddrs).to.exist()
     })
 
-    it('should fail on non valid key', async () => {
-      try {
-        await ipfs.config.get(1234)
-        expect.fail('config.get() did not throw on non valid key')
-      } catch (err) {
-        expect(err).to.exist()
-      }
+    it('should fail on non valid key', () => {
+      return expect(ipfs.config.get(1234)).to.eventually.be.rejected()
     })
 
-    it('should fail on non existent key', async () => {
-      try {
-        await ipfs.config.get('Bananas')
-        expect.fail('config.get() did not throw on non existent key')
-      } catch (err) {
-        expect(err).to.exist()
-      }
+    it('should fail on non existent key', () => {
+      return expect(ipfs.config.get('Bananas')).to.eventually.be.rejected()
     })
   })
 }

src/config/set.js

@@ -69,22 +69,12 @@ module.exports = (common, options) => {
       expect(result).to.deep.equal(val)
     })
 
-    it('should fail on non valid key', async () => {
-      try {
-        await ipfs.config.set(Buffer.from('heeey'), '')
-        expect.fail('config.set() did not throw on non valid key')
-      } catch (err) {
-        expect(err).to.exist()
-      }
+    it('should fail on non valid key', () => {
+      return expect(ipfs.config.set(Buffer.from('heeey'), '')).to.eventually.be.rejected()
     })
 
-    it('should fail on non valid value', async () => {
-      try {
-        await ipfs.config.set('Fruit', Buffer.from('abc'))
-        expect.fail('config.set() did not throw on non valid value')
-      } catch (err) {
-        expect(err).to.exist()
-      }
+    it('should fail on non valid value', () => {
+      return expect(ipfs.config.set('Fruit', Buffer.from('abc'))).to.eventually.be.rejected()
     })
   })
 }

src/dht/find-peer.js

@@ -37,13 +37,8 @@ module.exports = (common, options) => {
       expect(nodeAddresses).to.include(peerAddresses[0])
     })
 
-    it('should fail to find other peer if peer does not exist', async () => {
-      try {
-        await nodeA.dht.findPeer('Qmd7qZS4T7xXtsNFdRoK1trfMs5zU94EpokQ9WFtxdPxsZ')
-        expect.fail('dht.findPeer() did not throw when peer does not exist')
-      } catch (err) {
-        expect(err).to.exist()
-      }
+    it('should fail to find other peer if peer does not exist', () => {
+      return expect(nodeA.dht.findPeer('Qmd7qZS4T7xXtsNFdRoK1trfMs5zU94EpokQ9WFtxdPxsZ')).to.eventually.be.rejected()
     })
   })
 }

src/dht/find-provs.js

@@ -72,12 +72,7 @@ module.exports = (common, options) => {
 
       const cidV0 = await fakeCid()
 
-      try {
-        await nodeA.dht.findProvs(cidV0, options)
-        expect.fail('dht.findProvs() did not throw as expected')
-      } catch (err) {
-        expect(err).to.exist()
-      }
+      await expect(nodeA.dht.findProvs(cidV0, options)).to.be.rejected()
     })
   })
 }

src/dht/get.js

@@ -27,13 +27,8 @@ module.exports = (common, options) => {
 
     after(() => common.teardown())
 
-    it('should error when getting a non-existent key from the DHT', async () => {
-      try {
-        await nodeA.dht.get('non-existing', { timeout: 100 })
-        expect.fail('dht.get() did not throw when getting a non-existent key from the DHT')
-      } catch (err) {
-        expect(err).to.be.an.instanceof(Error)
-      }
+    it('should error when getting a non-existent key from the DHT', () => {
+      return expect(nodeA.dht.get('non-existing', { timeout: 100 })).to.eventually.be.rejected.and.be.an.instanceOf(Error)
     })
 
     it('should get a value after it was put on another node', async () => {

src/dht/provide.js

@@ -32,16 +32,13 @@ module.exports = (common, options) => {
       await ipfs.dht.provide(new CID(res[0].hash))
     })
 
-    it('should not provide if block not found locally', async () => {
+    it('should not provide if block not found locally', () => {
       const cid = new CID('Qmd7qZS4T7xXtsNFdRoK1trfMs5zU94EpokQ9WFtxdPxsZ')
 
-      try {
-        await ipfs.dht.provide(cid)
-        expect.fail('dht.provide() did not throw when block is not found locally')
-      } catch (err) {
-        expect(err).to.exist()
-        expect(err.message).to.include('not found locally')
-      }
+      return expect(ipfs.dht.provide(cid)).to.eventually.be.rejected
+        .and.be.an.instanceOf(Error)
+        .and.have.property('message')
+        .that.include('not found locally')
     })
 
     it('should allow multiple CIDs to be passed', async () => {
@@ -64,22 +61,12 @@ module.exports = (common, options) => {
       await ipfs.dht.provide(cid)
     })
 
-    it('should error on non CID arg', async () => {
-      try {
-        await ipfs.dht.provide({})
-        expect.fail('ipfs.dht.provide() did not throw on non CID arg')
-      } catch (err) {
-        expect(err).to.exist()
-      }
+    it('should error on non CID arg', () => {
+      return expect(ipfs.dht.provide({})).to.eventually.be.rejected()
     })
 
-    it('should error on array containing non CID arg', async () => {
-      try {
-        await ipfs.dht.provide([{}])
-        expect.fail('ipfs.dht.provide() did not throw on array containing non CID arg')
-      } catch (err) {
-        expect(err).to.exist()
-      }
+    it('should error on array containing non CID arg', () => {
+      return expect(ipfs.dht.provide([{}])).to.eventually.be.rejected()
     })
   })
 }

src/files-mfs/cp.js

@@ -23,15 +23,10 @@ module.exports = (common, options) => {
 
     after(() => common.teardown())
 
-    it('should copy file, expect error', async () => {
+    it('should copy file, expect error', () => {
       const testDir = `/test-${hat()}`
 
-      try {
-        await ipfs.files.cp(`${testDir}/c`, `${testDir}/b`)
-        expect.fail('files.cp() did not throw as expected on copy file')
-      } catch (err) {
-        expect(err).to.exist()
-      }
+      return expect(ipfs.files.cp(`${testDir}/c`, `${testDir}/b`)).to.eventually.be.rejected()
     })
 
     it('should copy file, expect no error', async () => {
@@ -42,15 +37,10 @@ module.exports = (common, options) => {
       await ipfs.files.cp(`${testDir}/a`, `${testDir}/b`)
     })
 
-    it('should copy dir, expect error', async () => {
+    it('should copy dir, expect error', () => {
       const testDir = `/test-${hat()}`
 
-      try {
-        await ipfs.files.cp(`${testDir}/lv1/lv3`, `${testDir}/lv1/lv4`)
-        expect.fail('files.cp() did not throw as expected on copy dir')
-      } catch (err) {
-        expect(err).to.exist()
-      }
+      return expect(ipfs.files.cp(`${testDir}/lv1/lv3`, `${testDir}/lv1/lv4`)).to.eventually.be.rejected()
     })
 
     it('should copy dir, expect no error', async () => {

src/files-mfs/ls.js

@@ -23,15 +23,10 @@ module.exports = (common, options) => {
 
     after(() => common.teardown())
 
-    it('should not ls not found file/dir, expect error', async () => {
+    it('should not ls not found file/dir, expect error', () => {
       const testDir = `/test-${hat()}`
 
-      try {
-        await ipfs.files.ls(`${testDir}/404`)
-        expect.fail('files.ls() did not throw when file/dir was not found')
-      } catch (err) {
-        expect(err).to.exist()
-      }
+      return expect(ipfs.files.ls(`${testDir}/404`)).to.eventually.be.rejected()
     })
 
     it('should ls directory', async () => {

src/files-mfs/mkdir.js

@@ -34,13 +34,8 @@ module.exports = (common, options) => {
       return ipfs.files.mkdir(`${testDir}/lv1/lv2`, { p: true })
     })
 
-    it('should not make already existent directory', async () => {
-      try {
-        await ipfs.files.mkdir('/')
-        expect.fail('files.mkdir() did not throw when making already existent directory')
-      } catch (err) {
-        expect(err).to.exist()
-      }
+    it('should not make already existent directory', () => {
+      return expect(ipfs.files.mkdir('/')).to.eventually.be.rejected()
     })
   })
 }

src/files-mfs/mv.js

@@ -26,15 +26,10 @@ module.exports = (common, options) => {
     })
     after(() => common.teardown())
 
-    it('should not move not found file/dir, expect error', async () => {
+    it('should not move not found file/dir, expect error', () => {
       const testDir = `/test-${hat()}`
 
-      try {
-        await ipfs.files.mv(`${testDir}/404`, `${testDir}/a`)
-        expect.fail('files.mv() did not throw while moving not found file/dir')
-      } catch (err) {
-        expect(err).to.exist()
-      }
+      return expect(ipfs.files.mv(`${testDir}/404`, `${testDir}/a`)).to.eventually.be.rejected()
     })
 
     it('should move file, expect no error', async () => {

src/files-mfs/read.js

@@ -23,16 +23,13 @@ module.exports = (common, options) => {
 
     after(() => common.teardown())
 
-    it('should not read not found, expect error', async () => {
+    it('should not read not found, expect error', () => {
       const testDir = `/test-${hat()}`
 
-      try {
-        await ipfs.files.read(`${testDir}/404`)
-        expect.fail('files.read() did not throw when reading not found file/dir')
-      } catch (err) {
-        expect(err).to.exist()
-        expect(err.message).to.contain('does not exist')
-      }
+      return expect(ipfs.files.cp(`${testDir}/c`, `${testDir}/b`)).to.eventually.be.rejected
+        .and.be.an.instanceOf(Error)
+        .and.to.have.property('message')
+        .that.include('does not exist')
     })
 
     it('should read file', async () => {

src/files-mfs/rm.js

@@ -22,15 +22,10 @@ module.exports = (common, options) => {
 
     after(() => common.teardown())
 
-    it('should not remove not found file/dir, expect error', async () => {
+    it('should not remove not found file/dir, expect error', () => {
       const testDir = `/test-${hat()}`
 
-      try {
-        await ipfs.files.rm(`${testDir}/a`)
-        expect.fail('files.read() did not throw when removing not found file/dir')
-      } catch (err) {
-        expect(err).to.exist()
-      }
+      return expect(ipfs.files.rm(`${testDir}/a`)).to.eventually.be.rejected()
     })
 
     it('should remove file, expect no error', async () => {