test: make block rm tests more comprehensive

Author: achingbrain

src/block/rm.js

@@ -2,14 +2,15 @@
 'use strict'
 
 const { getDescribe, getIt, expect } = require('../utils/mocha')
+const hat = require('hat')
 
 module.exports = (createCommon, options) => {
   const describe = getDescribe(options)
   const it = getIt(options)
   const common = createCommon()
 
   describe('.block.rm', function () {
-    let ipfs, cid
+    let ipfs
 
     before(function (done) {
       // CI takes longer to instantiate the daemon, so we need to increase the
@@ -26,60 +27,97 @@ module.exports = (createCommon, options) => {
       })
     })
 
-    beforeEach(function (done) {
-      const blob = Buffer.from('blorb')
-      ipfs.block.put(blob, (err, block) => {
-        if (err) return done(err)
-        cid = block.cid
-        done()
+    after((done) => common.teardown(done))
+
+    it('should remove by CID object', async () => {
+      const cid = await ipfs.dag.put(Buffer.from(hat()))
+
+      // block should be present in the local store
+      expect(await ipfs.refs.local()).to.deep.include({
+        ref: cid.toString(),
+        err: ''
+      })
+
+      const result = await ipfs.block.rm(cid)
+
+      expect(result).to.be.an('array').and.to.have.lengthOf(1)
+      expect(result[0]).to.have.property('hash', cid.toString())
+      expect(result[0]).to.not.have.property('error')
+
+      // did we actually remove the block?
+      expect(await ipfs.refs.local()).to.not.deep.include({
+        ref: cid.toString(),
+        err: ''
       })
     })
 
-    afterEach(function () {
-      cid = undefined
+    it('should remove by CID in string', async () => {
+      const cid = await ipfs.dag.put(Buffer.from(hat()))
+      const result = await ipfs.block.rm(cid.toString())
+
+      expect(result).to.be.an('array').and.to.have.lengthOf(1)
+      expect(result[0]).to.have.property('hash', cid.toString())
+      expect(result[0]).to.not.have.property('error')
     })
 
-    after((done) => common.teardown(done))
+    it('should remove by CID in buffer', async () => {
+      const cid = await ipfs.dag.put(Buffer.from(hat()))
+      const result = await ipfs.block.rm(cid.buffer)
 
-    it('should remove by CID object', (done) => {
-      ipfs.block.rm(cid, (err, resp) => {
-        expect(err).to.not.exist()
-        expect(resp).to.have.property('hash')
-        expect(resp.error).to.not.exist()
-        done()
-      })
+      expect(result).to.be.an('array').and.to.have.lengthOf(1)
+      expect(result[0]).to.have.property('hash', cid.toString())
+      expect(result[0]).to.not.have.property('error')
     })
 
-    it('should remove by CID in string', (done) => {
-      ipfs.block.rm(cid.toString(), (err, resp) => {
-        expect(err).to.not.exist()
-        expect(resp).to.have.property('hash')
-        expect(resp.error).to.not.exist()
-        done()
+    it('should remove multiple CIDs', async () => {
+      const cids = [
+        await ipfs.dag.put(Buffer.from(hat())),
+        await ipfs.dag.put(Buffer.from(hat())),
+        await ipfs.dag.put(Buffer.from(hat()))
+      ]
+
+      const result = await ipfs.block.rm(cids)
+
+      expect(result).to.be.an('array').and.to.have.lengthOf(3)
+
+      result.forEach((res, index) => {
+        expect(res).to.have.property('hash', cids[index].toString())
+        expect(res).to.not.have.property('error')
       })
     })
 
-    it('should remove by CID in buffer', (done) => {
-      ipfs.block.rm(cid.buffer, (err, resp) => {
-        expect(err).to.not.exist()
-        expect(resp).to.have.property('hash')
-        expect(resp.error).to.not.exist()
-        done()
-      })
+    it('should error when removing non-existent blocks', async () => {
+      const cid = await ipfs.dag.put(Buffer.from(hat()))
+
+      // remove it
+      await ipfs.block.rm(cid)
+
+      // remove it again
+      const result = await ipfs.block.rm(cid)
+
+      expect(result).to.be.an('array').and.to.have.lengthOf(1)
+      expect(result[0]).to.have.property('error').and.to.include('block not found')
     })
 
-    it('should remove multiple CIDs', (done) => {
-      const blob = Buffer.from('more blorb')
-      ipfs.block.put(blob, (err, block) => {
-        if (err) return done(err)
-        const cid1 = block.cid
-        ipfs.block.rm([cid, cid1], (err, resp) => {
-          expect(err).to.not.exist()
-          expect(resp).to.have.property('hash')
-          expect(resp.error).to.not.exist()
-          done()
-        })
-      })
+    it('should not error when force removing non-existent blocks', async () => {
+      const cid = await ipfs.dag.put(Buffer.from(hat()))
+
+      // remove it
+      await ipfs.block.rm(cid)
+
+      // remove it again
+      const result = await ipfs.block.rm(cid, { force: true })
+
+      expect(result).to.be.an('array').and.to.have.lengthOf(1)
+      expect(result[0]).to.have.property('hash', cid.toString())
+      expect(result[0]).to.not.have.property('error')
+    })
+
+    it('should return empty output when removing blocks quietly', async () => {
+      const cid = await ipfs.dag.put(Buffer.from(hat()))
+      const result = await ipfs.block.rm(cid, { quiet: true })
+
+      expect(result).to.be.an('array').and.to.have.lengthOf(0)
     })
   })
 }