From 95368894680bedce06c8bef781e0c748b6124c27 Mon Sep 17 00:00:00 2001
From: Sergei SMART <sergei.smart@gmail.com>
Date: Tue, 1 Mar 2022 11:16:52 +1000
Subject: [PATCH] add test coverage. more tests

---
 .nvmrc                                        |  1 +
 package.json                                  |  1 +
 src/fixedMerkleTree.ts                        | 29 +++++--------------
 ...leTree.spec.ts => fixedMerkleTree.spec.ts} | 18 +++++++++++-
 test/partialMerkleTree.spec.ts                |  2 --
 5 files changed, 27 insertions(+), 24 deletions(-)
 create mode 100644 .nvmrc
 rename test/{merkleTree.spec.ts => fixedMerkleTree.spec.ts} (94%)

diff --git a/.nvmrc b/.nvmrc
new file mode 100644
index 0000000..898c871
--- /dev/null
+++ b/.nvmrc
@@ -0,0 +1 @@
+14.17
diff --git a/package.json b/package.json
index 43b8459..777e82c 100644
--- a/package.json
+++ b/package.json
@@ -11,6 +11,7 @@
   },
   "scripts": {
     "test": "ts-mocha 'test/*.spec.ts'",
+    "coverage": "nyc npm run test",
     "build": "tsc",
     "clean": "rm -rf lib/",
     "prepare": "npm run clean && npm run build",
diff --git a/src/fixedMerkleTree.ts b/src/fixedMerkleTree.ts
index 4c4c6f9..def3a92 100644
--- a/src/fixedMerkleTree.ts
+++ b/src/fixedMerkleTree.ts
@@ -14,10 +14,6 @@ export default class MerkleTree {
     return this._layers.slice()
   }
 
-  set layers(value: Array<Element[]>) {
-    this._layers = value
-  }
-
   levels: number
   capacity: number
   private _hashFn: HashFunction<Element>
@@ -86,7 +82,7 @@ export default class MerkleTree {
    * Insert multiple elements into the tree.
    * @param {Array} elements Elements to insert
    */
-  bulkInsert(elements: Element[]) {
+  bulkInsert(elements: Element[]): void {
     if (!elements.length) {
       return
     }
@@ -172,30 +168,21 @@ export default class MerkleTree {
    * @param comparator A function that checks leaf value equality
    * @returns {number} Index if element is found, otherwise -1
    */
-  indexOf(element: Element, comparator?: <T, R> (arg0: T, arg1: T) => R): number {
+  indexOf(element: Element, comparator?: <T> (arg0: T, arg1: T) => boolean): number {
     if (comparator) {
-      return this._layers[0].findIndex((el) => comparator<Element, number>(element, el))
+      return this._layers[0].findIndex((el) => comparator<Element>(element, el))
     } else {
       return this._layers[0].indexOf(element)
     }
   }
 
-  getTreeEdge(edgeElement: Element, index?: number): TreeEdge {
-    if (edgeElement === 'undefined') {
-      throw new Error('element is required')
-    }
-    let edgeIndex: number
-    if (!Number.isInteger(index)) {
-      index = -1
-      const leaves = this._layers[0]
-      index = leaves.indexOf(edgeElement)
-      edgeIndex = index
-    }
-
-    if (index <= -1) {
+  getTreeEdge(edgeElement: Element): TreeEdge {
+    const leaves = this._layers[0]
+    const edgeIndex = leaves.indexOf(edgeElement)
+    if (edgeIndex <= -1) {
       return null
     }
-    const edgePath = this.path(index)
+    const edgePath = this.path(edgeIndex)
     return { edgePath, edgeElement, edgeIndex }
   }
 
diff --git a/test/merkleTree.spec.ts b/test/fixedMerkleTree.spec.ts
similarity index 94%
rename from test/merkleTree.spec.ts
rename to test/fixedMerkleTree.spec.ts
index 94f8975..23bc6c3 100644
--- a/test/merkleTree.spec.ts
+++ b/test/fixedMerkleTree.spec.ts
@@ -110,6 +110,12 @@ describe('MerkleTree', () => {
       const call = () => tree.bulkInsert([3, 4, 5])
       should().throw(call, 'Tree is full')
     })
+    it('should bypass empty elements', () => {
+      const elements = [1, 2, 3, 4]
+      const tree = new MerkleTree(2, elements)
+      tree.bulkInsert([])
+      assert.deepEqual(tree.elements, elements, 'No elements inserted')
+    })
   })
 
   describe('#update', () => {
@@ -164,6 +170,11 @@ describe('MerkleTree', () => {
       should().equal(tree.indexOf(3), 2)
     })
 
+    it('should work with comparator', () => {
+      const tree = new MerkleTree(10, [1, 2, 3, 4, 5])
+      should().equal(tree.indexOf(4, (arg0, arg1) => arg0 === arg1), 3)
+    })
+
     it('should return -1 for non existent element', () => {
       const tree = new MerkleTree(10, [1, 2, 3, 4, 5])
       should().equal(tree.indexOf(42), -1)
@@ -235,7 +246,12 @@ describe('MerkleTree', () => {
       ])
     })
   })
-
+  describe('#getTreeEdge', () => {
+    it('should return correct treeEdge', () => {
+      const tree = new MerkleTree(4, [0, 1, 2, 3, 4, 5])
+      console.log(tree.getTreeEdge(4))
+    })
+  })
   describe('#getters', () => {
     const elements = [1, 2, 3, 4, 5]
     const layers = [
diff --git a/test/partialMerkleTree.spec.ts b/test/partialMerkleTree.spec.ts
index cbe9a67..794644b 100644
--- a/test/partialMerkleTree.spec.ts
+++ b/test/partialMerkleTree.spec.ts
@@ -1,5 +1,4 @@
 import { MerkleTree, PartialMerkleTree } from '../src'
-import { assert, should } from 'chai'
 import { it } from 'mocha'
 
 describe('PartialMerkleTree', () => {
@@ -12,7 +11,6 @@ describe('PartialMerkleTree', () => {
     const leavesAfterEdge = leaves.splice(edge.edgeIndex)
     it('should initialize merkle tree', () => {
       const partialTree = new PartialMerkleTree(edge, leavesAfterEdge, root)
-      console.log(partialTree)
       return true
     })
   })