no sinon and rename to traversal

Author: patrickwoodhead

package.json

@@ -48,8 +48,8 @@
     "./block": {
       "import": "./src/block.js"
     },
-    "./traverse": {
-      "import": "./src/traverse.js"
+    "./traversal": {
+      "import": "./src/traversal.js"
     },
     "./bases/identity": {
       "import": "./src/bases/identity.js"
@@ -110,7 +110,6 @@
     "ipjs": "^5.1.2",
     "mocha": "^9.1.1",
     "polendina": "^1.1.0",
-    "sinon": "^12.0.1",
     "standard": "^16.0.3",
     "typescript": "~4.4.2"
   },

src/traverse.js renamed to src/traversal.js

@@ -14,9 +14,10 @@ import { base58btc } from 'multiformats/bases/base58'
  * @param {Object} options
  * @param {CID} options.cid
  * @param {(cid: CID) => Promise<Block<T>>} options.load
- * @param {Set<string>} options.seen
+ * @param {Set<string>?} options.seen
  */
-const walk = async ({ cid, load, seen = new Set() }) => {
+const walk = async ({ cid, load, seen }) => {
+  seen = seen || new Set()
   const b58Cid = cid.toString(base58btc)
   if (seen.has(b58Cid)) {
     return
@@ -25,9 +26,8 @@ const walk = async ({ cid, load, seen = new Set() }) => {
   const block = await load(cid)
   seen.add(b58Cid)
 
-  for (const link of block.links()) {
-    const linkCid = link[1]
-    await walk({ cid: linkCid, load, seen })
+  for (const [_,cid] of block.links()) {
+    await walk({ cid, load, seen })
   }
 }
 

test/test-traverse.js renamed to test/test-traversal.js

@@ -1,15 +1,15 @@
 /* globals describe, it */
-import sinon from 'sinon'
 import * as codec from 'multiformats/codecs/json'
 import * as dagPB from '@ipld/dag-pb'
 import { sha256 as hasher } from 'multiformats/hashes/sha2'
 import * as main from 'multiformats/block'
-import { walk } from 'multiformats/traverse'
+import { walk } from 'multiformats/traversal'
+import { deepStrictEqual as same } from 'assert'
 
 const test = it
 const { createLink, createNode } = dagPB
 
-describe('traverse', () => {
+describe('traversal', () => {
   describe('walk', async () => {
     // Forming the following DAG for testing
     //             A
@@ -61,18 +61,25 @@ describe('traverse', () => {
       throw new Error('unmatched CID')
     }
 
+    const loadWrapper = (load, arr = []) => (cid) => {
+      arr.push(cid.toString())
+      return load(cid)
+    }
+
     test('block with no links', async () => {
       // Test Case 1
       // Input DAG
       //            D
       //
       // Expect load to be called with D
-
-      const spy = sinon.spy(load)
-
-      await walk({ cid: cidD, load: spy })
-      sinon.assert.callCount(spy, 1)
-      sinon.assert.calledOnceWithExactly(spy, cidD)
+      const expectedCallArray = [cidD.toString()]
+      const callArray = []
+
+      await walk({ cid: cidD, load: loadWrapper(load, callArray) })
+      
+      expectedCallArray.forEach((value, index) => {
+        same(value, callArray[index])
+      })
     })
     test('block with links', async () => {
       // Test Case 2
@@ -82,15 +89,14 @@ describe('traverse', () => {
       //          D   E
       //
       // Expect load to be called with C, then D, then E
-
-      const spy = sinon.spy(load)
-
-      await walk({ cid: cidC, load: spy })
-
-      sinon.assert.callCount(spy, 3)
-      sinon.assert.calledWith(spy.firstCall, cidC)
-      sinon.assert.calledWith(spy.secondCall, cidD)
-      sinon.assert.calledWith(spy.thirdCall, cidE)
+      const expectedCallArray = [cidC.toString(), cidD.toString(), cidE.toString()]
+      const callArray = []
+
+      await walk({ cid: cidC, load: loadWrapper(load, callArray) })
+      
+      expectedCallArray.forEach((value, index) => {
+        same(value, callArray[index])
+      })
     })
     test('block with matching links', async () => {
       // Test Case 3
@@ -100,14 +106,14 @@ describe('traverse', () => {
       //          D   D
       //
       // Expect load to be called with B, then D
-
-      const spy = sinon.spy(load)
-
-      await walk({ cid: cidB, load: spy })
-
-      sinon.assert.callCount(spy, 2)
-      sinon.assert.calledWith(spy.firstCall, cidB)
-      sinon.assert.calledWith(spy.secondCall, cidD)
+      const expectedCallArray = [cidB.toString(), cidD.toString()]
+      const callArray = []
+
+      await walk({ cid: cidB, load: loadWrapper(load, callArray) })
+      
+      expectedCallArray.forEach((value, index) => {
+        same(value, callArray[index])
+      })
     })
     test('depth first with duplicated block', async () => {
       // Test Case 4
@@ -117,18 +123,22 @@ describe('traverse', () => {
       //          B     C
       //         / \   / \
       //        D   D D   E
+      //
       // Expect load to be called with A, then B, then D, then C, then E
-
-      const spy = sinon.spy(load)
-
-      await walk({ cid: cidA, load: spy })
-
-      sinon.assert.callCount(spy, 5)
-      sinon.assert.calledWith(spy.firstCall, cidA)
-      sinon.assert.calledWith(spy.secondCall, cidB)
-      sinon.assert.calledWith(spy.thirdCall, cidD)
-      sinon.assert.calledWith(spy.getCall(-2), cidC)
-      sinon.assert.calledWith(spy.lastCall, cidE)
+      const expectedCallArray = [
+        cidA.toString(),
+        cidB.toString(),
+        cidD.toString(),
+        cidC.toString(),
+        cidE.toString(),
+      ]
+      const callArray = []
+
+      await walk({ cid: cidA, load: loadWrapper(load, callArray) })
+
+      expectedCallArray.forEach((value, index) => {
+        same(value, callArray[index])
+      })
     })
   })
 })