fix: pin.ls ignored opts when hash was present

Adds tests to guard against issue described in
ipfs-inactive/js-ipfs-http-client#875

License: MIT
Signed-off-by: Marcin Rataj <[email protected]>

Author: lidel

js/src/pin/ls.js

@@ -31,12 +31,22 @@ module.exports = (createCommon, options) => {
 
       function populate () {
         parallel([
+          // two files wrapped in a directory, root CID pinned recursively
+          (cb) => {
+            const dir = fixtures.directory.files.map((file) => ({path: file.path, content: file.data}))
+            ipfs.files.add(dir, { pin: false }, (err, res) => {
+              if (err) return cb(err)
+              ipfs.pin.add(fixtures.directory.cid, { recursive: true }, cb)
+            })
+          },
+          // a file (CID pinned recursively)
           (cb) => {
             ipfs.files.add(fixtures.files[0].data, { pin: false }, (err, res) => {
               if (err) return cb(err)
               ipfs.pin.add(fixtures.files[0].cid, { recursive: true }, cb)
             })
           },
+          // a single CID (pinned directly)
           (cb) => {
             ipfs.files.add(fixtures.files[1].data, { pin: false }, (err, res) => {
               if (err) return cb(err)
@@ -50,21 +60,24 @@ module.exports = (createCommon, options) => {
     after((done) => common.teardown(done))
 
     // 1st, because ipfs.files.add pins automatically
-    it('should list recursive pins', (done) => {
+    it('should list all recursive pins', (done) => {
       ipfs.pin.ls({ type: 'recursive' }, (err, pinset) => {
         expect(err).to.not.exist()
         expect(pinset).to.deep.include({
           type: 'recursive',
           hash: fixtures.files[0].cid
         })
+        expect(pinset).to.deep.include({
+          type: 'recursive',
+          hash: fixtures.directory.cid
+        })
         done()
       })
     })
 
-    it('should list indirect pins', (done) => {
+    it('should list all indirect pins', (done) => {
       ipfs.pin.ls({ type: 'indirect' }, (err, pinset) => {
         expect(err).to.not.exist()
-        // because the pinned files have no links
         expect(pinset).to.not.deep.include({
           type: 'recursive',
           hash: fixtures.files[0].cid
@@ -73,14 +86,24 @@ module.exports = (createCommon, options) => {
           type: 'direct',
           hash: fixtures.files[1].cid
         })
+        expect(pinset).to.not.deep.include({
+          type: 'recursive',
+          hash: fixtures.directory.cid
+        })
         done()
       })
     })
 
-    it('should list pins', (done) => {
+    it('should list all types of pins', (done) => {
       ipfs.pin.ls((err, pinset) => {
         expect(err).to.not.exist()
         expect(pinset).to.not.be.empty()
+        expect(pinset).to.have.lengthOf(15)
+        // check the three "roots"
+        expect(pinset).to.deep.include({
+          type: 'recursive',
+          hash: fixtures.directory.cid
+        })
         expect(pinset).to.deep.include({
           type: 'recursive',
           hash: fixtures.files[0].cid
@@ -93,9 +116,16 @@ module.exports = (createCommon, options) => {
       })
     })
 
-    it('should list pins (promised)', () => {
+    it('should list all types of pins (promised)', () => {
       return ipfs.pin.ls()
         .then((pinset) => {
+          expect(pinset).to.not.be.empty()
+          expect(pinset).to.have.lengthOf(15)
+          // check our three "roots"
+          expect(pinset).to.deep.include({
+            type: 'recursive',
+            hash: fixtures.directory.cid
+          })
           expect(pinset).to.deep.include({
             type: 'recursive',
             hash: fixtures.files[0].cid
@@ -107,7 +137,7 @@ module.exports = (createCommon, options) => {
         })
     })
 
-    it('should list direct pins', (done) => {
+    it('should list all direct pins', (done) => {
       ipfs.pin.ls({ type: 'direct' }, (err, pinset) => {
         expect(err).to.not.exist()
         expect(pinset).to.deep.include({
@@ -138,5 +168,45 @@ module.exports = (createCommon, options) => {
           }])
         })
     })
+
+    it('should throw an error on missing direct pins for a specific path', (done) => {
+      // alice.txt is an indirect pin, so lookup for direct one should throw an error
+      ipfs.pin.ls(`/ipfs/${fixtures.directory.cid}/files/ipfs.txt`, { type: 'direct' }, (err, pinset) => {
+        expect(pinset).to.not.exist()
+        expect(err).to.not.be.empty()
+        expect(err.message).to.be.equal(`path '/ipfs/${fixtures.directory.cid}/files/ipfs.txt' is not pinned`)
+        done()
+      })
+    })
+
+    it('should throw an error on missing link for a specific path', (done) => {
+      ipfs.pin.ls(`/ipfs/${fixtures.directory.cid}/I-DONT-EXIST.txt`, { type: 'direct' }, (err, pinset) => {
+        expect(pinset).to.not.exist()
+        expect(err).to.not.be.empty()
+        expect(err.message).to.be.equal('no link by that name')
+        done()
+      })
+    })
+
+    it('should list indirect pins for a specific path', (done) => {
+      ipfs.pin.ls(`/ipfs/${fixtures.directory.cid}/files/ipfs.txt`, { type: 'indirect' }, (err, pinset) => {
+        expect(err).to.not.exist()
+        expect(pinset).to.deep.include({
+          type: `indirect through ${fixtures.directory.cid}`,
+          hash: fixtures.directory.files[1].cid
+        })
+        done()
+      })
+    })
+
+    it('should list recursive pins for a specific hash (promised)', () => {
+      return ipfs.pin.ls(fixtures.files[0].cid, { type: 'recursive' })
+        .then((pinset) => {
+          expect(pinset).to.deep.equal([{
+            type: 'recursive',
+            hash: fixtures.files[0].cid
+          }])
+        })
+    })
   })
 }

js/src/pin/utils.js

@@ -3,6 +3,18 @@
 const loadFixture = require('aegir/fixtures')
 
 exports.fixtures = Object.freeze({
+  directory: Object.freeze({
+    cid: 'QmVJV2VF9Qf7rJUFdimhpZDhkyyumM1i4CjjGcss5rqJPa',
+    files: Object.freeze([Object.freeze({
+      path: 'test-folder/ipfs-add.js',
+      data: loadFixture('js/test/fixtures/test-folder/ipfs-add.js', 'interface-ipfs-core'),
+      cid: 'QmU7wetVaAqc3Meurif9hcYBHGvQmL5QdpPJYBoZizyTNL'
+    }), Object.freeze({
+      path: 'test-folder/files/ipfs.txt',
+      data: loadFixture('js/test/fixtures/test-folder/files/ipfs.txt', 'interface-ipfs-core'),
+      cid: 'QmdFyxZXsFiP4csgfM5uPu99AvFiKH62CSPDw5TP92nr7w'
+    })])
+  }),
   files: Object.freeze([Object.freeze({
     data: loadFixture('js/test/fixtures/testfile.txt', 'interface-ipfs-core'),
     cid: 'Qma4hjFTnCasJ8PVp3mZbZK5g2vGDT4LByLJ7m8ciyRFZP'