diff --git a/src/index.js b/src/index.js
index 810d706..b8dad0f 100644
--- a/src/index.js
+++ b/src/index.js
@@ -74,7 +74,8 @@ class IPLDResolver {
           if (err) {
             return cb(err)
           }
-          this.resolvers[cid.codec].resolver.resolve(block, path, (err, result) => {
+          const r = this.resolvers[cid.codec]
+          r.resolver.resolve(block, path, (err, result) => {
             if (err) {
               return cb(err)
             }
diff --git a/test/test-ipld-dag-cbor.js b/test/test-ipld-dag-cbor.js
index 1b5656c..06a558b 100644
--- a/test/test-ipld-dag-cbor.js
+++ b/test/test-ipld-dag-cbor.js
@@ -4,7 +4,7 @@
 const expect = require('chai').expect
 const BlockService = require('ipfs-block-service')
 const dagCBOR = require('ipld-dag-cbor')
-// const series = require('async/series')
+const series = require('async/series')
 const pull = require('pull-stream')
 
 const IPLDResolver = require('../src')
@@ -17,11 +17,38 @@ module.exports = (repo) => {
     let node1
     let node2
     let node3
+    let cid1
+    let cid2
+    let cid3
 
-    before(() => {
+    before((done) => {
       node1 = { someData: new Buffer('I am 1') }
       node2 = { someData: new Buffer('I am 2') }
       node3 = { someData: new Buffer('I am 3') }
+
+      series([
+        (cb) => {
+          dagCBOR.util.cid(node1, (err, cid) => {
+            expect(err).to.not.exist
+            cid1 = cid
+            cb()
+          })
+        },
+        (cb) => {
+          dagCBOR.util.cid(node2, (err, cid) => {
+            expect(err).to.not.exist
+            cid2 = cid
+            cb()
+          })
+        },
+        (cb) => {
+          dagCBOR.util.cid(node3, (err, cid) => {
+            expect(err).to.not.exist
+            cid3 = cid
+            cb()
+          })
+        }
+      ], done)
     })
 
     it('creates an in memory repo if no blockService is passed', () => {
@@ -32,16 +59,16 @@ module.exports = (repo) => {
     it('resolver.put', (done) => {
       resolver.put({
         node: node1,
-        cid: dagCBOR.util.cid(node1)
+        cid: cid1
       }, done)
     })
 
     it('resolver.putStream', (done) => {
       pull(
         pull.values([
-          { node: node1, cid: dagCBOR.util.cid(node1) },
-          { node: node2, cid: dagCBOR.util.cid(node2) },
-          { node: node3, cid: dagCBOR.util.cid(node3) }
+          { node: node1, cid: cid1 },
+          { node: node2, cid: cid2 },
+          { node: node3, cid: cid3 }
         ]),
         resolver.putStream(done)
       )
@@ -50,10 +77,10 @@ module.exports = (repo) => {
     it('resolver.get', (done) => {
       resolver.put({
         node: node1,
-        cid: dagCBOR.util.cid(node1)
+        cid: cid1
       }, (err) => {
         expect(err).to.not.exist
-        resolver.get(dagCBOR.util.cid(node1), (err, node) => {
+        resolver.get(cid1, (err, node) => {
           expect(err).to.not.exist
           expect(node1).to.eql(node)
           done()
@@ -64,11 +91,11 @@ module.exports = (repo) => {
     it('resolver.getStream', (done) => {
       resolver.put({
         node: node1,
-        cid: dagCBOR.util.cid(node1)
+        cid: cid1
       }, (err) => {
         expect(err).to.not.exist
         pull(
-          resolver.getStream(dagCBOR.util.cid(node1)),
+          resolver.getStream(cid1),
           pull.collect((err, nodes) => {
             expect(err).to.not.exist
             expect(node1).to.eql(nodes[0])
@@ -78,47 +105,13 @@ module.exports = (repo) => {
       })
     })
 
-    it.skip('resolver.getRecursive', (done) => {
-      /*
-      // 1 -> 2 -> 3
-      const node1 = {data: '1'}
-      const node2 = {data: '2'}
-      const node3 = {data: '3'}
-
-      node2.ref = {
-        '/': ipld.multihash(ipld.marshal(node3))
-      }
-
-      node1.ref = {
-        '/': ipld.multihash(ipld.marshal(node2))
-      }
-
-      series([
-        (cb) => ipldService.put(node1, cb),
-        (cb) => ipldService.put(node2, cb),
-        (cb) => ipldService.put(node3, cb),
-        (cb) => {
-          const mh = multihash(ipld.marshal(node1), 'sha2-256')
-          ipldService.getRecursive(mh, (err, nodes) => {
-            expect(err).to.not.exist
-            expect(nodes).to.have.length(3)
-            cb()
-          })
-        }
-      ], (err) => {
-        expect(err).to.not.exist
-        done()
-      })
-      */
-    })
-
     it('resolver.remove', (done) => {
       resolver.put({
         node: node1,
-        cid: dagCBOR.util.cid(node1)
+        cid: cid1
       }, (err) => {
         expect(err).to.not.exist
-        resolver.get(dagCBOR.util.cid(node1), (err, node) => {
+        resolver.get(cid1, (err, node) => {
           expect(err).to.not.exist
           expect(node1).to.eql(node)
           remove()
@@ -126,9 +119,9 @@ module.exports = (repo) => {
       })
 
       function remove () {
-        resolver.remove(dagCBOR.util.cid(node1), (err) => {
+        resolver.remove(cid1, (err) => {
           expect(err).to.not.exist
-          resolver.get(dagCBOR.util.cid(node1), (err) => {
+          resolver.get(cid1, (err) => {
             expect(err).to.exist
             done()
           })
@@ -143,43 +136,78 @@ module.exports = (repo) => {
     let node1
     let node2
     let node3
+    let cid1
+    let cid2
+    let cid3
 
     before((done) => {
       resolver = new IPLDResolver()
 
-      node1 = {
-        someData: 'I am 1'
-      }
-      node2 = {
-        someData: 'I am 2',
-        'one': { '/': dagCBOR.util.cid(node1).toBaseEncodedString() }
-      }
-      node3 = {
-        someData: 'I am 3',
-        'one': { '/': dagCBOR.util.cid(node1).toBaseEncodedString() },
-        'two': { '/': dagCBOR.util.cid(node2).toBaseEncodedString() }
-      }
+      series([
+        (cb) => {
+          node1 = {
+            someData: 'I am 1'
+          }
 
-      pull(
-        pull.values([
-          { node: node1, cid: dagCBOR.util.cid(node1) },
-          { node: node2, cid: dagCBOR.util.cid(node2) },
-          { node: node3, cid: dagCBOR.util.cid(node3) }
-        ]),
-        resolver.putStream(done)
-      )
+          dagCBOR.util.cid(node1, (err, cid) => {
+            expect(err).to.not.exist
+            cid1 = cid
+            cb()
+          })
+        },
+        (cb) => {
+          node2 = {
+            someData: 'I am 2',
+            'one': { '/': cid1.toBaseEncodedString() }
+          }
+
+          dagCBOR.util.cid(node2, (err, cid) => {
+            expect(err).to.not.exist
+            cid2 = cid
+            cb()
+          })
+        },
+        (cb) => {
+          node3 = {
+            someData: 'I am 3',
+            'one': { '/': cid1.toBaseEncodedString() },
+            'two': { '/': cid2.toBaseEncodedString() }
+          }
+
+          dagCBOR.util.cid(node3, (err, cid) => {
+            expect(err).to.not.exist
+            cid3 = cid
+            cb()
+          })
+        }
+      ], store)
+
+      function store () {
+        pull(
+          pull.values([
+            { node: node1, cid: cid1 },
+            { node: node2, cid: cid2 },
+            { node: node3, cid: cid3 }
+          ]),
+          resolver.putStream(done)
+        )
+      }
     })
 
     it('root path (same as get)', (done) => {
-      resolver.resolve(dagCBOR.util.cid(node1), '/', (err, result) => {
+      resolver.resolve(cid1, '/', (err, result) => {
         expect(err).to.not.exist
-        expect(dagCBOR.util.cid(result)).to.eql(dagCBOR.util.cid(node1))
-        done()
+
+        dagCBOR.util.cid(result, (err, cid) => {
+          expect(err).to.not.exist
+          expect(cid).to.eql(cid1)
+          done()
+        })
       })
     })
 
     it('value within 1st node scope', (done) => {
-      resolver.resolve(dagCBOR.util.cid(node1), 'someData', (err, result) => {
+      resolver.resolve(cid1, 'someData', (err, result) => {
         expect(err).to.not.exist
         expect(result).to.eql('I am 1')
         done()
@@ -187,7 +215,7 @@ module.exports = (repo) => {
     })
 
     it('value within nested scope (1 level)', (done) => {
-      resolver.resolve(dagCBOR.util.cid(node2), 'one/someData', (err, result) => {
+      resolver.resolve(cid2, 'one/someData', (err, result) => {
         expect(err).to.not.exist
         expect(result).to.eql('I am 1')
         done()
@@ -195,7 +223,7 @@ module.exports = (repo) => {
     })
 
     it('value within nested scope (2 levels)', (done) => {
-      resolver.resolve(dagCBOR.util.cid(node3), 'two/one/someData', (err, result) => {
+      resolver.resolve(cid3, 'two/one/someData', (err, result) => {
         expect(err).to.not.exist
         expect(result).to.eql('I am 1')
         done()
diff --git a/test/test-ipld-dag-pb.js b/test/test-ipld-dag-pb.js
index 92bf77e..4d7c32f 100644
--- a/test/test-ipld-dag-pb.js
+++ b/test/test-ipld-dag-pb.js
@@ -10,7 +10,7 @@ const pull = require('pull-stream')
 const IPLDResolver = require('../src')
 
 module.exports = (repo) => {
-  describe.only('IPLD Resolver with dag-pb (MerkleDAG Protobuf)', () => {
+  describe('IPLD Resolver with dag-pb (MerkleDAG Protobuf)', () => {
     const bs = new BlockService(repo)
     const resolver = new IPLDResolver(bs)