feat: support for ipld-dag-pb

src/index.js

@@ -86,6 +86,8 @@ module.exports = class IPLDResolver {
     )
   }
 
+  // TODO: Consider if we still want this (fact: no one is using it
+  // right now and this will be just an IPLD selector anyway
   getRecursive (cid, callback) {
     pull(
       this.getRecursiveStream(cid),

test/test-ipld-dag-pb.js

@@ -4,8 +4,7 @@
 const expect = require('chai').expect
 const BlockService = require('ipfs-block-service')
 const dagPB = require('ipld-dag-pb')
-const multihash = require('multihashing')
-const series = require('async/series')
+// const series = require('async/series')
 const pull = require('pull-stream')
 
 const IPLDResolver = require('../src')
@@ -15,86 +14,63 @@ module.exports = (repo) => {
   const resolver = new IPLDResolver(bs)
 
   describe('IPLD Resolver with dag-pb (MerkleDAG Protobuf)', () => {
+    let node1
+    let node2
+    let node3
+
     before(() => {
-      // Create a bunch o nodes to be used
+      node1 = new dagPB.DAGNode(new Buffer('I am 1'))
+      node2 = new dagPB.DAGNode(new Buffer('I am 2'))
+      node3 = new dagPB.DAGNode(new Buffer('I am 3'))
     })
 
     it('throws when not passed a repo', () => {
       expect(() => new IPLDResolver()).to.throw(/requires a BlockService/)
     })
 
-    it.skip('resolver.put', (done) => {
-      /*
-      const node = {
-        name: 'hello.txt',
-        size: 11
-      }
-
-      ipldService.put(node, done)
-      */
+    it('resolver.put', (done) => {
+      resolver.put(node1, done)
     })
 
-    it.skip('resolver.putStream', (done) => {
-      /*
+    it('resolver.putStream', (done) => {
       pull(
         pull.values([
-          {name: 'pull.txt', size: 12}
+          node1,
+          node2,
+          node3
         ]),
-        ipldService.putStream(done)
+        resolver.putStream(done)
       )
-      */
     })
 
-    it.skip('resolver.get', (done) => {
-      /*
-      const node = {
-        name: 'world.txt',
-        size: 11
-      }
-
-      ipldService.put(node, (err) => {
+    it('resolver.get', (done) => {
+      resolver.put(node1, (err) => {
         expect(err).to.not.exist
-
-        const mh = multihash(ipld.marshal(node), 'sha2-256')
-
-        ipldService.get(mh, (err, fetchedNode) => {
+        resolver.get(node1.cid(), (err, node) => {
           expect(err).to.not.exist
-          expect(node).to.deep.equal(fetchedNode)
+          expect(node.multihash()).to.eql(node.multihash())
           done()
         })
       })
-      */
     })
 
-    it.skip('resolver.getStream', (done) => {
-      /*
-      const node = {
-        name: 'put.txt',
-        size: 15
-      }
-      const mh = multihash(ipld.marshal(node), 'sha2-256')
-      pull(
-        pull.values([node]),
-        ipldService.putStream(read)
-      )
-
-      function read (err) {
+    it('resolver.getStream', (done) => {
+      resolver.put(node1, (err) => {
         expect(err).to.not.exist
         pull(
-          ipldService.getStream(mh),
-          pull.collect((err, res) => {
+          resolver.getStream(node1.cid()),
+          pull.collect((err, nodes) => {
             expect(err).to.not.exist
-            expect(res[0]).to.be.eql(node)
+            expect(node1.multihash()).to.eql(nodes[0].multihash())
             done()
           })
         )
-      }
-      */
+      })
     })
 
     it.skip('resolver.getRecursive', (done) => {
-      // 1 -> 2 -> 3
       /*
+      // 1 -> 2 -> 3
       const node1 = {data: '1'}
       const node2 = {data: '2'}
       const node3 = {data: '3'}
@@ -126,24 +102,27 @@ module.exports = (repo) => {
       */
     })
 
-    it.skip('resolver.remove', (done) => {
-      /*
-      const node = {data: 'short lived node'}
-      const mh = multihash(ipld.marshal(node), 'sha2-256')
+    it('resolver.remove', (done) => {
+      resolver.put(node1, (err) => {
+        expect(err).to.not.exist
+        resolver.get(node1.cid(), (err, node) => {
+          expect(err).to.not.exist
+          expect(node.multihash()).to.eql(node.multihash())
+          remove()
+        })
+      })
 
-      series([
-        (cb) => ipldService.put(node, cb),
-        (cb) => ipldService.get(mh, cb),
-        (cb) => ipldService.remove(mh, cb),
-        (cb) => ipldService.get(mh, (err) => {
-          expect(err).to.exist
-          cb()
+      function remove () {
+        resolver.remove(node1.cid(), (err) => {
+          expect(err).to.not.exist
+          resolver.get(node1.cid(), (err, node) => {
+            expect(err).to.exist
+            done()
+          })
         })
-      ], done)
-      */
+      }
     })
   })
 
-  describe('IPLD Path Resolver', () => {
-  })
+  describe('IPLD Path Resolver', () => {})
 }